jaxl-python 0.0.1__py3-none-any.whl

jaxl/api/client/models/kyc_proof_upload_data_request.py

@@ -0,0 +1,164 @@
+"""
+Copyright (c) 2010-present by Jaxl Innovations Private Limited.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms,
+with or without modification, is strictly prohibited.
+"""
+
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union, cast
+
+import attr
+
+from ..models.iso_country_enum import IsoCountryEnum
+from ..models.resource_enum import ResourceEnum
+from ..types import UNSET, Unset
+
+
+if TYPE_CHECKING:
+    from ..models.proof_field_request import ProofFieldRequest
+
+
+T = TypeVar("T", bound="KycProofUploadDataRequest")
+
+
+@attr.s(auto_attribs=True)
+class KycProofUploadDataRequest:
+    """
+    Attributes:
+        useridentity_id (int):
+        address_id (int):
+        proof_fields (List['ProofFieldRequest']):
+        friendly_name (str):
+        document_type (str): Type of document eg: passport, business_registration, government_issued_document,
+            residence_permit etc
+        iso_country (IsoCountryEnum):
+        resource (Union[None, ResourceEnum, Unset]):
+    """
+
+    useridentity_id: int
+    address_id: int
+    proof_fields: List["ProofFieldRequest"]
+    friendly_name: str
+    document_type: str
+    iso_country: IsoCountryEnum
+    resource: Union[None, ResourceEnum, Unset] = UNSET
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        useridentity_id = self.useridentity_id
+        address_id = self.address_id
+        proof_fields = []
+        for proof_fields_item_data in self.proof_fields:
+            proof_fields_item = proof_fields_item_data.to_dict()
+
+            proof_fields.append(proof_fields_item)
+
+        friendly_name = self.friendly_name
+        document_type = self.document_type
+        iso_country = self.iso_country.value
+
+        resource: Union[None, Unset, str]
+        if isinstance(self.resource, Unset):
+            resource = UNSET
+        elif self.resource is None:
+            resource = None
+
+        elif isinstance(self.resource, ResourceEnum):
+            resource = UNSET
+            if not isinstance(self.resource, Unset):
+                resource = self.resource.value
+
+        else:
+            resource = self.resource
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "useridentity_id": useridentity_id,
+                "address_id": address_id,
+                "proof_fields": proof_fields,
+                "friendly_name": friendly_name,
+                "document_type": document_type,
+                "iso_country": iso_country,
+            }
+        )
+        if resource is not UNSET:
+            field_dict["resource"] = resource
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.proof_field_request import ProofFieldRequest
+
+        d = src_dict.copy()
+        useridentity_id = d.pop("useridentity_id")
+
+        address_id = d.pop("address_id")
+
+        proof_fields = []
+        _proof_fields = d.pop("proof_fields")
+        for proof_fields_item_data in _proof_fields:
+            proof_fields_item = ProofFieldRequest.from_dict(proof_fields_item_data)
+
+            proof_fields.append(proof_fields_item)
+
+        friendly_name = d.pop("friendly_name")
+
+        document_type = d.pop("document_type")
+
+        iso_country = IsoCountryEnum(d.pop("iso_country"))
+
+        def _parse_resource(data: object) -> Union[None, ResourceEnum, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                _resource_type_0 = data
+                resource_type_0: Union[Unset, ResourceEnum]
+                if isinstance(_resource_type_0, Unset):
+                    resource_type_0 = UNSET
+                else:
+                    resource_type_0 = ResourceEnum(_resource_type_0)
+
+                return resource_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[None, ResourceEnum, Unset], data)
+
+        resource = _parse_resource(d.pop("resource", UNSET))
+
+        kyc_proof_upload_data_request = cls(
+            useridentity_id=useridentity_id,
+            address_id=address_id,
+            proof_fields=proof_fields,
+            friendly_name=friendly_name,
+            document_type=document_type,
+            iso_country=iso_country,
+            resource=resource,
+        )
+
+        kyc_proof_upload_data_request.additional_properties = d
+        return kyc_proof_upload_data_request
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

jaxl/api/client/models/kyc_proof_upload_request.py

@@ -0,0 +1,142 @@
+"""
+Copyright (c) 2010-present by Jaxl Innovations Private Limited.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms,
+with or without modification, is strictly prohibited.
+"""
+
+import json
+from io import BytesIO
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar
+
+import attr
+
+from ..types import File, Unset
+
+
+if TYPE_CHECKING:
+    from ..models.kyc_proof_upload_data_request import (
+        KycProofUploadDataRequest,
+    )
+
+
+T = TypeVar("T", bound="KycProofUploadRequest")
+
+
+@attr.s(auto_attribs=True)
+class KycProofUploadRequest:
+    """
+    Attributes:
+        file (File):
+        payload (KycProofUploadDataRequest):
+        csek (str):
+        signature (str):
+    """
+
+    file: File
+    payload: "KycProofUploadDataRequest"
+    csek: str
+    signature: str
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        file = self.file.to_tuple()
+
+        payload = self.payload.to_dict()
+
+        csek = self.csek
+        signature = self.signature
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "file": file,
+                "payload": payload,
+                "csek": csek,
+                "signature": signature,
+            }
+        )
+
+        return field_dict
+
+    def to_multipart(self) -> Dict[str, Any]:
+        file = self.file.to_tuple()
+
+        payload = (
+            None,
+            json.dumps(self.payload.to_dict()).encode(),
+            "application/json",
+        )
+
+        csek = (
+            self.csek
+            if isinstance(self.csek, Unset)
+            else (None, str(self.csek).encode(), "text/plain")
+        )
+        signature = (
+            self.signature
+            if isinstance(self.signature, Unset)
+            else (None, str(self.signature).encode(), "text/plain")
+        )
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                key: (None, str(value).encode(), "text/plain")
+                for key, value in self.additional_properties.items()
+            }
+        )
+        field_dict.update(
+            {
+                "file": file,
+                "payload": payload,
+                "csek": csek,
+                "signature": signature,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.kyc_proof_upload_data_request import (
+            KycProofUploadDataRequest,
+        )
+
+        d = src_dict.copy()
+        file = File(payload=BytesIO(d.pop("file")))
+
+        payload = KycProofUploadDataRequest.from_dict(d.pop("payload"))
+
+        csek = d.pop("csek")
+
+        signature = d.pop("signature")
+
+        kyc_proof_upload_request = cls(
+            file=file,
+            payload=payload,
+            csek=csek,
+            signature=signature,
+        )
+
+        kyc_proof_upload_request.additional_properties = d
+        return kyc_proof_upload_request
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

jaxl/api/client/models/kyc_requirements_response.py

@@ -0,0 +1,114 @@
+"""
+Copyright (c) 2010-present by Jaxl Innovations Private Limited.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms,
+with or without modification, is strictly prohibited.
+"""
+
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar
+
+import attr
+
+
+if TYPE_CHECKING:
+    from ..models.additional_fields import AdditionalFields
+    from ..models.address_requirement import AddressRequirement
+    from ..models.identity_requirement import IdentityRequirement
+    from ..models.proofs_requirement import ProofsRequirement
+
+
+T = TypeVar("T", bound="KycRequirementsResponse")
+
+
+@attr.s(auto_attribs=True)
+class KycRequirementsResponse:
+    """
+    Attributes:
+        identity (IdentityRequirement):
+        address (AddressRequirement):
+        proofs (ProofsRequirement):
+        additional_fields (List['AdditionalFields']):
+    """
+
+    identity: "IdentityRequirement"
+    address: "AddressRequirement"
+    proofs: "ProofsRequirement"
+    additional_fields: List["AdditionalFields"]
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        identity = self.identity.to_dict()
+
+        address = self.address.to_dict()
+
+        proofs = self.proofs.to_dict()
+
+        additional_fields = []
+        for additional_fields_item_data in self.additional_fields:
+            additional_fields_item = additional_fields_item_data.to_dict()
+
+            additional_fields.append(additional_fields_item)
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "identity": identity,
+                "address": address,
+                "proofs": proofs,
+                "additional_fields": additional_fields,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.additional_fields import AdditionalFields
+        from ..models.address_requirement import AddressRequirement
+        from ..models.identity_requirement import IdentityRequirement
+        from ..models.proofs_requirement import ProofsRequirement
+
+        d = src_dict.copy()
+        identity = IdentityRequirement.from_dict(d.pop("identity"))
+
+        address = AddressRequirement.from_dict(d.pop("address"))
+
+        proofs = ProofsRequirement.from_dict(d.pop("proofs"))
+
+        additional_fields = []
+        _additional_fields = d.pop("additional_fields")
+        for additional_fields_item_data in _additional_fields:
+            additional_fields_item = AdditionalFields.from_dict(
+                additional_fields_item_data
+            )
+
+            additional_fields.append(additional_fields_item)
+
+        kyc_requirements_response = cls(
+            identity=identity,
+            address=address,
+            proofs=proofs,
+            additional_fields=additional_fields,
+        )
+
+        kyc_requirements_response.additional_properties = d
+        return kyc_requirements_response
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

jaxl/api/client/models/kyc_status_enum.py

@@ -0,0 +1,18 @@
+"""
+Copyright (c) 2010-present by Jaxl Innovations Private Limited.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms,
+with or without modification, is strictly prohibited.
+"""
+
+from enum import Enum
+
+
+class KycStatusEnum(str, Enum):
+    EDITED = "edited"
+    NEW = "new"
+
+    def __str__(self) -> str:
+        return str(self.value)

jaxl/api/client/models/kyc_summary.py

@@ -0,0 +1,115 @@
+"""
+Copyright (c) 2010-present by Jaxl Innovations Private Limited.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms,
+with or without modification, is strictly prohibited.
+"""
+
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, TypeVar
+
+import attr
+
+from ..models.iso_country_enum import IsoCountryEnum
+from ..models.provider_status_enum import ProviderStatusEnum
+
+
+if TYPE_CHECKING:
+    from ..models.address_provider import AddressProvider
+
+
+T = TypeVar("T", bound="KycSummary")
+
+
+@attr.s(auto_attribs=True)
+class KycSummary:
+    """Adds a 'jaxlid' field which contains signed ID information.
+
+    Attributes:
+        id (int):
+        address (AddressProvider):
+        iso_country (IsoCountryEnum):
+        provider_status (ProviderStatusEnum):
+        friendly_name (str):
+        jaxlid (Optional[str]):
+    """
+
+    id: int
+    address: "AddressProvider"
+    iso_country: IsoCountryEnum
+    provider_status: ProviderStatusEnum
+    friendly_name: str
+    jaxlid: Optional[str]
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        id = self.id
+        address = self.address.to_dict()
+
+        iso_country = self.iso_country.value
+
+        provider_status = self.provider_status.value
+
+        friendly_name = self.friendly_name
+        jaxlid = self.jaxlid
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "address": address,
+                "iso_country": iso_country,
+                "provider_status": provider_status,
+                "friendly_name": friendly_name,
+                "jaxlid": jaxlid,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.address_provider import AddressProvider
+
+        d = src_dict.copy()
+        id = d.pop("id")
+
+        address = AddressProvider.from_dict(d.pop("address"))
+
+        iso_country = IsoCountryEnum(d.pop("iso_country"))
+
+        provider_status = ProviderStatusEnum(d.pop("provider_status"))
+
+        friendly_name = d.pop("friendly_name")
+
+        jaxlid = d.pop("jaxlid")
+
+        kyc_summary = cls(
+            id=id,
+            address=address,
+            iso_country=iso_country,
+            provider_status=provider_status,
+            friendly_name=friendly_name,
+            jaxlid=jaxlid,
+        )
+
+        kyc_summary.additional_properties = d
+        return kyc_summary
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

jaxl/api/client/models/kyc_upload_metadata.py

@@ -0,0 +1,81 @@
+"""
+Copyright (c) 2010-present by Jaxl Innovations Private Limited.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms,
+with or without modification, is strictly prohibited.
+"""
+
+from typing import Any, Dict, List, Type, TypeVar
+
+import attr
+
+
+T = TypeVar("T", bound="KycUploadMetadata")
+
+
+@attr.s(auto_attribs=True)
+class KycUploadMetadata:
+    """
+    Attributes:
+        mimetype (str):
+        sha (str):
+        size (int):
+    """
+
+    mimetype: str
+    sha: str
+    size: int
+    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        mimetype = self.mimetype
+        sha = self.sha
+        size = self.size
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "mimetype": mimetype,
+                "sha": sha,
+                "size": size,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        mimetype = d.pop("mimetype")
+
+        sha = d.pop("sha")
+
+        size = d.pop("size")
+
+        kyc_upload_metadata = cls(
+            mimetype=mimetype,
+            sha=sha,
+            size=size,
+        )
+
+        kyc_upload_metadata.additional_properties = d
+        return kyc_upload_metadata
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

jaxl/api/client/models/language_enum.py

@@ -0,0 +1,75 @@
+"""
+Copyright (c) 2010-present by Jaxl Innovations Private Limited.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms,
+with or without modification, is strictly prohibited.
+"""
+
+from enum import Enum
+
+
+class LanguageEnum(str, Enum):
+    AFAFRIKAANS = "af:Afrikaans"
+    ARARABIC = "ar:Arabic"
+    BGBULGARIAN = "bg:Bulgarian"
+    BNBENGALI = "bn:Bengali"
+    BSBOSNIAN = "bs:Bosnian"
+    CACATALAN = "ca:Catalan"
+    CSCZECH = "cs:Czech"
+    DADANISH = "da:Danish"
+    DEGERMAN = "de:German"
+    ELGREEK = "el:Greek"
+    ENENGLISH = "en:English"
+    ESSPANISH = "es:Spanish"
+    ETESTONIAN = "et:Estonian"
+    FIFINNISH = "fi:Finnish"
+    FRFRENCH = "fr:French"
+    GUGUJARATI = "gu:Gujarati"
+    HIHINDI = "hi:Hindi"
+    HRCROATIAN = "hr:Croatian"
+    HUHUNGARIAN = "hu:Hungarian"
+    IDINDONESIAN = "id:Indonesian"
+    ISICELANDIC = "is:Icelandic"
+    ITITALIAN = "it:Italian"
+    IWHEBREW = "iw:Hebrew"
+    JAJAPANESE = "ja:Japanese"
+    JWJAVANESE = "jw:Javanese"
+    KMKHMER = "km:Khmer"
+    KNKANNADA = "kn:Kannada"
+    KOKOREAN = "ko:Korean"
+    LALATIN = "la:Latin"
+    LVLATVIAN = "lv:Latvian"
+    MLMALAYALAM = "ml:Malayalam"
+    MRMARATHI = "mr:Marathi"
+    MSMALAY = "ms:Malay"
+    MYMYANMAR_BURMESE = "my:Myanmar (Burmese)"
+    NENEPALI = "ne:Nepali"
+    NLDUTCH = "nl:Dutch"
+    NONORWEGIAN = "no:Norwegian"
+    PLPOLISH = "pl:Polish"
+    PTPORTUGUESE = "pt:Portuguese"
+    ROROMANIAN = "ro:Romanian"
+    RURUSSIAN = "ru:Russian"
+    SISINHALA = "si:Sinhala"
+    SKSLOVAK = "sk:Slovak"
+    SQALBANIAN = "sq:Albanian"
+    SRSERBIAN = "sr:Serbian"
+    SUSUNDANESE = "su:Sundanese"
+    SVSWEDISH = "sv:Swedish"
+    SWSWAHILI = "sw:Swahili"
+    TATAMIL = "ta:Tamil"
+    TETELUGU = "te:Telugu"
+    THTHAI = "th:Thai"
+    TLFILIPINO = "tl:Filipino"
+    TRTURKISH = "tr:Turkish"
+    UKUKRAINIAN = "uk:Ukrainian"
+    URURDU = "ur:Urdu"
+    VIVIETNAMESE = "vi:Vietnamese"
+    ZHCHINESE_MANDARIN = "zh:Chinese (Mandarin)"
+    ZH_CNCHINESE_SIMPLIFIED = "zh-CN:Chinese (Simplified)"
+    ZH_TWCHINESE_MANDARINTAIWAN = "zh-TW:Chinese (Mandarin/Taiwan)"
+
+    def __str__(self) -> str:
+        return str(self.value)