unit-openapi-python-sdk 0.0.2__py3-none-any.whl → 0.9.0__py3-none-any.whl

unit_finance_sdk/models/wallet_account.py

@@ -0,0 +1,122 @@
+# coding: utf-8
+
+"""
+    Unit API
+
+    JSON:API-compliant banking API.
+
+    The version of the OpenAPI document: 0.9.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from unit_finance_sdk.models.credit_account_relationships import CreditAccountRelationships
+from unit_finance_sdk.models.wallet_account_attributes import WalletAccountAttributes
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class WalletAccount(BaseModel):
+    """
+    `WalletAccount` is a JSON:API resource, top-level fields:
+    """ # noqa: E501
+    type: StrictStr
+    id: StrictStr
+    attributes: WalletAccountAttributes
+    relationships: Optional[CreditAccountRelationships] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["type", "id", "attributes", "relationships"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['walletAccount']):
+            raise ValueError("must be one of enum values ('walletAccount')")
+        return value
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of WalletAccount from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of attributes
+        if self.attributes:
+            _dict['attributes'] = self.attributes.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of relationships
+        if self.relationships:
+            _dict['relationships'] = self.relationships.to_dict()
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of WalletAccount from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "id": obj.get("id"),
+            "attributes": WalletAccountAttributes.from_dict(obj["attributes"]) if obj.get("attributes") is not None else None,
+            "relationships": CreditAccountRelationships.from_dict(obj["relationships"]) if obj.get("relationships") is not None else None
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

unit_finance_sdk/models/wallet_account_attributes.py

@@ -0,0 +1,128 @@
+# coding: utf-8
+
+"""
+    Unit API
+
+    JSON:API-compliant banking API.
+
+    The version of the OpenAPI document: 0.9.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class WalletAccountAttributes(BaseModel):
+    """
+    WalletAccountAttributes
+    """ # noqa: E501
+    created_at: datetime = Field(description="The date the resource was created.", alias="createdAt")
+    name: StrictStr = Field(description="The official name.")
+    status: StrictStr = Field(description="Status of the account, either Open, Frozen, or Closed.")
+    wallet_terms: StrictStr = Field(description="The name of the wallet terms.", alias="walletTerms")
+    routing_number: StrictStr = Field(description="Routing number of wallet.", alias="routingNumber")
+    account_number: StrictStr = Field(description="Account number, together with the routingNumber forms the identifier of the wallet on the ACH network.", alias="accountNumber")
+    currency: StrictStr = Field(description="Currency of the wallet.")
+    balance: StrictInt = Field(description="The balance amount (in cents). The balance represents the funds that are currently in the wallet (not taking into account future commitments). The balance equals the sum of 'available' and 'hold'.")
+    hold: StrictInt = Field(description="The hold amount (in cents). The hold represents funds that are not available for spending, due to an outstanding card authorization.")
+    available: StrictInt = Field(description="The available balance for spending (in cents). Equals the balance minus the hold amount.")
+    tags: Optional[Dict[str, Any]] = Field(default=None, description="See Tags.")
+    freeze_reason: Optional[StrictStr] = Field(default=None, description="Optional. The reason the wallet was frozen, either Fraud, ByBank, or free-text description.", alias="freezeReason")
+    close_reason: Optional[StrictStr] = Field(default=None, description="Optional. The reason the wallet was closed, either ByCustomer or Fraud.", alias="closeReason")
+    fraud_reason: Optional[StrictStr] = Field(default=None, description="Optional. The expanded fraud reason for closing the wallet when Fraud is specified as the reason. Can be one of: (ACHActivity, CardActivity, CheckActivity, ApplicationHistory, AccountActivity, ClientIdentified, IdentityTheft, LinkedToFraudulentCustomer).", alias="fraudReason")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["createdAt", "name", "status", "walletTerms", "routingNumber", "accountNumber", "currency", "balance", "hold", "available", "tags", "freezeReason", "closeReason", "fraudReason"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of WalletAccountAttributes from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of WalletAccountAttributes from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "createdAt": obj.get("createdAt"),
+            "name": obj.get("name"),
+            "status": obj.get("status"),
+            "walletTerms": obj.get("walletTerms"),
+            "routingNumber": obj.get("routingNumber"),
+            "accountNumber": obj.get("accountNumber"),
+            "currency": obj.get("currency"),
+            "balance": obj.get("balance"),
+            "hold": obj.get("hold"),
+            "available": obj.get("available"),
+            "tags": obj.get("tags"),
+            "freezeReason": obj.get("freezeReason"),
+            "closeReason": obj.get("closeReason"),
+            "fraudReason": obj.get("fraudReason")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

unit_finance_sdk/models/wire_counterparty_type.py

@@ -0,0 +1,111 @@
+# coding: utf-8
+
+"""
+    Unit API
+
+    JSON:API-compliant banking API.
+
+    The version of the OpenAPI document: 0.9.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from unit_finance_sdk.models.address_type import AddressType
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class WireCounterpartyType(BaseModel):
+    """
+    WireCounterpartyType
+    """ # noqa: E501
+    routing_number: StrictStr = Field(description="Valid 9-digit ABA routing transit number.", alias="routingNumber")
+    account_number: StrictStr = Field(description="Bank account number.", alias="accountNumber")
+    name: StrictStr = Field(description="Name of the person or company that owns the bank account.")
+    address: AddressType = Field(description="Address of the counterparty account owner.")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["routingNumber", "accountNumber", "name", "address"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of WireCounterpartyType from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of address
+        if self.address:
+            _dict['address'] = self.address.to_dict()
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of WireCounterpartyType from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "routingNumber": obj.get("routingNumber"),
+            "accountNumber": obj.get("accountNumber"),
+            "name": obj.get("name"),
+            "address": AddressType.from_dict(obj["address"]) if obj.get("address") is not None else None
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

unit_finance_sdk/models/wire_drawdown.py

@@ -0,0 +1,122 @@
+# coding: utf-8
+
+"""
+    Unit API
+
+    JSON:API-compliant banking API.
+
+    The version of the OpenAPI document: 0.9.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from unit_finance_sdk.models.wire_drawdown_attributes import WireDrawdownAttributes
+from unit_finance_sdk.models.wire_drawdown_relationships import WireDrawdownRelationships
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class WireDrawdown(BaseModel):
+    """
+    `WireDrawdown` is a JSON:API resource.
+    """ # noqa: E501
+    type: StrictStr
+    id: StrictStr
+    attributes: WireDrawdownAttributes
+    relationships: Optional[WireDrawdownRelationships] = None
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["type", "id", "attributes", "relationships"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['wireDrawdown']):
+            raise ValueError("must be one of enum values ('wireDrawdown')")
+        return value
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of WireDrawdown from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of attributes
+        if self.attributes:
+            _dict['attributes'] = self.attributes.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of relationships
+        if self.relationships:
+            _dict['relationships'] = self.relationships.to_dict()
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of WireDrawdown from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "id": obj.get("id"),
+            "attributes": WireDrawdownAttributes.from_dict(obj["attributes"]) if obj.get("attributes") is not None else None,
+            "relationships": WireDrawdownRelationships.from_dict(obj["relationships"]) if obj.get("relationships") is not None else None
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

unit_finance_sdk/models/wire_drawdown_attributes.py

@@ -0,0 +1,128 @@
+# coding: utf-8
+
+"""
+    Unit API
+
+    JSON:API-compliant banking API.
+
+    The version of the OpenAPI document: 0.9.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from unit_finance_sdk.models.wire_counterparty_type import WireCounterpartyType
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class WireDrawdownAttributes(BaseModel):
+    """
+    WireDrawdownAttributes
+    """ # noqa: E501
+    created_at: datetime = Field(description="The date the resource was created.", alias="createdAt")
+    amount: StrictInt = Field(description="The amount (cents) of the wire drawdown.")
+    description: StrictStr = Field(description="Wire drawdown description.")
+    counterparty: WireCounterpartyType = Field(description="The beneficiary party on the other end of the wire drawdown.")
+    direction: StrictStr = Field(description="The direction of the wire drawdown, either Incoming or Outgoing.")
+    imad: Optional[StrictStr] = Field(default=None, description="Input Message Accountability Data. It's a unique number given to each wire drawdown.")
+    omad: Optional[StrictStr] = Field(default=None, description="Output Message Accountability Data. It's a unique number given to each wire drawdown.")
+    sender_reference: Optional[StrictStr] = Field(default=None, description="Sender reference.", alias="senderReference")
+    reference_for_beneficiary: Optional[StrictStr] = Field(default=None, description="Reference for the Beneficiary.", alias="referenceForBeneficiary")
+    beneficiary_information: Optional[StrictStr] = Field(default=None, description="Beneficiary Information, multi-line string delimited by \\n.", alias="beneficiaryInformation")
+    beneficiary_advice_information: Optional[StrictStr] = Field(default=None, description="Beneficiary Advice Information, multi-line string delimited by \\n.", alias="beneficiaryAdviceInformation")
+    originator_to_beneficiary_information: Optional[StrictStr] = Field(default=None, description="Originator To Beneficiary Information, multi-line string delimited by \\n.", alias="originatorToBeneficiaryInformation")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["createdAt", "amount", "description", "counterparty", "direction", "imad", "omad", "senderReference", "referenceForBeneficiary", "beneficiaryInformation", "beneficiaryAdviceInformation", "originatorToBeneficiaryInformation"]
+
+    model_config = ConfigDict(
+        validate_by_name=True,
+        validate_by_alias=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(to_jsonable_python(self.to_dict()))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of WireDrawdownAttributes from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: Set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of counterparty
+        if self.counterparty:
+            _dict['counterparty'] = self.counterparty.to_dict()
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of WireDrawdownAttributes from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "createdAt": obj.get("createdAt"),
+            "amount": obj.get("amount"),
+            "description": obj.get("description"),
+            "counterparty": WireCounterpartyType.from_dict(obj["counterparty"]) if obj.get("counterparty") is not None else None,
+            "direction": obj.get("direction"),
+            "imad": obj.get("imad"),
+            "omad": obj.get("omad"),
+            "senderReference": obj.get("senderReference"),
+            "referenceForBeneficiary": obj.get("referenceForBeneficiary"),
+            "beneficiaryInformation": obj.get("beneficiaryInformation"),
+            "beneficiaryAdviceInformation": obj.get("beneficiaryAdviceInformation"),
+            "originatorToBeneficiaryInformation": obj.get("originatorToBeneficiaryInformation")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+