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 "".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 "".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 "".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 "".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 "".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 "".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 "".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 "".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 "".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 "".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 "".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 "".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 ), )