from reprlib import repr as limitedRepr


from typing import List


class ItunesLookupResp:
    class _results:

        _types_map = {
            "appletvScreenshotUrls": {"type": list, "subtype": float},
            "screenshotUrls": {"type": list, "subtype": str},
            "ipadScreenshotUrls": {"type": list, "subtype": str},
            "artworkUrl60": {"type": str, "subtype": None},
            "artworkUrl512": {"type": str, "subtype": None},
            "artworkUrl100": {"type": str, "subtype": None},
            "artistViewUrl": {"type": str, "subtype": None},
            "supportedDevices": {"type": list, "subtype": str},
            "advisories": {"type": list, "subtype": float},
            "isGameCenterEnabled": {"type": bool, "subtype": None},
            "kind": {"type": str, "subtype": None},
            "features": {"type": list, "subtype": str},
            "minimumOsVersion": {"type": str, "subtype": None},
            "trackCensoredName": {"type": str, "subtype": None},
            "languageCodesISO2A": {"type": list, "subtype": str},
            "fileSizeBytes": {"type": str, "subtype": None},
            "formattedPrice": {"type": str, "subtype": None},
            "contentAdvisoryRating": {"type": str, "subtype": None},
            "averageUserRatingForCurrentVersion": {"type": float, "subtype": None},
            "userRatingCountForCurrentVersion": {"type": int, "subtype": None},
            "averageUserRating": {"type": float, "subtype": None},
            "trackViewUrl": {"type": str, "subtype": None},
            "trackContentRating": {"type": str, "subtype": None},
            "releaseDate": {"type": str, "subtype": None},
            "genreIds": {"type": list, "subtype": str},
            "primaryGenreName": {"type": str, "subtype": None},
            "trackId": {"type": int, "subtype": None},
            "trackName": {"type": str, "subtype": None},
            "sellerName": {"type": str, "subtype": None},
            "isVppDeviceBasedLicensingEnabled": {"type": bool, "subtype": None},
            "currentVersionReleaseDate": {"type": str, "subtype": None},
            "releaseNotes": {"type": str, "subtype": None},
            "primaryGenreId": {"type": int, "subtype": None},
            "currency": {"type": str, "subtype": None},
            "version": {"type": str, "subtype": None},
            "wrapperType": {"type": str, "subtype": None},
            "artistId": {"type": int, "subtype": None},
            "artistName": {"type": str, "subtype": None},
            "genres": {"type": list, "subtype": str},
            "price": {"type": float, "subtype": None},
            "description": {"type": str, "subtype": None},
            "bundleId": {"type": str, "subtype": None},
            "userRatingCount": {"type": int, "subtype": None},
        }
        _formats_map = {}
        _validations_map = {
            "appletvScreenshotUrls": {
                "required": True,
            },
            "screenshotUrls": {
                "required": True,
            },
            "ipadScreenshotUrls": {
                "required": True,
            },
            "artworkUrl60": {
                "required": True,
            },
            "artworkUrl512": {
                "required": True,
            },
            "artworkUrl100": {
                "required": True,
            },
            "artistViewUrl": {
                "required": True,
            },
            "supportedDevices": {
                "required": True,
            },
            "advisories": {
                "required": True,
            },
            "isGameCenterEnabled": {
                "required": True,
            },
            "kind": {
                "required": True,
            },
            "features": {
                "required": True,
            },
            "minimumOsVersion": {
                "required": True,
            },
            "trackCensoredName": {
                "required": True,
            },
            "languageCodesISO2A": {
                "required": True,
            },
            "fileSizeBytes": {
                "required": True,
            },
            "formattedPrice": {
                "required": True,
            },
            "contentAdvisoryRating": {
                "required": True,
            },
            "averageUserRatingForCurrentVersion": {
                "required": True,
            },
            "userRatingCountForCurrentVersion": {
                "required": True,
            },
            "averageUserRating": {
                "required": True,
            },
            "trackViewUrl": {
                "required": True,
            },
            "trackContentRating": {
                "required": True,
            },
            "releaseDate": {
                "required": True,
            },
            "genreIds": {
                "required": True,
            },
            "primaryGenreName": {
                "required": True,
            },
            "trackId": {
                "required": True,
            },
            "trackName": {
                "required": True,
            },
            "sellerName": {
                "required": True,
            },
            "isVppDeviceBasedLicensingEnabled": {
                "required": True,
            },
            "currentVersionReleaseDate": {
                "required": True,
            },
            "releaseNotes": {
                "required": True,
            },
            "primaryGenreId": {
                "required": True,
            },
            "currency": {
                "required": True,
            },
            "version": {
                "required": True,
            },
            "wrapperType": {
                "required": True,
            },
            "artistId": {
                "required": True,
            },
            "artistName": {
                "required": True,
            },
            "genres": {
                "required": True,
            },
            "price": {
                "required": True,
            },
            "description": {
                "required": True,
            },
            "bundleId": {
                "required": True,
            },
            "userRatingCount": {
                "required": True,
            },
        }

        def __init__(
            self,
            appletvScreenshotUrls: List[float] = None,
            screenshotUrls: List[str] = None,
            ipadScreenshotUrls: List[str] = None,
            artworkUrl60: str = None,
            artworkUrl512: str = None,
            artworkUrl100: str = None,
            artistViewUrl: str = None,
            supportedDevices: List[str] = None,
            advisories: List[float] = None,
            isGameCenterEnabled: bool = None,
            kind: str = None,
            features: List[str] = None,
            minimumOsVersion: str = None,
            trackCensoredName: str = None,
            languageCodesISO2A: List[str] = None,
            fileSizeBytes: str = None,
            formattedPrice: str = None,
            contentAdvisoryRating: str = None,
            averageUserRatingForCurrentVersion: float = None,
            userRatingCountForCurrentVersion: int = None,
            averageUserRating: float = None,
            trackViewUrl: str = None,
            trackContentRating: str = None,
            releaseDate: str = None,
            genreIds: List[str] = None,
            primaryGenreName: str = None,
            trackId: int = None,
            trackName: str = None,
            sellerName: str = None,
            isVppDeviceBasedLicensingEnabled: bool = None,
            currentVersionReleaseDate: str = None,
            releaseNotes: str = None,
            primaryGenreId: int = None,
            currency: str = None,
            version: str = None,
            wrapperType: str = None,
            artistId: int = None,
            artistName: str = None,
            genres: List[str] = None,
            price: float = None,
            description: str = None,
            bundleId: str = None,
            userRatingCount: int = None,
        ):
            pass
            self.__appletvScreenshotUrls = appletvScreenshotUrls
            self.__screenshotUrls = screenshotUrls
            self.__ipadScreenshotUrls = ipadScreenshotUrls
            self.__artworkUrl60 = artworkUrl60
            self.__artworkUrl512 = artworkUrl512
            self.__artworkUrl100 = artworkUrl100
            self.__artistViewUrl = artistViewUrl
            self.__supportedDevices = supportedDevices
            self.__advisories = advisories
            self.__isGameCenterEnabled = isGameCenterEnabled
            self.__kind = kind
            self.__features = features
            self.__minimumOsVersion = minimumOsVersion
            self.__trackCensoredName = trackCensoredName
            self.__languageCodesISO2A = languageCodesISO2A
            self.__fileSizeBytes = fileSizeBytes
            self.__formattedPrice = formattedPrice
            self.__contentAdvisoryRating = contentAdvisoryRating
            self.__averageUserRatingForCurrentVersion = (
                averageUserRatingForCurrentVersion
            )
            self.__userRatingCountForCurrentVersion = userRatingCountForCurrentVersion
            self.__averageUserRating = averageUserRating
            self.__trackViewUrl = trackViewUrl
            self.__trackContentRating = trackContentRating
            self.__releaseDate = releaseDate
            self.__genreIds = genreIds
            self.__primaryGenreName = primaryGenreName
            self.__trackId = trackId
            self.__trackName = trackName
            self.__sellerName = sellerName
            self.__isVppDeviceBasedLicensingEnabled = isVppDeviceBasedLicensingEnabled
            self.__currentVersionReleaseDate = currentVersionReleaseDate
            self.__releaseNotes = releaseNotes
            self.__primaryGenreId = primaryGenreId
            self.__currency = currency
            self.__version = version
            self.__wrapperType = wrapperType
            self.__artistId = artistId
            self.__artistName = artistName
            self.__genres = genres
            self.__price = price
            self.__description = description
            self.__bundleId = bundleId
            self.__userRatingCount = userRatingCount

        def _get_appletvScreenshotUrls(self):
            return self.__appletvScreenshotUrls

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

            self.__appletvScreenshotUrls = value

        appletvScreenshotUrls = property(
            _get_appletvScreenshotUrls, _set_appletvScreenshotUrls
        )

        def _get_screenshotUrls(self):
            return self.__screenshotUrls

        def _set_screenshotUrls(self, value):
            if not isinstance(value, list):
                raise TypeError("screenshotUrls must be list")
            if not all(isinstance(i, str) for i in value):
                raise TypeError("screenshotUrls list values must be str")

            self.__screenshotUrls = value

        screenshotUrls = property(_get_screenshotUrls, _set_screenshotUrls)

        def _get_ipadScreenshotUrls(self):
            return self.__ipadScreenshotUrls

        def _set_ipadScreenshotUrls(self, value):
            if not isinstance(value, list):
                raise TypeError("ipadScreenshotUrls must be list")
            if not all(isinstance(i, str) for i in value):
                raise TypeError("ipadScreenshotUrls list values must be str")

            self.__ipadScreenshotUrls = value

        ipadScreenshotUrls = property(_get_ipadScreenshotUrls, _set_ipadScreenshotUrls)

        def _get_artworkUrl60(self):
            return self.__artworkUrl60

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

            self.__artworkUrl60 = value

        artworkUrl60 = property(_get_artworkUrl60, _set_artworkUrl60)

        def _get_artworkUrl512(self):
            return self.__artworkUrl512

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

            self.__artworkUrl512 = value

        artworkUrl512 = property(_get_artworkUrl512, _set_artworkUrl512)

        def _get_artworkUrl100(self):
            return self.__artworkUrl100

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

            self.__artworkUrl100 = value

        artworkUrl100 = property(_get_artworkUrl100, _set_artworkUrl100)

        def _get_artistViewUrl(self):
            return self.__artistViewUrl

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

            self.__artistViewUrl = value

        artistViewUrl = property(_get_artistViewUrl, _set_artistViewUrl)

        def _get_supportedDevices(self):
            return self.__supportedDevices

        def _set_supportedDevices(self, value):
            if not isinstance(value, list):
                raise TypeError("supportedDevices must be list")
            if not all(isinstance(i, str) for i in value):
                raise TypeError("supportedDevices list values must be str")

            self.__supportedDevices = value

        supportedDevices = property(_get_supportedDevices, _set_supportedDevices)

        def _get_advisories(self):
            return self.__advisories

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

            self.__advisories = value

        advisories = property(_get_advisories, _set_advisories)

        def _get_isGameCenterEnabled(self):
            return self.__isGameCenterEnabled

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

            self.__isGameCenterEnabled = value

        isGameCenterEnabled = property(
            _get_isGameCenterEnabled, _set_isGameCenterEnabled
        )

        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)

        def _get_features(self):
            return self.__features

        def _set_features(self, value):
            if not isinstance(value, list):
                raise TypeError("features must be list")
            if not all(isinstance(i, str) for i in value):
                raise TypeError("features list values must be str")

            self.__features = value

        features = property(_get_features, _set_features)

        def _get_minimumOsVersion(self):
            return self.__minimumOsVersion

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

            self.__minimumOsVersion = value

        minimumOsVersion = property(_get_minimumOsVersion, _set_minimumOsVersion)

        def _get_trackCensoredName(self):
            return self.__trackCensoredName

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

            self.__trackCensoredName = value

        trackCensoredName = property(_get_trackCensoredName, _set_trackCensoredName)

        def _get_languageCodesISO2A(self):
            return self.__languageCodesISO2A

        def _set_languageCodesISO2A(self, value):
            if not isinstance(value, list):
                raise TypeError("languageCodesISO2A must be list")
            if not all(isinstance(i, str) for i in value):
                raise TypeError("languageCodesISO2A list values must be str")

            self.__languageCodesISO2A = value

        languageCodesISO2A = property(_get_languageCodesISO2A, _set_languageCodesISO2A)

        def _get_fileSizeBytes(self):
            return self.__fileSizeBytes

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

            self.__fileSizeBytes = value

        fileSizeBytes = property(_get_fileSizeBytes, _set_fileSizeBytes)

        def _get_formattedPrice(self):
            return self.__formattedPrice

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

            self.__formattedPrice = value

        formattedPrice = property(_get_formattedPrice, _set_formattedPrice)

        def _get_contentAdvisoryRating(self):
            return self.__contentAdvisoryRating

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

            self.__contentAdvisoryRating = value

        contentAdvisoryRating = property(
            _get_contentAdvisoryRating, _set_contentAdvisoryRating
        )

        def _get_averageUserRatingForCurrentVersion(self):
            return self.__averageUserRatingForCurrentVersion

        def _set_averageUserRatingForCurrentVersion(self, value):
            if not isinstance(value, float):
                raise TypeError("averageUserRatingForCurrentVersion must be float")

            self.__averageUserRatingForCurrentVersion = value

        averageUserRatingForCurrentVersion = property(
            _get_averageUserRatingForCurrentVersion,
            _set_averageUserRatingForCurrentVersion,
        )

        def _get_userRatingCountForCurrentVersion(self):
            return self.__userRatingCountForCurrentVersion

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

            self.__userRatingCountForCurrentVersion = value

        userRatingCountForCurrentVersion = property(
            _get_userRatingCountForCurrentVersion, _set_userRatingCountForCurrentVersion
        )

        def _get_averageUserRating(self):
            return self.__averageUserRating

        def _set_averageUserRating(self, value):
            if not isinstance(value, float):
                raise TypeError("averageUserRating must be float")

            self.__averageUserRating = value

        averageUserRating = property(_get_averageUserRating, _set_averageUserRating)

        def _get_trackViewUrl(self):
            return self.__trackViewUrl

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

            self.__trackViewUrl = value

        trackViewUrl = property(_get_trackViewUrl, _set_trackViewUrl)

        def _get_trackContentRating(self):
            return self.__trackContentRating

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

            self.__trackContentRating = value

        trackContentRating = property(_get_trackContentRating, _set_trackContentRating)

        def _get_releaseDate(self):
            return self.__releaseDate

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

            self.__releaseDate = value

        releaseDate = property(_get_releaseDate, _set_releaseDate)

        def _get_genreIds(self):
            return self.__genreIds

        def _set_genreIds(self, value):
            if not isinstance(value, list):
                raise TypeError("genreIds must be list")
            if not all(isinstance(i, str) for i in value):
                raise TypeError("genreIds list values must be str")

            self.__genreIds = value

        genreIds = property(_get_genreIds, _set_genreIds)

        def _get_primaryGenreName(self):
            return self.__primaryGenreName

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

            self.__primaryGenreName = value

        primaryGenreName = property(_get_primaryGenreName, _set_primaryGenreName)

        def _get_trackId(self):
            return self.__trackId

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

            self.__trackId = value

        trackId = property(_get_trackId, _set_trackId)

        def _get_trackName(self):
            return self.__trackName

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

            self.__trackName = value

        trackName = property(_get_trackName, _set_trackName)

        def _get_sellerName(self):
            return self.__sellerName

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

            self.__sellerName = value

        sellerName = property(_get_sellerName, _set_sellerName)

        def _get_isVppDeviceBasedLicensingEnabled(self):
            return self.__isVppDeviceBasedLicensingEnabled

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

            self.__isVppDeviceBasedLicensingEnabled = value

        isVppDeviceBasedLicensingEnabled = property(
            _get_isVppDeviceBasedLicensingEnabled, _set_isVppDeviceBasedLicensingEnabled
        )

        def _get_currentVersionReleaseDate(self):
            return self.__currentVersionReleaseDate

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

            self.__currentVersionReleaseDate = value

        currentVersionReleaseDate = property(
            _get_currentVersionReleaseDate, _set_currentVersionReleaseDate
        )

        def _get_releaseNotes(self):
            return self.__releaseNotes

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

            self.__releaseNotes = value

        releaseNotes = property(_get_releaseNotes, _set_releaseNotes)

        def _get_primaryGenreId(self):
            return self.__primaryGenreId

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

            self.__primaryGenreId = value

        primaryGenreId = property(_get_primaryGenreId, _set_primaryGenreId)

        def _get_currency(self):
            return self.__currency

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

            self.__currency = value

        currency = property(_get_currency, _set_currency)

        def _get_version(self):
            return self.__version

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

            self.__version = value

        version = property(_get_version, _set_version)

        def _get_wrapperType(self):
            return self.__wrapperType

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

            self.__wrapperType = value

        wrapperType = property(_get_wrapperType, _set_wrapperType)

        def _get_artistId(self):
            return self.__artistId

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

            self.__artistId = value

        artistId = property(_get_artistId, _set_artistId)

        def _get_artistName(self):
            return self.__artistName

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

            self.__artistName = value

        artistName = property(_get_artistName, _set_artistName)

        def _get_genres(self):
            return self.__genres

        def _set_genres(self, value):
            if not isinstance(value, list):
                raise TypeError("genres must be list")
            if not all(isinstance(i, str) for i in value):
                raise TypeError("genres list values must be str")

            self.__genres = value

        genres = property(_get_genres, _set_genres)

        def _get_price(self):
            return self.__price

        def _set_price(self, value):
            if not isinstance(value, float):
                raise TypeError("price must be float")

            self.__price = value

        price = property(_get_price, _set_price)

        def _get_description(self):
            return self.__description

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

            self.__description = value

        description = property(_get_description, _set_description)

        def _get_bundleId(self):
            return self.__bundleId

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

            self.__bundleId = value

        bundleId = property(_get_bundleId, _set_bundleId)

        def _get_userRatingCount(self):
            return self.__userRatingCount

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

            self.__userRatingCount = value

        userRatingCount = property(_get_userRatingCount, _set_userRatingCount)

        @staticmethod
        def from_dict(d):
            v = {}
            if "appletvScreenshotUrls" in d:
                v["appletvScreenshotUrls"] = [
                    float.from_dict(p) if hasattr(float, "from_dict") else p
                    for p in d["appletvScreenshotUrls"]
                ]
            if "screenshotUrls" in d:
                v["screenshotUrls"] = [
                    str.from_dict(p) if hasattr(str, "from_dict") else p
                    for p in d["screenshotUrls"]
                ]
            if "ipadScreenshotUrls" in d:
                v["ipadScreenshotUrls"] = [
                    str.from_dict(p) if hasattr(str, "from_dict") else p
                    for p in d["ipadScreenshotUrls"]
                ]
            if "artworkUrl60" in d:
                v["artworkUrl60"] = (
                    str.from_dict(d["artworkUrl60"])
                    if hasattr(str, "from_dict")
                    else d["artworkUrl60"]
                )
            if "artworkUrl512" in d:
                v["artworkUrl512"] = (
                    str.from_dict(d["artworkUrl512"])
                    if hasattr(str, "from_dict")
                    else d["artworkUrl512"]
                )
            if "artworkUrl100" in d:
                v["artworkUrl100"] = (
                    str.from_dict(d["artworkUrl100"])
                    if hasattr(str, "from_dict")
                    else d["artworkUrl100"]
                )
            if "artistViewUrl" in d:
                v["artistViewUrl"] = (
                    str.from_dict(d["artistViewUrl"])
                    if hasattr(str, "from_dict")
                    else d["artistViewUrl"]
                )
            if "supportedDevices" in d:
                v["supportedDevices"] = [
                    str.from_dict(p) if hasattr(str, "from_dict") else p
                    for p in d["supportedDevices"]
                ]
            if "advisories" in d:
                v["advisories"] = [
                    float.from_dict(p) if hasattr(float, "from_dict") else p
                    for p in d["advisories"]
                ]
            if "isGameCenterEnabled" in d:
                v["isGameCenterEnabled"] = (
                    bool.from_dict(d["isGameCenterEnabled"])
                    if hasattr(bool, "from_dict")
                    else d["isGameCenterEnabled"]
                )
            if "kind" in d:
                v["kind"] = (
                    str.from_dict(d["kind"]) if hasattr(str, "from_dict") else d["kind"]
                )
            if "features" in d:
                v["features"] = [
                    str.from_dict(p) if hasattr(str, "from_dict") else p
                    for p in d["features"]
                ]
            if "minimumOsVersion" in d:
                v["minimumOsVersion"] = (
                    str.from_dict(d["minimumOsVersion"])
                    if hasattr(str, "from_dict")
                    else d["minimumOsVersion"]
                )
            if "trackCensoredName" in d:
                v["trackCensoredName"] = (
                    str.from_dict(d["trackCensoredName"])
                    if hasattr(str, "from_dict")
                    else d["trackCensoredName"]
                )
            if "languageCodesISO2A" in d:
                v["languageCodesISO2A"] = [
                    str.from_dict(p) if hasattr(str, "from_dict") else p
                    for p in d["languageCodesISO2A"]
                ]
            if "fileSizeBytes" in d:
                v["fileSizeBytes"] = (
                    str.from_dict(d["fileSizeBytes"])
                    if hasattr(str, "from_dict")
                    else d["fileSizeBytes"]
                )
            if "formattedPrice" in d:
                v["formattedPrice"] = (
                    str.from_dict(d["formattedPrice"])
                    if hasattr(str, "from_dict")
                    else d["formattedPrice"]
                )
            if "contentAdvisoryRating" in d:
                v["contentAdvisoryRating"] = (
                    str.from_dict(d["contentAdvisoryRating"])
                    if hasattr(str, "from_dict")
                    else d["contentAdvisoryRating"]
                )
            if "averageUserRatingForCurrentVersion" in d:
                v["averageUserRatingForCurrentVersion"] = (
                    float.from_dict(d["averageUserRatingForCurrentVersion"])
                    if hasattr(float, "from_dict")
                    else d["averageUserRatingForCurrentVersion"]
                )
            if "userRatingCountForCurrentVersion" in d:
                v["userRatingCountForCurrentVersion"] = (
                    int.from_dict(d["userRatingCountForCurrentVersion"])
                    if hasattr(int, "from_dict")
                    else d["userRatingCountForCurrentVersion"]
                )
            if "averageUserRating" in d:
                v["averageUserRating"] = (
                    float.from_dict(d["averageUserRating"])
                    if hasattr(float, "from_dict")
                    else d["averageUserRating"]
                )
            if "trackViewUrl" in d:
                v["trackViewUrl"] = (
                    str.from_dict(d["trackViewUrl"])
                    if hasattr(str, "from_dict")
                    else d["trackViewUrl"]
                )
            if "trackContentRating" in d:
                v["trackContentRating"] = (
                    str.from_dict(d["trackContentRating"])
                    if hasattr(str, "from_dict")
                    else d["trackContentRating"]
                )
            if "releaseDate" in d:
                v["releaseDate"] = (
                    str.from_dict(d["releaseDate"])
                    if hasattr(str, "from_dict")
                    else d["releaseDate"]
                )
            if "genreIds" in d:
                v["genreIds"] = [
                    str.from_dict(p) if hasattr(str, "from_dict") else p
                    for p in d["genreIds"]
                ]
            if "primaryGenreName" in d:
                v["primaryGenreName"] = (
                    str.from_dict(d["primaryGenreName"])
                    if hasattr(str, "from_dict")
                    else d["primaryGenreName"]
                )
            if "trackId" in d:
                v["trackId"] = (
                    int.from_dict(d["trackId"])
                    if hasattr(int, "from_dict")
                    else d["trackId"]
                )
            if "trackName" in d:
                v["trackName"] = (
                    str.from_dict(d["trackName"])
                    if hasattr(str, "from_dict")
                    else d["trackName"]
                )
            if "sellerName" in d:
                v["sellerName"] = (
                    str.from_dict(d["sellerName"])
                    if hasattr(str, "from_dict")
                    else d["sellerName"]
                )
            if "isVppDeviceBasedLicensingEnabled" in d:
                v["isVppDeviceBasedLicensingEnabled"] = (
                    bool.from_dict(d["isVppDeviceBasedLicensingEnabled"])
                    if hasattr(bool, "from_dict")
                    else d["isVppDeviceBasedLicensingEnabled"]
                )
            if "currentVersionReleaseDate" in d:
                v["currentVersionReleaseDate"] = (
                    str.from_dict(d["currentVersionReleaseDate"])
                    if hasattr(str, "from_dict")
                    else d["currentVersionReleaseDate"]
                )
            if "releaseNotes" in d:
                v["releaseNotes"] = (
                    str.from_dict(d["releaseNotes"])
                    if hasattr(str, "from_dict")
                    else d["releaseNotes"]
                )
            if "primaryGenreId" in d:
                v["primaryGenreId"] = (
                    int.from_dict(d["primaryGenreId"])
                    if hasattr(int, "from_dict")
                    else d["primaryGenreId"]
                )
            if "currency" in d:
                v["currency"] = (
                    str.from_dict(d["currency"])
                    if hasattr(str, "from_dict")
                    else d["currency"]
                )
            if "version" in d:
                v["version"] = (
                    str.from_dict(d["version"])
                    if hasattr(str, "from_dict")
                    else d["version"]
                )
            if "wrapperType" in d:
                v["wrapperType"] = (
                    str.from_dict(d["wrapperType"])
                    if hasattr(str, "from_dict")
                    else d["wrapperType"]
                )
            if "artistId" in d:
                v["artistId"] = (
                    int.from_dict(d["artistId"])
                    if hasattr(int, "from_dict")
                    else d["artistId"]
                )
            if "artistName" in d:
                v["artistName"] = (
                    str.from_dict(d["artistName"])
                    if hasattr(str, "from_dict")
                    else d["artistName"]
                )
            if "genres" in d:
                v["genres"] = [
                    str.from_dict(p) if hasattr(str, "from_dict") else p
                    for p in d["genres"]
                ]
            if "price" in d:
                v["price"] = (
                    float.from_dict(d["price"])
                    if hasattr(float, "from_dict")
                    else d["price"]
                )
            if "description" in d:
                v["description"] = (
                    str.from_dict(d["description"])
                    if hasattr(str, "from_dict")
                    else d["description"]
                )
            if "bundleId" in d:
                v["bundleId"] = (
                    str.from_dict(d["bundleId"])
                    if hasattr(str, "from_dict")
                    else d["bundleId"]
                )
            if "userRatingCount" in d:
                v["userRatingCount"] = (
                    int.from_dict(d["userRatingCount"])
                    if hasattr(int, "from_dict")
                    else d["userRatingCount"]
                )
            return ItunesLookupResp._results(**v)

        def as_dict(self):
            d = {}
            if self.__appletvScreenshotUrls is not None:
                d["appletvScreenshotUrls"] = [
                    p.as_dict() if hasattr(p, "as_dict") else p
                    for p in self.__appletvScreenshotUrls
                ]
            if self.__screenshotUrls is not None:
                d["screenshotUrls"] = [
                    p.as_dict() if hasattr(p, "as_dict") else p
                    for p in self.__screenshotUrls
                ]
            if self.__ipadScreenshotUrls is not None:
                d["ipadScreenshotUrls"] = [
                    p.as_dict() if hasattr(p, "as_dict") else p
                    for p in self.__ipadScreenshotUrls
                ]
            if self.__artworkUrl60 is not None:
                d["artworkUrl60"] = (
                    self.__artworkUrl60.as_dict()
                    if hasattr(self.__artworkUrl60, "as_dict")
                    else self.__artworkUrl60
                )
            if self.__artworkUrl512 is not None:
                d["artworkUrl512"] = (
                    self.__artworkUrl512.as_dict()
                    if hasattr(self.__artworkUrl512, "as_dict")
                    else self.__artworkUrl512
                )
            if self.__artworkUrl100 is not None:
                d["artworkUrl100"] = (
                    self.__artworkUrl100.as_dict()
                    if hasattr(self.__artworkUrl100, "as_dict")
                    else self.__artworkUrl100
                )
            if self.__artistViewUrl is not None:
                d["artistViewUrl"] = (
                    self.__artistViewUrl.as_dict()
                    if hasattr(self.__artistViewUrl, "as_dict")
                    else self.__artistViewUrl
                )
            if self.__supportedDevices is not None:
                d["supportedDevices"] = [
                    p.as_dict() if hasattr(p, "as_dict") else p
                    for p in self.__supportedDevices
                ]
            if self.__advisories is not None:
                d["advisories"] = [
                    p.as_dict() if hasattr(p, "as_dict") else p
                    for p in self.__advisories
                ]
            if self.__isGameCenterEnabled is not None:
                d["isGameCenterEnabled"] = (
                    self.__isGameCenterEnabled.as_dict()
                    if hasattr(self.__isGameCenterEnabled, "as_dict")
                    else self.__isGameCenterEnabled
                )
            if self.__kind is not None:
                d["kind"] = (
                    self.__kind.as_dict()
                    if hasattr(self.__kind, "as_dict")
                    else self.__kind
                )
            if self.__features is not None:
                d["features"] = [
                    p.as_dict() if hasattr(p, "as_dict") else p for p in self.__features
                ]
            if self.__minimumOsVersion is not None:
                d["minimumOsVersion"] = (
                    self.__minimumOsVersion.as_dict()
                    if hasattr(self.__minimumOsVersion, "as_dict")
                    else self.__minimumOsVersion
                )
            if self.__trackCensoredName is not None:
                d["trackCensoredName"] = (
                    self.__trackCensoredName.as_dict()
                    if hasattr(self.__trackCensoredName, "as_dict")
                    else self.__trackCensoredName
                )
            if self.__languageCodesISO2A is not None:
                d["languageCodesISO2A"] = [
                    p.as_dict() if hasattr(p, "as_dict") else p
                    for p in self.__languageCodesISO2A
                ]
            if self.__fileSizeBytes is not None:
                d["fileSizeBytes"] = (
                    self.__fileSizeBytes.as_dict()
                    if hasattr(self.__fileSizeBytes, "as_dict")
                    else self.__fileSizeBytes
                )
            if self.__formattedPrice is not None:
                d["formattedPrice"] = (
                    self.__formattedPrice.as_dict()
                    if hasattr(self.__formattedPrice, "as_dict")
                    else self.__formattedPrice
                )
            if self.__contentAdvisoryRating is not None:
                d["contentAdvisoryRating"] = (
                    self.__contentAdvisoryRating.as_dict()
                    if hasattr(self.__contentAdvisoryRating, "as_dict")
                    else self.__contentAdvisoryRating
                )
            if self.__averageUserRatingForCurrentVersion is not None:
                d["averageUserRatingForCurrentVersion"] = (
                    self.__averageUserRatingForCurrentVersion.as_dict()
                    if hasattr(self.__averageUserRatingForCurrentVersion, "as_dict")
                    else self.__averageUserRatingForCurrentVersion
                )
            if self.__userRatingCountForCurrentVersion is not None:
                d["userRatingCountForCurrentVersion"] = (
                    self.__userRatingCountForCurrentVersion.as_dict()
                    if hasattr(self.__userRatingCountForCurrentVersion, "as_dict")
                    else self.__userRatingCountForCurrentVersion
                )
            if self.__averageUserRating is not None:
                d["averageUserRating"] = (
                    self.__averageUserRating.as_dict()
                    if hasattr(self.__averageUserRating, "as_dict")
                    else self.__averageUserRating
                )
            if self.__trackViewUrl is not None:
                d["trackViewUrl"] = (
                    self.__trackViewUrl.as_dict()
                    if hasattr(self.__trackViewUrl, "as_dict")
                    else self.__trackViewUrl
                )
            if self.__trackContentRating is not None:
                d["trackContentRating"] = (
                    self.__trackContentRating.as_dict()
                    if hasattr(self.__trackContentRating, "as_dict")
                    else self.__trackContentRating
                )
            if self.__releaseDate is not None:
                d["releaseDate"] = (
                    self.__releaseDate.as_dict()
                    if hasattr(self.__releaseDate, "as_dict")
                    else self.__releaseDate
                )
            if self.__genreIds is not None:
                d["genreIds"] = [
                    p.as_dict() if hasattr(p, "as_dict") else p for p in self.__genreIds
                ]
            if self.__primaryGenreName is not None:
                d["primaryGenreName"] = (
                    self.__primaryGenreName.as_dict()
                    if hasattr(self.__primaryGenreName, "as_dict")
                    else self.__primaryGenreName
                )
            if self.__trackId is not None:
                d["trackId"] = (
                    self.__trackId.as_dict()
                    if hasattr(self.__trackId, "as_dict")
                    else self.__trackId
                )
            if self.__trackName is not None:
                d["trackName"] = (
                    self.__trackName.as_dict()
                    if hasattr(self.__trackName, "as_dict")
                    else self.__trackName
                )
            if self.__sellerName is not None:
                d["sellerName"] = (
                    self.__sellerName.as_dict()
                    if hasattr(self.__sellerName, "as_dict")
                    else self.__sellerName
                )
            if self.__isVppDeviceBasedLicensingEnabled is not None:
                d["isVppDeviceBasedLicensingEnabled"] = (
                    self.__isVppDeviceBasedLicensingEnabled.as_dict()
                    if hasattr(self.__isVppDeviceBasedLicensingEnabled, "as_dict")
                    else self.__isVppDeviceBasedLicensingEnabled
                )
            if self.__currentVersionReleaseDate is not None:
                d["currentVersionReleaseDate"] = (
                    self.__currentVersionReleaseDate.as_dict()
                    if hasattr(self.__currentVersionReleaseDate, "as_dict")
                    else self.__currentVersionReleaseDate
                )
            if self.__releaseNotes is not None:
                d["releaseNotes"] = (
                    self.__releaseNotes.as_dict()
                    if hasattr(self.__releaseNotes, "as_dict")
                    else self.__releaseNotes
                )
            if self.__primaryGenreId is not None:
                d["primaryGenreId"] = (
                    self.__primaryGenreId.as_dict()
                    if hasattr(self.__primaryGenreId, "as_dict")
                    else self.__primaryGenreId
                )
            if self.__currency is not None:
                d["currency"] = (
                    self.__currency.as_dict()
                    if hasattr(self.__currency, "as_dict")
                    else self.__currency
                )
            if self.__version is not None:
                d["version"] = (
                    self.__version.as_dict()
                    if hasattr(self.__version, "as_dict")
                    else self.__version
                )
            if self.__wrapperType is not None:
                d["wrapperType"] = (
                    self.__wrapperType.as_dict()
                    if hasattr(self.__wrapperType, "as_dict")
                    else self.__wrapperType
                )
            if self.__artistId is not None:
                d["artistId"] = (
                    self.__artistId.as_dict()
                    if hasattr(self.__artistId, "as_dict")
                    else self.__artistId
                )
            if self.__artistName is not None:
                d["artistName"] = (
                    self.__artistName.as_dict()
                    if hasattr(self.__artistName, "as_dict")
                    else self.__artistName
                )
            if self.__genres is not None:
                d["genres"] = [
                    p.as_dict() if hasattr(p, "as_dict") else p for p in self.__genres
                ]
            if self.__price is not None:
                d["price"] = (
                    self.__price.as_dict()
                    if hasattr(self.__price, "as_dict")
                    else self.__price
                )
            if self.__description is not None:
                d["description"] = (
                    self.__description.as_dict()
                    if hasattr(self.__description, "as_dict")
                    else self.__description
                )
            if self.__bundleId is not None:
                d["bundleId"] = (
                    self.__bundleId.as_dict()
                    if hasattr(self.__bundleId, "as_dict")
                    else self.__bundleId
                )
            if self.__userRatingCount is not None:
                d["userRatingCount"] = (
                    self.__userRatingCount.as_dict()
                    if hasattr(self.__userRatingCount, "as_dict")
                    else self.__userRatingCount
                )
            return d

        def __repr__(self):
            return "<Class _results. appletvScreenshotUrls: {}, screenshotUrls: {}, ipadScreenshotUrls: {}, artworkUrl60: {}, artworkUrl512: {}, artworkUrl100: {}, artistViewUrl: {}, supportedDevices: {}, advisories: {}, isGameCenterEnabled: {}, kind: {}, features: {}, minimumOsVersion: {}, trackCensoredName: {}, languageCodesISO2A: {}, fileSizeBytes: {}, formattedPrice: {}, contentAdvisoryRating: {}, averageUserRatingForCurrentVersion: {}, userRatingCountForCurrentVersion: {}, averageUserRating: {}, trackViewUrl: {}, trackContentRating: {}, releaseDate: {}, genreIds: {}, primaryGenreName: {}, trackId: {}, trackName: {}, sellerName: {}, isVppDeviceBasedLicensingEnabled: {}, currentVersionReleaseDate: {}, releaseNotes: {}, primaryGenreId: {}, currency: {}, version: {}, wrapperType: {}, artistId: {}, artistName: {}, genres: {}, price: {}, description: {}, bundleId: {}, userRatingCount: {}>".format(
                limitedRepr(
                    self.__appletvScreenshotUrls[:20]
                    if isinstance(self.__appletvScreenshotUrls, bytes)
                    else self.__appletvScreenshotUrls
                ),
                limitedRepr(
                    self.__screenshotUrls[:20]
                    if isinstance(self.__screenshotUrls, bytes)
                    else self.__screenshotUrls
                ),
                limitedRepr(
                    self.__ipadScreenshotUrls[:20]
                    if isinstance(self.__ipadScreenshotUrls, bytes)
                    else self.__ipadScreenshotUrls
                ),
                limitedRepr(
                    self.__artworkUrl60[:20]
                    if isinstance(self.__artworkUrl60, bytes)
                    else self.__artworkUrl60
                ),
                limitedRepr(
                    self.__artworkUrl512[:20]
                    if isinstance(self.__artworkUrl512, bytes)
                    else self.__artworkUrl512
                ),
                limitedRepr(
                    self.__artworkUrl100[:20]
                    if isinstance(self.__artworkUrl100, bytes)
                    else self.__artworkUrl100
                ),
                limitedRepr(
                    self.__artistViewUrl[:20]
                    if isinstance(self.__artistViewUrl, bytes)
                    else self.__artistViewUrl
                ),
                limitedRepr(
                    self.__supportedDevices[:20]
                    if isinstance(self.__supportedDevices, bytes)
                    else self.__supportedDevices
                ),
                limitedRepr(
                    self.__advisories[:20]
                    if isinstance(self.__advisories, bytes)
                    else self.__advisories
                ),
                limitedRepr(
                    self.__isGameCenterEnabled[:20]
                    if isinstance(self.__isGameCenterEnabled, bytes)
                    else self.__isGameCenterEnabled
                ),
                limitedRepr(
                    self.__kind[:20] if isinstance(self.__kind, bytes) else self.__kind
                ),
                limitedRepr(
                    self.__features[:20]
                    if isinstance(self.__features, bytes)
                    else self.__features
                ),
                limitedRepr(
                    self.__minimumOsVersion[:20]
                    if isinstance(self.__minimumOsVersion, bytes)
                    else self.__minimumOsVersion
                ),
                limitedRepr(
                    self.__trackCensoredName[:20]
                    if isinstance(self.__trackCensoredName, bytes)
                    else self.__trackCensoredName
                ),
                limitedRepr(
                    self.__languageCodesISO2A[:20]
                    if isinstance(self.__languageCodesISO2A, bytes)
                    else self.__languageCodesISO2A
                ),
                limitedRepr(
                    self.__fileSizeBytes[:20]
                    if isinstance(self.__fileSizeBytes, bytes)
                    else self.__fileSizeBytes
                ),
                limitedRepr(
                    self.__formattedPrice[:20]
                    if isinstance(self.__formattedPrice, bytes)
                    else self.__formattedPrice
                ),
                limitedRepr(
                    self.__contentAdvisoryRating[:20]
                    if isinstance(self.__contentAdvisoryRating, bytes)
                    else self.__contentAdvisoryRating
                ),
                limitedRepr(
                    self.__averageUserRatingForCurrentVersion[:20]
                    if isinstance(self.__averageUserRatingForCurrentVersion, bytes)
                    else self.__averageUserRatingForCurrentVersion
                ),
                limitedRepr(
                    self.__userRatingCountForCurrentVersion[:20]
                    if isinstance(self.__userRatingCountForCurrentVersion, bytes)
                    else self.__userRatingCountForCurrentVersion
                ),
                limitedRepr(
                    self.__averageUserRating[:20]
                    if isinstance(self.__averageUserRating, bytes)
                    else self.__averageUserRating
                ),
                limitedRepr(
                    self.__trackViewUrl[:20]
                    if isinstance(self.__trackViewUrl, bytes)
                    else self.__trackViewUrl
                ),
                limitedRepr(
                    self.__trackContentRating[:20]
                    if isinstance(self.__trackContentRating, bytes)
                    else self.__trackContentRating
                ),
                limitedRepr(
                    self.__releaseDate[:20]
                    if isinstance(self.__releaseDate, bytes)
                    else self.__releaseDate
                ),
                limitedRepr(
                    self.__genreIds[:20]
                    if isinstance(self.__genreIds, bytes)
                    else self.__genreIds
                ),
                limitedRepr(
                    self.__primaryGenreName[:20]
                    if isinstance(self.__primaryGenreName, bytes)
                    else self.__primaryGenreName
                ),
                limitedRepr(
                    self.__trackId[:20]
                    if isinstance(self.__trackId, bytes)
                    else self.__trackId
                ),
                limitedRepr(
                    self.__trackName[:20]
                    if isinstance(self.__trackName, bytes)
                    else self.__trackName
                ),
                limitedRepr(
                    self.__sellerName[:20]
                    if isinstance(self.__sellerName, bytes)
                    else self.__sellerName
                ),
                limitedRepr(
                    self.__isVppDeviceBasedLicensingEnabled[:20]
                    if isinstance(self.__isVppDeviceBasedLicensingEnabled, bytes)
                    else self.__isVppDeviceBasedLicensingEnabled
                ),
                limitedRepr(
                    self.__currentVersionReleaseDate[:20]
                    if isinstance(self.__currentVersionReleaseDate, bytes)
                    else self.__currentVersionReleaseDate
                ),
                limitedRepr(
                    self.__releaseNotes[:20]
                    if isinstance(self.__releaseNotes, bytes)
                    else self.__releaseNotes
                ),
                limitedRepr(
                    self.__primaryGenreId[:20]
                    if isinstance(self.__primaryGenreId, bytes)
                    else self.__primaryGenreId
                ),
                limitedRepr(
                    self.__currency[:20]
                    if isinstance(self.__currency, bytes)
                    else self.__currency
                ),
                limitedRepr(
                    self.__version[:20]
                    if isinstance(self.__version, bytes)
                    else self.__version
                ),
                limitedRepr(
                    self.__wrapperType[:20]
                    if isinstance(self.__wrapperType, bytes)
                    else self.__wrapperType
                ),
                limitedRepr(
                    self.__artistId[:20]
                    if isinstance(self.__artistId, bytes)
                    else self.__artistId
                ),
                limitedRepr(
                    self.__artistName[:20]
                    if isinstance(self.__artistName, bytes)
                    else self.__artistName
                ),
                limitedRepr(
                    self.__genres[:20]
                    if isinstance(self.__genres, bytes)
                    else self.__genres
                ),
                limitedRepr(
                    self.__price[:20]
                    if isinstance(self.__price, bytes)
                    else self.__price
                ),
                limitedRepr(
                    self.__description[:20]
                    if isinstance(self.__description, bytes)
                    else self.__description
                ),
                limitedRepr(
                    self.__bundleId[:20]
                    if isinstance(self.__bundleId, bytes)
                    else self.__bundleId
                ),
                limitedRepr(
                    self.__userRatingCount[:20]
                    if isinstance(self.__userRatingCount, bytes)
                    else self.__userRatingCount
                ),
            )

    _types_map = {
        "resultCount": {"type": int, "subtype": None},
        "results": {"type": list, "subtype": _results},
    }
    _formats_map = {}
    _validations_map = {
        "resultCount": {
            "required": True,
        },
        "results": {
            "required": True,
        },
    }

    def __init__(self, resultCount: int = None, results: List[_results] = None):
        pass
        self.__resultCount = resultCount
        self.__results = results

    def _get_resultCount(self):
        return self.__resultCount

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

        self.__resultCount = value

    resultCount = property(_get_resultCount, _set_resultCount)

    def _get_results(self):
        return self.__results

    def _set_results(self, value):
        if not isinstance(value, list):
            raise TypeError("results must be list")
        if not all(isinstance(i, ItunesLookupResp._results) for i in value):
            raise TypeError("results list values must be ItunesLookupResp._results")

        self.__results = value

    results = property(_get_results, _set_results)

    @staticmethod
    def from_dict(d):
        v = {}
        if "resultCount" in d:
            v["resultCount"] = (
                int.from_dict(d["resultCount"])
                if hasattr(int, "from_dict")
                else d["resultCount"]
            )
        if "results" in d:
            v["results"] = [
                ItunesLookupResp._results.from_dict(p)
                if hasattr(ItunesLookupResp._results, "from_dict")
                else p
                for p in d["results"]
            ]
        return ItunesLookupResp(**v)

    def as_dict(self):
        d = {}
        if self.__resultCount is not None:
            d["resultCount"] = (
                self.__resultCount.as_dict()
                if hasattr(self.__resultCount, "as_dict")
                else self.__resultCount
            )
        if self.__results is not None:
            d["results"] = [
                p.as_dict() if hasattr(p, "as_dict") else p for p in self.__results
            ]
        return d

    def __repr__(self):
        return "<Class ItunesLookupResp. resultCount: {}, results: {}>".format(
            limitedRepr(
                self.__resultCount[:20]
                if isinstance(self.__resultCount, bytes)
                else self.__resultCount
            ),
            limitedRepr(
                self.__results[:20]
                if isinstance(self.__results, bytes)
                else self.__results
            ),
        )
