# coding: utf-8

"""


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

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

from python_opendota 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 python_opendota import schemas  # noqa: F401

from . import path

# Path params
MatchIdSchema = schemas.IntSchema
RequestRequiredPathParams = typing_extensions.TypedDict(
    "RequestRequiredPathParams",
    {
        "match_id": typing.Union[
            MatchIdSchema,
            decimal.Decimal,
            int,
        ],
    },
)
RequestOptionalPathParams = typing_extensions.TypedDict(
    "RequestOptionalPathParams", {}, total=False
)


class RequestPathParams(RequestRequiredPathParams, RequestOptionalPathParams):
    pass


request_path_match_id = api_client.PathParameter(
    name="match_id",
    style=api_client.ParameterStyle.SIMPLE,
    schema=MatchIdSchema,
    required=True,
)


class SchemaFor200ResponseBodyApplicationJson(schemas.DictSchema):
    class MetaOapg:
        class properties:
            match_id = schemas.IntSchema
            barracks_status_dire = schemas.IntSchema
            barracks_status_radiant = schemas.IntSchema

            class chat(schemas.ListSchema):
                class MetaOapg:
                    class items(schemas.DictSchema):
                        class MetaOapg:
                            class properties:
                                time = schemas.IntSchema
                                unit = schemas.StrSchema
                                key = schemas.StrSchema
                                slot = schemas.IntSchema
                                player_slot = schemas.IntSchema
                                __annotations__ = {
                                    "time": time,
                                    "unit": unit,
                                    "key": key,
                                    "slot": slot,
                                    "player_slot": player_slot,
                                }

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["time"]
                        ) -> MetaOapg.properties.time:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["unit"]
                        ) -> MetaOapg.properties.unit:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["key"]
                        ) -> MetaOapg.properties.key:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["slot"]
                        ) -> MetaOapg.properties.slot:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["player_slot"]
                        ) -> MetaOapg.properties.player_slot:
                            ...

                        @typing.overload
                        def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema:
                            ...

                        def __getitem__(
                            self,
                            name: typing.Union[
                                typing_extensions.Literal[
                                    "time",
                                    "unit",
                                    "key",
                                    "slot",
                                    "player_slot",
                                ],
                                str,
                            ],
                        ):
                            # dict_instance[name] accessor
                            return super().__getitem__(name)

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["time"]
                        ) -> typing.Union[MetaOapg.properties.time, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["unit"]
                        ) -> typing.Union[MetaOapg.properties.unit, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["key"]
                        ) -> typing.Union[MetaOapg.properties.key, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["slot"]
                        ) -> typing.Union[MetaOapg.properties.slot, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["player_slot"]
                        ) -> typing.Union[
                            MetaOapg.properties.player_slot, 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[
                                    "time",
                                    "unit",
                                    "key",
                                    "slot",
                                    "player_slot",
                                ],
                                str,
                            ],
                        ):
                            return super().get_item_oapg(name)

                        def __new__(
                            cls,
                            *_args: typing.Union[
                                dict,
                                frozendict.frozendict,
                            ],
                            time: typing.Union[
                                MetaOapg.properties.time,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            unit: typing.Union[
                                MetaOapg.properties.unit, str, schemas.Unset
                            ] = schemas.unset,
                            key: typing.Union[
                                MetaOapg.properties.key, str, schemas.Unset
                            ] = schemas.unset,
                            slot: typing.Union[
                                MetaOapg.properties.slot,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            player_slot: typing.Union[
                                MetaOapg.properties.player_slot,
                                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,
                            ],
                        ) -> "items":
                            return super().__new__(
                                cls,
                                *_args,
                                time=time,
                                unit=unit,
                                key=key,
                                slot=slot,
                                player_slot=player_slot,
                                _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,
                ) -> "chat":
                    return super().__new__(
                        cls,
                        _arg,
                        _configuration=_configuration,
                    )

                def __getitem__(self, i: int) -> MetaOapg.items:
                    return super().__getitem__(i)

            cluster = schemas.IntSchema
            cosmetics = schemas.DictSchema
            dire_score = schemas.IntSchema

            class draft_timings(schemas.ListSchema):
                class MetaOapg:
                    class items(schemas.DictSchema):
                        class MetaOapg:
                            class properties:
                                order = schemas.IntSchema
                                pick = schemas.BoolSchema
                                active_team = schemas.IntSchema
                                hero_id = schemas.IntSchema
                                player_slot = schemas.IntSchema
                                extra_time = schemas.IntSchema
                                total_time_taken = schemas.IntSchema
                                __annotations__ = {
                                    "order": order,
                                    "pick": pick,
                                    "active_team": active_team,
                                    "hero_id": hero_id,
                                    "player_slot": player_slot,
                                    "extra_time": extra_time,
                                    "total_time_taken": total_time_taken,
                                }

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["order"]
                        ) -> MetaOapg.properties.order:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["pick"]
                        ) -> MetaOapg.properties.pick:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["active_team"]
                        ) -> MetaOapg.properties.active_team:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["hero_id"]
                        ) -> MetaOapg.properties.hero_id:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["player_slot"]
                        ) -> MetaOapg.properties.player_slot:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["extra_time"]
                        ) -> MetaOapg.properties.extra_time:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["total_time_taken"]
                        ) -> MetaOapg.properties.total_time_taken:
                            ...

                        @typing.overload
                        def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema:
                            ...

                        def __getitem__(
                            self,
                            name: typing.Union[
                                typing_extensions.Literal[
                                    "order",
                                    "pick",
                                    "active_team",
                                    "hero_id",
                                    "player_slot",
                                    "extra_time",
                                    "total_time_taken",
                                ],
                                str,
                            ],
                        ):
                            # dict_instance[name] accessor
                            return super().__getitem__(name)

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["order"]
                        ) -> typing.Union[MetaOapg.properties.order, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["pick"]
                        ) -> typing.Union[MetaOapg.properties.pick, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["active_team"]
                        ) -> typing.Union[
                            MetaOapg.properties.active_team, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["hero_id"]
                        ) -> typing.Union[MetaOapg.properties.hero_id, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["player_slot"]
                        ) -> typing.Union[
                            MetaOapg.properties.player_slot, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["extra_time"]
                        ) -> typing.Union[
                            MetaOapg.properties.extra_time, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["total_time_taken"]
                        ) -> typing.Union[
                            MetaOapg.properties.total_time_taken, 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[
                                    "order",
                                    "pick",
                                    "active_team",
                                    "hero_id",
                                    "player_slot",
                                    "extra_time",
                                    "total_time_taken",
                                ],
                                str,
                            ],
                        ):
                            return super().get_item_oapg(name)

                        def __new__(
                            cls,
                            *_args: typing.Union[
                                dict,
                                frozendict.frozendict,
                            ],
                            order: typing.Union[
                                MetaOapg.properties.order,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            pick: typing.Union[
                                MetaOapg.properties.pick, bool, schemas.Unset
                            ] = schemas.unset,
                            active_team: typing.Union[
                                MetaOapg.properties.active_team,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            hero_id: typing.Union[
                                MetaOapg.properties.hero_id,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            player_slot: typing.Union[
                                MetaOapg.properties.player_slot,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            extra_time: typing.Union[
                                MetaOapg.properties.extra_time,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            total_time_taken: typing.Union[
                                MetaOapg.properties.total_time_taken,
                                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,
                            ],
                        ) -> "items":
                            return super().__new__(
                                cls,
                                *_args,
                                order=order,
                                pick=pick,
                                active_team=active_team,
                                hero_id=hero_id,
                                player_slot=player_slot,
                                extra_time=extra_time,
                                total_time_taken=total_time_taken,
                                _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,
                ) -> "draft_timings":
                    return super().__new__(
                        cls,
                        _arg,
                        _configuration=_configuration,
                    )

                def __getitem__(self, i: int) -> MetaOapg.items:
                    return super().__getitem__(i)

            duration = schemas.IntSchema
            engine = schemas.IntSchema
            first_blood_time = schemas.IntSchema
            game_mode = schemas.IntSchema
            human_players = schemas.IntSchema
            leagueid = schemas.IntSchema
            lobby_type = schemas.IntSchema
            match_seq_num = schemas.IntSchema
            negative_votes = schemas.IntSchema
            objectives = schemas.DictSchema
            picks_bans = schemas.DictSchema
            positive_votes = schemas.IntSchema
            radiant_gold_adv = schemas.DictSchema
            radiant_score = schemas.IntSchema
            radiant_win = schemas.BoolSchema
            radiant_xp_adv = schemas.DictSchema
            start_time = schemas.IntSchema
            teamfights = schemas.DictSchema
            tower_status_dire = schemas.IntSchema
            tower_status_radiant = schemas.IntSchema
            version = schemas.IntSchema
            replay_salt = schemas.IntSchema
            series_id = schemas.IntSchema
            series_type = schemas.IntSchema
            radiant_team = schemas.DictSchema
            dire_team = schemas.DictSchema
            league = schemas.DictSchema
            skill = schemas.IntSchema

            class players(schemas.ListSchema):
                class MetaOapg:
                    class items(schemas.DictSchema):
                        class MetaOapg:
                            class properties:
                                match_id = schemas.IntSchema
                                player_slot = schemas.IntSchema

                                class ability_upgrades_arr(schemas.ListSchema):
                                    class MetaOapg:
                                        items = schemas.IntSchema

                                    def __new__(
                                        cls,
                                        _arg: typing.Union[
                                            typing.Tuple[
                                                typing.Union[
                                                    MetaOapg.items,
                                                    decimal.Decimal,
                                                    int,
                                                ]
                                            ],
                                            typing.List[
                                                typing.Union[
                                                    MetaOapg.items,
                                                    decimal.Decimal,
                                                    int,
                                                ]
                                            ],
                                        ],
                                        _configuration: typing.Optional[
                                            schemas.Configuration
                                        ] = None,
                                    ) -> "ability_upgrades_arr":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                ability_uses = schemas.DictSchema
                                ability_targets = schemas.DictSchema
                                damage_targets = schemas.DictSchema
                                account_id = schemas.IntSchema
                                actions = schemas.DictSchema
                                additional_units = schemas.DictSchema
                                assists = schemas.IntSchema
                                backpack_0 = schemas.IntSchema
                                backpack_1 = schemas.IntSchema
                                backpack_2 = schemas.IntSchema

                                class buyback_log(schemas.ListSchema):
                                    class MetaOapg:
                                        class items(schemas.DictSchema):
                                            class MetaOapg:
                                                class properties:
                                                    time = schemas.IntSchema
                                                    slot = schemas.IntSchema
                                                    player_slot = schemas.IntSchema
                                                    __annotations__ = {
                                                        "time": time,
                                                        "slot": slot,
                                                        "player_slot": player_slot,
                                                    }

                                            @typing.overload
                                            def __getitem__(
                                                self,
                                                name: typing_extensions.Literal["time"],
                                            ) -> MetaOapg.properties.time:
                                                ...

                                            @typing.overload
                                            def __getitem__(
                                                self,
                                                name: typing_extensions.Literal["slot"],
                                            ) -> MetaOapg.properties.slot:
                                                ...

                                            @typing.overload
                                            def __getitem__(
                                                self,
                                                name: typing_extensions.Literal[
                                                    "player_slot"
                                                ],
                                            ) -> MetaOapg.properties.player_slot:
                                                ...

                                            @typing.overload
                                            def __getitem__(
                                                self, name: str
                                            ) -> schemas.UnsetAnyTypeSchema:
                                                ...

                                            def __getitem__(
                                                self,
                                                name: typing.Union[
                                                    typing_extensions.Literal[
                                                        "time",
                                                        "slot",
                                                        "player_slot",
                                                    ],
                                                    str,
                                                ],
                                            ):
                                                # dict_instance[name] accessor
                                                return super().__getitem__(name)

                                            @typing.overload
                                            def get_item_oapg(
                                                self,
                                                name: typing_extensions.Literal["time"],
                                            ) -> typing.Union[
                                                MetaOapg.properties.time, schemas.Unset
                                            ]:
                                                ...

                                            @typing.overload
                                            def get_item_oapg(
                                                self,
                                                name: typing_extensions.Literal["slot"],
                                            ) -> typing.Union[
                                                MetaOapg.properties.slot, schemas.Unset
                                            ]:
                                                ...

                                            @typing.overload
                                            def get_item_oapg(
                                                self,
                                                name: typing_extensions.Literal[
                                                    "player_slot"
                                                ],
                                            ) -> typing.Union[
                                                MetaOapg.properties.player_slot,
                                                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[
                                                        "time",
                                                        "slot",
                                                        "player_slot",
                                                    ],
                                                    str,
                                                ],
                                            ):
                                                return super().get_item_oapg(name)

                                            def __new__(
                                                cls,
                                                *_args: typing.Union[
                                                    dict,
                                                    frozendict.frozendict,
                                                ],
                                                time: typing.Union[
                                                    MetaOapg.properties.time,
                                                    decimal.Decimal,
                                                    int,
                                                    schemas.Unset,
                                                ] = schemas.unset,
                                                slot: typing.Union[
                                                    MetaOapg.properties.slot,
                                                    decimal.Decimal,
                                                    int,
                                                    schemas.Unset,
                                                ] = schemas.unset,
                                                player_slot: typing.Union[
                                                    MetaOapg.properties.player_slot,
                                                    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,
                                                ],
                                            ) -> "items":
                                                return super().__new__(
                                                    cls,
                                                    *_args,
                                                    time=time,
                                                    slot=slot,
                                                    player_slot=player_slot,
                                                    _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,
                                    ) -> "buyback_log":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                camps_stacked = schemas.IntSchema

                                class connection_log(schemas.ListSchema):
                                    class MetaOapg:
                                        class items(schemas.DictSchema):
                                            class MetaOapg:
                                                class properties:
                                                    time = schemas.IntSchema
                                                    event = schemas.StrSchema
                                                    player_slot = schemas.IntSchema
                                                    __annotations__ = {
                                                        "time": time,
                                                        "event": event,
                                                        "player_slot": player_slot,
                                                    }

                                            @typing.overload
                                            def __getitem__(
                                                self,
                                                name: typing_extensions.Literal["time"],
                                            ) -> MetaOapg.properties.time:
                                                ...

                                            @typing.overload
                                            def __getitem__(
                                                self,
                                                name: typing_extensions.Literal[
                                                    "event"
                                                ],
                                            ) -> MetaOapg.properties.event:
                                                ...

                                            @typing.overload
                                            def __getitem__(
                                                self,
                                                name: typing_extensions.Literal[
                                                    "player_slot"
                                                ],
                                            ) -> MetaOapg.properties.player_slot:
                                                ...

                                            @typing.overload
                                            def __getitem__(
                                                self, name: str
                                            ) -> schemas.UnsetAnyTypeSchema:
                                                ...

                                            def __getitem__(
                                                self,
                                                name: typing.Union[
                                                    typing_extensions.Literal[
                                                        "time",
                                                        "event",
                                                        "player_slot",
                                                    ],
                                                    str,
                                                ],
                                            ):
                                                # dict_instance[name] accessor
                                                return super().__getitem__(name)

                                            @typing.overload
                                            def get_item_oapg(
                                                self,
                                                name: typing_extensions.Literal["time"],
                                            ) -> typing.Union[
                                                MetaOapg.properties.time, schemas.Unset
                                            ]:
                                                ...

                                            @typing.overload
                                            def get_item_oapg(
                                                self,
                                                name: typing_extensions.Literal[
                                                    "event"
                                                ],
                                            ) -> typing.Union[
                                                MetaOapg.properties.event, schemas.Unset
                                            ]:
                                                ...

                                            @typing.overload
                                            def get_item_oapg(
                                                self,
                                                name: typing_extensions.Literal[
                                                    "player_slot"
                                                ],
                                            ) -> typing.Union[
                                                MetaOapg.properties.player_slot,
                                                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[
                                                        "time",
                                                        "event",
                                                        "player_slot",
                                                    ],
                                                    str,
                                                ],
                                            ):
                                                return super().get_item_oapg(name)

                                            def __new__(
                                                cls,
                                                *_args: typing.Union[
                                                    dict,
                                                    frozendict.frozendict,
                                                ],
                                                time: typing.Union[
                                                    MetaOapg.properties.time,
                                                    decimal.Decimal,
                                                    int,
                                                    schemas.Unset,
                                                ] = schemas.unset,
                                                event: typing.Union[
                                                    MetaOapg.properties.event,
                                                    str,
                                                    schemas.Unset,
                                                ] = schemas.unset,
                                                player_slot: typing.Union[
                                                    MetaOapg.properties.player_slot,
                                                    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,
                                                ],
                                            ) -> "items":
                                                return super().__new__(
                                                    cls,
                                                    *_args,
                                                    time=time,
                                                    event=event,
                                                    player_slot=player_slot,
                                                    _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,
                                    ) -> "connection_log":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                creeps_stacked = schemas.IntSchema
                                damage = schemas.DictSchema
                                damage_inflictor = schemas.DictSchema
                                damage_inflictor_received = schemas.DictSchema
                                damage_taken = schemas.DictSchema
                                deaths = schemas.IntSchema
                                denies = schemas.IntSchema

                                class dn_t(schemas.ListSchema):
                                    class MetaOapg:
                                        items = schemas.IntSchema

                                    def __new__(
                                        cls,
                                        _arg: typing.Union[
                                            typing.Tuple[
                                                typing.Union[
                                                    MetaOapg.items,
                                                    decimal.Decimal,
                                                    int,
                                                ]
                                            ],
                                            typing.List[
                                                typing.Union[
                                                    MetaOapg.items,
                                                    decimal.Decimal,
                                                    int,
                                                ]
                                            ],
                                        ],
                                        _configuration: typing.Optional[
                                            schemas.Configuration
                                        ] = None,
                                    ) -> "dn_t":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                gold = schemas.IntSchema
                                gold_per_min = schemas.IntSchema
                                gold_reasons = schemas.DictSchema
                                gold_spent = schemas.IntSchema

                                class gold_t(schemas.ListSchema):
                                    class MetaOapg:
                                        items = schemas.IntSchema

                                    def __new__(
                                        cls,
                                        _arg: typing.Union[
                                            typing.Tuple[
                                                typing.Union[
                                                    MetaOapg.items,
                                                    decimal.Decimal,
                                                    int,
                                                ]
                                            ],
                                            typing.List[
                                                typing.Union[
                                                    MetaOapg.items,
                                                    decimal.Decimal,
                                                    int,
                                                ]
                                            ],
                                        ],
                                        _configuration: typing.Optional[
                                            schemas.Configuration
                                        ] = None,
                                    ) -> "gold_t":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                hero_damage = schemas.IntSchema
                                hero_healing = schemas.IntSchema
                                hero_hits = schemas.DictSchema
                                hero_id = schemas.IntSchema
                                item_0 = schemas.IntSchema
                                item_1 = schemas.IntSchema
                                item_2 = schemas.IntSchema
                                item_3 = schemas.IntSchema
                                item_4 = schemas.IntSchema
                                item_5 = schemas.IntSchema
                                item_uses = schemas.DictSchema
                                kill_streaks = schemas.DictSchema
                                killed = schemas.DictSchema
                                killed_by = schemas.DictSchema
                                kills = schemas.IntSchema

                                class kills_log(schemas.ListSchema):
                                    class MetaOapg:
                                        class items(schemas.DictSchema):
                                            class MetaOapg:
                                                class properties:
                                                    time = schemas.IntSchema
                                                    key = schemas.StrSchema
                                                    __annotations__ = {
                                                        "time": time,
                                                        "key": key,
                                                    }

                                            @typing.overload
                                            def __getitem__(
                                                self,
                                                name: typing_extensions.Literal["time"],
                                            ) -> MetaOapg.properties.time:
                                                ...

                                            @typing.overload
                                            def __getitem__(
                                                self,
                                                name: typing_extensions.Literal["key"],
                                            ) -> MetaOapg.properties.key:
                                                ...

                                            @typing.overload
                                            def __getitem__(
                                                self, name: str
                                            ) -> schemas.UnsetAnyTypeSchema:
                                                ...

                                            def __getitem__(
                                                self,
                                                name: typing.Union[
                                                    typing_extensions.Literal[
                                                        "time",
                                                        "key",
                                                    ],
                                                    str,
                                                ],
                                            ):
                                                # dict_instance[name] accessor
                                                return super().__getitem__(name)

                                            @typing.overload
                                            def get_item_oapg(
                                                self,
                                                name: typing_extensions.Literal["time"],
                                            ) -> typing.Union[
                                                MetaOapg.properties.time, schemas.Unset
                                            ]:
                                                ...

                                            @typing.overload
                                            def get_item_oapg(
                                                self,
                                                name: typing_extensions.Literal["key"],
                                            ) -> typing.Union[
                                                MetaOapg.properties.key, 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[
                                                        "time",
                                                        "key",
                                                    ],
                                                    str,
                                                ],
                                            ):
                                                return super().get_item_oapg(name)

                                            def __new__(
                                                cls,
                                                *_args: typing.Union[
                                                    dict,
                                                    frozendict.frozendict,
                                                ],
                                                time: typing.Union[
                                                    MetaOapg.properties.time,
                                                    decimal.Decimal,
                                                    int,
                                                    schemas.Unset,
                                                ] = schemas.unset,
                                                key: typing.Union[
                                                    MetaOapg.properties.key,
                                                    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,
                                                    time=time,
                                                    key=key,
                                                    _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,
                                    ) -> "kills_log":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                lane_pos = schemas.DictSchema
                                last_hits = schemas.IntSchema
                                leaver_status = schemas.IntSchema
                                level = schemas.IntSchema

                                class lh_t(schemas.ListSchema):
                                    class MetaOapg:
                                        items = schemas.IntSchema

                                    def __new__(
                                        cls,
                                        _arg: typing.Union[
                                            typing.Tuple[
                                                typing.Union[
                                                    MetaOapg.items,
                                                    decimal.Decimal,
                                                    int,
                                                ]
                                            ],
                                            typing.List[
                                                typing.Union[
                                                    MetaOapg.items,
                                                    decimal.Decimal,
                                                    int,
                                                ]
                                            ],
                                        ],
                                        _configuration: typing.Optional[
                                            schemas.Configuration
                                        ] = None,
                                    ) -> "lh_t":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                life_state = schemas.DictSchema
                                max_hero_hit = schemas.DictSchema
                                multi_kills = schemas.DictSchema
                                obs = schemas.DictSchema

                                class obs_left_log(schemas.ListSchema):
                                    class MetaOapg:
                                        items = schemas.DictSchema

                                    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,
                                    ) -> "obs_left_log":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                class obs_log(schemas.ListSchema):
                                    class MetaOapg:
                                        items = schemas.DictSchema

                                    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,
                                    ) -> "obs_log":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                obs_placed = schemas.IntSchema
                                party_id = schemas.IntSchema

                                class permanent_buffs(schemas.ListSchema):
                                    class MetaOapg:
                                        items = schemas.DictSchema

                                    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,
                                    ) -> "permanent_buffs":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                pings = schemas.IntSchema
                                purchase = schemas.DictSchema

                                class purchase_log(schemas.ListSchema):
                                    class MetaOapg:
                                        class items(schemas.DictSchema):
                                            class MetaOapg:
                                                class properties:
                                                    time = schemas.IntSchema
                                                    key = schemas.StrSchema
                                                    charges = schemas.IntSchema
                                                    __annotations__ = {
                                                        "time": time,
                                                        "key": key,
                                                        "charges": charges,
                                                    }

                                            @typing.overload
                                            def __getitem__(
                                                self,
                                                name: typing_extensions.Literal["time"],
                                            ) -> MetaOapg.properties.time:
                                                ...

                                            @typing.overload
                                            def __getitem__(
                                                self,
                                                name: typing_extensions.Literal["key"],
                                            ) -> MetaOapg.properties.key:
                                                ...

                                            @typing.overload
                                            def __getitem__(
                                                self,
                                                name: typing_extensions.Literal[
                                                    "charges"
                                                ],
                                            ) -> MetaOapg.properties.charges:
                                                ...

                                            @typing.overload
                                            def __getitem__(
                                                self, name: str
                                            ) -> schemas.UnsetAnyTypeSchema:
                                                ...

                                            def __getitem__(
                                                self,
                                                name: typing.Union[
                                                    typing_extensions.Literal[
                                                        "time",
                                                        "key",
                                                        "charges",
                                                    ],
                                                    str,
                                                ],
                                            ):
                                                # dict_instance[name] accessor
                                                return super().__getitem__(name)

                                            @typing.overload
                                            def get_item_oapg(
                                                self,
                                                name: typing_extensions.Literal["time"],
                                            ) -> typing.Union[
                                                MetaOapg.properties.time, schemas.Unset
                                            ]:
                                                ...

                                            @typing.overload
                                            def get_item_oapg(
                                                self,
                                                name: typing_extensions.Literal["key"],
                                            ) -> typing.Union[
                                                MetaOapg.properties.key, schemas.Unset
                                            ]:
                                                ...

                                            @typing.overload
                                            def get_item_oapg(
                                                self,
                                                name: typing_extensions.Literal[
                                                    "charges"
                                                ],
                                            ) -> typing.Union[
                                                MetaOapg.properties.charges,
                                                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[
                                                        "time",
                                                        "key",
                                                        "charges",
                                                    ],
                                                    str,
                                                ],
                                            ):
                                                return super().get_item_oapg(name)

                                            def __new__(
                                                cls,
                                                *_args: typing.Union[
                                                    dict,
                                                    frozendict.frozendict,
                                                ],
                                                time: typing.Union[
                                                    MetaOapg.properties.time,
                                                    decimal.Decimal,
                                                    int,
                                                    schemas.Unset,
                                                ] = schemas.unset,
                                                key: typing.Union[
                                                    MetaOapg.properties.key,
                                                    str,
                                                    schemas.Unset,
                                                ] = schemas.unset,
                                                charges: typing.Union[
                                                    MetaOapg.properties.charges,
                                                    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,
                                                ],
                                            ) -> "items":
                                                return super().__new__(
                                                    cls,
                                                    *_args,
                                                    time=time,
                                                    key=key,
                                                    charges=charges,
                                                    _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,
                                    ) -> "purchase_log":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                rune_pickups = schemas.IntSchema

                                class runes(schemas.DictSchema):
                                    class MetaOapg:
                                        additional_properties = schemas.IntSchema

                                    def __getitem__(
                                        self,
                                        name: typing.Union[
                                            str,
                                        ],
                                    ) -> MetaOapg.additional_properties:
                                        # dict_instance[name] accessor
                                        return super().__getitem__(name)

                                    def get_item_oapg(
                                        self,
                                        name: typing.Union[
                                            str,
                                        ],
                                    ) -> MetaOapg.additional_properties:
                                        return super().get_item_oapg(name)

                                    def __new__(
                                        cls,
                                        *_args: typing.Union[
                                            dict,
                                            frozendict.frozendict,
                                        ],
                                        _configuration: typing.Optional[
                                            schemas.Configuration
                                        ] = None,
                                        **kwargs: typing.Union[
                                            MetaOapg.additional_properties,
                                            decimal.Decimal,
                                            int,
                                        ],
                                    ) -> "runes":
                                        return super().__new__(
                                            cls,
                                            *_args,
                                            _configuration=_configuration,
                                            **kwargs,
                                        )

                                class runes_log(schemas.ListSchema):
                                    class MetaOapg:
                                        class items(schemas.DictSchema):
                                            class MetaOapg:
                                                class properties:
                                                    time = schemas.IntSchema
                                                    key = schemas.IntSchema
                                                    __annotations__ = {
                                                        "time": time,
                                                        "key": key,
                                                    }

                                            @typing.overload
                                            def __getitem__(
                                                self,
                                                name: typing_extensions.Literal["time"],
                                            ) -> MetaOapg.properties.time:
                                                ...

                                            @typing.overload
                                            def __getitem__(
                                                self,
                                                name: typing_extensions.Literal["key"],
                                            ) -> MetaOapg.properties.key:
                                                ...

                                            @typing.overload
                                            def __getitem__(
                                                self, name: str
                                            ) -> schemas.UnsetAnyTypeSchema:
                                                ...

                                            def __getitem__(
                                                self,
                                                name: typing.Union[
                                                    typing_extensions.Literal[
                                                        "time",
                                                        "key",
                                                    ],
                                                    str,
                                                ],
                                            ):
                                                # dict_instance[name] accessor
                                                return super().__getitem__(name)

                                            @typing.overload
                                            def get_item_oapg(
                                                self,
                                                name: typing_extensions.Literal["time"],
                                            ) -> typing.Union[
                                                MetaOapg.properties.time, schemas.Unset
                                            ]:
                                                ...

                                            @typing.overload
                                            def get_item_oapg(
                                                self,
                                                name: typing_extensions.Literal["key"],
                                            ) -> typing.Union[
                                                MetaOapg.properties.key, 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[
                                                        "time",
                                                        "key",
                                                    ],
                                                    str,
                                                ],
                                            ):
                                                return super().get_item_oapg(name)

                                            def __new__(
                                                cls,
                                                *_args: typing.Union[
                                                    dict,
                                                    frozendict.frozendict,
                                                ],
                                                time: typing.Union[
                                                    MetaOapg.properties.time,
                                                    decimal.Decimal,
                                                    int,
                                                    schemas.Unset,
                                                ] = schemas.unset,
                                                key: typing.Union[
                                                    MetaOapg.properties.key,
                                                    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,
                                                ],
                                            ) -> "items":
                                                return super().__new__(
                                                    cls,
                                                    *_args,
                                                    time=time,
                                                    key=key,
                                                    _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,
                                    ) -> "runes_log":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                sen = schemas.DictSchema

                                class sen_left_log(schemas.ListSchema):
                                    class MetaOapg:
                                        items = schemas.DictSchema

                                    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,
                                    ) -> "sen_left_log":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                class sen_log(schemas.ListSchema):
                                    class MetaOapg:
                                        items = schemas.DictSchema

                                    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,
                                    ) -> "sen_log":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                sen_placed = schemas.IntSchema
                                stuns = schemas.NumberSchema

                                class times(schemas.ListSchema):
                                    class MetaOapg:
                                        items = schemas.IntSchema

                                    def __new__(
                                        cls,
                                        _arg: typing.Union[
                                            typing.Tuple[
                                                typing.Union[
                                                    MetaOapg.items,
                                                    decimal.Decimal,
                                                    int,
                                                ]
                                            ],
                                            typing.List[
                                                typing.Union[
                                                    MetaOapg.items,
                                                    decimal.Decimal,
                                                    int,
                                                ]
                                            ],
                                        ],
                                        _configuration: typing.Optional[
                                            schemas.Configuration
                                        ] = None,
                                    ) -> "times":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                tower_damage = schemas.IntSchema
                                xp_per_min = schemas.IntSchema
                                xp_reasons = schemas.DictSchema

                                class xp_t(schemas.ListSchema):
                                    class MetaOapg:
                                        items = schemas.IntSchema

                                    def __new__(
                                        cls,
                                        _arg: typing.Union[
                                            typing.Tuple[
                                                typing.Union[
                                                    MetaOapg.items,
                                                    decimal.Decimal,
                                                    int,
                                                ]
                                            ],
                                            typing.List[
                                                typing.Union[
                                                    MetaOapg.items,
                                                    decimal.Decimal,
                                                    int,
                                                ]
                                            ],
                                        ],
                                        _configuration: typing.Optional[
                                            schemas.Configuration
                                        ] = None,
                                    ) -> "xp_t":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                personaname = schemas.StrSchema
                                name = schemas.StrSchema
                                last_login = schemas.DateTimeSchema
                                radiant_win = schemas.BoolSchema
                                start_time = schemas.IntSchema
                                duration = schemas.IntSchema
                                cluster = schemas.IntSchema
                                lobby_type = schemas.IntSchema
                                game_mode = schemas.IntSchema
                                patch = schemas.IntSchema
                                region = schemas.IntSchema
                                isRadiant = schemas.BoolSchema
                                win = schemas.IntSchema
                                lose = schemas.IntSchema
                                total_gold = schemas.IntSchema
                                total_xp = schemas.IntSchema
                                kills_per_min = schemas.NumberSchema
                                kda = schemas.NumberSchema
                                abandons = schemas.IntSchema
                                neutral_kills = schemas.IntSchema
                                tower_kills = schemas.IntSchema
                                courier_kills = schemas.IntSchema
                                lane_kills = schemas.IntSchema
                                hero_kills = schemas.IntSchema
                                observer_kills = schemas.IntSchema
                                sentry_kills = schemas.IntSchema
                                roshan_kills = schemas.IntSchema
                                necronomicon_kills = schemas.IntSchema
                                ancient_kills = schemas.IntSchema
                                buyback_count = schemas.IntSchema
                                observer_uses = schemas.IntSchema
                                sentry_uses = schemas.IntSchema
                                lane_efficiency = schemas.NumberSchema
                                lane_efficiency_pct = schemas.NumberSchema
                                lane = schemas.IntSchema
                                lane_role = schemas.IntSchema
                                is_roaming = schemas.BoolSchema
                                purchase_time = schemas.DictSchema
                                first_purchase_time = schemas.DictSchema
                                item_win = schemas.DictSchema
                                item_usage = schemas.DictSchema
                                purchase_tpscroll = schemas.DictSchema
                                actions_per_min = schemas.IntSchema
                                life_state_dead = schemas.IntSchema
                                rank_tier = schemas.IntSchema

                                class cosmetics(schemas.ListSchema):
                                    class MetaOapg:
                                        items = schemas.IntSchema

                                    def __new__(
                                        cls,
                                        _arg: typing.Union[
                                            typing.Tuple[
                                                typing.Union[
                                                    MetaOapg.items,
                                                    decimal.Decimal,
                                                    int,
                                                ]
                                            ],
                                            typing.List[
                                                typing.Union[
                                                    MetaOapg.items,
                                                    decimal.Decimal,
                                                    int,
                                                ]
                                            ],
                                        ],
                                        _configuration: typing.Optional[
                                            schemas.Configuration
                                        ] = None,
                                    ) -> "cosmetics":
                                        return super().__new__(
                                            cls,
                                            _arg,
                                            _configuration=_configuration,
                                        )

                                    def __getitem__(self, i: int) -> MetaOapg.items:
                                        return super().__getitem__(i)

                                benchmarks = schemas.DictSchema
                                __annotations__ = {
                                    "match_id": match_id,
                                    "player_slot": player_slot,
                                    "ability_upgrades_arr": ability_upgrades_arr,
                                    "ability_uses": ability_uses,
                                    "ability_targets": ability_targets,
                                    "damage_targets": damage_targets,
                                    "account_id": account_id,
                                    "actions": actions,
                                    "additional_units": additional_units,
                                    "assists": assists,
                                    "backpack_0": backpack_0,
                                    "backpack_1": backpack_1,
                                    "backpack_2": backpack_2,
                                    "buyback_log": buyback_log,
                                    "camps_stacked": camps_stacked,
                                    "connection_log": connection_log,
                                    "creeps_stacked": creeps_stacked,
                                    "damage": damage,
                                    "damage_inflictor": damage_inflictor,
                                    "damage_inflictor_received": damage_inflictor_received,
                                    "damage_taken": damage_taken,
                                    "deaths": deaths,
                                    "denies": denies,
                                    "dn_t": dn_t,
                                    "gold": gold,
                                    "gold_per_min": gold_per_min,
                                    "gold_reasons": gold_reasons,
                                    "gold_spent": gold_spent,
                                    "gold_t": gold_t,
                                    "hero_damage": hero_damage,
                                    "hero_healing": hero_healing,
                                    "hero_hits": hero_hits,
                                    "hero_id": hero_id,
                                    "item_0": item_0,
                                    "item_1": item_1,
                                    "item_2": item_2,
                                    "item_3": item_3,
                                    "item_4": item_4,
                                    "item_5": item_5,
                                    "item_uses": item_uses,
                                    "kill_streaks": kill_streaks,
                                    "killed": killed,
                                    "killed_by": killed_by,
                                    "kills": kills,
                                    "kills_log": kills_log,
                                    "lane_pos": lane_pos,
                                    "last_hits": last_hits,
                                    "leaver_status": leaver_status,
                                    "level": level,
                                    "lh_t": lh_t,
                                    "life_state": life_state,
                                    "max_hero_hit": max_hero_hit,
                                    "multi_kills": multi_kills,
                                    "obs": obs,
                                    "obs_left_log": obs_left_log,
                                    "obs_log": obs_log,
                                    "obs_placed": obs_placed,
                                    "party_id": party_id,
                                    "permanent_buffs": permanent_buffs,
                                    "pings": pings,
                                    "purchase": purchase,
                                    "purchase_log": purchase_log,
                                    "rune_pickups": rune_pickups,
                                    "runes": runes,
                                    "runes_log": runes_log,
                                    "sen": sen,
                                    "sen_left_log": sen_left_log,
                                    "sen_log": sen_log,
                                    "sen_placed": sen_placed,
                                    "stuns": stuns,
                                    "times": times,
                                    "tower_damage": tower_damage,
                                    "xp_per_min": xp_per_min,
                                    "xp_reasons": xp_reasons,
                                    "xp_t": xp_t,
                                    "personaname": personaname,
                                    "name": name,
                                    "last_login": last_login,
                                    "radiant_win": radiant_win,
                                    "start_time": start_time,
                                    "duration": duration,
                                    "cluster": cluster,
                                    "lobby_type": lobby_type,
                                    "game_mode": game_mode,
                                    "patch": patch,
                                    "region": region,
                                    "isRadiant": isRadiant,
                                    "win": win,
                                    "lose": lose,
                                    "total_gold": total_gold,
                                    "total_xp": total_xp,
                                    "kills_per_min": kills_per_min,
                                    "kda": kda,
                                    "abandons": abandons,
                                    "neutral_kills": neutral_kills,
                                    "tower_kills": tower_kills,
                                    "courier_kills": courier_kills,
                                    "lane_kills": lane_kills,
                                    "hero_kills": hero_kills,
                                    "observer_kills": observer_kills,
                                    "sentry_kills": sentry_kills,
                                    "roshan_kills": roshan_kills,
                                    "necronomicon_kills": necronomicon_kills,
                                    "ancient_kills": ancient_kills,
                                    "buyback_count": buyback_count,
                                    "observer_uses": observer_uses,
                                    "sentry_uses": sentry_uses,
                                    "lane_efficiency": lane_efficiency,
                                    "lane_efficiency_pct": lane_efficiency_pct,
                                    "lane": lane,
                                    "lane_role": lane_role,
                                    "is_roaming": is_roaming,
                                    "purchase_time": purchase_time,
                                    "first_purchase_time": first_purchase_time,
                                    "item_win": item_win,
                                    "item_usage": item_usage,
                                    "purchase_tpscroll": purchase_tpscroll,
                                    "actions_per_min": actions_per_min,
                                    "life_state_dead": life_state_dead,
                                    "rank_tier": rank_tier,
                                    "cosmetics": cosmetics,
                                    "benchmarks": benchmarks,
                                }

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["match_id"]
                        ) -> MetaOapg.properties.match_id:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["player_slot"]
                        ) -> MetaOapg.properties.player_slot:
                            ...

                        @typing.overload
                        def __getitem__(
                            self,
                            name: typing_extensions.Literal["ability_upgrades_arr"],
                        ) -> MetaOapg.properties.ability_upgrades_arr:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["ability_uses"]
                        ) -> MetaOapg.properties.ability_uses:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["ability_targets"]
                        ) -> MetaOapg.properties.ability_targets:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["damage_targets"]
                        ) -> MetaOapg.properties.damage_targets:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["account_id"]
                        ) -> MetaOapg.properties.account_id:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["actions"]
                        ) -> MetaOapg.properties.actions:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["additional_units"]
                        ) -> MetaOapg.properties.additional_units:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["assists"]
                        ) -> MetaOapg.properties.assists:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["backpack_0"]
                        ) -> MetaOapg.properties.backpack_0:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["backpack_1"]
                        ) -> MetaOapg.properties.backpack_1:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["backpack_2"]
                        ) -> MetaOapg.properties.backpack_2:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["buyback_log"]
                        ) -> MetaOapg.properties.buyback_log:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["camps_stacked"]
                        ) -> MetaOapg.properties.camps_stacked:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["connection_log"]
                        ) -> MetaOapg.properties.connection_log:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["creeps_stacked"]
                        ) -> MetaOapg.properties.creeps_stacked:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["damage"]
                        ) -> MetaOapg.properties.damage:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["damage_inflictor"]
                        ) -> MetaOapg.properties.damage_inflictor:
                            ...

                        @typing.overload
                        def __getitem__(
                            self,
                            name: typing_extensions.Literal[
                                "damage_inflictor_received"
                            ],
                        ) -> MetaOapg.properties.damage_inflictor_received:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["damage_taken"]
                        ) -> MetaOapg.properties.damage_taken:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["deaths"]
                        ) -> MetaOapg.properties.deaths:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["denies"]
                        ) -> MetaOapg.properties.denies:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["dn_t"]
                        ) -> MetaOapg.properties.dn_t:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["gold"]
                        ) -> MetaOapg.properties.gold:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["gold_per_min"]
                        ) -> MetaOapg.properties.gold_per_min:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["gold_reasons"]
                        ) -> MetaOapg.properties.gold_reasons:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["gold_spent"]
                        ) -> MetaOapg.properties.gold_spent:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["gold_t"]
                        ) -> MetaOapg.properties.gold_t:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["hero_damage"]
                        ) -> MetaOapg.properties.hero_damage:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["hero_healing"]
                        ) -> MetaOapg.properties.hero_healing:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["hero_hits"]
                        ) -> MetaOapg.properties.hero_hits:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["hero_id"]
                        ) -> MetaOapg.properties.hero_id:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["item_0"]
                        ) -> MetaOapg.properties.item_0:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["item_1"]
                        ) -> MetaOapg.properties.item_1:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["item_2"]
                        ) -> MetaOapg.properties.item_2:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["item_3"]
                        ) -> MetaOapg.properties.item_3:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["item_4"]
                        ) -> MetaOapg.properties.item_4:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["item_5"]
                        ) -> MetaOapg.properties.item_5:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["item_uses"]
                        ) -> MetaOapg.properties.item_uses:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["kill_streaks"]
                        ) -> MetaOapg.properties.kill_streaks:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["killed"]
                        ) -> MetaOapg.properties.killed:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["killed_by"]
                        ) -> MetaOapg.properties.killed_by:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["kills"]
                        ) -> MetaOapg.properties.kills:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["kills_log"]
                        ) -> MetaOapg.properties.kills_log:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["lane_pos"]
                        ) -> MetaOapg.properties.lane_pos:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["last_hits"]
                        ) -> MetaOapg.properties.last_hits:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["leaver_status"]
                        ) -> MetaOapg.properties.leaver_status:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["level"]
                        ) -> MetaOapg.properties.level:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["lh_t"]
                        ) -> MetaOapg.properties.lh_t:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["life_state"]
                        ) -> MetaOapg.properties.life_state:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["max_hero_hit"]
                        ) -> MetaOapg.properties.max_hero_hit:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["multi_kills"]
                        ) -> MetaOapg.properties.multi_kills:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["obs"]
                        ) -> MetaOapg.properties.obs:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["obs_left_log"]
                        ) -> MetaOapg.properties.obs_left_log:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["obs_log"]
                        ) -> MetaOapg.properties.obs_log:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["obs_placed"]
                        ) -> MetaOapg.properties.obs_placed:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["party_id"]
                        ) -> MetaOapg.properties.party_id:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["permanent_buffs"]
                        ) -> MetaOapg.properties.permanent_buffs:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["pings"]
                        ) -> MetaOapg.properties.pings:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["purchase"]
                        ) -> MetaOapg.properties.purchase:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["purchase_log"]
                        ) -> MetaOapg.properties.purchase_log:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["rune_pickups"]
                        ) -> MetaOapg.properties.rune_pickups:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["runes"]
                        ) -> MetaOapg.properties.runes:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["runes_log"]
                        ) -> MetaOapg.properties.runes_log:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["sen"]
                        ) -> MetaOapg.properties.sen:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["sen_left_log"]
                        ) -> MetaOapg.properties.sen_left_log:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["sen_log"]
                        ) -> MetaOapg.properties.sen_log:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["sen_placed"]
                        ) -> MetaOapg.properties.sen_placed:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["stuns"]
                        ) -> MetaOapg.properties.stuns:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["times"]
                        ) -> MetaOapg.properties.times:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["tower_damage"]
                        ) -> MetaOapg.properties.tower_damage:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["xp_per_min"]
                        ) -> MetaOapg.properties.xp_per_min:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["xp_reasons"]
                        ) -> MetaOapg.properties.xp_reasons:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["xp_t"]
                        ) -> MetaOapg.properties.xp_t:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["personaname"]
                        ) -> MetaOapg.properties.personaname:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["name"]
                        ) -> MetaOapg.properties.name:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["last_login"]
                        ) -> MetaOapg.properties.last_login:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["radiant_win"]
                        ) -> MetaOapg.properties.radiant_win:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["start_time"]
                        ) -> MetaOapg.properties.start_time:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["duration"]
                        ) -> MetaOapg.properties.duration:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["cluster"]
                        ) -> MetaOapg.properties.cluster:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["lobby_type"]
                        ) -> MetaOapg.properties.lobby_type:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["game_mode"]
                        ) -> MetaOapg.properties.game_mode:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["patch"]
                        ) -> MetaOapg.properties.patch:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["region"]
                        ) -> MetaOapg.properties.region:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["isRadiant"]
                        ) -> MetaOapg.properties.isRadiant:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["win"]
                        ) -> MetaOapg.properties.win:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["lose"]
                        ) -> MetaOapg.properties.lose:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["total_gold"]
                        ) -> MetaOapg.properties.total_gold:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["total_xp"]
                        ) -> MetaOapg.properties.total_xp:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["kills_per_min"]
                        ) -> MetaOapg.properties.kills_per_min:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["kda"]
                        ) -> MetaOapg.properties.kda:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["abandons"]
                        ) -> MetaOapg.properties.abandons:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["neutral_kills"]
                        ) -> MetaOapg.properties.neutral_kills:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["tower_kills"]
                        ) -> MetaOapg.properties.tower_kills:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["courier_kills"]
                        ) -> MetaOapg.properties.courier_kills:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["lane_kills"]
                        ) -> MetaOapg.properties.lane_kills:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["hero_kills"]
                        ) -> MetaOapg.properties.hero_kills:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["observer_kills"]
                        ) -> MetaOapg.properties.observer_kills:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["sentry_kills"]
                        ) -> MetaOapg.properties.sentry_kills:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["roshan_kills"]
                        ) -> MetaOapg.properties.roshan_kills:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["necronomicon_kills"]
                        ) -> MetaOapg.properties.necronomicon_kills:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["ancient_kills"]
                        ) -> MetaOapg.properties.ancient_kills:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["buyback_count"]
                        ) -> MetaOapg.properties.buyback_count:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["observer_uses"]
                        ) -> MetaOapg.properties.observer_uses:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["sentry_uses"]
                        ) -> MetaOapg.properties.sentry_uses:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["lane_efficiency"]
                        ) -> MetaOapg.properties.lane_efficiency:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["lane_efficiency_pct"]
                        ) -> MetaOapg.properties.lane_efficiency_pct:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["lane"]
                        ) -> MetaOapg.properties.lane:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["lane_role"]
                        ) -> MetaOapg.properties.lane_role:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["is_roaming"]
                        ) -> MetaOapg.properties.is_roaming:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["purchase_time"]
                        ) -> MetaOapg.properties.purchase_time:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["first_purchase_time"]
                        ) -> MetaOapg.properties.first_purchase_time:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["item_win"]
                        ) -> MetaOapg.properties.item_win:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["item_usage"]
                        ) -> MetaOapg.properties.item_usage:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["purchase_tpscroll"]
                        ) -> MetaOapg.properties.purchase_tpscroll:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["actions_per_min"]
                        ) -> MetaOapg.properties.actions_per_min:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["life_state_dead"]
                        ) -> MetaOapg.properties.life_state_dead:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["rank_tier"]
                        ) -> MetaOapg.properties.rank_tier:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["cosmetics"]
                        ) -> MetaOapg.properties.cosmetics:
                            ...

                        @typing.overload
                        def __getitem__(
                            self, name: typing_extensions.Literal["benchmarks"]
                        ) -> MetaOapg.properties.benchmarks:
                            ...

                        @typing.overload
                        def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema:
                            ...

                        def __getitem__(
                            self,
                            name: typing.Union[
                                typing_extensions.Literal[
                                    "match_id",
                                    "player_slot",
                                    "ability_upgrades_arr",
                                    "ability_uses",
                                    "ability_targets",
                                    "damage_targets",
                                    "account_id",
                                    "actions",
                                    "additional_units",
                                    "assists",
                                    "backpack_0",
                                    "backpack_1",
                                    "backpack_2",
                                    "buyback_log",
                                    "camps_stacked",
                                    "connection_log",
                                    "creeps_stacked",
                                    "damage",
                                    "damage_inflictor",
                                    "damage_inflictor_received",
                                    "damage_taken",
                                    "deaths",
                                    "denies",
                                    "dn_t",
                                    "gold",
                                    "gold_per_min",
                                    "gold_reasons",
                                    "gold_spent",
                                    "gold_t",
                                    "hero_damage",
                                    "hero_healing",
                                    "hero_hits",
                                    "hero_id",
                                    "item_0",
                                    "item_1",
                                    "item_2",
                                    "item_3",
                                    "item_4",
                                    "item_5",
                                    "item_uses",
                                    "kill_streaks",
                                    "killed",
                                    "killed_by",
                                    "kills",
                                    "kills_log",
                                    "lane_pos",
                                    "last_hits",
                                    "leaver_status",
                                    "level",
                                    "lh_t",
                                    "life_state",
                                    "max_hero_hit",
                                    "multi_kills",
                                    "obs",
                                    "obs_left_log",
                                    "obs_log",
                                    "obs_placed",
                                    "party_id",
                                    "permanent_buffs",
                                    "pings",
                                    "purchase",
                                    "purchase_log",
                                    "rune_pickups",
                                    "runes",
                                    "runes_log",
                                    "sen",
                                    "sen_left_log",
                                    "sen_log",
                                    "sen_placed",
                                    "stuns",
                                    "times",
                                    "tower_damage",
                                    "xp_per_min",
                                    "xp_reasons",
                                    "xp_t",
                                    "personaname",
                                    "name",
                                    "last_login",
                                    "radiant_win",
                                    "start_time",
                                    "duration",
                                    "cluster",
                                    "lobby_type",
                                    "game_mode",
                                    "patch",
                                    "region",
                                    "isRadiant",
                                    "win",
                                    "lose",
                                    "total_gold",
                                    "total_xp",
                                    "kills_per_min",
                                    "kda",
                                    "abandons",
                                    "neutral_kills",
                                    "tower_kills",
                                    "courier_kills",
                                    "lane_kills",
                                    "hero_kills",
                                    "observer_kills",
                                    "sentry_kills",
                                    "roshan_kills",
                                    "necronomicon_kills",
                                    "ancient_kills",
                                    "buyback_count",
                                    "observer_uses",
                                    "sentry_uses",
                                    "lane_efficiency",
                                    "lane_efficiency_pct",
                                    "lane",
                                    "lane_role",
                                    "is_roaming",
                                    "purchase_time",
                                    "first_purchase_time",
                                    "item_win",
                                    "item_usage",
                                    "purchase_tpscroll",
                                    "actions_per_min",
                                    "life_state_dead",
                                    "rank_tier",
                                    "cosmetics",
                                    "benchmarks",
                                ],
                                str,
                            ],
                        ):
                            # dict_instance[name] accessor
                            return super().__getitem__(name)

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["match_id"]
                        ) -> typing.Union[MetaOapg.properties.match_id, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["player_slot"]
                        ) -> typing.Union[
                            MetaOapg.properties.player_slot, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self,
                            name: typing_extensions.Literal["ability_upgrades_arr"],
                        ) -> typing.Union[
                            MetaOapg.properties.ability_upgrades_arr, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["ability_uses"]
                        ) -> typing.Union[
                            MetaOapg.properties.ability_uses, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["ability_targets"]
                        ) -> typing.Union[
                            MetaOapg.properties.ability_targets, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["damage_targets"]
                        ) -> typing.Union[
                            MetaOapg.properties.damage_targets, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["account_id"]
                        ) -> typing.Union[
                            MetaOapg.properties.account_id, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["actions"]
                        ) -> typing.Union[MetaOapg.properties.actions, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["additional_units"]
                        ) -> typing.Union[
                            MetaOapg.properties.additional_units, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["assists"]
                        ) -> typing.Union[MetaOapg.properties.assists, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["backpack_0"]
                        ) -> typing.Union[
                            MetaOapg.properties.backpack_0, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["backpack_1"]
                        ) -> typing.Union[
                            MetaOapg.properties.backpack_1, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["backpack_2"]
                        ) -> typing.Union[
                            MetaOapg.properties.backpack_2, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["buyback_log"]
                        ) -> typing.Union[
                            MetaOapg.properties.buyback_log, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["camps_stacked"]
                        ) -> typing.Union[
                            MetaOapg.properties.camps_stacked, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["connection_log"]
                        ) -> typing.Union[
                            MetaOapg.properties.connection_log, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["creeps_stacked"]
                        ) -> typing.Union[
                            MetaOapg.properties.creeps_stacked, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["damage"]
                        ) -> typing.Union[MetaOapg.properties.damage, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["damage_inflictor"]
                        ) -> typing.Union[
                            MetaOapg.properties.damage_inflictor, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self,
                            name: typing_extensions.Literal[
                                "damage_inflictor_received"
                            ],
                        ) -> typing.Union[
                            MetaOapg.properties.damage_inflictor_received, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["damage_taken"]
                        ) -> typing.Union[
                            MetaOapg.properties.damage_taken, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["deaths"]
                        ) -> typing.Union[MetaOapg.properties.deaths, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["denies"]
                        ) -> typing.Union[MetaOapg.properties.denies, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["dn_t"]
                        ) -> typing.Union[MetaOapg.properties.dn_t, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["gold"]
                        ) -> typing.Union[MetaOapg.properties.gold, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["gold_per_min"]
                        ) -> typing.Union[
                            MetaOapg.properties.gold_per_min, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["gold_reasons"]
                        ) -> typing.Union[
                            MetaOapg.properties.gold_reasons, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["gold_spent"]
                        ) -> typing.Union[
                            MetaOapg.properties.gold_spent, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["gold_t"]
                        ) -> typing.Union[MetaOapg.properties.gold_t, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["hero_damage"]
                        ) -> typing.Union[
                            MetaOapg.properties.hero_damage, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["hero_healing"]
                        ) -> typing.Union[
                            MetaOapg.properties.hero_healing, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["hero_hits"]
                        ) -> typing.Union[MetaOapg.properties.hero_hits, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["hero_id"]
                        ) -> typing.Union[MetaOapg.properties.hero_id, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["item_0"]
                        ) -> typing.Union[MetaOapg.properties.item_0, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["item_1"]
                        ) -> typing.Union[MetaOapg.properties.item_1, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["item_2"]
                        ) -> typing.Union[MetaOapg.properties.item_2, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["item_3"]
                        ) -> typing.Union[MetaOapg.properties.item_3, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["item_4"]
                        ) -> typing.Union[MetaOapg.properties.item_4, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["item_5"]
                        ) -> typing.Union[MetaOapg.properties.item_5, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["item_uses"]
                        ) -> typing.Union[MetaOapg.properties.item_uses, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["kill_streaks"]
                        ) -> typing.Union[
                            MetaOapg.properties.kill_streaks, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["killed"]
                        ) -> typing.Union[MetaOapg.properties.killed, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["killed_by"]
                        ) -> typing.Union[MetaOapg.properties.killed_by, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["kills"]
                        ) -> typing.Union[MetaOapg.properties.kills, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["kills_log"]
                        ) -> typing.Union[MetaOapg.properties.kills_log, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["lane_pos"]
                        ) -> typing.Union[MetaOapg.properties.lane_pos, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["last_hits"]
                        ) -> typing.Union[MetaOapg.properties.last_hits, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["leaver_status"]
                        ) -> typing.Union[
                            MetaOapg.properties.leaver_status, 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["lh_t"]
                        ) -> typing.Union[MetaOapg.properties.lh_t, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["life_state"]
                        ) -> typing.Union[
                            MetaOapg.properties.life_state, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["max_hero_hit"]
                        ) -> typing.Union[
                            MetaOapg.properties.max_hero_hit, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["multi_kills"]
                        ) -> typing.Union[
                            MetaOapg.properties.multi_kills, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["obs"]
                        ) -> typing.Union[MetaOapg.properties.obs, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["obs_left_log"]
                        ) -> typing.Union[
                            MetaOapg.properties.obs_left_log, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["obs_log"]
                        ) -> typing.Union[MetaOapg.properties.obs_log, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["obs_placed"]
                        ) -> typing.Union[
                            MetaOapg.properties.obs_placed, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["party_id"]
                        ) -> typing.Union[MetaOapg.properties.party_id, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["permanent_buffs"]
                        ) -> typing.Union[
                            MetaOapg.properties.permanent_buffs, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["pings"]
                        ) -> typing.Union[MetaOapg.properties.pings, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["purchase"]
                        ) -> typing.Union[MetaOapg.properties.purchase, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["purchase_log"]
                        ) -> typing.Union[
                            MetaOapg.properties.purchase_log, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["rune_pickups"]
                        ) -> typing.Union[
                            MetaOapg.properties.rune_pickups, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["runes"]
                        ) -> typing.Union[MetaOapg.properties.runes, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["runes_log"]
                        ) -> typing.Union[MetaOapg.properties.runes_log, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["sen"]
                        ) -> typing.Union[MetaOapg.properties.sen, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["sen_left_log"]
                        ) -> typing.Union[
                            MetaOapg.properties.sen_left_log, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["sen_log"]
                        ) -> typing.Union[MetaOapg.properties.sen_log, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["sen_placed"]
                        ) -> typing.Union[
                            MetaOapg.properties.sen_placed, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["stuns"]
                        ) -> typing.Union[MetaOapg.properties.stuns, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["times"]
                        ) -> typing.Union[MetaOapg.properties.times, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["tower_damage"]
                        ) -> typing.Union[
                            MetaOapg.properties.tower_damage, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["xp_per_min"]
                        ) -> typing.Union[
                            MetaOapg.properties.xp_per_min, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["xp_reasons"]
                        ) -> typing.Union[
                            MetaOapg.properties.xp_reasons, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["xp_t"]
                        ) -> typing.Union[MetaOapg.properties.xp_t, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["personaname"]
                        ) -> typing.Union[
                            MetaOapg.properties.personaname, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["name"]
                        ) -> typing.Union[MetaOapg.properties.name, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["last_login"]
                        ) -> typing.Union[
                            MetaOapg.properties.last_login, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["radiant_win"]
                        ) -> typing.Union[
                            MetaOapg.properties.radiant_win, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["start_time"]
                        ) -> typing.Union[
                            MetaOapg.properties.start_time, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["duration"]
                        ) -> typing.Union[MetaOapg.properties.duration, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["cluster"]
                        ) -> typing.Union[MetaOapg.properties.cluster, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["lobby_type"]
                        ) -> typing.Union[
                            MetaOapg.properties.lobby_type, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["game_mode"]
                        ) -> typing.Union[MetaOapg.properties.game_mode, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["patch"]
                        ) -> typing.Union[MetaOapg.properties.patch, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["region"]
                        ) -> typing.Union[MetaOapg.properties.region, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["isRadiant"]
                        ) -> typing.Union[MetaOapg.properties.isRadiant, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["win"]
                        ) -> typing.Union[MetaOapg.properties.win, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["lose"]
                        ) -> typing.Union[MetaOapg.properties.lose, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["total_gold"]
                        ) -> typing.Union[
                            MetaOapg.properties.total_gold, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["total_xp"]
                        ) -> typing.Union[MetaOapg.properties.total_xp, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["kills_per_min"]
                        ) -> typing.Union[
                            MetaOapg.properties.kills_per_min, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["kda"]
                        ) -> typing.Union[MetaOapg.properties.kda, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["abandons"]
                        ) -> typing.Union[MetaOapg.properties.abandons, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["neutral_kills"]
                        ) -> typing.Union[
                            MetaOapg.properties.neutral_kills, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["tower_kills"]
                        ) -> typing.Union[
                            MetaOapg.properties.tower_kills, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["courier_kills"]
                        ) -> typing.Union[
                            MetaOapg.properties.courier_kills, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["lane_kills"]
                        ) -> typing.Union[
                            MetaOapg.properties.lane_kills, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["hero_kills"]
                        ) -> typing.Union[
                            MetaOapg.properties.hero_kills, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["observer_kills"]
                        ) -> typing.Union[
                            MetaOapg.properties.observer_kills, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["sentry_kills"]
                        ) -> typing.Union[
                            MetaOapg.properties.sentry_kills, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["roshan_kills"]
                        ) -> typing.Union[
                            MetaOapg.properties.roshan_kills, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["necronomicon_kills"]
                        ) -> typing.Union[
                            MetaOapg.properties.necronomicon_kills, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["ancient_kills"]
                        ) -> typing.Union[
                            MetaOapg.properties.ancient_kills, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["buyback_count"]
                        ) -> typing.Union[
                            MetaOapg.properties.buyback_count, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["observer_uses"]
                        ) -> typing.Union[
                            MetaOapg.properties.observer_uses, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["sentry_uses"]
                        ) -> typing.Union[
                            MetaOapg.properties.sentry_uses, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["lane_efficiency"]
                        ) -> typing.Union[
                            MetaOapg.properties.lane_efficiency, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["lane_efficiency_pct"]
                        ) -> typing.Union[
                            MetaOapg.properties.lane_efficiency_pct, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["lane"]
                        ) -> typing.Union[MetaOapg.properties.lane, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["lane_role"]
                        ) -> typing.Union[MetaOapg.properties.lane_role, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["is_roaming"]
                        ) -> typing.Union[
                            MetaOapg.properties.is_roaming, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["purchase_time"]
                        ) -> typing.Union[
                            MetaOapg.properties.purchase_time, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["first_purchase_time"]
                        ) -> typing.Union[
                            MetaOapg.properties.first_purchase_time, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["item_win"]
                        ) -> typing.Union[MetaOapg.properties.item_win, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["item_usage"]
                        ) -> typing.Union[
                            MetaOapg.properties.item_usage, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["purchase_tpscroll"]
                        ) -> typing.Union[
                            MetaOapg.properties.purchase_tpscroll, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["actions_per_min"]
                        ) -> typing.Union[
                            MetaOapg.properties.actions_per_min, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["life_state_dead"]
                        ) -> typing.Union[
                            MetaOapg.properties.life_state_dead, schemas.Unset
                        ]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["rank_tier"]
                        ) -> typing.Union[MetaOapg.properties.rank_tier, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["cosmetics"]
                        ) -> typing.Union[MetaOapg.properties.cosmetics, schemas.Unset]:
                            ...

                        @typing.overload
                        def get_item_oapg(
                            self, name: typing_extensions.Literal["benchmarks"]
                        ) -> typing.Union[
                            MetaOapg.properties.benchmarks, 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[
                                    "match_id",
                                    "player_slot",
                                    "ability_upgrades_arr",
                                    "ability_uses",
                                    "ability_targets",
                                    "damage_targets",
                                    "account_id",
                                    "actions",
                                    "additional_units",
                                    "assists",
                                    "backpack_0",
                                    "backpack_1",
                                    "backpack_2",
                                    "buyback_log",
                                    "camps_stacked",
                                    "connection_log",
                                    "creeps_stacked",
                                    "damage",
                                    "damage_inflictor",
                                    "damage_inflictor_received",
                                    "damage_taken",
                                    "deaths",
                                    "denies",
                                    "dn_t",
                                    "gold",
                                    "gold_per_min",
                                    "gold_reasons",
                                    "gold_spent",
                                    "gold_t",
                                    "hero_damage",
                                    "hero_healing",
                                    "hero_hits",
                                    "hero_id",
                                    "item_0",
                                    "item_1",
                                    "item_2",
                                    "item_3",
                                    "item_4",
                                    "item_5",
                                    "item_uses",
                                    "kill_streaks",
                                    "killed",
                                    "killed_by",
                                    "kills",
                                    "kills_log",
                                    "lane_pos",
                                    "last_hits",
                                    "leaver_status",
                                    "level",
                                    "lh_t",
                                    "life_state",
                                    "max_hero_hit",
                                    "multi_kills",
                                    "obs",
                                    "obs_left_log",
                                    "obs_log",
                                    "obs_placed",
                                    "party_id",
                                    "permanent_buffs",
                                    "pings",
                                    "purchase",
                                    "purchase_log",
                                    "rune_pickups",
                                    "runes",
                                    "runes_log",
                                    "sen",
                                    "sen_left_log",
                                    "sen_log",
                                    "sen_placed",
                                    "stuns",
                                    "times",
                                    "tower_damage",
                                    "xp_per_min",
                                    "xp_reasons",
                                    "xp_t",
                                    "personaname",
                                    "name",
                                    "last_login",
                                    "radiant_win",
                                    "start_time",
                                    "duration",
                                    "cluster",
                                    "lobby_type",
                                    "game_mode",
                                    "patch",
                                    "region",
                                    "isRadiant",
                                    "win",
                                    "lose",
                                    "total_gold",
                                    "total_xp",
                                    "kills_per_min",
                                    "kda",
                                    "abandons",
                                    "neutral_kills",
                                    "tower_kills",
                                    "courier_kills",
                                    "lane_kills",
                                    "hero_kills",
                                    "observer_kills",
                                    "sentry_kills",
                                    "roshan_kills",
                                    "necronomicon_kills",
                                    "ancient_kills",
                                    "buyback_count",
                                    "observer_uses",
                                    "sentry_uses",
                                    "lane_efficiency",
                                    "lane_efficiency_pct",
                                    "lane",
                                    "lane_role",
                                    "is_roaming",
                                    "purchase_time",
                                    "first_purchase_time",
                                    "item_win",
                                    "item_usage",
                                    "purchase_tpscroll",
                                    "actions_per_min",
                                    "life_state_dead",
                                    "rank_tier",
                                    "cosmetics",
                                    "benchmarks",
                                ],
                                str,
                            ],
                        ):
                            return super().get_item_oapg(name)

                        def __new__(
                            cls,
                            *_args: typing.Union[
                                dict,
                                frozendict.frozendict,
                            ],
                            match_id: typing.Union[
                                MetaOapg.properties.match_id,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            player_slot: typing.Union[
                                MetaOapg.properties.player_slot,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            ability_upgrades_arr: typing.Union[
                                MetaOapg.properties.ability_upgrades_arr,
                                list,
                                tuple,
                                schemas.Unset,
                            ] = schemas.unset,
                            ability_uses: typing.Union[
                                MetaOapg.properties.ability_uses,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            ability_targets: typing.Union[
                                MetaOapg.properties.ability_targets,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            damage_targets: typing.Union[
                                MetaOapg.properties.damage_targets,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            account_id: typing.Union[
                                MetaOapg.properties.account_id,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            actions: typing.Union[
                                MetaOapg.properties.actions,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            additional_units: typing.Union[
                                MetaOapg.properties.additional_units,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            assists: typing.Union[
                                MetaOapg.properties.assists,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            backpack_0: typing.Union[
                                MetaOapg.properties.backpack_0,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            backpack_1: typing.Union[
                                MetaOapg.properties.backpack_1,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            backpack_2: typing.Union[
                                MetaOapg.properties.backpack_2,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            buyback_log: typing.Union[
                                MetaOapg.properties.buyback_log,
                                list,
                                tuple,
                                schemas.Unset,
                            ] = schemas.unset,
                            camps_stacked: typing.Union[
                                MetaOapg.properties.camps_stacked,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            connection_log: typing.Union[
                                MetaOapg.properties.connection_log,
                                list,
                                tuple,
                                schemas.Unset,
                            ] = schemas.unset,
                            creeps_stacked: typing.Union[
                                MetaOapg.properties.creeps_stacked,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            damage: typing.Union[
                                MetaOapg.properties.damage,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            damage_inflictor: typing.Union[
                                MetaOapg.properties.damage_inflictor,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            damage_inflictor_received: typing.Union[
                                MetaOapg.properties.damage_inflictor_received,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            damage_taken: typing.Union[
                                MetaOapg.properties.damage_taken,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            deaths: typing.Union[
                                MetaOapg.properties.deaths,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            denies: typing.Union[
                                MetaOapg.properties.denies,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            dn_t: typing.Union[
                                MetaOapg.properties.dn_t, list, tuple, schemas.Unset
                            ] = schemas.unset,
                            gold: typing.Union[
                                MetaOapg.properties.gold,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            gold_per_min: typing.Union[
                                MetaOapg.properties.gold_per_min,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            gold_reasons: typing.Union[
                                MetaOapg.properties.gold_reasons,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            gold_spent: typing.Union[
                                MetaOapg.properties.gold_spent,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            gold_t: typing.Union[
                                MetaOapg.properties.gold_t, list, tuple, schemas.Unset
                            ] = schemas.unset,
                            hero_damage: typing.Union[
                                MetaOapg.properties.hero_damage,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            hero_healing: typing.Union[
                                MetaOapg.properties.hero_healing,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            hero_hits: typing.Union[
                                MetaOapg.properties.hero_hits,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            hero_id: typing.Union[
                                MetaOapg.properties.hero_id,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            item_0: typing.Union[
                                MetaOapg.properties.item_0,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            item_1: typing.Union[
                                MetaOapg.properties.item_1,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            item_2: typing.Union[
                                MetaOapg.properties.item_2,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            item_3: typing.Union[
                                MetaOapg.properties.item_3,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            item_4: typing.Union[
                                MetaOapg.properties.item_4,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            item_5: typing.Union[
                                MetaOapg.properties.item_5,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            item_uses: typing.Union[
                                MetaOapg.properties.item_uses,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            kill_streaks: typing.Union[
                                MetaOapg.properties.kill_streaks,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            killed: typing.Union[
                                MetaOapg.properties.killed,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            killed_by: typing.Union[
                                MetaOapg.properties.killed_by,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            kills: typing.Union[
                                MetaOapg.properties.kills,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            kills_log: typing.Union[
                                MetaOapg.properties.kills_log,
                                list,
                                tuple,
                                schemas.Unset,
                            ] = schemas.unset,
                            lane_pos: typing.Union[
                                MetaOapg.properties.lane_pos,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            last_hits: typing.Union[
                                MetaOapg.properties.last_hits,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            leaver_status: typing.Union[
                                MetaOapg.properties.leaver_status,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            level: typing.Union[
                                MetaOapg.properties.level,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            lh_t: typing.Union[
                                MetaOapg.properties.lh_t, list, tuple, schemas.Unset
                            ] = schemas.unset,
                            life_state: typing.Union[
                                MetaOapg.properties.life_state,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            max_hero_hit: typing.Union[
                                MetaOapg.properties.max_hero_hit,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            multi_kills: typing.Union[
                                MetaOapg.properties.multi_kills,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            obs: typing.Union[
                                MetaOapg.properties.obs,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            obs_left_log: typing.Union[
                                MetaOapg.properties.obs_left_log,
                                list,
                                tuple,
                                schemas.Unset,
                            ] = schemas.unset,
                            obs_log: typing.Union[
                                MetaOapg.properties.obs_log, list, tuple, schemas.Unset
                            ] = schemas.unset,
                            obs_placed: typing.Union[
                                MetaOapg.properties.obs_placed,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            party_id: typing.Union[
                                MetaOapg.properties.party_id,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            permanent_buffs: typing.Union[
                                MetaOapg.properties.permanent_buffs,
                                list,
                                tuple,
                                schemas.Unset,
                            ] = schemas.unset,
                            pings: typing.Union[
                                MetaOapg.properties.pings,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            purchase: typing.Union[
                                MetaOapg.properties.purchase,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            purchase_log: typing.Union[
                                MetaOapg.properties.purchase_log,
                                list,
                                tuple,
                                schemas.Unset,
                            ] = schemas.unset,
                            rune_pickups: typing.Union[
                                MetaOapg.properties.rune_pickups,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            runes: typing.Union[
                                MetaOapg.properties.runes,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            runes_log: typing.Union[
                                MetaOapg.properties.runes_log,
                                list,
                                tuple,
                                schemas.Unset,
                            ] = schemas.unset,
                            sen: typing.Union[
                                MetaOapg.properties.sen,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            sen_left_log: typing.Union[
                                MetaOapg.properties.sen_left_log,
                                list,
                                tuple,
                                schemas.Unset,
                            ] = schemas.unset,
                            sen_log: typing.Union[
                                MetaOapg.properties.sen_log, list, tuple, schemas.Unset
                            ] = schemas.unset,
                            sen_placed: typing.Union[
                                MetaOapg.properties.sen_placed,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            stuns: typing.Union[
                                MetaOapg.properties.stuns,
                                decimal.Decimal,
                                int,
                                float,
                                schemas.Unset,
                            ] = schemas.unset,
                            times: typing.Union[
                                MetaOapg.properties.times, list, tuple, schemas.Unset
                            ] = schemas.unset,
                            tower_damage: typing.Union[
                                MetaOapg.properties.tower_damage,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            xp_per_min: typing.Union[
                                MetaOapg.properties.xp_per_min,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            xp_reasons: typing.Union[
                                MetaOapg.properties.xp_reasons,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            xp_t: typing.Union[
                                MetaOapg.properties.xp_t, list, tuple, schemas.Unset
                            ] = schemas.unset,
                            personaname: typing.Union[
                                MetaOapg.properties.personaname, str, schemas.Unset
                            ] = schemas.unset,
                            name: typing.Union[
                                MetaOapg.properties.name, str, schemas.Unset
                            ] = schemas.unset,
                            last_login: typing.Union[
                                MetaOapg.properties.last_login,
                                str,
                                datetime,
                                schemas.Unset,
                            ] = schemas.unset,
                            radiant_win: typing.Union[
                                MetaOapg.properties.radiant_win, bool, schemas.Unset
                            ] = schemas.unset,
                            start_time: typing.Union[
                                MetaOapg.properties.start_time,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            duration: typing.Union[
                                MetaOapg.properties.duration,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            cluster: typing.Union[
                                MetaOapg.properties.cluster,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            lobby_type: typing.Union[
                                MetaOapg.properties.lobby_type,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            game_mode: typing.Union[
                                MetaOapg.properties.game_mode,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            patch: typing.Union[
                                MetaOapg.properties.patch,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            region: typing.Union[
                                MetaOapg.properties.region,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            isRadiant: typing.Union[
                                MetaOapg.properties.isRadiant, bool, schemas.Unset
                            ] = schemas.unset,
                            win: typing.Union[
                                MetaOapg.properties.win,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            lose: typing.Union[
                                MetaOapg.properties.lose,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            total_gold: typing.Union[
                                MetaOapg.properties.total_gold,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            total_xp: typing.Union[
                                MetaOapg.properties.total_xp,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            kills_per_min: typing.Union[
                                MetaOapg.properties.kills_per_min,
                                decimal.Decimal,
                                int,
                                float,
                                schemas.Unset,
                            ] = schemas.unset,
                            kda: typing.Union[
                                MetaOapg.properties.kda,
                                decimal.Decimal,
                                int,
                                float,
                                schemas.Unset,
                            ] = schemas.unset,
                            abandons: typing.Union[
                                MetaOapg.properties.abandons,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            neutral_kills: typing.Union[
                                MetaOapg.properties.neutral_kills,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            tower_kills: typing.Union[
                                MetaOapg.properties.tower_kills,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            courier_kills: typing.Union[
                                MetaOapg.properties.courier_kills,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            lane_kills: typing.Union[
                                MetaOapg.properties.lane_kills,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            hero_kills: typing.Union[
                                MetaOapg.properties.hero_kills,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            observer_kills: typing.Union[
                                MetaOapg.properties.observer_kills,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            sentry_kills: typing.Union[
                                MetaOapg.properties.sentry_kills,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            roshan_kills: typing.Union[
                                MetaOapg.properties.roshan_kills,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            necronomicon_kills: typing.Union[
                                MetaOapg.properties.necronomicon_kills,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            ancient_kills: typing.Union[
                                MetaOapg.properties.ancient_kills,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            buyback_count: typing.Union[
                                MetaOapg.properties.buyback_count,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            observer_uses: typing.Union[
                                MetaOapg.properties.observer_uses,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            sentry_uses: typing.Union[
                                MetaOapg.properties.sentry_uses,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            lane_efficiency: typing.Union[
                                MetaOapg.properties.lane_efficiency,
                                decimal.Decimal,
                                int,
                                float,
                                schemas.Unset,
                            ] = schemas.unset,
                            lane_efficiency_pct: typing.Union[
                                MetaOapg.properties.lane_efficiency_pct,
                                decimal.Decimal,
                                int,
                                float,
                                schemas.Unset,
                            ] = schemas.unset,
                            lane: typing.Union[
                                MetaOapg.properties.lane,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            lane_role: typing.Union[
                                MetaOapg.properties.lane_role,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            is_roaming: typing.Union[
                                MetaOapg.properties.is_roaming, bool, schemas.Unset
                            ] = schemas.unset,
                            purchase_time: typing.Union[
                                MetaOapg.properties.purchase_time,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            first_purchase_time: typing.Union[
                                MetaOapg.properties.first_purchase_time,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            item_win: typing.Union[
                                MetaOapg.properties.item_win,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            item_usage: typing.Union[
                                MetaOapg.properties.item_usage,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            purchase_tpscroll: typing.Union[
                                MetaOapg.properties.purchase_tpscroll,
                                dict,
                                frozendict.frozendict,
                                schemas.Unset,
                            ] = schemas.unset,
                            actions_per_min: typing.Union[
                                MetaOapg.properties.actions_per_min,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            life_state_dead: typing.Union[
                                MetaOapg.properties.life_state_dead,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            rank_tier: typing.Union[
                                MetaOapg.properties.rank_tier,
                                decimal.Decimal,
                                int,
                                schemas.Unset,
                            ] = schemas.unset,
                            cosmetics: typing.Union[
                                MetaOapg.properties.cosmetics,
                                list,
                                tuple,
                                schemas.Unset,
                            ] = schemas.unset,
                            benchmarks: typing.Union[
                                MetaOapg.properties.benchmarks,
                                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,
                                match_id=match_id,
                                player_slot=player_slot,
                                ability_upgrades_arr=ability_upgrades_arr,
                                ability_uses=ability_uses,
                                ability_targets=ability_targets,
                                damage_targets=damage_targets,
                                account_id=account_id,
                                actions=actions,
                                additional_units=additional_units,
                                assists=assists,
                                backpack_0=backpack_0,
                                backpack_1=backpack_1,
                                backpack_2=backpack_2,
                                buyback_log=buyback_log,
                                camps_stacked=camps_stacked,
                                connection_log=connection_log,
                                creeps_stacked=creeps_stacked,
                                damage=damage,
                                damage_inflictor=damage_inflictor,
                                damage_inflictor_received=damage_inflictor_received,
                                damage_taken=damage_taken,
                                deaths=deaths,
                                denies=denies,
                                dn_t=dn_t,
                                gold=gold,
                                gold_per_min=gold_per_min,
                                gold_reasons=gold_reasons,
                                gold_spent=gold_spent,
                                gold_t=gold_t,
                                hero_damage=hero_damage,
                                hero_healing=hero_healing,
                                hero_hits=hero_hits,
                                hero_id=hero_id,
                                item_0=item_0,
                                item_1=item_1,
                                item_2=item_2,
                                item_3=item_3,
                                item_4=item_4,
                                item_5=item_5,
                                item_uses=item_uses,
                                kill_streaks=kill_streaks,
                                killed=killed,
                                killed_by=killed_by,
                                kills=kills,
                                kills_log=kills_log,
                                lane_pos=lane_pos,
                                last_hits=last_hits,
                                leaver_status=leaver_status,
                                level=level,
                                lh_t=lh_t,
                                life_state=life_state,
                                max_hero_hit=max_hero_hit,
                                multi_kills=multi_kills,
                                obs=obs,
                                obs_left_log=obs_left_log,
                                obs_log=obs_log,
                                obs_placed=obs_placed,
                                party_id=party_id,
                                permanent_buffs=permanent_buffs,
                                pings=pings,
                                purchase=purchase,
                                purchase_log=purchase_log,
                                rune_pickups=rune_pickups,
                                runes=runes,
                                runes_log=runes_log,
                                sen=sen,
                                sen_left_log=sen_left_log,
                                sen_log=sen_log,
                                sen_placed=sen_placed,
                                stuns=stuns,
                                times=times,
                                tower_damage=tower_damage,
                                xp_per_min=xp_per_min,
                                xp_reasons=xp_reasons,
                                xp_t=xp_t,
                                personaname=personaname,
                                name=name,
                                last_login=last_login,
                                radiant_win=radiant_win,
                                start_time=start_time,
                                duration=duration,
                                cluster=cluster,
                                lobby_type=lobby_type,
                                game_mode=game_mode,
                                patch=patch,
                                region=region,
                                isRadiant=isRadiant,
                                win=win,
                                lose=lose,
                                total_gold=total_gold,
                                total_xp=total_xp,
                                kills_per_min=kills_per_min,
                                kda=kda,
                                abandons=abandons,
                                neutral_kills=neutral_kills,
                                tower_kills=tower_kills,
                                courier_kills=courier_kills,
                                lane_kills=lane_kills,
                                hero_kills=hero_kills,
                                observer_kills=observer_kills,
                                sentry_kills=sentry_kills,
                                roshan_kills=roshan_kills,
                                necronomicon_kills=necronomicon_kills,
                                ancient_kills=ancient_kills,
                                buyback_count=buyback_count,
                                observer_uses=observer_uses,
                                sentry_uses=sentry_uses,
                                lane_efficiency=lane_efficiency,
                                lane_efficiency_pct=lane_efficiency_pct,
                                lane=lane,
                                lane_role=lane_role,
                                is_roaming=is_roaming,
                                purchase_time=purchase_time,
                                first_purchase_time=first_purchase_time,
                                item_win=item_win,
                                item_usage=item_usage,
                                purchase_tpscroll=purchase_tpscroll,
                                actions_per_min=actions_per_min,
                                life_state_dead=life_state_dead,
                                rank_tier=rank_tier,
                                cosmetics=cosmetics,
                                benchmarks=benchmarks,
                                _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,
                ) -> "players":
                    return super().__new__(
                        cls,
                        _arg,
                        _configuration=_configuration,
                    )

                def __getitem__(self, i: int) -> MetaOapg.items:
                    return super().__getitem__(i)

            patch = schemas.IntSchema
            region = schemas.IntSchema
            all_word_counts = schemas.DictSchema
            my_word_counts = schemas.DictSchema
            throw = schemas.IntSchema
            comeback = schemas.IntSchema
            loss = schemas.IntSchema
            win = schemas.IntSchema
            replay_url = schemas.StrSchema
            __annotations__ = {
                "match_id": match_id,
                "barracks_status_dire": barracks_status_dire,
                "barracks_status_radiant": barracks_status_radiant,
                "chat": chat,
                "cluster": cluster,
                "cosmetics": cosmetics,
                "dire_score": dire_score,
                "draft_timings": draft_timings,
                "duration": duration,
                "engine": engine,
                "first_blood_time": first_blood_time,
                "game_mode": game_mode,
                "human_players": human_players,
                "leagueid": leagueid,
                "lobby_type": lobby_type,
                "match_seq_num": match_seq_num,
                "negative_votes": negative_votes,
                "objectives": objectives,
                "picks_bans": picks_bans,
                "positive_votes": positive_votes,
                "radiant_gold_adv": radiant_gold_adv,
                "radiant_score": radiant_score,
                "radiant_win": radiant_win,
                "radiant_xp_adv": radiant_xp_adv,
                "start_time": start_time,
                "teamfights": teamfights,
                "tower_status_dire": tower_status_dire,
                "tower_status_radiant": tower_status_radiant,
                "version": version,
                "replay_salt": replay_salt,
                "series_id": series_id,
                "series_type": series_type,
                "radiant_team": radiant_team,
                "dire_team": dire_team,
                "league": league,
                "skill": skill,
                "players": players,
                "patch": patch,
                "region": region,
                "all_word_counts": all_word_counts,
                "my_word_counts": my_word_counts,
                "throw": throw,
                "comeback": comeback,
                "loss": loss,
                "win": win,
                "replay_url": replay_url,
            }

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["match_id"]
    ) -> MetaOapg.properties.match_id:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["barracks_status_dire"]
    ) -> MetaOapg.properties.barracks_status_dire:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["barracks_status_radiant"]
    ) -> MetaOapg.properties.barracks_status_radiant:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["chat"]
    ) -> MetaOapg.properties.chat:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["cluster"]
    ) -> MetaOapg.properties.cluster:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["cosmetics"]
    ) -> MetaOapg.properties.cosmetics:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["dire_score"]
    ) -> MetaOapg.properties.dire_score:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["draft_timings"]
    ) -> MetaOapg.properties.draft_timings:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["duration"]
    ) -> MetaOapg.properties.duration:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["engine"]
    ) -> MetaOapg.properties.engine:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["first_blood_time"]
    ) -> MetaOapg.properties.first_blood_time:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["game_mode"]
    ) -> MetaOapg.properties.game_mode:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["human_players"]
    ) -> MetaOapg.properties.human_players:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["leagueid"]
    ) -> MetaOapg.properties.leagueid:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["lobby_type"]
    ) -> MetaOapg.properties.lobby_type:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["match_seq_num"]
    ) -> MetaOapg.properties.match_seq_num:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["negative_votes"]
    ) -> MetaOapg.properties.negative_votes:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["objectives"]
    ) -> MetaOapg.properties.objectives:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["picks_bans"]
    ) -> MetaOapg.properties.picks_bans:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["positive_votes"]
    ) -> MetaOapg.properties.positive_votes:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["radiant_gold_adv"]
    ) -> MetaOapg.properties.radiant_gold_adv:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["radiant_score"]
    ) -> MetaOapg.properties.radiant_score:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["radiant_win"]
    ) -> MetaOapg.properties.radiant_win:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["radiant_xp_adv"]
    ) -> MetaOapg.properties.radiant_xp_adv:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["start_time"]
    ) -> MetaOapg.properties.start_time:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["teamfights"]
    ) -> MetaOapg.properties.teamfights:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["tower_status_dire"]
    ) -> MetaOapg.properties.tower_status_dire:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["tower_status_radiant"]
    ) -> MetaOapg.properties.tower_status_radiant:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["version"]
    ) -> MetaOapg.properties.version:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["replay_salt"]
    ) -> MetaOapg.properties.replay_salt:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["series_id"]
    ) -> MetaOapg.properties.series_id:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["series_type"]
    ) -> MetaOapg.properties.series_type:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["radiant_team"]
    ) -> MetaOapg.properties.radiant_team:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["dire_team"]
    ) -> MetaOapg.properties.dire_team:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["league"]
    ) -> MetaOapg.properties.league:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["skill"]
    ) -> MetaOapg.properties.skill:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["players"]
    ) -> MetaOapg.properties.players:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["patch"]
    ) -> MetaOapg.properties.patch:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["region"]
    ) -> MetaOapg.properties.region:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["all_word_counts"]
    ) -> MetaOapg.properties.all_word_counts:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["my_word_counts"]
    ) -> MetaOapg.properties.my_word_counts:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["throw"]
    ) -> MetaOapg.properties.throw:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["comeback"]
    ) -> MetaOapg.properties.comeback:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["loss"]
    ) -> MetaOapg.properties.loss:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["win"]
    ) -> MetaOapg.properties.win:
        ...

    @typing.overload
    def __getitem__(
        self, name: typing_extensions.Literal["replay_url"]
    ) -> MetaOapg.properties.replay_url:
        ...

    @typing.overload
    def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema:
        ...

    def __getitem__(
        self,
        name: typing.Union[
            typing_extensions.Literal[
                "match_id",
                "barracks_status_dire",
                "barracks_status_radiant",
                "chat",
                "cluster",
                "cosmetics",
                "dire_score",
                "draft_timings",
                "duration",
                "engine",
                "first_blood_time",
                "game_mode",
                "human_players",
                "leagueid",
                "lobby_type",
                "match_seq_num",
                "negative_votes",
                "objectives",
                "picks_bans",
                "positive_votes",
                "radiant_gold_adv",
                "radiant_score",
                "radiant_win",
                "radiant_xp_adv",
                "start_time",
                "teamfights",
                "tower_status_dire",
                "tower_status_radiant",
                "version",
                "replay_salt",
                "series_id",
                "series_type",
                "radiant_team",
                "dire_team",
                "league",
                "skill",
                "players",
                "patch",
                "region",
                "all_word_counts",
                "my_word_counts",
                "throw",
                "comeback",
                "loss",
                "win",
                "replay_url",
            ],
            str,
        ],
    ):
        # dict_instance[name] accessor
        return super().__getitem__(name)

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["match_id"]
    ) -> typing.Union[MetaOapg.properties.match_id, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["barracks_status_dire"]
    ) -> typing.Union[MetaOapg.properties.barracks_status_dire, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["barracks_status_radiant"]
    ) -> typing.Union[MetaOapg.properties.barracks_status_radiant, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["chat"]
    ) -> typing.Union[MetaOapg.properties.chat, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["cluster"]
    ) -> typing.Union[MetaOapg.properties.cluster, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["cosmetics"]
    ) -> typing.Union[MetaOapg.properties.cosmetics, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["dire_score"]
    ) -> typing.Union[MetaOapg.properties.dire_score, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["draft_timings"]
    ) -> typing.Union[MetaOapg.properties.draft_timings, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["duration"]
    ) -> typing.Union[MetaOapg.properties.duration, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["engine"]
    ) -> typing.Union[MetaOapg.properties.engine, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["first_blood_time"]
    ) -> typing.Union[MetaOapg.properties.first_blood_time, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["game_mode"]
    ) -> typing.Union[MetaOapg.properties.game_mode, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["human_players"]
    ) -> typing.Union[MetaOapg.properties.human_players, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["leagueid"]
    ) -> typing.Union[MetaOapg.properties.leagueid, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["lobby_type"]
    ) -> typing.Union[MetaOapg.properties.lobby_type, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["match_seq_num"]
    ) -> typing.Union[MetaOapg.properties.match_seq_num, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["negative_votes"]
    ) -> typing.Union[MetaOapg.properties.negative_votes, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["objectives"]
    ) -> typing.Union[MetaOapg.properties.objectives, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["picks_bans"]
    ) -> typing.Union[MetaOapg.properties.picks_bans, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["positive_votes"]
    ) -> typing.Union[MetaOapg.properties.positive_votes, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["radiant_gold_adv"]
    ) -> typing.Union[MetaOapg.properties.radiant_gold_adv, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["radiant_score"]
    ) -> typing.Union[MetaOapg.properties.radiant_score, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["radiant_win"]
    ) -> typing.Union[MetaOapg.properties.radiant_win, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["radiant_xp_adv"]
    ) -> typing.Union[MetaOapg.properties.radiant_xp_adv, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["start_time"]
    ) -> typing.Union[MetaOapg.properties.start_time, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["teamfights"]
    ) -> typing.Union[MetaOapg.properties.teamfights, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["tower_status_dire"]
    ) -> typing.Union[MetaOapg.properties.tower_status_dire, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["tower_status_radiant"]
    ) -> typing.Union[MetaOapg.properties.tower_status_radiant, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["version"]
    ) -> typing.Union[MetaOapg.properties.version, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["replay_salt"]
    ) -> typing.Union[MetaOapg.properties.replay_salt, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["series_id"]
    ) -> typing.Union[MetaOapg.properties.series_id, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["series_type"]
    ) -> typing.Union[MetaOapg.properties.series_type, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["radiant_team"]
    ) -> typing.Union[MetaOapg.properties.radiant_team, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["dire_team"]
    ) -> typing.Union[MetaOapg.properties.dire_team, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["league"]
    ) -> typing.Union[MetaOapg.properties.league, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["skill"]
    ) -> typing.Union[MetaOapg.properties.skill, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["players"]
    ) -> typing.Union[MetaOapg.properties.players, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["patch"]
    ) -> typing.Union[MetaOapg.properties.patch, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["region"]
    ) -> typing.Union[MetaOapg.properties.region, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["all_word_counts"]
    ) -> typing.Union[MetaOapg.properties.all_word_counts, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["my_word_counts"]
    ) -> typing.Union[MetaOapg.properties.my_word_counts, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["throw"]
    ) -> typing.Union[MetaOapg.properties.throw, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["comeback"]
    ) -> typing.Union[MetaOapg.properties.comeback, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["loss"]
    ) -> typing.Union[MetaOapg.properties.loss, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["win"]
    ) -> typing.Union[MetaOapg.properties.win, schemas.Unset]:
        ...

    @typing.overload
    def get_item_oapg(
        self, name: typing_extensions.Literal["replay_url"]
    ) -> typing.Union[MetaOapg.properties.replay_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[
                "match_id",
                "barracks_status_dire",
                "barracks_status_radiant",
                "chat",
                "cluster",
                "cosmetics",
                "dire_score",
                "draft_timings",
                "duration",
                "engine",
                "first_blood_time",
                "game_mode",
                "human_players",
                "leagueid",
                "lobby_type",
                "match_seq_num",
                "negative_votes",
                "objectives",
                "picks_bans",
                "positive_votes",
                "radiant_gold_adv",
                "radiant_score",
                "radiant_win",
                "radiant_xp_adv",
                "start_time",
                "teamfights",
                "tower_status_dire",
                "tower_status_radiant",
                "version",
                "replay_salt",
                "series_id",
                "series_type",
                "radiant_team",
                "dire_team",
                "league",
                "skill",
                "players",
                "patch",
                "region",
                "all_word_counts",
                "my_word_counts",
                "throw",
                "comeback",
                "loss",
                "win",
                "replay_url",
            ],
            str,
        ],
    ):
        return super().get_item_oapg(name)

    def __new__(
        cls,
        *_args: typing.Union[
            dict,
            frozendict.frozendict,
        ],
        match_id: typing.Union[
            MetaOapg.properties.match_id, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        barracks_status_dire: typing.Union[
            MetaOapg.properties.barracks_status_dire,
            decimal.Decimal,
            int,
            schemas.Unset,
        ] = schemas.unset,
        barracks_status_radiant: typing.Union[
            MetaOapg.properties.barracks_status_radiant,
            decimal.Decimal,
            int,
            schemas.Unset,
        ] = schemas.unset,
        chat: typing.Union[
            MetaOapg.properties.chat, list, tuple, schemas.Unset
        ] = schemas.unset,
        cluster: typing.Union[
            MetaOapg.properties.cluster, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        cosmetics: typing.Union[
            MetaOapg.properties.cosmetics, dict, frozendict.frozendict, schemas.Unset
        ] = schemas.unset,
        dire_score: typing.Union[
            MetaOapg.properties.dire_score, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        draft_timings: typing.Union[
            MetaOapg.properties.draft_timings, list, tuple, schemas.Unset
        ] = schemas.unset,
        duration: typing.Union[
            MetaOapg.properties.duration, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        engine: typing.Union[
            MetaOapg.properties.engine, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        first_blood_time: typing.Union[
            MetaOapg.properties.first_blood_time, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        game_mode: typing.Union[
            MetaOapg.properties.game_mode, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        human_players: typing.Union[
            MetaOapg.properties.human_players, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        leagueid: typing.Union[
            MetaOapg.properties.leagueid, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        lobby_type: typing.Union[
            MetaOapg.properties.lobby_type, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        match_seq_num: typing.Union[
            MetaOapg.properties.match_seq_num, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        negative_votes: typing.Union[
            MetaOapg.properties.negative_votes, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        objectives: typing.Union[
            MetaOapg.properties.objectives, dict, frozendict.frozendict, schemas.Unset
        ] = schemas.unset,
        picks_bans: typing.Union[
            MetaOapg.properties.picks_bans, dict, frozendict.frozendict, schemas.Unset
        ] = schemas.unset,
        positive_votes: typing.Union[
            MetaOapg.properties.positive_votes, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        radiant_gold_adv: typing.Union[
            MetaOapg.properties.radiant_gold_adv,
            dict,
            frozendict.frozendict,
            schemas.Unset,
        ] = schemas.unset,
        radiant_score: typing.Union[
            MetaOapg.properties.radiant_score, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        radiant_win: typing.Union[
            MetaOapg.properties.radiant_win, bool, schemas.Unset
        ] = schemas.unset,
        radiant_xp_adv: typing.Union[
            MetaOapg.properties.radiant_xp_adv,
            dict,
            frozendict.frozendict,
            schemas.Unset,
        ] = schemas.unset,
        start_time: typing.Union[
            MetaOapg.properties.start_time, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        teamfights: typing.Union[
            MetaOapg.properties.teamfights, dict, frozendict.frozendict, schemas.Unset
        ] = schemas.unset,
        tower_status_dire: typing.Union[
            MetaOapg.properties.tower_status_dire, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        tower_status_radiant: typing.Union[
            MetaOapg.properties.tower_status_radiant,
            decimal.Decimal,
            int,
            schemas.Unset,
        ] = schemas.unset,
        version: typing.Union[
            MetaOapg.properties.version, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        replay_salt: typing.Union[
            MetaOapg.properties.replay_salt, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        series_id: typing.Union[
            MetaOapg.properties.series_id, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        series_type: typing.Union[
            MetaOapg.properties.series_type, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        radiant_team: typing.Union[
            MetaOapg.properties.radiant_team, dict, frozendict.frozendict, schemas.Unset
        ] = schemas.unset,
        dire_team: typing.Union[
            MetaOapg.properties.dire_team, dict, frozendict.frozendict, schemas.Unset
        ] = schemas.unset,
        league: typing.Union[
            MetaOapg.properties.league, dict, frozendict.frozendict, schemas.Unset
        ] = schemas.unset,
        skill: typing.Union[
            MetaOapg.properties.skill, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        players: typing.Union[
            MetaOapg.properties.players, list, tuple, schemas.Unset
        ] = schemas.unset,
        patch: typing.Union[
            MetaOapg.properties.patch, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        region: typing.Union[
            MetaOapg.properties.region, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        all_word_counts: typing.Union[
            MetaOapg.properties.all_word_counts,
            dict,
            frozendict.frozendict,
            schemas.Unset,
        ] = schemas.unset,
        my_word_counts: typing.Union[
            MetaOapg.properties.my_word_counts,
            dict,
            frozendict.frozendict,
            schemas.Unset,
        ] = schemas.unset,
        throw: typing.Union[
            MetaOapg.properties.throw, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        comeback: typing.Union[
            MetaOapg.properties.comeback, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        loss: typing.Union[
            MetaOapg.properties.loss, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        win: typing.Union[
            MetaOapg.properties.win, decimal.Decimal, int, schemas.Unset
        ] = schemas.unset,
        replay_url: typing.Union[
            MetaOapg.properties.replay_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,
        ],
    ) -> "SchemaFor200ResponseBodyApplicationJson":
        return super().__new__(
            cls,
            *_args,
            match_id=match_id,
            barracks_status_dire=barracks_status_dire,
            barracks_status_radiant=barracks_status_radiant,
            chat=chat,
            cluster=cluster,
            cosmetics=cosmetics,
            dire_score=dire_score,
            draft_timings=draft_timings,
            duration=duration,
            engine=engine,
            first_blood_time=first_blood_time,
            game_mode=game_mode,
            human_players=human_players,
            leagueid=leagueid,
            lobby_type=lobby_type,
            match_seq_num=match_seq_num,
            negative_votes=negative_votes,
            objectives=objectives,
            picks_bans=picks_bans,
            positive_votes=positive_votes,
            radiant_gold_adv=radiant_gold_adv,
            radiant_score=radiant_score,
            radiant_win=radiant_win,
            radiant_xp_adv=radiant_xp_adv,
            start_time=start_time,
            teamfights=teamfights,
            tower_status_dire=tower_status_dire,
            tower_status_radiant=tower_status_radiant,
            version=version,
            replay_salt=replay_salt,
            series_id=series_id,
            series_type=series_type,
            radiant_team=radiant_team,
            dire_team=dire_team,
            league=league,
            skill=skill,
            players=players,
            patch=patch,
            region=region,
            all_word_counts=all_word_counts,
            my_word_counts=my_word_counts,
            throw=throw,
            comeback=comeback,
            loss=loss,
            win=win,
            replay_url=replay_url,
            _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
        ),
    },
)
_status_code_to_response = {
    "200": _response_for_200,
}
_all_accept_content_types = ("application/json",)


class BaseApi(api_client.Api):
    @typing.overload
    def _matches_match_id_get_oapg(
        self,
        path_params: RequestPathParams = 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: typing_extensions.Literal[False] = ...,
    ) -> typing.Union[ApiResponseFor200,]:
        ...

    @typing.overload
    def _matches_match_id_get_oapg(
        self,
        skip_deserialization: typing_extensions.Literal[True],
        path_params: RequestPathParams = frozendict.frozendict(),
        accept_content_types: typing.Tuple[str] = _all_accept_content_types,
        stream: bool = False,
        timeout: typing.Optional[typing.Union[int, typing.Tuple]] = None,
    ) -> api_client.ApiResponseWithoutDeserialization:
        ...

    @typing.overload
    def _matches_match_id_get_oapg(
        self,
        path_params: RequestPathParams = 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 = ...,
    ) -> typing.Union[ApiResponseFor200, api_client.ApiResponseWithoutDeserialization,]:
        ...

    def _matches_match_id_get_oapg(
        self,
        path_params: RequestPathParams = 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,
    ):
        """
        GET /matches/{match_id}
        :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(RequestPathParams, path_params)
        used_path = path.value

        _path_params = {}
        for parameter in (request_path_match_id,):
            parameter_data = path_params.get(parameter.name, schemas.unset)
            if parameter_data is schemas.unset:
                continue
            serialized_data = parameter.serialize(parameter_data)
            _path_params.update(serialized_data)

        for k, v in _path_params.items():
            used_path = used_path.replace("{%s}" % k, v)

        _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,
            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(
                status=response.status,
                reason=response.reason,
                api_response=api_response,
            )

        return api_response


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

    @typing.overload
    def matches_match_id_get(
        self,
        path_params: RequestPathParams = 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: typing_extensions.Literal[False] = ...,
    ) -> typing.Union[ApiResponseFor200,]:
        ...

    @typing.overload
    def matches_match_id_get(
        self,
        skip_deserialization: typing_extensions.Literal[True],
        path_params: RequestPathParams = frozendict.frozendict(),
        accept_content_types: typing.Tuple[str] = _all_accept_content_types,
        stream: bool = False,
        timeout: typing.Optional[typing.Union[int, typing.Tuple]] = None,
    ) -> api_client.ApiResponseWithoutDeserialization:
        ...

    @typing.overload
    def matches_match_id_get(
        self,
        path_params: RequestPathParams = 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 = ...,
    ) -> typing.Union[ApiResponseFor200, api_client.ApiResponseWithoutDeserialization,]:
        ...

    def matches_match_id_get(
        self,
        path_params: RequestPathParams = 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,
    ):
        return self._matches_match_id_get_oapg(
            path_params=path_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

    @typing.overload
    def get(
        self,
        path_params: RequestPathParams = 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: typing_extensions.Literal[False] = ...,
    ) -> typing.Union[ApiResponseFor200,]:
        ...

    @typing.overload
    def get(
        self,
        skip_deserialization: typing_extensions.Literal[True],
        path_params: RequestPathParams = frozendict.frozendict(),
        accept_content_types: typing.Tuple[str] = _all_accept_content_types,
        stream: bool = False,
        timeout: typing.Optional[typing.Union[int, typing.Tuple]] = None,
    ) -> api_client.ApiResponseWithoutDeserialization:
        ...

    @typing.overload
    def get(
        self,
        path_params: RequestPathParams = 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 = ...,
    ) -> typing.Union[ApiResponseFor200, api_client.ApiResponseWithoutDeserialization,]:
        ...

    def get(
        self,
        path_params: RequestPathParams = 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,
    ):
        return self._matches_match_id_get_oapg(
            path_params=path_params,
            accept_content_types=accept_content_types,
            stream=stream,
            timeout=timeout,
            skip_deserialization=skip_deserialization,
        )
