# coding: utf-8

"""


    Generated by: https://openapi-generator.tech
"""

from dataclasses import dataclass
import typing_extensions
import urllib3
from urllib3._collections import HTTPHeaderDict

from banyanclient import api_client, exceptions
from datetime import date, datetime  # noqa: F401
import decimal  # noqa: F401
import functools  # noqa: F401
import io  # noqa: F401
import re  # noqa: F401
import typing  # noqa: F401
import typing_extensions  # noqa: F401
import uuid  # noqa: F401

import frozendict  # noqa: F401

from banyanclient import schemas  # noqa: F401

from . import path

# query params
SerialNumberSchema = schemas.StrSchema
EmailSchema = schemas.StrSchema
NameSchema = schemas.StrSchema
ModelSchema = schemas.StrSchema
PlatformSchema = schemas.StrSchema
TrustLevelSchema = schemas.StrSchema
IdSchema = schemas.StrSchema
OwnershipSchema = schemas.StrSchema
SourceSchema = schemas.StrSchema
ArchitectureSchema = schemas.StrSchema
OsSchema = schemas.StrSchema
MdmPresentSchema = schemas.BoolSchema
MdmVendorNameSchema = schemas.StrSchema
BannedSchema = schemas.BoolSchema
AppVersionSchema = schemas.StrSchema
RoleNamesSchema = schemas.StrSchema
SkipDefault0Schema = schemas.IntSchema
LimitDefault10Schema = schemas.IntSchema
OrderDefaultdescSchema = schemas.StrSchema
OrderByDefaultcreatedAtSchema = schemas.StrSchema
LastLoginBeforeSchema = schemas.IntSchema
LastLoginAfterSchema = schemas.IntSchema
TrustscoreStatusSchema = schemas.StrSchema
ExactEmailSchema = schemas.StrSchema
ExactSerialNumberSchema = schemas.StrSchema
RequestRequiredQueryParams = typing_extensions.TypedDict(
    'RequestRequiredQueryParams',
    {
    }
)
RequestOptionalQueryParams = typing_extensions.TypedDict(
    'RequestOptionalQueryParams',
    {
        'serial_number': typing.Union[SerialNumberSchema, str, ],
        'email': typing.Union[EmailSchema, str, ],
        'name': typing.Union[NameSchema, str, ],
        'model': typing.Union[ModelSchema, str, ],
        'platform': typing.Union[PlatformSchema, str, ],
        'trust_level': typing.Union[TrustLevelSchema, str, ],
        'id': typing.Union[IdSchema, str, ],
        'ownership': typing.Union[OwnershipSchema, str, ],
        'source': typing.Union[SourceSchema, str, ],
        'architecture': typing.Union[ArchitectureSchema, str, ],
        'os': typing.Union[OsSchema, str, ],
        'mdm_present': typing.Union[MdmPresentSchema, bool, ],
        'mdm_vendor_name': typing.Union[MdmVendorNameSchema, str, ],
        'banned': typing.Union[BannedSchema, bool, ],
        'app_version': typing.Union[AppVersionSchema, str, ],
        'role_names': typing.Union[RoleNamesSchema, str, ],
        'skip (default&#x3D;0)': typing.Union[SkipDefault0Schema, decimal.Decimal, int, ],
        'limit (default&#x3D;10)': typing.Union[LimitDefault10Schema, decimal.Decimal, int, ],
        'order (default&#x3D;desc)': typing.Union[OrderDefaultdescSchema, str, ],
        'order_by (default&#x3D;created_at)': typing.Union[OrderByDefaultcreatedAtSchema, str, ],
        'last_login_before': typing.Union[LastLoginBeforeSchema, decimal.Decimal, int, ],
        'last_login_after': typing.Union[LastLoginAfterSchema, decimal.Decimal, int, ],
        'trustscore_status': typing.Union[TrustscoreStatusSchema, str, ],
        'exact_email': typing.Union[ExactEmailSchema, str, ],
        'exact_serial_number': typing.Union[ExactSerialNumberSchema, str, ],
    },
    total=False
)


class RequestQueryParams(RequestRequiredQueryParams, RequestOptionalQueryParams):
    pass


request_query_serial_number = api_client.QueryParameter(
    name="serial_number",
    style=api_client.ParameterStyle.FORM,
    schema=SerialNumberSchema,
    explode=True,
)
request_query_email = api_client.QueryParameter(
    name="email",
    style=api_client.ParameterStyle.FORM,
    schema=EmailSchema,
    explode=True,
)
request_query_name = api_client.QueryParameter(
    name="name",
    style=api_client.ParameterStyle.FORM,
    schema=NameSchema,
    explode=True,
)
request_query_model = api_client.QueryParameter(
    name="model",
    style=api_client.ParameterStyle.FORM,
    schema=ModelSchema,
    explode=True,
)
request_query_platform = api_client.QueryParameter(
    name="platform",
    style=api_client.ParameterStyle.FORM,
    schema=PlatformSchema,
    explode=True,
)
request_query_trust_level = api_client.QueryParameter(
    name="trust_level",
    style=api_client.ParameterStyle.FORM,
    schema=TrustLevelSchema,
    explode=True,
)
request_query_id = api_client.QueryParameter(
    name="id",
    style=api_client.ParameterStyle.FORM,
    schema=IdSchema,
    explode=True,
)
request_query_ownership = api_client.QueryParameter(
    name="ownership",
    style=api_client.ParameterStyle.FORM,
    schema=OwnershipSchema,
    explode=True,
)
request_query_source = api_client.QueryParameter(
    name="source",
    style=api_client.ParameterStyle.FORM,
    schema=SourceSchema,
    explode=True,
)
request_query_architecture = api_client.QueryParameter(
    name="architecture",
    style=api_client.ParameterStyle.FORM,
    schema=ArchitectureSchema,
    explode=True,
)
request_query_os = api_client.QueryParameter(
    name="os",
    style=api_client.ParameterStyle.FORM,
    schema=OsSchema,
    explode=True,
)
request_query_mdm_present = api_client.QueryParameter(
    name="mdm_present",
    style=api_client.ParameterStyle.FORM,
    schema=MdmPresentSchema,
    explode=True,
)
request_query_mdm_vendor_name = api_client.QueryParameter(
    name="mdm_vendor_name",
    style=api_client.ParameterStyle.FORM,
    schema=MdmVendorNameSchema,
    explode=True,
)
request_query_banned = api_client.QueryParameter(
    name="banned",
    style=api_client.ParameterStyle.FORM,
    schema=BannedSchema,
    explode=True,
)
request_query_app_version = api_client.QueryParameter(
    name="app_version",
    style=api_client.ParameterStyle.FORM,
    schema=AppVersionSchema,
    explode=True,
)
request_query_role_names = api_client.QueryParameter(
    name="role_names",
    style=api_client.ParameterStyle.FORM,
    schema=RoleNamesSchema,
    explode=True,
)
request_query_skip__default0 = api_client.QueryParameter(
    name="skip (default&#x3D;0)",
    style=api_client.ParameterStyle.FORM,
    schema=SkipDefault0Schema,
    explode=True,
)
request_query_limit__default10 = api_client.QueryParameter(
    name="limit (default&#x3D;10)",
    style=api_client.ParameterStyle.FORM,
    schema=LimitDefault10Schema,
    explode=True,
)
request_query_order__defaultdesc = api_client.QueryParameter(
    name="order (default&#x3D;desc)",
    style=api_client.ParameterStyle.FORM,
    schema=OrderDefaultdescSchema,
    explode=True,
)
request_query_order_by__defaultcreated_at = api_client.QueryParameter(
    name="order_by (default&#x3D;created_at)",
    style=api_client.ParameterStyle.FORM,
    schema=OrderByDefaultcreatedAtSchema,
    explode=True,
)
request_query_last_login_before = api_client.QueryParameter(
    name="last_login_before",
    style=api_client.ParameterStyle.FORM,
    schema=LastLoginBeforeSchema,
    explode=True,
)
request_query_last_login_after = api_client.QueryParameter(
    name="last_login_after",
    style=api_client.ParameterStyle.FORM,
    schema=LastLoginAfterSchema,
    explode=True,
)
request_query_trustscore_status = api_client.QueryParameter(
    name="trustscore_status",
    style=api_client.ParameterStyle.FORM,
    schema=TrustscoreStatusSchema,
    explode=True,
)
request_query_exact_email = api_client.QueryParameter(
    name="exact_email",
    style=api_client.ParameterStyle.FORM,
    schema=ExactEmailSchema,
    explode=True,
)
request_query_exact_serial_number = api_client.QueryParameter(
    name="exact_serial_number",
    style=api_client.ParameterStyle.FORM,
    schema=ExactSerialNumberSchema,
    explode=True,
)
_auth = [
    'bearerAuthToken',
]


class SchemaFor200ResponseBodyApplicationJson(
    schemas.DictSchema
):


    class MetaOapg:
        
        class properties:
            request_id = schemas.StrSchema
            error_code = schemas.IntSchema
            error_description = schemas.StrSchema
            
            
            class data(
                schemas.DictSchema
            ):
            
            
                class MetaOapg:
                    
                    class properties:
                        
                        
                        class devices(
                            schemas.ListSchema
                        ):
                        
                        
                            class MetaOapg:
                                
                                
                                class items(
                                    schemas.DictSchema
                                ):
                                
                                
                                    class MetaOapg:
                                        
                                        class properties:
                                            id = schemas.StrSchema
                                            serial_number = schemas.StrSchema
                                            name = schemas.StrSchema
                                            model = schemas.StrSchema
                                            ownership = schemas.StrSchema
                                            platform = schemas.StrSchema
                                            architechture = schemas.StrSchema
                                            source = schemas.StrSchema
                                            banned = schemas.IntSchema
                                            os = schemas.StrSchema
                                            mdm_present = schemas.IntSchema
                                            mdm_vendor_name = schemas.StrSchema
                                            mdm_vendor_udid = schemas.StrSchema
                                            mdm_compliant = schemas.StrSchema
                                            app_version = schemas.StrSchema
                                            created_at = schemas.IntSchema
                                            last_login = schemas.IntSchema
                                            
                                            
                                            class extra_details(
                                                schemas.DictSchema
                                            ):
                                            
                                            
                                                class MetaOapg:
                                                    
                                                    class properties:
                                                        
                                                        
                                                        class trust(
                                                            schemas.DictSchema
                                                        ):
                                                        
                                                        
                                                            class MetaOapg:
                                                                
                                                                class properties:
                                                                    value = schemas.IntSchema
                                                                    level = schemas.StrSchema
                                                                    status = schemas.StrSchema
                                                                    
                                                                    
                                                                    class last_evaluated(
                                                                        schemas.DictSchema
                                                                    ):
                                                                    
                                                                    
                                                                        class MetaOapg:
                                                                            
                                                                            class properties:
                                                                                last_evaluated_at = schemas.IntSchema
                                                                                last_evaluated_value = schemas.IntSchema
                                                                                last_evaluated_level = schemas.StrSchema
                                                                                
                                                                                
                                                                                class last_evaluated_factors(
                                                                                    schemas.ListSchema
                                                                                ):
                                                                                
                                                                                
                                                                                    class MetaOapg:
                                                                                        
                                                                                        
                                                                                        class items(
                                                                                            schemas.DictSchema
                                                                                        ):
                                                                                        
                                                                                        
                                                                                            class MetaOapg:
                                                                                                
                                                                                                class properties:
                                                                                                    name = schemas.StrSchema
                                                                                                    value = schemas.StrSchema
                                                                                                    type = schemas.StrSchema
                                                                                                    source = schemas.StrSchema
                                                                                                    description = schemas.StrSchema
                                                                                                    
                                                                                                    
                                                                                                    class remediation(
                                                                                                        schemas.DictSchema
                                                                                                    ):
                                                                                                    
                                                                                                    
                                                                                                        class MetaOapg:
                                                                                                            
                                                                                                            class properties:
                                                                                                                description = schemas.StrSchema
                                                                                                                url = schemas.StrSchema
                                                                                                                __annotations__ = {
                                                                                                                    "description": description,
                                                                                                                    "url": url,
                                                                                                                }
                                                                                                        
                                                                                                        @typing.overload
                                                                                                        def __getitem__(self, name: typing_extensions.Literal["description"]) -> MetaOapg.properties.description: ...
                                                                                                        
                                                                                                        @typing.overload
                                                                                                        def __getitem__(self, name: typing_extensions.Literal["url"]) -> MetaOapg.properties.url: ...
                                                                                                        
                                                                                                        @typing.overload
                                                                                                        def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
                                                                                                        
                                                                                                        def __getitem__(self, name: typing.Union[typing_extensions.Literal["description", "url", ], str]):
                                                                                                            # dict_instance[name] accessor
                                                                                                            return super().__getitem__(name)
                                                                                                        
                                                                                                        
                                                                                                        @typing.overload
                                                                                                        def get_item_oapg(self, name: typing_extensions.Literal["description"]) -> typing.Union[MetaOapg.properties.description, schemas.Unset]: ...
                                                                                                        
                                                                                                        @typing.overload
                                                                                                        def get_item_oapg(self, name: typing_extensions.Literal["url"]) -> typing.Union[MetaOapg.properties.url, schemas.Unset]: ...
                                                                                                        
                                                                                                        @typing.overload
                                                                                                        def get_item_oapg(self, name: str) -> typing.Union[schemas.UnsetAnyTypeSchema, schemas.Unset]: ...
                                                                                                        
                                                                                                        def get_item_oapg(self, name: typing.Union[typing_extensions.Literal["description", "url", ], str]):
                                                                                                            return super().get_item_oapg(name)
                                                                                                        
                                                                                                    
                                                                                                        def __new__(
                                                                                                            cls,
                                                                                                            *args: typing.Union[dict, frozendict.frozendict, ],
                                                                                                            description: typing.Union[MetaOapg.properties.description, str, schemas.Unset] = schemas.unset,
                                                                                                            url: typing.Union[MetaOapg.properties.url, str, schemas.Unset] = schemas.unset,
                                                                                                            _configuration: typing.Optional[schemas.Configuration] = None,
                                                                                                            **kwargs: typing.Union[schemas.AnyTypeSchema, dict, frozendict.frozendict, str, date, datetime, uuid.UUID, int, float, decimal.Decimal, None, list, tuple, bytes],
                                                                                                        ) -> 'remediation':
                                                                                                            return super().__new__(
                                                                                                                cls,
                                                                                                                *args,
                                                                                                                description=description,
                                                                                                                url=url,
                                                                                                                _configuration=_configuration,
                                                                                                                **kwargs,
                                                                                                            )
                                                                                                    __annotations__ = {
                                                                                                        "name": name,
                                                                                                        "value": value,
                                                                                                        "type": type,
                                                                                                        "source": source,
                                                                                                        "description": description,
                                                                                                        "remediation": remediation,
                                                                                                    }
                                                                                            
                                                                                            @typing.overload
                                                                                            def __getitem__(self, name: typing_extensions.Literal["name"]) -> MetaOapg.properties.name: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def __getitem__(self, name: typing_extensions.Literal["value"]) -> MetaOapg.properties.value: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def __getitem__(self, name: typing_extensions.Literal["type"]) -> MetaOapg.properties.type: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def __getitem__(self, name: typing_extensions.Literal["source"]) -> MetaOapg.properties.source: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def __getitem__(self, name: typing_extensions.Literal["description"]) -> MetaOapg.properties.description: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def __getitem__(self, name: typing_extensions.Literal["remediation"]) -> MetaOapg.properties.remediation: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
                                                                                            
                                                                                            def __getitem__(self, name: typing.Union[typing_extensions.Literal["name", "value", "type", "source", "description", "remediation", ], str]):
                                                                                                # dict_instance[name] accessor
                                                                                                return super().__getitem__(name)
                                                                                            
                                                                                            
                                                                                            @typing.overload
                                                                                            def get_item_oapg(self, name: typing_extensions.Literal["name"]) -> typing.Union[MetaOapg.properties.name, schemas.Unset]: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def get_item_oapg(self, name: typing_extensions.Literal["value"]) -> typing.Union[MetaOapg.properties.value, schemas.Unset]: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def get_item_oapg(self, name: typing_extensions.Literal["type"]) -> typing.Union[MetaOapg.properties.type, schemas.Unset]: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def get_item_oapg(self, name: typing_extensions.Literal["source"]) -> typing.Union[MetaOapg.properties.source, schemas.Unset]: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def get_item_oapg(self, name: typing_extensions.Literal["description"]) -> typing.Union[MetaOapg.properties.description, schemas.Unset]: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def get_item_oapg(self, name: typing_extensions.Literal["remediation"]) -> typing.Union[MetaOapg.properties.remediation, schemas.Unset]: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def get_item_oapg(self, name: str) -> typing.Union[schemas.UnsetAnyTypeSchema, schemas.Unset]: ...
                                                                                            
                                                                                            def get_item_oapg(self, name: typing.Union[typing_extensions.Literal["name", "value", "type", "source", "description", "remediation", ], str]):
                                                                                                return super().get_item_oapg(name)
                                                                                            
                                                                                        
                                                                                            def __new__(
                                                                                                cls,
                                                                                                *args: typing.Union[dict, frozendict.frozendict, ],
                                                                                                name: typing.Union[MetaOapg.properties.name, str, schemas.Unset] = schemas.unset,
                                                                                                value: typing.Union[MetaOapg.properties.value, str, schemas.Unset] = schemas.unset,
                                                                                                type: typing.Union[MetaOapg.properties.type, str, schemas.Unset] = schemas.unset,
                                                                                                source: typing.Union[MetaOapg.properties.source, str, schemas.Unset] = schemas.unset,
                                                                                                description: typing.Union[MetaOapg.properties.description, str, schemas.Unset] = schemas.unset,
                                                                                                remediation: typing.Union[MetaOapg.properties.remediation, dict, frozendict.frozendict, schemas.Unset] = schemas.unset,
                                                                                                _configuration: typing.Optional[schemas.Configuration] = None,
                                                                                                **kwargs: typing.Union[schemas.AnyTypeSchema, dict, frozendict.frozendict, str, date, datetime, uuid.UUID, int, float, decimal.Decimal, None, list, tuple, bytes],
                                                                                            ) -> 'items':
                                                                                                return super().__new__(
                                                                                                    cls,
                                                                                                    *args,
                                                                                                    name=name,
                                                                                                    value=value,
                                                                                                    type=type,
                                                                                                    source=source,
                                                                                                    description=description,
                                                                                                    remediation=remediation,
                                                                                                    _configuration=_configuration,
                                                                                                    **kwargs,
                                                                                                )
                                                                                
                                                                                    def __new__(
                                                                                        cls,
                                                                                        arg: typing.Union[typing.Tuple[typing.Union[MetaOapg.items, dict, frozendict.frozendict, ]], typing.List[typing.Union[MetaOapg.items, dict, frozendict.frozendict, ]]],
                                                                                        _configuration: typing.Optional[schemas.Configuration] = None,
                                                                                    ) -> 'last_evaluated_factors':
                                                                                        return super().__new__(
                                                                                            cls,
                                                                                            arg,
                                                                                            _configuration=_configuration,
                                                                                        )
                                                                                
                                                                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                                                                        return super().__getitem__(i)
                                                                                __annotations__ = {
                                                                                    "last_evaluated_at": last_evaluated_at,
                                                                                    "last_evaluated_value": last_evaluated_value,
                                                                                    "last_evaluated_level": last_evaluated_level,
                                                                                    "last_evaluated_factors": last_evaluated_factors,
                                                                                }
                                                                        
                                                                        @typing.overload
                                                                        def __getitem__(self, name: typing_extensions.Literal["last_evaluated_at"]) -> MetaOapg.properties.last_evaluated_at: ...
                                                                        
                                                                        @typing.overload
                                                                        def __getitem__(self, name: typing_extensions.Literal["last_evaluated_value"]) -> MetaOapg.properties.last_evaluated_value: ...
                                                                        
                                                                        @typing.overload
                                                                        def __getitem__(self, name: typing_extensions.Literal["last_evaluated_level"]) -> MetaOapg.properties.last_evaluated_level: ...
                                                                        
                                                                        @typing.overload
                                                                        def __getitem__(self, name: typing_extensions.Literal["last_evaluated_factors"]) -> MetaOapg.properties.last_evaluated_factors: ...
                                                                        
                                                                        @typing.overload
                                                                        def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
                                                                        
                                                                        def __getitem__(self, name: typing.Union[typing_extensions.Literal["last_evaluated_at", "last_evaluated_value", "last_evaluated_level", "last_evaluated_factors", ], str]):
                                                                            # dict_instance[name] accessor
                                                                            return super().__getitem__(name)
                                                                        
                                                                        
                                                                        @typing.overload
                                                                        def get_item_oapg(self, name: typing_extensions.Literal["last_evaluated_at"]) -> typing.Union[MetaOapg.properties.last_evaluated_at, schemas.Unset]: ...
                                                                        
                                                                        @typing.overload
                                                                        def get_item_oapg(self, name: typing_extensions.Literal["last_evaluated_value"]) -> typing.Union[MetaOapg.properties.last_evaluated_value, schemas.Unset]: ...
                                                                        
                                                                        @typing.overload
                                                                        def get_item_oapg(self, name: typing_extensions.Literal["last_evaluated_level"]) -> typing.Union[MetaOapg.properties.last_evaluated_level, schemas.Unset]: ...
                                                                        
                                                                        @typing.overload
                                                                        def get_item_oapg(self, name: typing_extensions.Literal["last_evaluated_factors"]) -> typing.Union[MetaOapg.properties.last_evaluated_factors, schemas.Unset]: ...
                                                                        
                                                                        @typing.overload
                                                                        def get_item_oapg(self, name: str) -> typing.Union[schemas.UnsetAnyTypeSchema, schemas.Unset]: ...
                                                                        
                                                                        def get_item_oapg(self, name: typing.Union[typing_extensions.Literal["last_evaluated_at", "last_evaluated_value", "last_evaluated_level", "last_evaluated_factors", ], str]):
                                                                            return super().get_item_oapg(name)
                                                                        
                                                                    
                                                                        def __new__(
                                                                            cls,
                                                                            *args: typing.Union[dict, frozendict.frozendict, ],
                                                                            last_evaluated_at: typing.Union[MetaOapg.properties.last_evaluated_at, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                                                            last_evaluated_value: typing.Union[MetaOapg.properties.last_evaluated_value, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                                                            last_evaluated_level: typing.Union[MetaOapg.properties.last_evaluated_level, str, schemas.Unset] = schemas.unset,
                                                                            last_evaluated_factors: typing.Union[MetaOapg.properties.last_evaluated_factors, list, tuple, schemas.Unset] = schemas.unset,
                                                                            _configuration: typing.Optional[schemas.Configuration] = None,
                                                                            **kwargs: typing.Union[schemas.AnyTypeSchema, dict, frozendict.frozendict, str, date, datetime, uuid.UUID, int, float, decimal.Decimal, None, list, tuple, bytes],
                                                                        ) -> 'last_evaluated':
                                                                            return super().__new__(
                                                                                cls,
                                                                                *args,
                                                                                last_evaluated_at=last_evaluated_at,
                                                                                last_evaluated_value=last_evaluated_value,
                                                                                last_evaluated_level=last_evaluated_level,
                                                                                last_evaluated_factors=last_evaluated_factors,
                                                                                _configuration=_configuration,
                                                                                **kwargs,
                                                                            )
                                                                    expired_at = schemas.IntSchema
                                                                    
                                                                    
                                                                    class factors(
                                                                        schemas.ListSchema
                                                                    ):
                                                                    
                                                                    
                                                                        class MetaOapg:
                                                                            
                                                                            
                                                                            class items(
                                                                                schemas.DictSchema
                                                                            ):
                                                                            
                                                                            
                                                                                class MetaOapg:
                                                                                    
                                                                                    class properties:
                                                                                        name = schemas.StrSchema
                                                                                        value = schemas.StrSchema
                                                                                        type = schemas.StrSchema
                                                                                        source = schemas.StrSchema
                                                                                        description = schemas.StrSchema
                                                                                        
                                                                                        
                                                                                        class remediation(
                                                                                            schemas.DictSchema
                                                                                        ):
                                                                                        
                                                                                        
                                                                                            class MetaOapg:
                                                                                                
                                                                                                class properties:
                                                                                                    description = schemas.StrSchema
                                                                                                    url = schemas.StrSchema
                                                                                                    __annotations__ = {
                                                                                                        "description": description,
                                                                                                        "url": url,
                                                                                                    }
                                                                                            
                                                                                            @typing.overload
                                                                                            def __getitem__(self, name: typing_extensions.Literal["description"]) -> MetaOapg.properties.description: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def __getitem__(self, name: typing_extensions.Literal["url"]) -> MetaOapg.properties.url: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
                                                                                            
                                                                                            def __getitem__(self, name: typing.Union[typing_extensions.Literal["description", "url", ], str]):
                                                                                                # dict_instance[name] accessor
                                                                                                return super().__getitem__(name)
                                                                                            
                                                                                            
                                                                                            @typing.overload
                                                                                            def get_item_oapg(self, name: typing_extensions.Literal["description"]) -> typing.Union[MetaOapg.properties.description, schemas.Unset]: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def get_item_oapg(self, name: typing_extensions.Literal["url"]) -> typing.Union[MetaOapg.properties.url, schemas.Unset]: ...
                                                                                            
                                                                                            @typing.overload
                                                                                            def get_item_oapg(self, name: str) -> typing.Union[schemas.UnsetAnyTypeSchema, schemas.Unset]: ...
                                                                                            
                                                                                            def get_item_oapg(self, name: typing.Union[typing_extensions.Literal["description", "url", ], str]):
                                                                                                return super().get_item_oapg(name)
                                                                                            
                                                                                        
                                                                                            def __new__(
                                                                                                cls,
                                                                                                *args: typing.Union[dict, frozendict.frozendict, ],
                                                                                                description: typing.Union[MetaOapg.properties.description, str, schemas.Unset] = schemas.unset,
                                                                                                url: typing.Union[MetaOapg.properties.url, str, schemas.Unset] = schemas.unset,
                                                                                                _configuration: typing.Optional[schemas.Configuration] = None,
                                                                                                **kwargs: typing.Union[schemas.AnyTypeSchema, dict, frozendict.frozendict, str, date, datetime, uuid.UUID, int, float, decimal.Decimal, None, list, tuple, bytes],
                                                                                            ) -> 'remediation':
                                                                                                return super().__new__(
                                                                                                    cls,
                                                                                                    *args,
                                                                                                    description=description,
                                                                                                    url=url,
                                                                                                    _configuration=_configuration,
                                                                                                    **kwargs,
                                                                                                )
                                                                                        __annotations__ = {
                                                                                            "name": name,
                                                                                            "value": value,
                                                                                            "type": type,
                                                                                            "source": source,
                                                                                            "description": description,
                                                                                            "remediation": remediation,
                                                                                        }
                                                                                
                                                                                @typing.overload
                                                                                def __getitem__(self, name: typing_extensions.Literal["name"]) -> MetaOapg.properties.name: ...
                                                                                
                                                                                @typing.overload
                                                                                def __getitem__(self, name: typing_extensions.Literal["value"]) -> MetaOapg.properties.value: ...
                                                                                
                                                                                @typing.overload
                                                                                def __getitem__(self, name: typing_extensions.Literal["type"]) -> MetaOapg.properties.type: ...
                                                                                
                                                                                @typing.overload
                                                                                def __getitem__(self, name: typing_extensions.Literal["source"]) -> MetaOapg.properties.source: ...
                                                                                
                                                                                @typing.overload
                                                                                def __getitem__(self, name: typing_extensions.Literal["description"]) -> MetaOapg.properties.description: ...
                                                                                
                                                                                @typing.overload
                                                                                def __getitem__(self, name: typing_extensions.Literal["remediation"]) -> MetaOapg.properties.remediation: ...
                                                                                
                                                                                @typing.overload
                                                                                def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
                                                                                
                                                                                def __getitem__(self, name: typing.Union[typing_extensions.Literal["name", "value", "type", "source", "description", "remediation", ], str]):
                                                                                    # dict_instance[name] accessor
                                                                                    return super().__getitem__(name)
                                                                                
                                                                                
                                                                                @typing.overload
                                                                                def get_item_oapg(self, name: typing_extensions.Literal["name"]) -> typing.Union[MetaOapg.properties.name, schemas.Unset]: ...
                                                                                
                                                                                @typing.overload
                                                                                def get_item_oapg(self, name: typing_extensions.Literal["value"]) -> typing.Union[MetaOapg.properties.value, schemas.Unset]: ...
                                                                                
                                                                                @typing.overload
                                                                                def get_item_oapg(self, name: typing_extensions.Literal["type"]) -> typing.Union[MetaOapg.properties.type, schemas.Unset]: ...
                                                                                
                                                                                @typing.overload
                                                                                def get_item_oapg(self, name: typing_extensions.Literal["source"]) -> typing.Union[MetaOapg.properties.source, schemas.Unset]: ...
                                                                                
                                                                                @typing.overload
                                                                                def get_item_oapg(self, name: typing_extensions.Literal["description"]) -> typing.Union[MetaOapg.properties.description, schemas.Unset]: ...
                                                                                
                                                                                @typing.overload
                                                                                def get_item_oapg(self, name: typing_extensions.Literal["remediation"]) -> typing.Union[MetaOapg.properties.remediation, schemas.Unset]: ...
                                                                                
                                                                                @typing.overload
                                                                                def get_item_oapg(self, name: str) -> typing.Union[schemas.UnsetAnyTypeSchema, schemas.Unset]: ...
                                                                                
                                                                                def get_item_oapg(self, name: typing.Union[typing_extensions.Literal["name", "value", "type", "source", "description", "remediation", ], str]):
                                                                                    return super().get_item_oapg(name)
                                                                                
                                                                            
                                                                                def __new__(
                                                                                    cls,
                                                                                    *args: typing.Union[dict, frozendict.frozendict, ],
                                                                                    name: typing.Union[MetaOapg.properties.name, str, schemas.Unset] = schemas.unset,
                                                                                    value: typing.Union[MetaOapg.properties.value, str, schemas.Unset] = schemas.unset,
                                                                                    type: typing.Union[MetaOapg.properties.type, str, schemas.Unset] = schemas.unset,
                                                                                    source: typing.Union[MetaOapg.properties.source, str, schemas.Unset] = schemas.unset,
                                                                                    description: typing.Union[MetaOapg.properties.description, str, schemas.Unset] = schemas.unset,
                                                                                    remediation: typing.Union[MetaOapg.properties.remediation, dict, frozendict.frozendict, schemas.Unset] = schemas.unset,
                                                                                    _configuration: typing.Optional[schemas.Configuration] = None,
                                                                                    **kwargs: typing.Union[schemas.AnyTypeSchema, dict, frozendict.frozendict, str, date, datetime, uuid.UUID, int, float, decimal.Decimal, None, list, tuple, bytes],
                                                                                ) -> 'items':
                                                                                    return super().__new__(
                                                                                        cls,
                                                                                        *args,
                                                                                        name=name,
                                                                                        value=value,
                                                                                        type=type,
                                                                                        source=source,
                                                                                        description=description,
                                                                                        remediation=remediation,
                                                                                        _configuration=_configuration,
                                                                                        **kwargs,
                                                                                    )
                                                                    
                                                                        def __new__(
                                                                            cls,
                                                                            arg: typing.Union[typing.Tuple[typing.Union[MetaOapg.items, dict, frozendict.frozendict, ]], typing.List[typing.Union[MetaOapg.items, dict, frozendict.frozendict, ]]],
                                                                            _configuration: typing.Optional[schemas.Configuration] = None,
                                                                        ) -> 'factors':
                                                                            return super().__new__(
                                                                                cls,
                                                                                arg,
                                                                                _configuration=_configuration,
                                                                            )
                                                                    
                                                                        def __getitem__(self, i: int) -> MetaOapg.items:
                                                                            return super().__getitem__(i)
                                                                    __annotations__ = {
                                                                        "value": value,
                                                                        "level": level,
                                                                        "status": status,
                                                                        "last_evaluated": last_evaluated,
                                                                        "expired_at": expired_at,
                                                                        "factors": factors,
                                                                    }
                                                            
                                                            @typing.overload
                                                            def __getitem__(self, name: typing_extensions.Literal["value"]) -> MetaOapg.properties.value: ...
                                                            
                                                            @typing.overload
                                                            def __getitem__(self, name: typing_extensions.Literal["level"]) -> MetaOapg.properties.level: ...
                                                            
                                                            @typing.overload
                                                            def __getitem__(self, name: typing_extensions.Literal["status"]) -> MetaOapg.properties.status: ...
                                                            
                                                            @typing.overload
                                                            def __getitem__(self, name: typing_extensions.Literal["last_evaluated"]) -> MetaOapg.properties.last_evaluated: ...
                                                            
                                                            @typing.overload
                                                            def __getitem__(self, name: typing_extensions.Literal["expired_at"]) -> MetaOapg.properties.expired_at: ...
                                                            
                                                            @typing.overload
                                                            def __getitem__(self, name: typing_extensions.Literal["factors"]) -> MetaOapg.properties.factors: ...
                                                            
                                                            @typing.overload
                                                            def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
                                                            
                                                            def __getitem__(self, name: typing.Union[typing_extensions.Literal["value", "level", "status", "last_evaluated", "expired_at", "factors", ], str]):
                                                                # dict_instance[name] accessor
                                                                return super().__getitem__(name)
                                                            
                                                            
                                                            @typing.overload
                                                            def get_item_oapg(self, name: typing_extensions.Literal["value"]) -> typing.Union[MetaOapg.properties.value, schemas.Unset]: ...
                                                            
                                                            @typing.overload
                                                            def get_item_oapg(self, name: typing_extensions.Literal["level"]) -> typing.Union[MetaOapg.properties.level, schemas.Unset]: ...
                                                            
                                                            @typing.overload
                                                            def get_item_oapg(self, name: typing_extensions.Literal["status"]) -> typing.Union[MetaOapg.properties.status, schemas.Unset]: ...
                                                            
                                                            @typing.overload
                                                            def get_item_oapg(self, name: typing_extensions.Literal["last_evaluated"]) -> typing.Union[MetaOapg.properties.last_evaluated, schemas.Unset]: ...
                                                            
                                                            @typing.overload
                                                            def get_item_oapg(self, name: typing_extensions.Literal["expired_at"]) -> typing.Union[MetaOapg.properties.expired_at, schemas.Unset]: ...
                                                            
                                                            @typing.overload
                                                            def get_item_oapg(self, name: typing_extensions.Literal["factors"]) -> typing.Union[MetaOapg.properties.factors, schemas.Unset]: ...
                                                            
                                                            @typing.overload
                                                            def get_item_oapg(self, name: str) -> typing.Union[schemas.UnsetAnyTypeSchema, schemas.Unset]: ...
                                                            
                                                            def get_item_oapg(self, name: typing.Union[typing_extensions.Literal["value", "level", "status", "last_evaluated", "expired_at", "factors", ], str]):
                                                                return super().get_item_oapg(name)
                                                            
                                                        
                                                            def __new__(
                                                                cls,
                                                                *args: typing.Union[dict, frozendict.frozendict, ],
                                                                value: typing.Union[MetaOapg.properties.value, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                                                level: typing.Union[MetaOapg.properties.level, str, schemas.Unset] = schemas.unset,
                                                                status: typing.Union[MetaOapg.properties.status, str, schemas.Unset] = schemas.unset,
                                                                last_evaluated: typing.Union[MetaOapg.properties.last_evaluated, dict, frozendict.frozendict, schemas.Unset] = schemas.unset,
                                                                expired_at: typing.Union[MetaOapg.properties.expired_at, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                                                factors: typing.Union[MetaOapg.properties.factors, list, tuple, schemas.Unset] = schemas.unset,
                                                                _configuration: typing.Optional[schemas.Configuration] = None,
                                                                **kwargs: typing.Union[schemas.AnyTypeSchema, dict, frozendict.frozendict, str, date, datetime, uuid.UUID, int, float, decimal.Decimal, None, list, tuple, bytes],
                                                            ) -> 'trust':
                                                                return super().__new__(
                                                                    cls,
                                                                    *args,
                                                                    value=value,
                                                                    level=level,
                                                                    status=status,
                                                                    last_evaluated=last_evaluated,
                                                                    expired_at=expired_at,
                                                                    factors=factors,
                                                                    _configuration=_configuration,
                                                                    **kwargs,
                                                                )
                                                        
                                                        
                                                        class trustscore(
                                                            schemas.DictSchema
                                                        ):
                                                        
                                                        
                                                            class MetaOapg:
                                                                
                                                                class properties:
                                                                    entity_trustscore = schemas.IntSchema
                                                                    override_trustscore = schemas.IntSchema
                                                                    access_trustscore = schemas.IntSchema
                                                                    override_active = schemas.IntSchema
                                                                    trust_level = schemas.StrSchema
                                                                    updated_at = schemas.IntSchema
                                                                    __annotations__ = {
                                                                        "entity_trustscore": entity_trustscore,
                                                                        "override_trustscore": override_trustscore,
                                                                        "access_trustscore": access_trustscore,
                                                                        "override_active": override_active,
                                                                        "trust_level": trust_level,
                                                                        "updated_at": updated_at,
                                                                    }
                                                            
                                                            @typing.overload
                                                            def __getitem__(self, name: typing_extensions.Literal["entity_trustscore"]) -> MetaOapg.properties.entity_trustscore: ...
                                                            
                                                            @typing.overload
                                                            def __getitem__(self, name: typing_extensions.Literal["override_trustscore"]) -> MetaOapg.properties.override_trustscore: ...
                                                            
                                                            @typing.overload
                                                            def __getitem__(self, name: typing_extensions.Literal["access_trustscore"]) -> MetaOapg.properties.access_trustscore: ...
                                                            
                                                            @typing.overload
                                                            def __getitem__(self, name: typing_extensions.Literal["override_active"]) -> MetaOapg.properties.override_active: ...
                                                            
                                                            @typing.overload
                                                            def __getitem__(self, name: typing_extensions.Literal["trust_level"]) -> MetaOapg.properties.trust_level: ...
                                                            
                                                            @typing.overload
                                                            def __getitem__(self, name: typing_extensions.Literal["updated_at"]) -> MetaOapg.properties.updated_at: ...
                                                            
                                                            @typing.overload
                                                            def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
                                                            
                                                            def __getitem__(self, name: typing.Union[typing_extensions.Literal["entity_trustscore", "override_trustscore", "access_trustscore", "override_active", "trust_level", "updated_at", ], str]):
                                                                # dict_instance[name] accessor
                                                                return super().__getitem__(name)
                                                            
                                                            
                                                            @typing.overload
                                                            def get_item_oapg(self, name: typing_extensions.Literal["entity_trustscore"]) -> typing.Union[MetaOapg.properties.entity_trustscore, schemas.Unset]: ...
                                                            
                                                            @typing.overload
                                                            def get_item_oapg(self, name: typing_extensions.Literal["override_trustscore"]) -> typing.Union[MetaOapg.properties.override_trustscore, schemas.Unset]: ...
                                                            
                                                            @typing.overload
                                                            def get_item_oapg(self, name: typing_extensions.Literal["access_trustscore"]) -> typing.Union[MetaOapg.properties.access_trustscore, schemas.Unset]: ...
                                                            
                                                            @typing.overload
                                                            def get_item_oapg(self, name: typing_extensions.Literal["override_active"]) -> typing.Union[MetaOapg.properties.override_active, schemas.Unset]: ...
                                                            
                                                            @typing.overload
                                                            def get_item_oapg(self, name: typing_extensions.Literal["trust_level"]) -> typing.Union[MetaOapg.properties.trust_level, schemas.Unset]: ...
                                                            
                                                            @typing.overload
                                                            def get_item_oapg(self, name: typing_extensions.Literal["updated_at"]) -> typing.Union[MetaOapg.properties.updated_at, schemas.Unset]: ...
                                                            
                                                            @typing.overload
                                                            def get_item_oapg(self, name: str) -> typing.Union[schemas.UnsetAnyTypeSchema, schemas.Unset]: ...
                                                            
                                                            def get_item_oapg(self, name: typing.Union[typing_extensions.Literal["entity_trustscore", "override_trustscore", "access_trustscore", "override_active", "trust_level", "updated_at", ], str]):
                                                                return super().get_item_oapg(name)
                                                            
                                                        
                                                            def __new__(
                                                                cls,
                                                                *args: typing.Union[dict, frozendict.frozendict, ],
                                                                entity_trustscore: typing.Union[MetaOapg.properties.entity_trustscore, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                                                override_trustscore: typing.Union[MetaOapg.properties.override_trustscore, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                                                access_trustscore: typing.Union[MetaOapg.properties.access_trustscore, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                                                override_active: typing.Union[MetaOapg.properties.override_active, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                                                trust_level: typing.Union[MetaOapg.properties.trust_level, str, schemas.Unset] = schemas.unset,
                                                                updated_at: typing.Union[MetaOapg.properties.updated_at, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                                                _configuration: typing.Optional[schemas.Configuration] = None,
                                                                **kwargs: typing.Union[schemas.AnyTypeSchema, dict, frozendict.frozendict, str, date, datetime, uuid.UUID, int, float, decimal.Decimal, None, list, tuple, bytes],
                                                            ) -> 'trustscore':
                                                                return super().__new__(
                                                                    cls,
                                                                    *args,
                                                                    entity_trustscore=entity_trustscore,
                                                                    override_trustscore=override_trustscore,
                                                                    access_trustscore=access_trustscore,
                                                                    override_active=override_active,
                                                                    trust_level=trust_level,
                                                                    updated_at=updated_at,
                                                                    _configuration=_configuration,
                                                                    **kwargs,
                                                                )
                                                        
                                                        
                                                        class role_names(
                                                            schemas.ListSchema
                                                        ):
                                                        
                                                        
                                                            class MetaOapg:
                                                                items = schemas.StrSchema
                                                        
                                                            def __new__(
                                                                cls,
                                                                arg: typing.Union[typing.Tuple[typing.Union[MetaOapg.items, str, ]], typing.List[typing.Union[MetaOapg.items, str, ]]],
                                                                _configuration: typing.Optional[schemas.Configuration] = None,
                                                            ) -> 'role_names':
                                                                return super().__new__(
                                                                    cls,
                                                                    arg,
                                                                    _configuration=_configuration,
                                                                )
                                                        
                                                            def __getitem__(self, i: int) -> MetaOapg.items:
                                                                return super().__getitem__(i)
                                                        
                                                        
                                                        class emails(
                                                            schemas.ListSchema
                                                        ):
                                                        
                                                        
                                                            class MetaOapg:
                                                                items = schemas.StrSchema
                                                        
                                                            def __new__(
                                                                cls,
                                                                arg: typing.Union[typing.Tuple[typing.Union[MetaOapg.items, str, ]], typing.List[typing.Union[MetaOapg.items, str, ]]],
                                                                _configuration: typing.Optional[schemas.Configuration] = None,
                                                            ) -> 'emails':
                                                                return super().__new__(
                                                                    cls,
                                                                    arg,
                                                                    _configuration=_configuration,
                                                                )
                                                        
                                                            def __getitem__(self, i: int) -> MetaOapg.items:
                                                                return super().__getitem__(i)
                                                        number_of_users = schemas.IntSchema
                                                        __annotations__ = {
                                                            "trust": trust,
                                                            "trustscore": trustscore,
                                                            "role_names": role_names,
                                                            "emails": emails,
                                                            "number_of_users": number_of_users,
                                                        }
                                                
                                                @typing.overload
                                                def __getitem__(self, name: typing_extensions.Literal["trust"]) -> MetaOapg.properties.trust: ...
                                                
                                                @typing.overload
                                                def __getitem__(self, name: typing_extensions.Literal["trustscore"]) -> MetaOapg.properties.trustscore: ...
                                                
                                                @typing.overload
                                                def __getitem__(self, name: typing_extensions.Literal["role_names"]) -> MetaOapg.properties.role_names: ...
                                                
                                                @typing.overload
                                                def __getitem__(self, name: typing_extensions.Literal["emails"]) -> MetaOapg.properties.emails: ...
                                                
                                                @typing.overload
                                                def __getitem__(self, name: typing_extensions.Literal["number_of_users"]) -> MetaOapg.properties.number_of_users: ...
                                                
                                                @typing.overload
                                                def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
                                                
                                                def __getitem__(self, name: typing.Union[typing_extensions.Literal["trust", "trustscore", "role_names", "emails", "number_of_users", ], str]):
                                                    # dict_instance[name] accessor
                                                    return super().__getitem__(name)
                                                
                                                
                                                @typing.overload
                                                def get_item_oapg(self, name: typing_extensions.Literal["trust"]) -> typing.Union[MetaOapg.properties.trust, schemas.Unset]: ...
                                                
                                                @typing.overload
                                                def get_item_oapg(self, name: typing_extensions.Literal["trustscore"]) -> typing.Union[MetaOapg.properties.trustscore, schemas.Unset]: ...
                                                
                                                @typing.overload
                                                def get_item_oapg(self, name: typing_extensions.Literal["role_names"]) -> typing.Union[MetaOapg.properties.role_names, schemas.Unset]: ...
                                                
                                                @typing.overload
                                                def get_item_oapg(self, name: typing_extensions.Literal["emails"]) -> typing.Union[MetaOapg.properties.emails, schemas.Unset]: ...
                                                
                                                @typing.overload
                                                def get_item_oapg(self, name: typing_extensions.Literal["number_of_users"]) -> typing.Union[MetaOapg.properties.number_of_users, schemas.Unset]: ...
                                                
                                                @typing.overload
                                                def get_item_oapg(self, name: str) -> typing.Union[schemas.UnsetAnyTypeSchema, schemas.Unset]: ...
                                                
                                                def get_item_oapg(self, name: typing.Union[typing_extensions.Literal["trust", "trustscore", "role_names", "emails", "number_of_users", ], str]):
                                                    return super().get_item_oapg(name)
                                                
                                            
                                                def __new__(
                                                    cls,
                                                    *args: typing.Union[dict, frozendict.frozendict, ],
                                                    trust: typing.Union[MetaOapg.properties.trust, dict, frozendict.frozendict, schemas.Unset] = schemas.unset,
                                                    trustscore: typing.Union[MetaOapg.properties.trustscore, dict, frozendict.frozendict, schemas.Unset] = schemas.unset,
                                                    role_names: typing.Union[MetaOapg.properties.role_names, list, tuple, schemas.Unset] = schemas.unset,
                                                    emails: typing.Union[MetaOapg.properties.emails, list, tuple, schemas.Unset] = schemas.unset,
                                                    number_of_users: typing.Union[MetaOapg.properties.number_of_users, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                                    _configuration: typing.Optional[schemas.Configuration] = None,
                                                    **kwargs: typing.Union[schemas.AnyTypeSchema, dict, frozendict.frozendict, str, date, datetime, uuid.UUID, int, float, decimal.Decimal, None, list, tuple, bytes],
                                                ) -> 'extra_details':
                                                    return super().__new__(
                                                        cls,
                                                        *args,
                                                        trust=trust,
                                                        trustscore=trustscore,
                                                        role_names=role_names,
                                                        emails=emails,
                                                        number_of_users=number_of_users,
                                                        _configuration=_configuration,
                                                        **kwargs,
                                                    )
                                            __annotations__ = {
                                                "id": id,
                                                "serial_number": serial_number,
                                                "name": name,
                                                "model": model,
                                                "ownership": ownership,
                                                "platform": platform,
                                                "architechture": architechture,
                                                "source": source,
                                                "banned": banned,
                                                "os": os,
                                                "mdm_present": mdm_present,
                                                "mdm_vendor_name": mdm_vendor_name,
                                                "mdm_vendor_udid": mdm_vendor_udid,
                                                "mdm_compliant": mdm_compliant,
                                                "app_version": app_version,
                                                "created_at": created_at,
                                                "last_login": last_login,
                                                "extra_details": extra_details,
                                            }
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["id"]) -> MetaOapg.properties.id: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["serial_number"]) -> MetaOapg.properties.serial_number: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["name"]) -> MetaOapg.properties.name: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["model"]) -> MetaOapg.properties.model: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["ownership"]) -> MetaOapg.properties.ownership: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["platform"]) -> MetaOapg.properties.platform: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["architechture"]) -> MetaOapg.properties.architechture: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["source"]) -> MetaOapg.properties.source: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["banned"]) -> MetaOapg.properties.banned: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["os"]) -> MetaOapg.properties.os: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["mdm_present"]) -> MetaOapg.properties.mdm_present: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["mdm_vendor_name"]) -> MetaOapg.properties.mdm_vendor_name: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["mdm_vendor_udid"]) -> MetaOapg.properties.mdm_vendor_udid: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["mdm_compliant"]) -> MetaOapg.properties.mdm_compliant: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["app_version"]) -> MetaOapg.properties.app_version: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["created_at"]) -> MetaOapg.properties.created_at: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["last_login"]) -> MetaOapg.properties.last_login: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["extra_details"]) -> MetaOapg.properties.extra_details: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
                                    
                                    def __getitem__(self, name: typing.Union[typing_extensions.Literal["id", "serial_number", "name", "model", "ownership", "platform", "architechture", "source", "banned", "os", "mdm_present", "mdm_vendor_name", "mdm_vendor_udid", "mdm_compliant", "app_version", "created_at", "last_login", "extra_details", ], str]):
                                        # dict_instance[name] accessor
                                        return super().__getitem__(name)
                                    
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["id"]) -> typing.Union[MetaOapg.properties.id, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["serial_number"]) -> typing.Union[MetaOapg.properties.serial_number, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["name"]) -> typing.Union[MetaOapg.properties.name, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["model"]) -> typing.Union[MetaOapg.properties.model, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["ownership"]) -> typing.Union[MetaOapg.properties.ownership, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["platform"]) -> typing.Union[MetaOapg.properties.platform, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["architechture"]) -> typing.Union[MetaOapg.properties.architechture, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["source"]) -> typing.Union[MetaOapg.properties.source, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["banned"]) -> typing.Union[MetaOapg.properties.banned, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["os"]) -> typing.Union[MetaOapg.properties.os, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["mdm_present"]) -> typing.Union[MetaOapg.properties.mdm_present, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["mdm_vendor_name"]) -> typing.Union[MetaOapg.properties.mdm_vendor_name, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["mdm_vendor_udid"]) -> typing.Union[MetaOapg.properties.mdm_vendor_udid, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["mdm_compliant"]) -> typing.Union[MetaOapg.properties.mdm_compliant, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["app_version"]) -> typing.Union[MetaOapg.properties.app_version, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["created_at"]) -> typing.Union[MetaOapg.properties.created_at, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["last_login"]) -> typing.Union[MetaOapg.properties.last_login, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["extra_details"]) -> typing.Union[MetaOapg.properties.extra_details, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: str) -> typing.Union[schemas.UnsetAnyTypeSchema, schemas.Unset]: ...
                                    
                                    def get_item_oapg(self, name: typing.Union[typing_extensions.Literal["id", "serial_number", "name", "model", "ownership", "platform", "architechture", "source", "banned", "os", "mdm_present", "mdm_vendor_name", "mdm_vendor_udid", "mdm_compliant", "app_version", "created_at", "last_login", "extra_details", ], str]):
                                        return super().get_item_oapg(name)
                                    
                                
                                    def __new__(
                                        cls,
                                        *args: typing.Union[dict, frozendict.frozendict, ],
                                        id: typing.Union[MetaOapg.properties.id, str, schemas.Unset] = schemas.unset,
                                        serial_number: typing.Union[MetaOapg.properties.serial_number, str, schemas.Unset] = schemas.unset,
                                        name: typing.Union[MetaOapg.properties.name, str, schemas.Unset] = schemas.unset,
                                        model: typing.Union[MetaOapg.properties.model, str, schemas.Unset] = schemas.unset,
                                        ownership: typing.Union[MetaOapg.properties.ownership, str, schemas.Unset] = schemas.unset,
                                        platform: typing.Union[MetaOapg.properties.platform, str, schemas.Unset] = schemas.unset,
                                        architechture: typing.Union[MetaOapg.properties.architechture, str, schemas.Unset] = schemas.unset,
                                        source: typing.Union[MetaOapg.properties.source, str, schemas.Unset] = schemas.unset,
                                        banned: typing.Union[MetaOapg.properties.banned, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                        os: typing.Union[MetaOapg.properties.os, str, schemas.Unset] = schemas.unset,
                                        mdm_present: typing.Union[MetaOapg.properties.mdm_present, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                        mdm_vendor_name: typing.Union[MetaOapg.properties.mdm_vendor_name, str, schemas.Unset] = schemas.unset,
                                        mdm_vendor_udid: typing.Union[MetaOapg.properties.mdm_vendor_udid, str, schemas.Unset] = schemas.unset,
                                        mdm_compliant: typing.Union[MetaOapg.properties.mdm_compliant, str, schemas.Unset] = schemas.unset,
                                        app_version: typing.Union[MetaOapg.properties.app_version, str, schemas.Unset] = schemas.unset,
                                        created_at: typing.Union[MetaOapg.properties.created_at, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                        last_login: typing.Union[MetaOapg.properties.last_login, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                        extra_details: typing.Union[MetaOapg.properties.extra_details, dict, frozendict.frozendict, schemas.Unset] = schemas.unset,
                                        _configuration: typing.Optional[schemas.Configuration] = None,
                                        **kwargs: typing.Union[schemas.AnyTypeSchema, dict, frozendict.frozendict, str, date, datetime, uuid.UUID, int, float, decimal.Decimal, None, list, tuple, bytes],
                                    ) -> 'items':
                                        return super().__new__(
                                            cls,
                                            *args,
                                            id=id,
                                            serial_number=serial_number,
                                            name=name,
                                            model=model,
                                            ownership=ownership,
                                            platform=platform,
                                            architechture=architechture,
                                            source=source,
                                            banned=banned,
                                            os=os,
                                            mdm_present=mdm_present,
                                            mdm_vendor_name=mdm_vendor_name,
                                            mdm_vendor_udid=mdm_vendor_udid,
                                            mdm_compliant=mdm_compliant,
                                            app_version=app_version,
                                            created_at=created_at,
                                            last_login=last_login,
                                            extra_details=extra_details,
                                            _configuration=_configuration,
                                            **kwargs,
                                        )
                        
                            def __new__(
                                cls,
                                arg: typing.Union[typing.Tuple[typing.Union[MetaOapg.items, dict, frozendict.frozendict, ]], typing.List[typing.Union[MetaOapg.items, dict, frozendict.frozendict, ]]],
                                _configuration: typing.Optional[schemas.Configuration] = None,
                            ) -> 'devices':
                                return super().__new__(
                                    cls,
                                    arg,
                                    _configuration=_configuration,
                                )
                        
                            def __getitem__(self, i: int) -> MetaOapg.items:
                                return super().__getitem__(i)
                        count = schemas.IntSchema
                        __annotations__ = {
                            "devices": devices,
                            "count": count,
                        }
                
                @typing.overload
                def __getitem__(self, name: typing_extensions.Literal["devices"]) -> MetaOapg.properties.devices: ...
                
                @typing.overload
                def __getitem__(self, name: typing_extensions.Literal["count"]) -> MetaOapg.properties.count: ...
                
                @typing.overload
                def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
                
                def __getitem__(self, name: typing.Union[typing_extensions.Literal["devices", "count", ], str]):
                    # dict_instance[name] accessor
                    return super().__getitem__(name)
                
                
                @typing.overload
                def get_item_oapg(self, name: typing_extensions.Literal["devices"]) -> typing.Union[MetaOapg.properties.devices, schemas.Unset]: ...
                
                @typing.overload
                def get_item_oapg(self, name: typing_extensions.Literal["count"]) -> typing.Union[MetaOapg.properties.count, schemas.Unset]: ...
                
                @typing.overload
                def get_item_oapg(self, name: str) -> typing.Union[schemas.UnsetAnyTypeSchema, schemas.Unset]: ...
                
                def get_item_oapg(self, name: typing.Union[typing_extensions.Literal["devices", "count", ], str]):
                    return super().get_item_oapg(name)
                
            
                def __new__(
                    cls,
                    *args: typing.Union[dict, frozendict.frozendict, ],
                    devices: typing.Union[MetaOapg.properties.devices, list, tuple, schemas.Unset] = schemas.unset,
                    count: typing.Union[MetaOapg.properties.count, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                    _configuration: typing.Optional[schemas.Configuration] = None,
                    **kwargs: typing.Union[schemas.AnyTypeSchema, dict, frozendict.frozendict, str, date, datetime, uuid.UUID, int, float, decimal.Decimal, None, list, tuple, bytes],
                ) -> 'data':
                    return super().__new__(
                        cls,
                        *args,
                        devices=devices,
                        count=count,
                        _configuration=_configuration,
                        **kwargs,
                    )
            __annotations__ = {
                "request_id": request_id,
                "error_code": error_code,
                "error_description": error_description,
                "data": data,
            }
    
    @typing.overload
    def __getitem__(self, name: typing_extensions.Literal["request_id"]) -> MetaOapg.properties.request_id: ...
    
    @typing.overload
    def __getitem__(self, name: typing_extensions.Literal["error_code"]) -> MetaOapg.properties.error_code: ...
    
    @typing.overload
    def __getitem__(self, name: typing_extensions.Literal["error_description"]) -> MetaOapg.properties.error_description: ...
    
    @typing.overload
    def __getitem__(self, name: typing_extensions.Literal["data"]) -> MetaOapg.properties.data: ...
    
    @typing.overload
    def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
    
    def __getitem__(self, name: typing.Union[typing_extensions.Literal["request_id", "error_code", "error_description", "data", ], str]):
        # dict_instance[name] accessor
        return super().__getitem__(name)
    
    
    @typing.overload
    def get_item_oapg(self, name: typing_extensions.Literal["request_id"]) -> typing.Union[MetaOapg.properties.request_id, schemas.Unset]: ...
    
    @typing.overload
    def get_item_oapg(self, name: typing_extensions.Literal["error_code"]) -> typing.Union[MetaOapg.properties.error_code, schemas.Unset]: ...
    
    @typing.overload
    def get_item_oapg(self, name: typing_extensions.Literal["error_description"]) -> typing.Union[MetaOapg.properties.error_description, schemas.Unset]: ...
    
    @typing.overload
    def get_item_oapg(self, name: typing_extensions.Literal["data"]) -> typing.Union[MetaOapg.properties.data, schemas.Unset]: ...
    
    @typing.overload
    def get_item_oapg(self, name: str) -> typing.Union[schemas.UnsetAnyTypeSchema, schemas.Unset]: ...
    
    def get_item_oapg(self, name: typing.Union[typing_extensions.Literal["request_id", "error_code", "error_description", "data", ], str]):
        return super().get_item_oapg(name)
    

    def __new__(
        cls,
        *args: typing.Union[dict, frozendict.frozendict, ],
        request_id: typing.Union[MetaOapg.properties.request_id, str, schemas.Unset] = schemas.unset,
        error_code: typing.Union[MetaOapg.properties.error_code, decimal.Decimal, int, schemas.Unset] = schemas.unset,
        error_description: typing.Union[MetaOapg.properties.error_description, str, schemas.Unset] = schemas.unset,
        data: typing.Union[MetaOapg.properties.data, dict, frozendict.frozendict, schemas.Unset] = schemas.unset,
        _configuration: typing.Optional[schemas.Configuration] = None,
        **kwargs: typing.Union[schemas.AnyTypeSchema, dict, frozendict.frozendict, str, date, datetime, uuid.UUID, int, float, decimal.Decimal, None, list, tuple, bytes],
    ) -> 'SchemaFor200ResponseBodyApplicationJson':
        return super().__new__(
            cls,
            *args,
            request_id=request_id,
            error_code=error_code,
            error_description=error_description,
            data=data,
            _configuration=_configuration,
            **kwargs,
        )


@dataclass
class ApiResponseFor200(api_client.ApiResponse):
    response: urllib3.HTTPResponse
    body: typing.Union[
        SchemaFor200ResponseBodyApplicationJson,
    ]
    headers: schemas.Unset = schemas.unset


_response_for_200 = api_client.OpenApiResponse(
    response_cls=ApiResponseFor200,
    content={
        'application/json': api_client.MediaType(
            schema=SchemaFor200ResponseBodyApplicationJson),
    },
)


@dataclass
class ApiResponseFor400(api_client.ApiResponse):
    response: urllib3.HTTPResponse
    body: schemas.Unset = schemas.unset
    headers: schemas.Unset = schemas.unset


_response_for_400 = api_client.OpenApiResponse(
    response_cls=ApiResponseFor400,
)


@dataclass
class ApiResponseFor401(api_client.ApiResponse):
    response: urllib3.HTTPResponse
    body: schemas.Unset = schemas.unset
    headers: schemas.Unset = schemas.unset


_response_for_401 = api_client.OpenApiResponse(
    response_cls=ApiResponseFor401,
)


@dataclass
class ApiResponseFor500(api_client.ApiResponse):
    response: urllib3.HTTPResponse
    body: schemas.Unset = schemas.unset
    headers: schemas.Unset = schemas.unset


_response_for_500 = api_client.OpenApiResponse(
    response_cls=ApiResponseFor500,
)
_status_code_to_response = {
    '200': _response_for_200,
    '400': _response_for_400,
    '401': _response_for_401,
    '500': _response_for_500,
}
_all_accept_content_types = (
    'application/json',
)


class BaseApi(api_client.Api):

    def _v2_devices_get_oapg(
        self: api_client.Api,
        query_params: RequestQueryParams = frozendict.frozendict(),
        accept_content_types: typing.Tuple[str] = _all_accept_content_types,
        stream: bool = False,
        timeout: typing.Optional[typing.Union[int, typing.Tuple]] = None,
        skip_deserialization: bool = False,
    ) -> typing.Union[
        ApiResponseFor200,
        api_client.ApiResponseWithoutDeserialization
    ]:
        """
         Get the Devices in an Organization
        :param skip_deserialization: If true then api_response.response will be set but
            api_response.body and api_response.headers will not be deserialized into schema
            class instances
        """
        self._verify_typed_dict_inputs_oapg(RequestQueryParams, query_params)
        used_path = path.value

        prefix_separator_iterator = None
        for parameter in (
            request_query_serial_number,
            request_query_email,
            request_query_name,
            request_query_model,
            request_query_platform,
            request_query_trust_level,
            request_query_id,
            request_query_ownership,
            request_query_source,
            request_query_architecture,
            request_query_os,
            request_query_mdm_present,
            request_query_mdm_vendor_name,
            request_query_banned,
            request_query_app_version,
            request_query_role_names,
            request_query_skip__default0,
            request_query_limit__default10,
            request_query_order__defaultdesc,
            request_query_order_by__defaultcreated_at,
            request_query_last_login_before,
            request_query_last_login_after,
            request_query_trustscore_status,
            request_query_exact_email,
            request_query_exact_serial_number,
        ):
            parameter_data = query_params.get(parameter.name, schemas.unset)
            if parameter_data is schemas.unset:
                continue
            if prefix_separator_iterator is None:
                prefix_separator_iterator = parameter.get_prefix_separator_iterator()
            serialized_data = parameter.serialize(parameter_data, prefix_separator_iterator)
            for serialized_value in serialized_data.values():
                used_path += serialized_value

        _headers = HTTPHeaderDict()
        # TODO add cookie handling
        if accept_content_types:
            for accept_content_type in accept_content_types:
                _headers.add('Accept', accept_content_type)

        response = self.api_client.call_api(
            resource_path=used_path,
            method='get'.upper(),
            headers=_headers,
            auth_settings=_auth,
            stream=stream,
            timeout=timeout,
        )

        if skip_deserialization:
            api_response = api_client.ApiResponseWithoutDeserialization(response=response)
        else:
            response_for_status = _status_code_to_response.get(str(response.status))
            if response_for_status:
                api_response = response_for_status.deserialize(response, self.api_client.configuration)
            else:
                api_response = api_client.ApiResponseWithoutDeserialization(response=response)

        if not 200 <= response.status <= 299:
            raise exceptions.ApiException(api_response=api_response)

        return api_response


class V2DevicesGet(BaseApi):
    # this class is used by api classes that refer to endpoints with operationId fn names

    def v2_devices_get(
        self: BaseApi,
        query_params: RequestQueryParams = frozendict.frozendict(),
        accept_content_types: typing.Tuple[str] = _all_accept_content_types,
        stream: bool = False,
        timeout: typing.Optional[typing.Union[int, typing.Tuple]] = None,
        skip_deserialization: bool = False,
    ) -> typing.Union[
        ApiResponseFor200,
        api_client.ApiResponseWithoutDeserialization
    ]:
        return self._v2_devices_get_oapg(
            query_params=query_params,
            accept_content_types=accept_content_types,
            stream=stream,
            timeout=timeout,
            skip_deserialization=skip_deserialization
        )


class ApiForget(BaseApi):
    # this class is used by api classes that refer to endpoints by path and http method names

    def get(
        self: BaseApi,
        query_params: RequestQueryParams = frozendict.frozendict(),
        accept_content_types: typing.Tuple[str] = _all_accept_content_types,
        stream: bool = False,
        timeout: typing.Optional[typing.Union[int, typing.Tuple]] = None,
        skip_deserialization: bool = False,
    ) -> typing.Union[
        ApiResponseFor200,
        api_client.ApiResponseWithoutDeserialization
    ]:
        return self._v2_devices_get_oapg(
            query_params=query_params,
            accept_content_types=accept_content_types,
            stream=stream,
            timeout=timeout,
            skip_deserialization=skip_deserialization
        )


