from reprlib import repr as limitedRepr


from typing import List


class StoreAuthenticateResp:
    class _subscriptionStatus:
        class _terms:

            _types_map = {
                "type": {"type": str, "subtype": None},
                "latestTerms": {"type": int, "subtype": None},
                "agreedToTerms": {"type": int, "subtype": None},
                "source": {"type": str, "subtype": None},
            }
            _formats_map = {}
            _validations_map = {
                "type": {
                    "required": True,
                },
                "latestTerms": {
                    "required": True,
                },
                "agreedToTerms": {
                    "required": True,
                },
                "source": {
                    "required": True,
                },
            }

            def __init__(
                self,
                type: str = None,
                latestTerms: int = None,
                agreedToTerms: int = None,
                source: str = None,
            ):
                pass
                self.__type = type
                self.__latestTerms = latestTerms
                self.__agreedToTerms = agreedToTerms
                self.__source = source

            def _get_type(self):
                return self.__type

            def _set_type(self, value):
                if not isinstance(value, str):
                    raise TypeError("type must be str")

                self.__type = value

            type = property(_get_type, _set_type)

            def _get_latestTerms(self):
                return self.__latestTerms

            def _set_latestTerms(self, value):
                if not isinstance(value, int):
                    raise TypeError("latestTerms must be int")

                self.__latestTerms = value

            latestTerms = property(_get_latestTerms, _set_latestTerms)

            def _get_agreedToTerms(self):
                return self.__agreedToTerms

            def _set_agreedToTerms(self, value):
                if not isinstance(value, int):
                    raise TypeError("agreedToTerms must be int")

                self.__agreedToTerms = value

            agreedToTerms = property(_get_agreedToTerms, _set_agreedToTerms)

            def _get_source(self):
                return self.__source

            def _set_source(self, value):
                if not isinstance(value, str):
                    raise TypeError("source must be str")

                self.__source = value

            source = property(_get_source, _set_source)

            @staticmethod
            def from_dict(d):
                v = {}
                if "type" in d:
                    v["type"] = (
                        str.from_dict(d["type"])
                        if hasattr(str, "from_dict")
                        else d["type"]
                    )
                if "latestTerms" in d:
                    v["latestTerms"] = (
                        int.from_dict(d["latestTerms"])
                        if hasattr(int, "from_dict")
                        else d["latestTerms"]
                    )
                if "agreedToTerms" in d:
                    v["agreedToTerms"] = (
                        int.from_dict(d["agreedToTerms"])
                        if hasattr(int, "from_dict")
                        else d["agreedToTerms"]
                    )
                if "source" in d:
                    v["source"] = (
                        str.from_dict(d["source"])
                        if hasattr(str, "from_dict")
                        else d["source"]
                    )
                return StoreAuthenticateResp._subscriptionStatus._terms(**v)

            def as_dict(self):
                d = {}
                if self.__type is not None:
                    d["type"] = (
                        self.__type.as_dict()
                        if hasattr(self.__type, "as_dict")
                        else self.__type
                    )
                if self.__latestTerms is not None:
                    d["latestTerms"] = (
                        self.__latestTerms.as_dict()
                        if hasattr(self.__latestTerms, "as_dict")
                        else self.__latestTerms
                    )
                if self.__agreedToTerms is not None:
                    d["agreedToTerms"] = (
                        self.__agreedToTerms.as_dict()
                        if hasattr(self.__agreedToTerms, "as_dict")
                        else self.__agreedToTerms
                    )
                if self.__source is not None:
                    d["source"] = (
                        self.__source.as_dict()
                        if hasattr(self.__source, "as_dict")
                        else self.__source
                    )
                return d

            def __repr__(self):
                return "<Class _terms. type: {}, latestTerms: {}, agreedToTerms: {}, source: {}>".format(
                    limitedRepr(
                        self.__type[:20]
                        if isinstance(self.__type, bytes)
                        else self.__type
                    ),
                    limitedRepr(
                        self.__latestTerms[:20]
                        if isinstance(self.__latestTerms, bytes)
                        else self.__latestTerms
                    ),
                    limitedRepr(
                        self.__agreedToTerms[:20]
                        if isinstance(self.__agreedToTerms, bytes)
                        else self.__agreedToTerms
                    ),
                    limitedRepr(
                        self.__source[:20]
                        if isinstance(self.__source, bytes)
                        else self.__source
                    ),
                )

        class _account:

            _types_map = {
                "isMinor": {"type": bool, "subtype": None},
                "suspectUnderage": {"type": bool, "subtype": None},
            }
            _formats_map = {}
            _validations_map = {
                "isMinor": {
                    "required": True,
                },
                "suspectUnderage": {
                    "required": True,
                },
            }

            def __init__(self, isMinor: bool = None, suspectUnderage: bool = None):
                pass
                self.__isMinor = isMinor
                self.__suspectUnderage = suspectUnderage

            def _get_isMinor(self):
                return self.__isMinor

            def _set_isMinor(self, value):
                if not isinstance(value, bool):
                    raise TypeError("isMinor must be bool")

                self.__isMinor = value

            isMinor = property(_get_isMinor, _set_isMinor)

            def _get_suspectUnderage(self):
                return self.__suspectUnderage

            def _set_suspectUnderage(self, value):
                if not isinstance(value, bool):
                    raise TypeError("suspectUnderage must be bool")

                self.__suspectUnderage = value

            suspectUnderage = property(_get_suspectUnderage, _set_suspectUnderage)

            @staticmethod
            def from_dict(d):
                v = {}
                if "isMinor" in d:
                    v["isMinor"] = (
                        bool.from_dict(d["isMinor"])
                        if hasattr(bool, "from_dict")
                        else d["isMinor"]
                    )
                if "suspectUnderage" in d:
                    v["suspectUnderage"] = (
                        bool.from_dict(d["suspectUnderage"])
                        if hasattr(bool, "from_dict")
                        else d["suspectUnderage"]
                    )
                return StoreAuthenticateResp._subscriptionStatus._account(**v)

            def as_dict(self):
                d = {}
                if self.__isMinor is not None:
                    d["isMinor"] = (
                        self.__isMinor.as_dict()
                        if hasattr(self.__isMinor, "as_dict")
                        else self.__isMinor
                    )
                if self.__suspectUnderage is not None:
                    d["suspectUnderage"] = (
                        self.__suspectUnderage.as_dict()
                        if hasattr(self.__suspectUnderage, "as_dict")
                        else self.__suspectUnderage
                    )
                return d

            def __repr__(self):
                return "<Class _account. isMinor: {}, suspectUnderage: {}>".format(
                    limitedRepr(
                        self.__isMinor[:20]
                        if isinstance(self.__isMinor, bytes)
                        else self.__isMinor
                    ),
                    limitedRepr(
                        self.__suspectUnderage[:20]
                        if isinstance(self.__suspectUnderage, bytes)
                        else self.__suspectUnderage
                    ),
                )

        class _family:

            _types_map = {
                "hasFamily": {"type": bool, "subtype": None},
            }
            _formats_map = {}
            _validations_map = {
                "hasFamily": {
                    "required": True,
                },
            }

            def __init__(self, hasFamily: bool = None):
                pass
                self.__hasFamily = hasFamily

            def _get_hasFamily(self):
                return self.__hasFamily

            def _set_hasFamily(self, value):
                if not isinstance(value, bool):
                    raise TypeError("hasFamily must be bool")

                self.__hasFamily = value

            hasFamily = property(_get_hasFamily, _set_hasFamily)

            @staticmethod
            def from_dict(d):
                v = {}
                if "hasFamily" in d:
                    v["hasFamily"] = (
                        bool.from_dict(d["hasFamily"])
                        if hasattr(bool, "from_dict")
                        else d["hasFamily"]
                    )
                return StoreAuthenticateResp._subscriptionStatus._family(**v)

            def as_dict(self):
                d = {}
                if self.__hasFamily is not None:
                    d["hasFamily"] = (
                        self.__hasFamily.as_dict()
                        if hasattr(self.__hasFamily, "as_dict")
                        else self.__hasFamily
                    )
                return d

            def __repr__(self):
                return "<Class _family. hasFamily: {}>".format(
                    limitedRepr(
                        self.__hasFamily[:20]
                        if isinstance(self.__hasFamily, bytes)
                        else self.__hasFamily
                    )
                )

        _types_map = {
            "terms": {"type": list, "subtype": _terms},
            "account": {"type": _account, "subtype": None},
            "family": {"type": _family, "subtype": None},
        }
        _formats_map = {}
        _validations_map = {
            "terms": {
                "required": True,
            },
            "account": {
                "required": True,
            },
            "family": {
                "required": True,
            },
        }

        def __init__(
            self,
            terms: List[_terms] = None,
            account: _account = None,
            family: _family = None,
        ):
            pass
            self.__terms = terms
            self.__account = account
            self.__family = family

        def _get_terms(self):
            return self.__terms

        def _set_terms(self, value):
            if not isinstance(value, list):
                raise TypeError("terms must be list")
            if not all(
                isinstance(i, StoreAuthenticateResp._subscriptionStatus._terms)
                for i in value
            ):
                raise TypeError(
                    "terms list values must be StoreAuthenticateResp._subscriptionStatus._terms"
                )

            self.__terms = value

        terms = property(_get_terms, _set_terms)

        def _get_account(self):
            return self.__account

        def _set_account(self, value):
            if not isinstance(
                value, StoreAuthenticateResp._subscriptionStatus._account
            ):
                raise TypeError(
                    "account must be StoreAuthenticateResp._subscriptionStatus._account"
                )

            self.__account = value

        account = property(_get_account, _set_account)

        def _get_family(self):
            return self.__family

        def _set_family(self, value):
            if not isinstance(value, StoreAuthenticateResp._subscriptionStatus._family):
                raise TypeError(
                    "family must be StoreAuthenticateResp._subscriptionStatus._family"
                )

            self.__family = value

        family = property(_get_family, _set_family)

        @staticmethod
        def from_dict(d):
            v = {}
            if "terms" in d:
                v["terms"] = [
                    StoreAuthenticateResp._subscriptionStatus._terms.from_dict(p)
                    if hasattr(
                        StoreAuthenticateResp._subscriptionStatus._terms, "from_dict"
                    )
                    else p
                    for p in d["terms"]
                ]
            if "account" in d:
                v["account"] = (
                    StoreAuthenticateResp._subscriptionStatus._account.from_dict(
                        d["account"]
                    )
                    if hasattr(
                        StoreAuthenticateResp._subscriptionStatus._account, "from_dict"
                    )
                    else d["account"]
                )
            if "family" in d:
                v["family"] = (
                    StoreAuthenticateResp._subscriptionStatus._family.from_dict(
                        d["family"]
                    )
                    if hasattr(
                        StoreAuthenticateResp._subscriptionStatus._family, "from_dict"
                    )
                    else d["family"]
                )
            return StoreAuthenticateResp._subscriptionStatus(**v)

        def as_dict(self):
            d = {}
            if self.__terms is not None:
                d["terms"] = [
                    p.as_dict() if hasattr(p, "as_dict") else p for p in self.__terms
                ]
            if self.__account is not None:
                d["account"] = (
                    self.__account.as_dict()
                    if hasattr(self.__account, "as_dict")
                    else self.__account
                )
            if self.__family is not None:
                d["family"] = (
                    self.__family.as_dict()
                    if hasattr(self.__family, "as_dict")
                    else self.__family
                )
            return d

        def __repr__(self):
            return "<Class _subscriptionStatus. terms: {}, account: {}, family: {}>".format(
                limitedRepr(
                    self.__terms[:20]
                    if isinstance(self.__terms, bytes)
                    else self.__terms
                ),
                limitedRepr(
                    self.__account[:20]
                    if isinstance(self.__account, bytes)
                    else self.__account
                ),
                limitedRepr(
                    self.__family[:20]
                    if isinstance(self.__family, bytes)
                    else self.__family
                ),
            )

    class _download_queue_info:

        _types_map = {
            "download_queue_item_count": {"type": int, "subtype": None},
            "dsid": {"type": int, "subtype": None},
            "is_auto_download_machine": {"type": bool, "subtype": None},
        }
        _formats_map = {}
        _validations_map = {
            "download_queue_item_count": {
                "required": True,
            },
            "dsid": {
                "required": True,
            },
            "is_auto_download_machine": {
                "required": True,
            },
        }

        def __init__(
            self,
            download_queue_item_count: int = None,
            dsid: int = None,
            is_auto_download_machine: bool = None,
        ):
            pass
            self.__download_queue_item_count = download_queue_item_count
            self.__dsid = dsid
            self.__is_auto_download_machine = is_auto_download_machine

        def _get_download_queue_item_count(self):
            return self.__download_queue_item_count

        def _set_download_queue_item_count(self, value):
            if not isinstance(value, int):
                raise TypeError("download_queue_item_count must be int")

            self.__download_queue_item_count = value

        download_queue_item_count = property(
            _get_download_queue_item_count, _set_download_queue_item_count
        )

        def _get_dsid(self):
            return self.__dsid

        def _set_dsid(self, value):
            if not isinstance(value, int):
                raise TypeError("dsid must be int")

            self.__dsid = value

        dsid = property(_get_dsid, _set_dsid)

        def _get_is_auto_download_machine(self):
            return self.__is_auto_download_machine

        def _set_is_auto_download_machine(self, value):
            if not isinstance(value, bool):
                raise TypeError("is_auto_download_machine must be bool")

            self.__is_auto_download_machine = value

        is_auto_download_machine = property(
            _get_is_auto_download_machine, _set_is_auto_download_machine
        )

        @staticmethod
        def from_dict(d):
            v = {}
            if "download-queue-item-count" in d:
                v["download_queue_item_count"] = (
                    int.from_dict(d["download-queue-item-count"])
                    if hasattr(int, "from_dict")
                    else d["download-queue-item-count"]
                )
            if "dsid" in d:
                v["dsid"] = (
                    int.from_dict(d["dsid"]) if hasattr(int, "from_dict") else d["dsid"]
                )
            if "is-auto-download-machine" in d:
                v["is_auto_download_machine"] = (
                    bool.from_dict(d["is-auto-download-machine"])
                    if hasattr(bool, "from_dict")
                    else d["is-auto-download-machine"]
                )
            return StoreAuthenticateResp._download_queue_info(**v)

        def as_dict(self):
            d = {}
            if self.__download_queue_item_count is not None:
                d["download-queue-item-count"] = (
                    self.__download_queue_item_count.as_dict()
                    if hasattr(self.__download_queue_item_count, "as_dict")
                    else self.__download_queue_item_count
                )
            if self.__dsid is not None:
                d["dsid"] = (
                    self.__dsid.as_dict()
                    if hasattr(self.__dsid, "as_dict")
                    else self.__dsid
                )
            if self.__is_auto_download_machine is not None:
                d["is-auto-download-machine"] = (
                    self.__is_auto_download_machine.as_dict()
                    if hasattr(self.__is_auto_download_machine, "as_dict")
                    else self.__is_auto_download_machine
                )
            return d

        def __repr__(self):
            return "<Class _download_queue_info. download_queue_item_count: {}, dsid: {}, is_auto_download_machine: {}>".format(
                limitedRepr(
                    self.__download_queue_item_count[:20]
                    if isinstance(self.__download_queue_item_count, bytes)
                    else self.__download_queue_item_count
                ),
                limitedRepr(
                    self.__dsid[:20] if isinstance(self.__dsid, bytes) else self.__dsid
                ),
                limitedRepr(
                    self.__is_auto_download_machine[:20]
                    if isinstance(self.__is_auto_download_machine, bytes)
                    else self.__is_auto_download_machine
                ),
            )

    class _dialog:

        _types_map = {
            "m_allowed": {"type": bool, "subtype": None},
            "message": {"type": str, "subtype": None},
            "explanation": {"type": str, "subtype": None},
            "defaultButton": {"type": str, "subtype": None},
            "okButtonString": {"type": str, "subtype": None},
            "initialCheckboxValue": {"type": bool, "subtype": None},
        }
        _formats_map = {}
        _validations_map = {
            "m_allowed": {
                "required": True,
            },
            "message": {
                "required": True,
            },
            "explanation": {
                "required": True,
            },
            "defaultButton": {
                "required": True,
            },
            "okButtonString": {
                "required": True,
            },
            "initialCheckboxValue": {
                "required": True,
            },
        }

        def __init__(
            self,
            m_allowed: bool = None,
            message: str = None,
            explanation: str = None,
            defaultButton: str = None,
            okButtonString: str = None,
            initialCheckboxValue: bool = None,
        ):
            pass
            self.__m_allowed = m_allowed
            self.__message = message
            self.__explanation = explanation
            self.__defaultButton = defaultButton
            self.__okButtonString = okButtonString
            self.__initialCheckboxValue = initialCheckboxValue

        def _get_m_allowed(self):
            return self.__m_allowed

        def _set_m_allowed(self, value):
            if not isinstance(value, bool):
                raise TypeError("m_allowed must be bool")

            self.__m_allowed = value

        m_allowed = property(_get_m_allowed, _set_m_allowed)

        def _get_message(self):
            return self.__message

        def _set_message(self, value):
            if not isinstance(value, str):
                raise TypeError("message must be str")

            self.__message = value

        message = property(_get_message, _set_message)

        def _get_explanation(self):
            return self.__explanation

        def _set_explanation(self, value):
            if not isinstance(value, str):
                raise TypeError("explanation must be str")

            self.__explanation = value

        explanation = property(_get_explanation, _set_explanation)

        def _get_defaultButton(self):
            return self.__defaultButton

        def _set_defaultButton(self, value):
            if not isinstance(value, str):
                raise TypeError("defaultButton must be str")

            self.__defaultButton = value

        defaultButton = property(_get_defaultButton, _set_defaultButton)

        def _get_okButtonString(self):
            return self.__okButtonString

        def _set_okButtonString(self, value):
            if not isinstance(value, str):
                raise TypeError("okButtonString must be str")

            self.__okButtonString = value

        okButtonString = property(_get_okButtonString, _set_okButtonString)

        def _get_initialCheckboxValue(self):
            return self.__initialCheckboxValue

        def _set_initialCheckboxValue(self, value):
            if not isinstance(value, bool):
                raise TypeError("initialCheckboxValue must be bool")

            self.__initialCheckboxValue = value

        initialCheckboxValue = property(
            _get_initialCheckboxValue, _set_initialCheckboxValue
        )

        @staticmethod
        def from_dict(d):
            v = {}
            if "m-allowed" in d:
                v["m_allowed"] = (
                    bool.from_dict(d["m-allowed"])
                    if hasattr(bool, "from_dict")
                    else d["m-allowed"]
                )
            if "message" in d:
                v["message"] = (
                    str.from_dict(d["message"])
                    if hasattr(str, "from_dict")
                    else d["message"]
                )
            if "explanation" in d:
                v["explanation"] = (
                    str.from_dict(d["explanation"])
                    if hasattr(str, "from_dict")
                    else d["explanation"]
                )
            if "defaultButton" in d:
                v["defaultButton"] = (
                    str.from_dict(d["defaultButton"])
                    if hasattr(str, "from_dict")
                    else d["defaultButton"]
                )
            if "okButtonString" in d:
                v["okButtonString"] = (
                    str.from_dict(d["okButtonString"])
                    if hasattr(str, "from_dict")
                    else d["okButtonString"]
                )
            if "initialCheckboxValue" in d:
                v["initialCheckboxValue"] = (
                    bool.from_dict(d["initialCheckboxValue"])
                    if hasattr(bool, "from_dict")
                    else d["initialCheckboxValue"]
                )
            return StoreAuthenticateResp._dialog(**v)

        def as_dict(self):
            d = {}
            if self.__m_allowed is not None:
                d["m-allowed"] = (
                    self.__m_allowed.as_dict()
                    if hasattr(self.__m_allowed, "as_dict")
                    else self.__m_allowed
                )
            if self.__message is not None:
                d["message"] = (
                    self.__message.as_dict()
                    if hasattr(self.__message, "as_dict")
                    else self.__message
                )
            if self.__explanation is not None:
                d["explanation"] = (
                    self.__explanation.as_dict()
                    if hasattr(self.__explanation, "as_dict")
                    else self.__explanation
                )
            if self.__defaultButton is not None:
                d["defaultButton"] = (
                    self.__defaultButton.as_dict()
                    if hasattr(self.__defaultButton, "as_dict")
                    else self.__defaultButton
                )
            if self.__okButtonString is not None:
                d["okButtonString"] = (
                    self.__okButtonString.as_dict()
                    if hasattr(self.__okButtonString, "as_dict")
                    else self.__okButtonString
                )
            if self.__initialCheckboxValue is not None:
                d["initialCheckboxValue"] = (
                    self.__initialCheckboxValue.as_dict()
                    if hasattr(self.__initialCheckboxValue, "as_dict")
                    else self.__initialCheckboxValue
                )
            return d

        def __repr__(self):
            return "<Class _dialog. m_allowed: {}, message: {}, explanation: {}, defaultButton: {}, okButtonString: {}, initialCheckboxValue: {}>".format(
                limitedRepr(
                    self.__m_allowed[:20]
                    if isinstance(self.__m_allowed, bytes)
                    else self.__m_allowed
                ),
                limitedRepr(
                    self.__message[:20]
                    if isinstance(self.__message, bytes)
                    else self.__message
                ),
                limitedRepr(
                    self.__explanation[:20]
                    if isinstance(self.__explanation, bytes)
                    else self.__explanation
                ),
                limitedRepr(
                    self.__defaultButton[:20]
                    if isinstance(self.__defaultButton, bytes)
                    else self.__defaultButton
                ),
                limitedRepr(
                    self.__okButtonString[:20]
                    if isinstance(self.__okButtonString, bytes)
                    else self.__okButtonString
                ),
                limitedRepr(
                    self.__initialCheckboxValue[:20]
                    if isinstance(self.__initialCheckboxValue, bytes)
                    else self.__initialCheckboxValue
                ),
            )

    class _privacyAcknowledgement:

        _types_map = {
            "com_apple_onboarding_appstore": {"type": int, "subtype": None},
            "com_apple_onboarding_applemusic": {"type": int, "subtype": None},
            "com_apple_onboarding_videos": {"type": int, "subtype": None},
            "com_apple_onboarding_itunesstore": {"type": int, "subtype": None},
            "com_apple_onboarding_itunesu": {"type": int, "subtype": None},
            "com_apple_onboarding_applearcade": {"type": int, "subtype": None},
        }
        _formats_map = {}
        _validations_map = {
            "com_apple_onboarding_appstore": {
                "required": True,
            },
            "com_apple_onboarding_applemusic": {
                "required": True,
            },
            "com_apple_onboarding_videos": {
                "required": True,
            },
            "com_apple_onboarding_itunesstore": {
                "required": True,
            },
            "com_apple_onboarding_itunesu": {
                "required": True,
            },
            "com_apple_onboarding_applearcade": {
                "required": True,
            },
        }

        def __init__(
            self,
            com_apple_onboarding_appstore: int = None,
            com_apple_onboarding_applemusic: int = None,
            com_apple_onboarding_videos: int = None,
            com_apple_onboarding_itunesstore: int = None,
            com_apple_onboarding_itunesu: int = None,
            com_apple_onboarding_applearcade: int = None,
        ):
            pass
            self.__com_apple_onboarding_appstore = com_apple_onboarding_appstore
            self.__com_apple_onboarding_applemusic = com_apple_onboarding_applemusic
            self.__com_apple_onboarding_videos = com_apple_onboarding_videos
            self.__com_apple_onboarding_itunesstore = com_apple_onboarding_itunesstore
            self.__com_apple_onboarding_itunesu = com_apple_onboarding_itunesu
            self.__com_apple_onboarding_applearcade = com_apple_onboarding_applearcade

        def _get_com_apple_onboarding_appstore(self):
            return self.__com_apple_onboarding_appstore

        def _set_com_apple_onboarding_appstore(self, value):
            if not isinstance(value, int):
                raise TypeError("com_apple_onboarding_appstore must be int")

            self.__com_apple_onboarding_appstore = value

        com_apple_onboarding_appstore = property(
            _get_com_apple_onboarding_appstore, _set_com_apple_onboarding_appstore
        )

        def _get_com_apple_onboarding_applemusic(self):
            return self.__com_apple_onboarding_applemusic

        def _set_com_apple_onboarding_applemusic(self, value):
            if not isinstance(value, int):
                raise TypeError("com_apple_onboarding_applemusic must be int")

            self.__com_apple_onboarding_applemusic = value

        com_apple_onboarding_applemusic = property(
            _get_com_apple_onboarding_applemusic, _set_com_apple_onboarding_applemusic
        )

        def _get_com_apple_onboarding_videos(self):
            return self.__com_apple_onboarding_videos

        def _set_com_apple_onboarding_videos(self, value):
            if not isinstance(value, int):
                raise TypeError("com_apple_onboarding_videos must be int")

            self.__com_apple_onboarding_videos = value

        com_apple_onboarding_videos = property(
            _get_com_apple_onboarding_videos, _set_com_apple_onboarding_videos
        )

        def _get_com_apple_onboarding_itunesstore(self):
            return self.__com_apple_onboarding_itunesstore

        def _set_com_apple_onboarding_itunesstore(self, value):
            if not isinstance(value, int):
                raise TypeError("com_apple_onboarding_itunesstore must be int")

            self.__com_apple_onboarding_itunesstore = value

        com_apple_onboarding_itunesstore = property(
            _get_com_apple_onboarding_itunesstore, _set_com_apple_onboarding_itunesstore
        )

        def _get_com_apple_onboarding_itunesu(self):
            return self.__com_apple_onboarding_itunesu

        def _set_com_apple_onboarding_itunesu(self, value):
            if not isinstance(value, int):
                raise TypeError("com_apple_onboarding_itunesu must be int")

            self.__com_apple_onboarding_itunesu = value

        com_apple_onboarding_itunesu = property(
            _get_com_apple_onboarding_itunesu, _set_com_apple_onboarding_itunesu
        )

        def _get_com_apple_onboarding_applearcade(self):
            return self.__com_apple_onboarding_applearcade

        def _set_com_apple_onboarding_applearcade(self, value):
            if not isinstance(value, int):
                raise TypeError("com_apple_onboarding_applearcade must be int")

            self.__com_apple_onboarding_applearcade = value

        com_apple_onboarding_applearcade = property(
            _get_com_apple_onboarding_applearcade, _set_com_apple_onboarding_applearcade
        )

        @staticmethod
        def from_dict(d):
            v = {}
            if "com.apple.onboarding.appstore" in d:
                v["com_apple_onboarding_appstore"] = (
                    int.from_dict(d["com.apple.onboarding.appstore"])
                    if hasattr(int, "from_dict")
                    else d["com.apple.onboarding.appstore"]
                )
            if "com.apple.onboarding.applemusic" in d:
                v["com_apple_onboarding_applemusic"] = (
                    int.from_dict(d["com.apple.onboarding.applemusic"])
                    if hasattr(int, "from_dict")
                    else d["com.apple.onboarding.applemusic"]
                )
            if "com.apple.onboarding.videos" in d:
                v["com_apple_onboarding_videos"] = (
                    int.from_dict(d["com.apple.onboarding.videos"])
                    if hasattr(int, "from_dict")
                    else d["com.apple.onboarding.videos"]
                )
            if "com.apple.onboarding.itunesstore" in d:
                v["com_apple_onboarding_itunesstore"] = (
                    int.from_dict(d["com.apple.onboarding.itunesstore"])
                    if hasattr(int, "from_dict")
                    else d["com.apple.onboarding.itunesstore"]
                )
            if "com.apple.onboarding.itunesu" in d:
                v["com_apple_onboarding_itunesu"] = (
                    int.from_dict(d["com.apple.onboarding.itunesu"])
                    if hasattr(int, "from_dict")
                    else d["com.apple.onboarding.itunesu"]
                )
            if "com.apple.onboarding.applearcade" in d:
                v["com_apple_onboarding_applearcade"] = (
                    int.from_dict(d["com.apple.onboarding.applearcade"])
                    if hasattr(int, "from_dict")
                    else d["com.apple.onboarding.applearcade"]
                )
            return StoreAuthenticateResp._privacyAcknowledgement(**v)

        def as_dict(self):
            d = {}
            if self.__com_apple_onboarding_appstore is not None:
                d["com.apple.onboarding.appstore"] = (
                    self.__com_apple_onboarding_appstore.as_dict()
                    if hasattr(self.__com_apple_onboarding_appstore, "as_dict")
                    else self.__com_apple_onboarding_appstore
                )
            if self.__com_apple_onboarding_applemusic is not None:
                d["com.apple.onboarding.applemusic"] = (
                    self.__com_apple_onboarding_applemusic.as_dict()
                    if hasattr(self.__com_apple_onboarding_applemusic, "as_dict")
                    else self.__com_apple_onboarding_applemusic
                )
            if self.__com_apple_onboarding_videos is not None:
                d["com.apple.onboarding.videos"] = (
                    self.__com_apple_onboarding_videos.as_dict()
                    if hasattr(self.__com_apple_onboarding_videos, "as_dict")
                    else self.__com_apple_onboarding_videos
                )
            if self.__com_apple_onboarding_itunesstore is not None:
                d["com.apple.onboarding.itunesstore"] = (
                    self.__com_apple_onboarding_itunesstore.as_dict()
                    if hasattr(self.__com_apple_onboarding_itunesstore, "as_dict")
                    else self.__com_apple_onboarding_itunesstore
                )
            if self.__com_apple_onboarding_itunesu is not None:
                d["com.apple.onboarding.itunesu"] = (
                    self.__com_apple_onboarding_itunesu.as_dict()
                    if hasattr(self.__com_apple_onboarding_itunesu, "as_dict")
                    else self.__com_apple_onboarding_itunesu
                )
            if self.__com_apple_onboarding_applearcade is not None:
                d["com.apple.onboarding.applearcade"] = (
                    self.__com_apple_onboarding_applearcade.as_dict()
                    if hasattr(self.__com_apple_onboarding_applearcade, "as_dict")
                    else self.__com_apple_onboarding_applearcade
                )
            return d

        def __repr__(self):
            return "<Class _privacyAcknowledgement. com_apple_onboarding_appstore: {}, com_apple_onboarding_applemusic: {}, com_apple_onboarding_videos: {}, com_apple_onboarding_itunesstore: {}, com_apple_onboarding_itunesu: {}, com_apple_onboarding_applearcade: {}>".format(
                limitedRepr(
                    self.__com_apple_onboarding_appstore[:20]
                    if isinstance(self.__com_apple_onboarding_appstore, bytes)
                    else self.__com_apple_onboarding_appstore
                ),
                limitedRepr(
                    self.__com_apple_onboarding_applemusic[:20]
                    if isinstance(self.__com_apple_onboarding_applemusic, bytes)
                    else self.__com_apple_onboarding_applemusic
                ),
                limitedRepr(
                    self.__com_apple_onboarding_videos[:20]
                    if isinstance(self.__com_apple_onboarding_videos, bytes)
                    else self.__com_apple_onboarding_videos
                ),
                limitedRepr(
                    self.__com_apple_onboarding_itunesstore[:20]
                    if isinstance(self.__com_apple_onboarding_itunesstore, bytes)
                    else self.__com_apple_onboarding_itunesstore
                ),
                limitedRepr(
                    self.__com_apple_onboarding_itunesu[:20]
                    if isinstance(self.__com_apple_onboarding_itunesu, bytes)
                    else self.__com_apple_onboarding_itunesu
                ),
                limitedRepr(
                    self.__com_apple_onboarding_applearcade[:20]
                    if isinstance(self.__com_apple_onboarding_applearcade, bytes)
                    else self.__com_apple_onboarding_applearcade
                ),
            )

    class _action:

        _types_map = {
            "kind": {"type": str, "subtype": None},
        }
        _formats_map = {}
        _validations_map = {
            "kind": {
                "required": True,
            },
        }

        def __init__(self, kind: str = None):
            pass
            self.__kind = kind

        def _get_kind(self):
            return self.__kind

        def _set_kind(self, value):
            if not isinstance(value, str):
                raise TypeError("kind must be str")

            self.__kind = value

        kind = property(_get_kind, _set_kind)

        @staticmethod
        def from_dict(d):
            v = {}
            if "kind" in d:
                v["kind"] = (
                    str.from_dict(d["kind"]) if hasattr(str, "from_dict") else d["kind"]
                )
            return StoreAuthenticateResp._action(**v)

        def as_dict(self):
            d = {}
            if self.__kind is not None:
                d["kind"] = (
                    self.__kind.as_dict()
                    if hasattr(self.__kind, "as_dict")
                    else self.__kind
                )
            return d

        def __repr__(self):
            return "<Class _action. kind: {}>".format(
                limitedRepr(
                    self.__kind[:20] if isinstance(self.__kind, bytes) else self.__kind
                )
            )

    class _accountInfo:
        class _address:

            _types_map = {
                "firstName": {"type": str, "subtype": None},
                "lastName": {"type": str, "subtype": None},
            }
            _formats_map = {}
            _validations_map = {
                "firstName": {
                    "required": True,
                },
                "lastName": {
                    "required": True,
                },
            }

            def __init__(self, firstName: str = None, lastName: str = None):
                pass
                self.__firstName = firstName
                self.__lastName = lastName

            def _get_firstName(self):
                return self.__firstName

            def _set_firstName(self, value):
                if not isinstance(value, str):
                    raise TypeError("firstName must be str")

                self.__firstName = value

            firstName = property(_get_firstName, _set_firstName)

            def _get_lastName(self):
                return self.__lastName

            def _set_lastName(self, value):
                if not isinstance(value, str):
                    raise TypeError("lastName must be str")

                self.__lastName = value

            lastName = property(_get_lastName, _set_lastName)

            @staticmethod
            def from_dict(d):
                v = {}
                if "firstName" in d:
                    v["firstName"] = (
                        str.from_dict(d["firstName"])
                        if hasattr(str, "from_dict")
                        else d["firstName"]
                    )
                if "lastName" in d:
                    v["lastName"] = (
                        str.from_dict(d["lastName"])
                        if hasattr(str, "from_dict")
                        else d["lastName"]
                    )
                return StoreAuthenticateResp._accountInfo._address(**v)

            def as_dict(self):
                d = {}
                if self.__firstName is not None:
                    d["firstName"] = (
                        self.__firstName.as_dict()
                        if hasattr(self.__firstName, "as_dict")
                        else self.__firstName
                    )
                if self.__lastName is not None:
                    d["lastName"] = (
                        self.__lastName.as_dict()
                        if hasattr(self.__lastName, "as_dict")
                        else self.__lastName
                    )
                return d

            def __repr__(self):
                return "<Class _address. firstName: {}, lastName: {}>".format(
                    limitedRepr(
                        self.__firstName[:20]
                        if isinstance(self.__firstName, bytes)
                        else self.__firstName
                    ),
                    limitedRepr(
                        self.__lastName[:20]
                        if isinstance(self.__lastName, bytes)
                        else self.__lastName
                    ),
                )

        _types_map = {
            "appleId": {"type": str, "subtype": None},
            "address": {"type": _address, "subtype": None},
        }
        _formats_map = {}
        _validations_map = {
            "appleId": {
                "required": True,
            },
            "address": {
                "required": True,
            },
        }

        def __init__(self, appleId: str = None, address: _address = None):
            pass
            self.__appleId = appleId
            self.__address = address

        def _get_appleId(self):
            return self.__appleId

        def _set_appleId(self, value):
            if not isinstance(value, str):
                raise TypeError("appleId must be str")

            self.__appleId = value

        appleId = property(_get_appleId, _set_appleId)

        def _get_address(self):
            return self.__address

        def _set_address(self, value):
            if not isinstance(value, StoreAuthenticateResp._accountInfo._address):
                raise TypeError(
                    "address must be StoreAuthenticateResp._accountInfo._address"
                )

            self.__address = value

        address = property(_get_address, _set_address)

        @staticmethod
        def from_dict(d):
            v = {}
            if "appleId" in d:
                v["appleId"] = (
                    str.from_dict(d["appleId"])
                    if hasattr(str, "from_dict")
                    else d["appleId"]
                )
            if "address" in d:
                v["address"] = (
                    StoreAuthenticateResp._accountInfo._address.from_dict(d["address"])
                    if hasattr(StoreAuthenticateResp._accountInfo._address, "from_dict")
                    else d["address"]
                )
            return StoreAuthenticateResp._accountInfo(**v)

        def as_dict(self):
            d = {}
            if self.__appleId is not None:
                d["appleId"] = (
                    self.__appleId.as_dict()
                    if hasattr(self.__appleId, "as_dict")
                    else self.__appleId
                )
            if self.__address is not None:
                d["address"] = (
                    self.__address.as_dict()
                    if hasattr(self.__address, "as_dict")
                    else self.__address
                )
            return d

        def __repr__(self):
            return "<Class _accountInfo. appleId: {}, address: {}>".format(
                limitedRepr(
                    self.__appleId[:20]
                    if isinstance(self.__appleId, bytes)
                    else self.__appleId
                ),
                limitedRepr(
                    self.__address[:20]
                    if isinstance(self.__address, bytes)
                    else self.__address
                ),
            )

    class _accountFlags:

        _types_map = {
            "personalization": {"type": bool, "subtype": None},
            "underThirteen": {"type": bool, "subtype": None},
            "identityLastVerified": {"type": int, "subtype": None},
            "verifiedExpirationDate": {"type": int, "subtype": None},
            "retailDemo": {"type": bool, "subtype": None},
            "autoPlay": {"type": bool, "subtype": None},
            "isDisabledAccount": {"type": bool, "subtype": None},
            "isRestrictedAccount": {"type": bool, "subtype": None},
            "isManagedAccount": {"type": bool, "subtype": None},
            "isInRestrictedRegion": {"type": bool, "subtype": None},
            "accountFlagsVersion": {"type": int, "subtype": None},
            "hasAgreedToTerms": {"type": bool, "subtype": None},
            "hasAgreedToAppClipTerms": {"type": bool, "subtype": None},
            "hasWatchHardwareOffer": {"type": bool, "subtype": None},
            "isInFamily": {"type": bool, "subtype": None},
            "hasSubscriptionFamilySharingEnabled": {"type": bool, "subtype": None},
        }
        _formats_map = {}
        _validations_map = {
            "personalization": {
                "required": True,
            },
            "underThirteen": {
                "required": True,
            },
            "identityLastVerified": {
                "required": True,
            },
            "verifiedExpirationDate": {
                "required": True,
            },
            "retailDemo": {
                "required": True,
            },
            "autoPlay": {
                "required": True,
            },
            "isDisabledAccount": {
                "required": True,
            },
            "isRestrictedAccount": {
                "required": True,
            },
            "isManagedAccount": {
                "required": True,
            },
            "isInRestrictedRegion": {
                "required": True,
            },
            "accountFlagsVersion": {
                "required": True,
            },
            "hasAgreedToTerms": {
                "required": True,
            },
            "hasAgreedToAppClipTerms": {
                "required": True,
            },
            "hasWatchHardwareOffer": {
                "required": True,
            },
            "isInFamily": {
                "required": True,
            },
            "hasSubscriptionFamilySharingEnabled": {
                "required": True,
            },
        }

        def __init__(
            self,
            personalization: bool = None,
            underThirteen: bool = None,
            identityLastVerified: int = None,
            verifiedExpirationDate: int = None,
            retailDemo: bool = None,
            autoPlay: bool = None,
            isDisabledAccount: bool = None,
            isRestrictedAccount: bool = None,
            isManagedAccount: bool = None,
            isInRestrictedRegion: bool = None,
            accountFlagsVersion: int = None,
            hasAgreedToTerms: bool = None,
            hasAgreedToAppClipTerms: bool = None,
            hasWatchHardwareOffer: bool = None,
            isInFamily: bool = None,
            hasSubscriptionFamilySharingEnabled: bool = None,
        ):
            pass
            self.__personalization = personalization
            self.__underThirteen = underThirteen
            self.__identityLastVerified = identityLastVerified
            self.__verifiedExpirationDate = verifiedExpirationDate
            self.__retailDemo = retailDemo
            self.__autoPlay = autoPlay
            self.__isDisabledAccount = isDisabledAccount
            self.__isRestrictedAccount = isRestrictedAccount
            self.__isManagedAccount = isManagedAccount
            self.__isInRestrictedRegion = isInRestrictedRegion
            self.__accountFlagsVersion = accountFlagsVersion
            self.__hasAgreedToTerms = hasAgreedToTerms
            self.__hasAgreedToAppClipTerms = hasAgreedToAppClipTerms
            self.__hasWatchHardwareOffer = hasWatchHardwareOffer
            self.__isInFamily = isInFamily
            self.__hasSubscriptionFamilySharingEnabled = (
                hasSubscriptionFamilySharingEnabled
            )

        def _get_personalization(self):
            return self.__personalization

        def _set_personalization(self, value):
            if not isinstance(value, bool):
                raise TypeError("personalization must be bool")

            self.__personalization = value

        personalization = property(_get_personalization, _set_personalization)

        def _get_underThirteen(self):
            return self.__underThirteen

        def _set_underThirteen(self, value):
            if not isinstance(value, bool):
                raise TypeError("underThirteen must be bool")

            self.__underThirteen = value

        underThirteen = property(_get_underThirteen, _set_underThirteen)

        def _get_identityLastVerified(self):
            return self.__identityLastVerified

        def _set_identityLastVerified(self, value):
            if not isinstance(value, int):
                raise TypeError("identityLastVerified must be int")

            self.__identityLastVerified = value

        identityLastVerified = property(
            _get_identityLastVerified, _set_identityLastVerified
        )

        def _get_verifiedExpirationDate(self):
            return self.__verifiedExpirationDate

        def _set_verifiedExpirationDate(self, value):
            if not isinstance(value, int):
                raise TypeError("verifiedExpirationDate must be int")

            self.__verifiedExpirationDate = value

        verifiedExpirationDate = property(
            _get_verifiedExpirationDate, _set_verifiedExpirationDate
        )

        def _get_retailDemo(self):
            return self.__retailDemo

        def _set_retailDemo(self, value):
            if not isinstance(value, bool):
                raise TypeError("retailDemo must be bool")

            self.__retailDemo = value

        retailDemo = property(_get_retailDemo, _set_retailDemo)

        def _get_autoPlay(self):
            return self.__autoPlay

        def _set_autoPlay(self, value):
            if not isinstance(value, bool):
                raise TypeError("autoPlay must be bool")

            self.__autoPlay = value

        autoPlay = property(_get_autoPlay, _set_autoPlay)

        def _get_isDisabledAccount(self):
            return self.__isDisabledAccount

        def _set_isDisabledAccount(self, value):
            if not isinstance(value, bool):
                raise TypeError("isDisabledAccount must be bool")

            self.__isDisabledAccount = value

        isDisabledAccount = property(_get_isDisabledAccount, _set_isDisabledAccount)

        def _get_isRestrictedAccount(self):
            return self.__isRestrictedAccount

        def _set_isRestrictedAccount(self, value):
            if not isinstance(value, bool):
                raise TypeError("isRestrictedAccount must be bool")

            self.__isRestrictedAccount = value

        isRestrictedAccount = property(
            _get_isRestrictedAccount, _set_isRestrictedAccount
        )

        def _get_isManagedAccount(self):
            return self.__isManagedAccount

        def _set_isManagedAccount(self, value):
            if not isinstance(value, bool):
                raise TypeError("isManagedAccount must be bool")

            self.__isManagedAccount = value

        isManagedAccount = property(_get_isManagedAccount, _set_isManagedAccount)

        def _get_isInRestrictedRegion(self):
            return self.__isInRestrictedRegion

        def _set_isInRestrictedRegion(self, value):
            if not isinstance(value, bool):
                raise TypeError("isInRestrictedRegion must be bool")

            self.__isInRestrictedRegion = value

        isInRestrictedRegion = property(
            _get_isInRestrictedRegion, _set_isInRestrictedRegion
        )

        def _get_accountFlagsVersion(self):
            return self.__accountFlagsVersion

        def _set_accountFlagsVersion(self, value):
            if not isinstance(value, int):
                raise TypeError("accountFlagsVersion must be int")

            self.__accountFlagsVersion = value

        accountFlagsVersion = property(
            _get_accountFlagsVersion, _set_accountFlagsVersion
        )

        def _get_hasAgreedToTerms(self):
            return self.__hasAgreedToTerms

        def _set_hasAgreedToTerms(self, value):
            if not isinstance(value, bool):
                raise TypeError("hasAgreedToTerms must be bool")

            self.__hasAgreedToTerms = value

        hasAgreedToTerms = property(_get_hasAgreedToTerms, _set_hasAgreedToTerms)

        def _get_hasAgreedToAppClipTerms(self):
            return self.__hasAgreedToAppClipTerms

        def _set_hasAgreedToAppClipTerms(self, value):
            if not isinstance(value, bool):
                raise TypeError("hasAgreedToAppClipTerms must be bool")

            self.__hasAgreedToAppClipTerms = value

        hasAgreedToAppClipTerms = property(
            _get_hasAgreedToAppClipTerms, _set_hasAgreedToAppClipTerms
        )

        def _get_hasWatchHardwareOffer(self):
            return self.__hasWatchHardwareOffer

        def _set_hasWatchHardwareOffer(self, value):
            if not isinstance(value, bool):
                raise TypeError("hasWatchHardwareOffer must be bool")

            self.__hasWatchHardwareOffer = value

        hasWatchHardwareOffer = property(
            _get_hasWatchHardwareOffer, _set_hasWatchHardwareOffer
        )

        def _get_isInFamily(self):
            return self.__isInFamily

        def _set_isInFamily(self, value):
            if not isinstance(value, bool):
                raise TypeError("isInFamily must be bool")

            self.__isInFamily = value

        isInFamily = property(_get_isInFamily, _set_isInFamily)

        def _get_hasSubscriptionFamilySharingEnabled(self):
            return self.__hasSubscriptionFamilySharingEnabled

        def _set_hasSubscriptionFamilySharingEnabled(self, value):
            if not isinstance(value, bool):
                raise TypeError("hasSubscriptionFamilySharingEnabled must be bool")

            self.__hasSubscriptionFamilySharingEnabled = value

        hasSubscriptionFamilySharingEnabled = property(
            _get_hasSubscriptionFamilySharingEnabled,
            _set_hasSubscriptionFamilySharingEnabled,
        )

        @staticmethod
        def from_dict(d):
            v = {}
            if "personalization" in d:
                v["personalization"] = (
                    bool.from_dict(d["personalization"])
                    if hasattr(bool, "from_dict")
                    else d["personalization"]
                )
            if "underThirteen" in d:
                v["underThirteen"] = (
                    bool.from_dict(d["underThirteen"])
                    if hasattr(bool, "from_dict")
                    else d["underThirteen"]
                )
            if "identityLastVerified" in d:
                v["identityLastVerified"] = (
                    int.from_dict(d["identityLastVerified"])
                    if hasattr(int, "from_dict")
                    else d["identityLastVerified"]
                )
            if "verifiedExpirationDate" in d:
                v["verifiedExpirationDate"] = (
                    int.from_dict(d["verifiedExpirationDate"])
                    if hasattr(int, "from_dict")
                    else d["verifiedExpirationDate"]
                )
            if "retailDemo" in d:
                v["retailDemo"] = (
                    bool.from_dict(d["retailDemo"])
                    if hasattr(bool, "from_dict")
                    else d["retailDemo"]
                )
            if "autoPlay" in d:
                v["autoPlay"] = (
                    bool.from_dict(d["autoPlay"])
                    if hasattr(bool, "from_dict")
                    else d["autoPlay"]
                )
            if "isDisabledAccount" in d:
                v["isDisabledAccount"] = (
                    bool.from_dict(d["isDisabledAccount"])
                    if hasattr(bool, "from_dict")
                    else d["isDisabledAccount"]
                )
            if "isRestrictedAccount" in d:
                v["isRestrictedAccount"] = (
                    bool.from_dict(d["isRestrictedAccount"])
                    if hasattr(bool, "from_dict")
                    else d["isRestrictedAccount"]
                )
            if "isManagedAccount" in d:
                v["isManagedAccount"] = (
                    bool.from_dict(d["isManagedAccount"])
                    if hasattr(bool, "from_dict")
                    else d["isManagedAccount"]
                )
            if "isInRestrictedRegion" in d:
                v["isInRestrictedRegion"] = (
                    bool.from_dict(d["isInRestrictedRegion"])
                    if hasattr(bool, "from_dict")
                    else d["isInRestrictedRegion"]
                )
            if "accountFlagsVersion" in d:
                v["accountFlagsVersion"] = (
                    int.from_dict(d["accountFlagsVersion"])
                    if hasattr(int, "from_dict")
                    else d["accountFlagsVersion"]
                )
            if "hasAgreedToTerms" in d:
                v["hasAgreedToTerms"] = (
                    bool.from_dict(d["hasAgreedToTerms"])
                    if hasattr(bool, "from_dict")
                    else d["hasAgreedToTerms"]
                )
            if "hasAgreedToAppClipTerms" in d:
                v["hasAgreedToAppClipTerms"] = (
                    bool.from_dict(d["hasAgreedToAppClipTerms"])
                    if hasattr(bool, "from_dict")
                    else d["hasAgreedToAppClipTerms"]
                )
            if "hasWatchHardwareOffer" in d:
                v["hasWatchHardwareOffer"] = (
                    bool.from_dict(d["hasWatchHardwareOffer"])
                    if hasattr(bool, "from_dict")
                    else d["hasWatchHardwareOffer"]
                )
            if "isInFamily" in d:
                v["isInFamily"] = (
                    bool.from_dict(d["isInFamily"])
                    if hasattr(bool, "from_dict")
                    else d["isInFamily"]
                )
            if "hasSubscriptionFamilySharingEnabled" in d:
                v["hasSubscriptionFamilySharingEnabled"] = (
                    bool.from_dict(d["hasSubscriptionFamilySharingEnabled"])
                    if hasattr(bool, "from_dict")
                    else d["hasSubscriptionFamilySharingEnabled"]
                )
            return StoreAuthenticateResp._accountFlags(**v)

        def as_dict(self):
            d = {}
            if self.__personalization is not None:
                d["personalization"] = (
                    self.__personalization.as_dict()
                    if hasattr(self.__personalization, "as_dict")
                    else self.__personalization
                )
            if self.__underThirteen is not None:
                d["underThirteen"] = (
                    self.__underThirteen.as_dict()
                    if hasattr(self.__underThirteen, "as_dict")
                    else self.__underThirteen
                )
            if self.__identityLastVerified is not None:
                d["identityLastVerified"] = (
                    self.__identityLastVerified.as_dict()
                    if hasattr(self.__identityLastVerified, "as_dict")
                    else self.__identityLastVerified
                )
            if self.__verifiedExpirationDate is not None:
                d["verifiedExpirationDate"] = (
                    self.__verifiedExpirationDate.as_dict()
                    if hasattr(self.__verifiedExpirationDate, "as_dict")
                    else self.__verifiedExpirationDate
                )
            if self.__retailDemo is not None:
                d["retailDemo"] = (
                    self.__retailDemo.as_dict()
                    if hasattr(self.__retailDemo, "as_dict")
                    else self.__retailDemo
                )
            if self.__autoPlay is not None:
                d["autoPlay"] = (
                    self.__autoPlay.as_dict()
                    if hasattr(self.__autoPlay, "as_dict")
                    else self.__autoPlay
                )
            if self.__isDisabledAccount is not None:
                d["isDisabledAccount"] = (
                    self.__isDisabledAccount.as_dict()
                    if hasattr(self.__isDisabledAccount, "as_dict")
                    else self.__isDisabledAccount
                )
            if self.__isRestrictedAccount is not None:
                d["isRestrictedAccount"] = (
                    self.__isRestrictedAccount.as_dict()
                    if hasattr(self.__isRestrictedAccount, "as_dict")
                    else self.__isRestrictedAccount
                )
            if self.__isManagedAccount is not None:
                d["isManagedAccount"] = (
                    self.__isManagedAccount.as_dict()
                    if hasattr(self.__isManagedAccount, "as_dict")
                    else self.__isManagedAccount
                )
            if self.__isInRestrictedRegion is not None:
                d["isInRestrictedRegion"] = (
                    self.__isInRestrictedRegion.as_dict()
                    if hasattr(self.__isInRestrictedRegion, "as_dict")
                    else self.__isInRestrictedRegion
                )
            if self.__accountFlagsVersion is not None:
                d["accountFlagsVersion"] = (
                    self.__accountFlagsVersion.as_dict()
                    if hasattr(self.__accountFlagsVersion, "as_dict")
                    else self.__accountFlagsVersion
                )
            if self.__hasAgreedToTerms is not None:
                d["hasAgreedToTerms"] = (
                    self.__hasAgreedToTerms.as_dict()
                    if hasattr(self.__hasAgreedToTerms, "as_dict")
                    else self.__hasAgreedToTerms
                )
            if self.__hasAgreedToAppClipTerms is not None:
                d["hasAgreedToAppClipTerms"] = (
                    self.__hasAgreedToAppClipTerms.as_dict()
                    if hasattr(self.__hasAgreedToAppClipTerms, "as_dict")
                    else self.__hasAgreedToAppClipTerms
                )
            if self.__hasWatchHardwareOffer is not None:
                d["hasWatchHardwareOffer"] = (
                    self.__hasWatchHardwareOffer.as_dict()
                    if hasattr(self.__hasWatchHardwareOffer, "as_dict")
                    else self.__hasWatchHardwareOffer
                )
            if self.__isInFamily is not None:
                d["isInFamily"] = (
                    self.__isInFamily.as_dict()
                    if hasattr(self.__isInFamily, "as_dict")
                    else self.__isInFamily
                )
            if self.__hasSubscriptionFamilySharingEnabled is not None:
                d["hasSubscriptionFamilySharingEnabled"] = (
                    self.__hasSubscriptionFamilySharingEnabled.as_dict()
                    if hasattr(self.__hasSubscriptionFamilySharingEnabled, "as_dict")
                    else self.__hasSubscriptionFamilySharingEnabled
                )
            return d

        def __repr__(self):
            return "<Class _accountFlags. personalization: {}, underThirteen: {}, identityLastVerified: {}, verifiedExpirationDate: {}, retailDemo: {}, autoPlay: {}, isDisabledAccount: {}, isRestrictedAccount: {}, isManagedAccount: {}, isInRestrictedRegion: {}, accountFlagsVersion: {}, hasAgreedToTerms: {}, hasAgreedToAppClipTerms: {}, hasWatchHardwareOffer: {}, isInFamily: {}, hasSubscriptionFamilySharingEnabled: {}>".format(
                limitedRepr(
                    self.__personalization[:20]
                    if isinstance(self.__personalization, bytes)
                    else self.__personalization
                ),
                limitedRepr(
                    self.__underThirteen[:20]
                    if isinstance(self.__underThirteen, bytes)
                    else self.__underThirteen
                ),
                limitedRepr(
                    self.__identityLastVerified[:20]
                    if isinstance(self.__identityLastVerified, bytes)
                    else self.__identityLastVerified
                ),
                limitedRepr(
                    self.__verifiedExpirationDate[:20]
                    if isinstance(self.__verifiedExpirationDate, bytes)
                    else self.__verifiedExpirationDate
                ),
                limitedRepr(
                    self.__retailDemo[:20]
                    if isinstance(self.__retailDemo, bytes)
                    else self.__retailDemo
                ),
                limitedRepr(
                    self.__autoPlay[:20]
                    if isinstance(self.__autoPlay, bytes)
                    else self.__autoPlay
                ),
                limitedRepr(
                    self.__isDisabledAccount[:20]
                    if isinstance(self.__isDisabledAccount, bytes)
                    else self.__isDisabledAccount
                ),
                limitedRepr(
                    self.__isRestrictedAccount[:20]
                    if isinstance(self.__isRestrictedAccount, bytes)
                    else self.__isRestrictedAccount
                ),
                limitedRepr(
                    self.__isManagedAccount[:20]
                    if isinstance(self.__isManagedAccount, bytes)
                    else self.__isManagedAccount
                ),
                limitedRepr(
                    self.__isInRestrictedRegion[:20]
                    if isinstance(self.__isInRestrictedRegion, bytes)
                    else self.__isInRestrictedRegion
                ),
                limitedRepr(
                    self.__accountFlagsVersion[:20]
                    if isinstance(self.__accountFlagsVersion, bytes)
                    else self.__accountFlagsVersion
                ),
                limitedRepr(
                    self.__hasAgreedToTerms[:20]
                    if isinstance(self.__hasAgreedToTerms, bytes)
                    else self.__hasAgreedToTerms
                ),
                limitedRepr(
                    self.__hasAgreedToAppClipTerms[:20]
                    if isinstance(self.__hasAgreedToAppClipTerms, bytes)
                    else self.__hasAgreedToAppClipTerms
                ),
                limitedRepr(
                    self.__hasWatchHardwareOffer[:20]
                    if isinstance(self.__hasWatchHardwareOffer, bytes)
                    else self.__hasWatchHardwareOffer
                ),
                limitedRepr(
                    self.__isInFamily[:20]
                    if isinstance(self.__isInFamily, bytes)
                    else self.__isInFamily
                ),
                limitedRepr(
                    self.__hasSubscriptionFamilySharingEnabled[:20]
                    if isinstance(self.__hasSubscriptionFamilySharingEnabled, bytes)
                    else self.__hasSubscriptionFamilySharingEnabled
                ),
            )

    _types_map = {
        "pings": {"type": list, "subtype": float},
        "cancel_purchase_batch": {"type": bool, "subtype": None},
        "customerMessage": {"type": str, "subtype": None},
        "failureType": {"type": str, "subtype": None},
        "accountInfo": {"type": _accountInfo, "subtype": None},
        "passwordToken": {"type": str, "subtype": None},
        "clearToken": {"type": str, "subtype": None},
        "m_allowed": {"type": bool, "subtype": None},
        "is_cloud_enabled": {"type": str, "subtype": None},
        "dsPersonId": {"type": str, "subtype": None},
        "creditDisplay": {"type": str, "subtype": None},
        "creditBalance": {"type": str, "subtype": None},
        "freeSongBalance": {"type": str, "subtype": None},
        "isManagedStudent": {"type": bool, "subtype": None},
        "action": {"type": _action, "subtype": None},
        "subscriptionStatus": {"type": _subscriptionStatus, "subtype": None},
        "accountFlags": {"type": _accountFlags, "subtype": None},
        "status": {"type": int, "subtype": None},
        "download_queue_info": {"type": _download_queue_info, "subtype": None},
        "privacyAcknowledgement": {"type": _privacyAcknowledgement, "subtype": None},
        "dialog": {"type": _dialog, "subtype": None},
    }
    _formats_map = {}
    _validations_map = {
        "pings": {
            "required": True,
        },
        "cancel_purchase_batch": {
            "required": False,
        },
        "customerMessage": {
            "required": False,
        },
        "failureType": {
            "required": False,
        },
        "accountInfo": {
            "required": True,
        },
        "passwordToken": {
            "required": True,
        },
        "clearToken": {
            "required": True,
        },
        "m_allowed": {
            "required": True,
        },
        "is_cloud_enabled": {
            "required": True,
        },
        "dsPersonId": {
            "required": True,
        },
        "creditDisplay": {
            "required": True,
        },
        "creditBalance": {
            "required": True,
        },
        "freeSongBalance": {
            "required": True,
        },
        "isManagedStudent": {
            "required": True,
        },
        "action": {
            "required": True,
        },
        "subscriptionStatus": {
            "required": True,
        },
        "accountFlags": {
            "required": True,
        },
        "status": {
            "required": True,
        },
        "download_queue_info": {
            "required": True,
        },
        "privacyAcknowledgement": {
            "required": True,
        },
        "dialog": {
            "required": True,
        },
    }

    def __init__(
        self,
        pings: List[float] = None,
        cancel_purchase_batch: bool = None,
        customerMessage: str = None,
        failureType: str = None,
        accountInfo: _accountInfo = None,
        passwordToken: str = None,
        clearToken: str = None,
        m_allowed: bool = None,
        is_cloud_enabled: str = None,
        dsPersonId: str = None,
        creditDisplay: str = None,
        creditBalance: str = None,
        freeSongBalance: str = None,
        isManagedStudent: bool = None,
        action: _action = None,
        subscriptionStatus: _subscriptionStatus = None,
        accountFlags: _accountFlags = None,
        status: int = None,
        download_queue_info: _download_queue_info = None,
        privacyAcknowledgement: _privacyAcknowledgement = None,
        dialog: _dialog = None,
    ):
        pass
        self.__pings = pings
        self.__cancel_purchase_batch = cancel_purchase_batch
        self.__customerMessage = customerMessage
        self.__failureType = failureType
        self.__accountInfo = accountInfo
        self.__passwordToken = passwordToken
        self.__clearToken = clearToken
        self.__m_allowed = m_allowed
        self.__is_cloud_enabled = is_cloud_enabled
        self.__dsPersonId = dsPersonId
        self.__creditDisplay = creditDisplay
        self.__creditBalance = creditBalance
        self.__freeSongBalance = freeSongBalance
        self.__isManagedStudent = isManagedStudent
        self.__action = action
        self.__subscriptionStatus = subscriptionStatus
        self.__accountFlags = accountFlags
        self.__status = status
        self.__download_queue_info = download_queue_info
        self.__privacyAcknowledgement = privacyAcknowledgement
        self.__dialog = dialog

    def _get_pings(self):
        return self.__pings

    def _set_pings(self, value):
        if not isinstance(value, list):
            raise TypeError("pings must be list")
        if not all(isinstance(i, float) for i in value):
            raise TypeError("pings list values must be float")

        self.__pings = value

    pings = property(_get_pings, _set_pings)

    def _get_cancel_purchase_batch(self):
        return self.__cancel_purchase_batch

    def _set_cancel_purchase_batch(self, value):
        if value is not None and not isinstance(value, bool):
            raise TypeError("cancel_purchase_batch must be bool")

        self.__cancel_purchase_batch = value

    cancel_purchase_batch = property(
        _get_cancel_purchase_batch, _set_cancel_purchase_batch
    )

    def _get_customerMessage(self):
        return self.__customerMessage

    def _set_customerMessage(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("customerMessage must be str")

        self.__customerMessage = value

    customerMessage = property(_get_customerMessage, _set_customerMessage)

    def _get_failureType(self):
        return self.__failureType

    def _set_failureType(self, value):
        if value is not None and not isinstance(value, str):
            raise TypeError("failureType must be str")

        self.__failureType = value

    failureType = property(_get_failureType, _set_failureType)

    def _get_accountInfo(self):
        return self.__accountInfo

    def _set_accountInfo(self, value):
        if not isinstance(value, StoreAuthenticateResp._accountInfo):
            raise TypeError("accountInfo must be StoreAuthenticateResp._accountInfo")

        self.__accountInfo = value

    accountInfo = property(_get_accountInfo, _set_accountInfo)

    def _get_passwordToken(self):
        return self.__passwordToken

    def _set_passwordToken(self, value):
        if not isinstance(value, str):
            raise TypeError("passwordToken must be str")

        self.__passwordToken = value

    passwordToken = property(_get_passwordToken, _set_passwordToken)

    def _get_clearToken(self):
        return self.__clearToken

    def _set_clearToken(self, value):
        if not isinstance(value, str):
            raise TypeError("clearToken must be str")

        self.__clearToken = value

    clearToken = property(_get_clearToken, _set_clearToken)

    def _get_m_allowed(self):
        return self.__m_allowed

    def _set_m_allowed(self, value):
        if not isinstance(value, bool):
            raise TypeError("m_allowed must be bool")

        self.__m_allowed = value

    m_allowed = property(_get_m_allowed, _set_m_allowed)

    def _get_is_cloud_enabled(self):
        return self.__is_cloud_enabled

    def _set_is_cloud_enabled(self, value):
        if not isinstance(value, str):
            raise TypeError("is_cloud_enabled must be str")

        self.__is_cloud_enabled = value

    is_cloud_enabled = property(_get_is_cloud_enabled, _set_is_cloud_enabled)

    def _get_dsPersonId(self):
        return self.__dsPersonId

    def _set_dsPersonId(self, value):
        if not isinstance(value, str):
            raise TypeError("dsPersonId must be str")

        self.__dsPersonId = value

    dsPersonId = property(_get_dsPersonId, _set_dsPersonId)

    def _get_creditDisplay(self):
        return self.__creditDisplay

    def _set_creditDisplay(self, value):
        if not isinstance(value, str):
            raise TypeError("creditDisplay must be str")

        self.__creditDisplay = value

    creditDisplay = property(_get_creditDisplay, _set_creditDisplay)

    def _get_creditBalance(self):
        return self.__creditBalance

    def _set_creditBalance(self, value):
        if not isinstance(value, str):
            raise TypeError("creditBalance must be str")

        self.__creditBalance = value

    creditBalance = property(_get_creditBalance, _set_creditBalance)

    def _get_freeSongBalance(self):
        return self.__freeSongBalance

    def _set_freeSongBalance(self, value):
        if not isinstance(value, str):
            raise TypeError("freeSongBalance must be str")

        self.__freeSongBalance = value

    freeSongBalance = property(_get_freeSongBalance, _set_freeSongBalance)

    def _get_isManagedStudent(self):
        return self.__isManagedStudent

    def _set_isManagedStudent(self, value):
        if not isinstance(value, bool):
            raise TypeError("isManagedStudent must be bool")

        self.__isManagedStudent = value

    isManagedStudent = property(_get_isManagedStudent, _set_isManagedStudent)

    def _get_action(self):
        return self.__action

    def _set_action(self, value):
        if not isinstance(value, StoreAuthenticateResp._action):
            raise TypeError("action must be StoreAuthenticateResp._action")

        self.__action = value

    action = property(_get_action, _set_action)

    def _get_subscriptionStatus(self):
        return self.__subscriptionStatus

    def _set_subscriptionStatus(self, value):
        if not isinstance(value, StoreAuthenticateResp._subscriptionStatus):
            raise TypeError(
                "subscriptionStatus must be StoreAuthenticateResp._subscriptionStatus"
            )

        self.__subscriptionStatus = value

    subscriptionStatus = property(_get_subscriptionStatus, _set_subscriptionStatus)

    def _get_accountFlags(self):
        return self.__accountFlags

    def _set_accountFlags(self, value):
        if not isinstance(value, StoreAuthenticateResp._accountFlags):
            raise TypeError("accountFlags must be StoreAuthenticateResp._accountFlags")

        self.__accountFlags = value

    accountFlags = property(_get_accountFlags, _set_accountFlags)

    def _get_status(self):
        return self.__status

    def _set_status(self, value):
        if not isinstance(value, int):
            raise TypeError("status must be int")

        self.__status = value

    status = property(_get_status, _set_status)

    def _get_download_queue_info(self):
        return self.__download_queue_info

    def _set_download_queue_info(self, value):
        if not isinstance(value, StoreAuthenticateResp._download_queue_info):
            raise TypeError(
                "download_queue_info must be StoreAuthenticateResp._download_queue_info"
            )

        self.__download_queue_info = value

    download_queue_info = property(_get_download_queue_info, _set_download_queue_info)

    def _get_privacyAcknowledgement(self):
        return self.__privacyAcknowledgement

    def _set_privacyAcknowledgement(self, value):
        if not isinstance(value, StoreAuthenticateResp._privacyAcknowledgement):
            raise TypeError(
                "privacyAcknowledgement must be StoreAuthenticateResp._privacyAcknowledgement"
            )

        self.__privacyAcknowledgement = value

    privacyAcknowledgement = property(
        _get_privacyAcknowledgement, _set_privacyAcknowledgement
    )

    def _get_dialog(self):
        return self.__dialog

    def _set_dialog(self, value):
        if not isinstance(value, StoreAuthenticateResp._dialog):
            raise TypeError("dialog must be StoreAuthenticateResp._dialog")

        self.__dialog = value

    dialog = property(_get_dialog, _set_dialog)

    @staticmethod
    def from_dict(d):
        v = {}
        if "pings" in d:
            v["pings"] = [
                float.from_dict(p) if hasattr(float, "from_dict") else p
                for p in d["pings"]
            ]
        if "cancel-purchase-batch" in d:
            v["cancel_purchase_batch"] = (
                bool.from_dict(d["cancel-purchase-batch"])
                if hasattr(bool, "from_dict")
                else d["cancel-purchase-batch"]
            )
        if "customerMessage" in d:
            v["customerMessage"] = (
                str.from_dict(d["customerMessage"])
                if hasattr(str, "from_dict")
                else d["customerMessage"]
            )
        if "failureType" in d:
            v["failureType"] = (
                str.from_dict(d["failureType"])
                if hasattr(str, "from_dict")
                else d["failureType"]
            )
        if "accountInfo" in d:
            v["accountInfo"] = (
                StoreAuthenticateResp._accountInfo.from_dict(d["accountInfo"])
                if hasattr(StoreAuthenticateResp._accountInfo, "from_dict")
                else d["accountInfo"]
            )
        if "passwordToken" in d:
            v["passwordToken"] = (
                str.from_dict(d["passwordToken"])
                if hasattr(str, "from_dict")
                else d["passwordToken"]
            )
        if "clearToken" in d:
            v["clearToken"] = (
                str.from_dict(d["clearToken"])
                if hasattr(str, "from_dict")
                else d["clearToken"]
            )
        if "m-allowed" in d:
            v["m_allowed"] = (
                bool.from_dict(d["m-allowed"])
                if hasattr(bool, "from_dict")
                else d["m-allowed"]
            )
        if "is-cloud-enabled" in d:
            v["is_cloud_enabled"] = (
                str.from_dict(d["is-cloud-enabled"])
                if hasattr(str, "from_dict")
                else d["is-cloud-enabled"]
            )
        if "dsPersonId" in d:
            v["dsPersonId"] = (
                str.from_dict(d["dsPersonId"])
                if hasattr(str, "from_dict")
                else d["dsPersonId"]
            )
        if "creditDisplay" in d:
            v["creditDisplay"] = (
                str.from_dict(d["creditDisplay"])
                if hasattr(str, "from_dict")
                else d["creditDisplay"]
            )
        if "creditBalance" in d:
            v["creditBalance"] = (
                str.from_dict(d["creditBalance"])
                if hasattr(str, "from_dict")
                else d["creditBalance"]
            )
        if "freeSongBalance" in d:
            v["freeSongBalance"] = (
                str.from_dict(d["freeSongBalance"])
                if hasattr(str, "from_dict")
                else d["freeSongBalance"]
            )
        if "isManagedStudent" in d:
            v["isManagedStudent"] = (
                bool.from_dict(d["isManagedStudent"])
                if hasattr(bool, "from_dict")
                else d["isManagedStudent"]
            )
        if "action" in d:
            v["action"] = (
                StoreAuthenticateResp._action.from_dict(d["action"])
                if hasattr(StoreAuthenticateResp._action, "from_dict")
                else d["action"]
            )
        if "subscriptionStatus" in d:
            v["subscriptionStatus"] = (
                StoreAuthenticateResp._subscriptionStatus.from_dict(
                    d["subscriptionStatus"]
                )
                if hasattr(StoreAuthenticateResp._subscriptionStatus, "from_dict")
                else d["subscriptionStatus"]
            )
        if "accountFlags" in d:
            v["accountFlags"] = (
                StoreAuthenticateResp._accountFlags.from_dict(d["accountFlags"])
                if hasattr(StoreAuthenticateResp._accountFlags, "from_dict")
                else d["accountFlags"]
            )
        if "status" in d:
            v["status"] = (
                int.from_dict(d["status"]) if hasattr(int, "from_dict") else d["status"]
            )
        if "download-queue-info" in d:
            v["download_queue_info"] = (
                StoreAuthenticateResp._download_queue_info.from_dict(
                    d["download-queue-info"]
                )
                if hasattr(StoreAuthenticateResp._download_queue_info, "from_dict")
                else d["download-queue-info"]
            )
        if "privacyAcknowledgement" in d:
            v["privacyAcknowledgement"] = (
                StoreAuthenticateResp._privacyAcknowledgement.from_dict(
                    d["privacyAcknowledgement"]
                )
                if hasattr(StoreAuthenticateResp._privacyAcknowledgement, "from_dict")
                else d["privacyAcknowledgement"]
            )
        if "dialog" in d:
            v["dialog"] = (
                StoreAuthenticateResp._dialog.from_dict(d["dialog"])
                if hasattr(StoreAuthenticateResp._dialog, "from_dict")
                else d["dialog"]
            )
        return StoreAuthenticateResp(**v)

    def as_dict(self):
        d = {}
        if self.__pings is not None:
            d["pings"] = [
                p.as_dict() if hasattr(p, "as_dict") else p for p in self.__pings
            ]
        if self.__cancel_purchase_batch is not None:
            d["cancel-purchase-batch"] = (
                self.__cancel_purchase_batch.as_dict()
                if hasattr(self.__cancel_purchase_batch, "as_dict")
                else self.__cancel_purchase_batch
            )
        if self.__customerMessage is not None:
            d["customerMessage"] = (
                self.__customerMessage.as_dict()
                if hasattr(self.__customerMessage, "as_dict")
                else self.__customerMessage
            )
        if self.__failureType is not None:
            d["failureType"] = (
                self.__failureType.as_dict()
                if hasattr(self.__failureType, "as_dict")
                else self.__failureType
            )
        if self.__accountInfo is not None:
            d["accountInfo"] = (
                self.__accountInfo.as_dict()
                if hasattr(self.__accountInfo, "as_dict")
                else self.__accountInfo
            )
        if self.__passwordToken is not None:
            d["passwordToken"] = (
                self.__passwordToken.as_dict()
                if hasattr(self.__passwordToken, "as_dict")
                else self.__passwordToken
            )
        if self.__clearToken is not None:
            d["clearToken"] = (
                self.__clearToken.as_dict()
                if hasattr(self.__clearToken, "as_dict")
                else self.__clearToken
            )
        if self.__m_allowed is not None:
            d["m-allowed"] = (
                self.__m_allowed.as_dict()
                if hasattr(self.__m_allowed, "as_dict")
                else self.__m_allowed
            )
        if self.__is_cloud_enabled is not None:
            d["is-cloud-enabled"] = (
                self.__is_cloud_enabled.as_dict()
                if hasattr(self.__is_cloud_enabled, "as_dict")
                else self.__is_cloud_enabled
            )
        if self.__dsPersonId is not None:
            d["dsPersonId"] = (
                self.__dsPersonId.as_dict()
                if hasattr(self.__dsPersonId, "as_dict")
                else self.__dsPersonId
            )
        if self.__creditDisplay is not None:
            d["creditDisplay"] = (
                self.__creditDisplay.as_dict()
                if hasattr(self.__creditDisplay, "as_dict")
                else self.__creditDisplay
            )
        if self.__creditBalance is not None:
            d["creditBalance"] = (
                self.__creditBalance.as_dict()
                if hasattr(self.__creditBalance, "as_dict")
                else self.__creditBalance
            )
        if self.__freeSongBalance is not None:
            d["freeSongBalance"] = (
                self.__freeSongBalance.as_dict()
                if hasattr(self.__freeSongBalance, "as_dict")
                else self.__freeSongBalance
            )
        if self.__isManagedStudent is not None:
            d["isManagedStudent"] = (
                self.__isManagedStudent.as_dict()
                if hasattr(self.__isManagedStudent, "as_dict")
                else self.__isManagedStudent
            )
        if self.__action is not None:
            d["action"] = (
                self.__action.as_dict()
                if hasattr(self.__action, "as_dict")
                else self.__action
            )
        if self.__subscriptionStatus is not None:
            d["subscriptionStatus"] = (
                self.__subscriptionStatus.as_dict()
                if hasattr(self.__subscriptionStatus, "as_dict")
                else self.__subscriptionStatus
            )
        if self.__accountFlags is not None:
            d["accountFlags"] = (
                self.__accountFlags.as_dict()
                if hasattr(self.__accountFlags, "as_dict")
                else self.__accountFlags
            )
        if self.__status is not None:
            d["status"] = (
                self.__status.as_dict()
                if hasattr(self.__status, "as_dict")
                else self.__status
            )
        if self.__download_queue_info is not None:
            d["download-queue-info"] = (
                self.__download_queue_info.as_dict()
                if hasattr(self.__download_queue_info, "as_dict")
                else self.__download_queue_info
            )
        if self.__privacyAcknowledgement is not None:
            d["privacyAcknowledgement"] = (
                self.__privacyAcknowledgement.as_dict()
                if hasattr(self.__privacyAcknowledgement, "as_dict")
                else self.__privacyAcknowledgement
            )
        if self.__dialog is not None:
            d["dialog"] = (
                self.__dialog.as_dict()
                if hasattr(self.__dialog, "as_dict")
                else self.__dialog
            )
        return d

    def __repr__(self):
        return "<Class StoreAuthenticateResp. pings: {}, cancel_purchase_batch: {}, customerMessage: {}, failureType: {}, accountInfo: {}, passwordToken: {}, clearToken: {}, m_allowed: {}, is_cloud_enabled: {}, dsPersonId: {}, creditDisplay: {}, creditBalance: {}, freeSongBalance: {}, isManagedStudent: {}, action: {}, subscriptionStatus: {}, accountFlags: {}, status: {}, download_queue_info: {}, privacyAcknowledgement: {}, dialog: {}>".format(
            limitedRepr(
                self.__pings[:20] if isinstance(self.__pings, bytes) else self.__pings
            ),
            limitedRepr(
                self.__cancel_purchase_batch[:20]
                if isinstance(self.__cancel_purchase_batch, bytes)
                else self.__cancel_purchase_batch
            ),
            limitedRepr(
                self.__customerMessage[:20]
                if isinstance(self.__customerMessage, bytes)
                else self.__customerMessage
            ),
            limitedRepr(
                self.__failureType[:20]
                if isinstance(self.__failureType, bytes)
                else self.__failureType
            ),
            limitedRepr(
                self.__accountInfo[:20]
                if isinstance(self.__accountInfo, bytes)
                else self.__accountInfo
            ),
            limitedRepr(
                self.__passwordToken[:20]
                if isinstance(self.__passwordToken, bytes)
                else self.__passwordToken
            ),
            limitedRepr(
                self.__clearToken[:20]
                if isinstance(self.__clearToken, bytes)
                else self.__clearToken
            ),
            limitedRepr(
                self.__m_allowed[:20]
                if isinstance(self.__m_allowed, bytes)
                else self.__m_allowed
            ),
            limitedRepr(
                self.__is_cloud_enabled[:20]
                if isinstance(self.__is_cloud_enabled, bytes)
                else self.__is_cloud_enabled
            ),
            limitedRepr(
                self.__dsPersonId[:20]
                if isinstance(self.__dsPersonId, bytes)
                else self.__dsPersonId
            ),
            limitedRepr(
                self.__creditDisplay[:20]
                if isinstance(self.__creditDisplay, bytes)
                else self.__creditDisplay
            ),
            limitedRepr(
                self.__creditBalance[:20]
                if isinstance(self.__creditBalance, bytes)
                else self.__creditBalance
            ),
            limitedRepr(
                self.__freeSongBalance[:20]
                if isinstance(self.__freeSongBalance, bytes)
                else self.__freeSongBalance
            ),
            limitedRepr(
                self.__isManagedStudent[:20]
                if isinstance(self.__isManagedStudent, bytes)
                else self.__isManagedStudent
            ),
            limitedRepr(
                self.__action[:20]
                if isinstance(self.__action, bytes)
                else self.__action
            ),
            limitedRepr(
                self.__subscriptionStatus[:20]
                if isinstance(self.__subscriptionStatus, bytes)
                else self.__subscriptionStatus
            ),
            limitedRepr(
                self.__accountFlags[:20]
                if isinstance(self.__accountFlags, bytes)
                else self.__accountFlags
            ),
            limitedRepr(
                self.__status[:20]
                if isinstance(self.__status, bytes)
                else self.__status
            ),
            limitedRepr(
                self.__download_queue_info[:20]
                if isinstance(self.__download_queue_info, bytes)
                else self.__download_queue_info
            ),
            limitedRepr(
                self.__privacyAcknowledgement[:20]
                if isinstance(self.__privacyAcknowledgement, bytes)
                else self.__privacyAcknowledgement
            ),
            limitedRepr(
                self.__dialog[:20]
                if isinstance(self.__dialog, bytes)
                else self.__dialog
            ),
        )
