# 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
SkipSchema = schemas.IntSchema
LimitSchema = schemas.IntSchema
ModelSchema = schemas.StrSchema
DeviceFriendlyNameSchema = schemas.StrSchema
OrderSchema = schemas.StrSchema
OrderBySchema = schemas.StrSchema
RequestRequiredQueryParams = typing_extensions.TypedDict(
    'RequestRequiredQueryParams',
    {
    }
)
RequestOptionalQueryParams = typing_extensions.TypedDict(
    'RequestOptionalQueryParams',
    {
        'Serialnumber': typing.Union[SerialnumberSchema, str, ],
        'Email': typing.Union[EmailSchema, str, ],
        'Skip': typing.Union[SkipSchema, decimal.Decimal, int, ],
        'Limit': typing.Union[LimitSchema, decimal.Decimal, int, ],
        'Model': typing.Union[ModelSchema, str, ],
        'DeviceFriendlyName': typing.Union[DeviceFriendlyNameSchema, str, ],
        'Order': typing.Union[OrderSchema, str, ],
        'OrderBy': typing.Union[OrderBySchema, str, ],
    },
    total=False
)


class RequestQueryParams(RequestRequiredQueryParams, RequestOptionalQueryParams):
    pass


request_query_serialnumber = api_client.QueryParameter(
    name="Serialnumber",
    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_skip = api_client.QueryParameter(
    name="Skip",
    style=api_client.ParameterStyle.FORM,
    schema=SkipSchema,
    explode=True,
)
request_query_limit = api_client.QueryParameter(
    name="Limit",
    style=api_client.ParameterStyle.FORM,
    schema=LimitSchema,
    explode=True,
)
request_query_model = api_client.QueryParameter(
    name="Model",
    style=api_client.ParameterStyle.FORM,
    schema=ModelSchema,
    explode=True,
)
request_query_device_friendly_name = api_client.QueryParameter(
    name="DeviceFriendlyName",
    style=api_client.ParameterStyle.FORM,
    schema=DeviceFriendlyNameSchema,
    explode=True,
)
request_query_order = api_client.QueryParameter(
    name="Order",
    style=api_client.ParameterStyle.FORM,
    schema=OrderSchema,
    explode=True,
)
request_query_order_by = api_client.QueryParameter(
    name="OrderBy",
    style=api_client.ParameterStyle.FORM,
    schema=OrderBySchema,
    explode=True,
)
_auth = [
    'bearerAuthToken',
]


class SchemaFor200ResponseBodyApplicationJson(
    schemas.DictSchema
):


    class MetaOapg:
        
        class properties:
            
            
            class devices(
                schemas.ListSchema
            ):
            
            
                class MetaOapg:
                    
                    
                    class items(
                        schemas.DictSchema
                    ):
                    
                    
                        class MetaOapg:
                            
                            class properties:
                                DeviceID = schemas.StrSchema
                                SerialNumber = schemas.StrSchema
                                DeviceFriendlyName = schemas.StrSchema
                                Ownership = schemas.StrSchema
                                Platform = schemas.StrSchema
                                Model = schemas.StrSchema
                                Architecture = schemas.StrSchema
                                RegisteredStatus = schemas.StrSchema
                                
                                
                                class MdmData(
                                    schemas.DictSchema
                                ):
                                
                                
                                    class MetaOapg:
                                        
                                        class properties:
                                            Timestamp = schemas.IntSchema
                                            Source = schemas.StrSchema
                                            CompromisedStatus = schemas.StrSchema
                                            CompliantStatus = schemas.StrSchema
                                            __annotations__ = {
                                                "Timestamp": Timestamp,
                                                "Source": Source,
                                                "CompromisedStatus": CompromisedStatus,
                                                "CompliantStatus": CompliantStatus,
                                            }
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["Timestamp"]) -> MetaOapg.properties.Timestamp: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["Source"]) -> MetaOapg.properties.Source: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["CompromisedStatus"]) -> MetaOapg.properties.CompromisedStatus: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["CompliantStatus"]) -> MetaOapg.properties.CompliantStatus: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
                                    
                                    def __getitem__(self, name: typing.Union[typing_extensions.Literal["Timestamp", "Source", "CompromisedStatus", "CompliantStatus", ], str]):
                                        # dict_instance[name] accessor
                                        return super().__getitem__(name)
                                    
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["Timestamp"]) -> typing.Union[MetaOapg.properties.Timestamp, 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["CompromisedStatus"]) -> typing.Union[MetaOapg.properties.CompromisedStatus, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["CompliantStatus"]) -> typing.Union[MetaOapg.properties.CompliantStatus, 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["Timestamp", "Source", "CompromisedStatus", "CompliantStatus", ], str]):
                                        return super().get_item_oapg(name)
                                    
                                
                                    def __new__(
                                        cls,
                                        *args: typing.Union[dict, frozendict.frozendict, ],
                                        Timestamp: typing.Union[MetaOapg.properties.Timestamp, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                        Source: typing.Union[MetaOapg.properties.Source, str, schemas.Unset] = schemas.unset,
                                        CompromisedStatus: typing.Union[MetaOapg.properties.CompromisedStatus, str, schemas.Unset] = schemas.unset,
                                        CompliantStatus: typing.Union[MetaOapg.properties.CompliantStatus, 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],
                                    ) -> 'MdmData':
                                        return super().__new__(
                                            cls,
                                            *args,
                                            Timestamp=Timestamp,
                                            Source=Source,
                                            CompromisedStatus=CompromisedStatus,
                                            CompliantStatus=CompliantStatus,
                                            _configuration=_configuration,
                                            **kwargs,
                                        )
                                
                                
                                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 TrustData(
                                    schemas.DictSchema
                                ):
                                
                                
                                    class MetaOapg:
                                        
                                        class properties:
                                            EntityTrustscore = schemas.IntSchema
                                            OverrideTrustscore = schemas.IntSchema
                                            AccessTrustscore = schemas.IntSchema
                                            OverrideActive = schemas.StrSchema
                                            Level = schemas.StrSchema
                                            UpdatedAt = 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
                                                                RemediationDescription = schemas.StrSchema
                                                                RemediationURL = schemas.StrSchema
                                                                __annotations__ = {
                                                                    "Name": Name,
                                                                    "Value": Value,
                                                                    "Type": Type,
                                                                    "Source": Source,
                                                                    "Description": Description,
                                                                    "RemediationDescription": RemediationDescription,
                                                                    "RemediationURL": RemediationURL,
                                                                }
                                                        
                                                        @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["RemediationDescription"]) -> MetaOapg.properties.RemediationDescription: ...
                                                        
                                                        @typing.overload
                                                        def __getitem__(self, name: typing_extensions.Literal["RemediationURL"]) -> MetaOapg.properties.RemediationURL: ...
                                                        
                                                        @typing.overload
                                                        def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
                                                        
                                                        def __getitem__(self, name: typing.Union[typing_extensions.Literal["Name", "Value", "Type", "Source", "Description", "RemediationDescription", "RemediationURL", ], 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["RemediationDescription"]) -> typing.Union[MetaOapg.properties.RemediationDescription, schemas.Unset]: ...
                                                        
                                                        @typing.overload
                                                        def get_item_oapg(self, name: typing_extensions.Literal["RemediationURL"]) -> typing.Union[MetaOapg.properties.RemediationURL, 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", "RemediationDescription", "RemediationURL", ], 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,
                                                            RemediationDescription: typing.Union[MetaOapg.properties.RemediationDescription, str, schemas.Unset] = schemas.unset,
                                                            RemediationURL: typing.Union[MetaOapg.properties.RemediationURL, 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],
                                                        ) -> 'items':
                                                            return super().__new__(
                                                                cls,
                                                                *args,
                                                                Name=Name,
                                                                Value=Value,
                                                                Type=Type,
                                                                Source=Source,
                                                                Description=Description,
                                                                RemediationDescription=RemediationDescription,
                                                                RemediationURL=RemediationURL,
                                                                _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__ = {
                                                "EntityTrustscore": EntityTrustscore,
                                                "OverrideTrustscore": OverrideTrustscore,
                                                "AccessTrustscore": AccessTrustscore,
                                                "OverrideActive": OverrideActive,
                                                "Level": Level,
                                                "UpdatedAt": UpdatedAt,
                                                "Factors": Factors,
                                            }
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["EntityTrustscore"]) -> MetaOapg.properties.EntityTrustscore: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["OverrideTrustscore"]) -> MetaOapg.properties.OverrideTrustscore: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["AccessTrustscore"]) -> MetaOapg.properties.AccessTrustscore: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["OverrideActive"]) -> MetaOapg.properties.OverrideActive: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["Level"]) -> MetaOapg.properties.Level: ...
                                    
                                    @typing.overload
                                    def __getitem__(self, name: typing_extensions.Literal["UpdatedAt"]) -> MetaOapg.properties.UpdatedAt: ...
                                    
                                    @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["EntityTrustscore", "OverrideTrustscore", "AccessTrustscore", "OverrideActive", "Level", "UpdatedAt", "Factors", ], str]):
                                        # dict_instance[name] accessor
                                        return super().__getitem__(name)
                                    
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["EntityTrustscore"]) -> typing.Union[MetaOapg.properties.EntityTrustscore, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["OverrideTrustscore"]) -> typing.Union[MetaOapg.properties.OverrideTrustscore, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["AccessTrustscore"]) -> typing.Union[MetaOapg.properties.AccessTrustscore, schemas.Unset]: ...
                                    
                                    @typing.overload
                                    def get_item_oapg(self, name: typing_extensions.Literal["OverrideActive"]) -> typing.Union[MetaOapg.properties.OverrideActive, 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["UpdatedAt"]) -> typing.Union[MetaOapg.properties.UpdatedAt, 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["EntityTrustscore", "OverrideTrustscore", "AccessTrustscore", "OverrideActive", "Level", "UpdatedAt", "Factors", ], str]):
                                        return super().get_item_oapg(name)
                                    
                                
                                    def __new__(
                                        cls,
                                        *args: typing.Union[dict, frozendict.frozendict, ],
                                        EntityTrustscore: typing.Union[MetaOapg.properties.EntityTrustscore, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                        OverrideTrustscore: typing.Union[MetaOapg.properties.OverrideTrustscore, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                        AccessTrustscore: typing.Union[MetaOapg.properties.AccessTrustscore, decimal.Decimal, int, schemas.Unset] = schemas.unset,
                                        OverrideActive: typing.Union[MetaOapg.properties.OverrideActive, str, schemas.Unset] = schemas.unset,
                                        Level: typing.Union[MetaOapg.properties.Level, str, schemas.Unset] = schemas.unset,
                                        UpdatedAt: typing.Union[MetaOapg.properties.UpdatedAt, 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],
                                    ) -> 'TrustData':
                                        return super().__new__(
                                            cls,
                                            *args,
                                            EntityTrustscore=EntityTrustscore,
                                            OverrideTrustscore=OverrideTrustscore,
                                            AccessTrustscore=AccessTrustscore,
                                            OverrideActive=OverrideActive,
                                            Level=Level,
                                            UpdatedAt=UpdatedAt,
                                            Factors=Factors,
                                            _configuration=_configuration,
                                            **kwargs,
                                        )
                                
                                
                                class Roles(
                                    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,
                                    ) -> 'Roles':
                                        return super().__new__(
                                            cls,
                                            arg,
                                            _configuration=_configuration,
                                        )
                                
                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)
                                Banned = schemas.StrSchema
                                OS = schemas.StrSchema
                                AppVersion = schemas.StrSchema
                                __annotations__ = {
                                    "DeviceID": DeviceID,
                                    "SerialNumber": SerialNumber,
                                    "DeviceFriendlyName": DeviceFriendlyName,
                                    "Ownership": Ownership,
                                    "Platform": Platform,
                                    "Model": Model,
                                    "Architecture": Architecture,
                                    "RegisteredStatus": RegisteredStatus,
                                    "MdmData": MdmData,
                                    "trust": trust,
                                    "TrustData": TrustData,
                                    "Roles": Roles,
                                    "Banned": Banned,
                                    "OS": OS,
                                    "AppVersion": AppVersion,
                                }
                        
                        @typing.overload
                        def __getitem__(self, name: typing_extensions.Literal["DeviceID"]) -> MetaOapg.properties.DeviceID: ...
                        
                        @typing.overload
                        def __getitem__(self, name: typing_extensions.Literal["SerialNumber"]) -> MetaOapg.properties.SerialNumber: ...
                        
                        @typing.overload
                        def __getitem__(self, name: typing_extensions.Literal["DeviceFriendlyName"]) -> MetaOapg.properties.DeviceFriendlyName: ...
                        
                        @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["Model"]) -> MetaOapg.properties.Model: ...
                        
                        @typing.overload
                        def __getitem__(self, name: typing_extensions.Literal["Architecture"]) -> MetaOapg.properties.Architecture: ...
                        
                        @typing.overload
                        def __getitem__(self, name: typing_extensions.Literal["RegisteredStatus"]) -> MetaOapg.properties.RegisteredStatus: ...
                        
                        @typing.overload
                        def __getitem__(self, name: typing_extensions.Literal["MdmData"]) -> MetaOapg.properties.MdmData: ...
                        
                        @typing.overload
                        def __getitem__(self, name: typing_extensions.Literal["trust"]) -> MetaOapg.properties.trust: ...
                        
                        @typing.overload
                        def __getitem__(self, name: typing_extensions.Literal["TrustData"]) -> MetaOapg.properties.TrustData: ...
                        
                        @typing.overload
                        def __getitem__(self, name: typing_extensions.Literal["Roles"]) -> MetaOapg.properties.Roles: ...
                        
                        @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["AppVersion"]) -> MetaOapg.properties.AppVersion: ...
                        
                        @typing.overload
                        def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
                        
                        def __getitem__(self, name: typing.Union[typing_extensions.Literal["DeviceID", "SerialNumber", "DeviceFriendlyName", "Ownership", "Platform", "Model", "Architecture", "RegisteredStatus", "MdmData", "trust", "TrustData", "Roles", "Banned", "OS", "AppVersion", ], str]):
                            # dict_instance[name] accessor
                            return super().__getitem__(name)
                        
                        
                        @typing.overload
                        def get_item_oapg(self, name: typing_extensions.Literal["DeviceID"]) -> typing.Union[MetaOapg.properties.DeviceID, schemas.Unset]: ...
                        
                        @typing.overload
                        def get_item_oapg(self, name: typing_extensions.Literal["SerialNumber"]) -> typing.Union[MetaOapg.properties.SerialNumber, schemas.Unset]: ...
                        
                        @typing.overload
                        def get_item_oapg(self, name: typing_extensions.Literal["DeviceFriendlyName"]) -> typing.Union[MetaOapg.properties.DeviceFriendlyName, 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["Model"]) -> typing.Union[MetaOapg.properties.Model, schemas.Unset]: ...
                        
                        @typing.overload
                        def get_item_oapg(self, name: typing_extensions.Literal["Architecture"]) -> typing.Union[MetaOapg.properties.Architecture, schemas.Unset]: ...
                        
                        @typing.overload
                        def get_item_oapg(self, name: typing_extensions.Literal["RegisteredStatus"]) -> typing.Union[MetaOapg.properties.RegisteredStatus, schemas.Unset]: ...
                        
                        @typing.overload
                        def get_item_oapg(self, name: typing_extensions.Literal["MdmData"]) -> typing.Union[MetaOapg.properties.MdmData, schemas.Unset]: ...
                        
                        @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["TrustData"]) -> typing.Union[MetaOapg.properties.TrustData, schemas.Unset]: ...
                        
                        @typing.overload
                        def get_item_oapg(self, name: typing_extensions.Literal["Roles"]) -> typing.Union[MetaOapg.properties.Roles, 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["AppVersion"]) -> typing.Union[MetaOapg.properties.AppVersion, 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["DeviceID", "SerialNumber", "DeviceFriendlyName", "Ownership", "Platform", "Model", "Architecture", "RegisteredStatus", "MdmData", "trust", "TrustData", "Roles", "Banned", "OS", "AppVersion", ], str]):
                            return super().get_item_oapg(name)
                        
                    
                        def __new__(
                            cls,
                            *args: typing.Union[dict, frozendict.frozendict, ],
                            DeviceID: typing.Union[MetaOapg.properties.DeviceID, str, schemas.Unset] = schemas.unset,
                            SerialNumber: typing.Union[MetaOapg.properties.SerialNumber, str, schemas.Unset] = schemas.unset,
                            DeviceFriendlyName: typing.Union[MetaOapg.properties.DeviceFriendlyName, 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,
                            Model: typing.Union[MetaOapg.properties.Model, str, schemas.Unset] = schemas.unset,
                            Architecture: typing.Union[MetaOapg.properties.Architecture, str, schemas.Unset] = schemas.unset,
                            RegisteredStatus: typing.Union[MetaOapg.properties.RegisteredStatus, str, schemas.Unset] = schemas.unset,
                            MdmData: typing.Union[MetaOapg.properties.MdmData, dict, frozendict.frozendict, schemas.Unset] = schemas.unset,
                            trust: typing.Union[MetaOapg.properties.trust, dict, frozendict.frozendict, schemas.Unset] = schemas.unset,
                            TrustData: typing.Union[MetaOapg.properties.TrustData, dict, frozendict.frozendict, schemas.Unset] = schemas.unset,
                            Roles: typing.Union[MetaOapg.properties.Roles, list, tuple, schemas.Unset] = schemas.unset,
                            Banned: typing.Union[MetaOapg.properties.Banned, str, schemas.Unset] = schemas.unset,
                            OS: typing.Union[MetaOapg.properties.OS, str, schemas.Unset] = schemas.unset,
                            AppVersion: typing.Union[MetaOapg.properties.AppVersion, 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],
                        ) -> 'items':
                            return super().__new__(
                                cls,
                                *args,
                                DeviceID=DeviceID,
                                SerialNumber=SerialNumber,
                                DeviceFriendlyName=DeviceFriendlyName,
                                Ownership=Ownership,
                                Platform=Platform,
                                Model=Model,
                                Architecture=Architecture,
                                RegisteredStatus=RegisteredStatus,
                                MdmData=MdmData,
                                trust=trust,
                                TrustData=TrustData,
                                Roles=Roles,
                                Banned=Banned,
                                OS=OS,
                                AppVersion=AppVersion,
                                _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],
    ) -> 'SchemaFor200ResponseBodyApplicationJson':
        return super().__new__(
            cls,
            *args,
            devices=devices,
            count=count,
            _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 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,
    '500': _response_for_500,
}
_all_accept_content_types = (
    'application/json',
)


class BaseApi(api_client.Api):

    def _v1_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_serialnumber,
            request_query_email,
            request_query_skip,
            request_query_limit,
            request_query_model,
            request_query_device_friendly_name,
            request_query_order,
            request_query_order_by,
        ):
            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 V1DevicesGet(BaseApi):
    # this class is used by api classes that refer to endpoints with operationId fn names

    def v1_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._v1_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._v1_devices_get_oapg(
            query_params=query_params,
            accept_content_types=accept_content_types,
            stream=stream,
            timeout=timeout,
            skip_deserialization=skip_deserialization
        )


