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

unit_finance_sdk/models/book_transaction_attributes.py

@@ -0,0 +1,118 @@
+# 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
+from unit_finance_sdk.models.counterparty_type import CounterpartyType
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class BookTransactionAttributes(BaseModel):
+    """
+    BookTransactionAttributes
+    """ # noqa: E501
+    created_at: datetime = Field(description="The date the transaction was created. Common to all transaction types.", alias="createdAt")
+    direction: StrictStr = Field(description="The direction in which the funds flow. Common to all transaction types.")
+    amount: StrictInt = Field(description="The amount (cents) of the transaction. Common to all transaction types.")
+    balance: StrictInt = Field(description="The account balance (cents) after the transaction. Common to all transaction types.")
+    summary: StrictStr = Field(description="Summary of the transaction. Common to all transaction types.")
+    counterparty: CounterpartyType = Field(description="The party on the other end of the transaction.")
+    tags: Dict[str, Any] = Field(description="See Tags. Inherited from the payment tags (see Tag Inheritance).")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["createdAt", "direction", "amount", "balance", "summary", "counterparty", "tags"]
+
+    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 BookTransactionAttributes 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 BookTransactionAttributes 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"),
+            "direction": obj.get("direction"),
+            "amount": obj.get("amount"),
+            "balance": obj.get("balance"),
+            "summary": obj.get("summary"),
+            "counterparty": CounterpartyType.from_dict(obj["counterparty"]) if obj.get("counterparty") is not None else None,
+            "tags": obj.get("tags")
+        })
+        # 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/book_transaction_relationships.py

@@ -0,0 +1,135 @@
+# 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
+from typing import Any, ClassVar, Dict, List, Optional
+from unit_finance_sdk.models.relationship import Relationship
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class BookTransactionRelationships(BaseModel):
+    """
+    BookTransactionRelationships
+    """ # noqa: E501
+    account: Optional[Relationship] = None
+    customer: Optional[Relationship] = None
+    customers: Optional[Relationship] = None
+    counterparty_account: Optional[Relationship] = Field(default=None, alias="counterpartyAccount")
+    counterparty_customer: Optional[Relationship] = Field(default=None, alias="counterpartyCustomer")
+    payment: Optional[Relationship] = None
+    recurring_payment: Optional[Relationship] = Field(default=None, alias="recurringPayment")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["account", "customer", "customers", "counterpartyAccount", "counterpartyCustomer", "payment", "recurringPayment"]
+
+    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 BookTransactionRelationships 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 account
+        if self.account:
+            _dict['account'] = self.account.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of customer
+        if self.customer:
+            _dict['customer'] = self.customer.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of customers
+        if self.customers:
+            _dict['customers'] = self.customers.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of counterparty_account
+        if self.counterparty_account:
+            _dict['counterpartyAccount'] = self.counterparty_account.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of counterparty_customer
+        if self.counterparty_customer:
+            _dict['counterpartyCustomer'] = self.counterparty_customer.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of payment
+        if self.payment:
+            _dict['payment'] = self.payment.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of recurring_payment
+        if self.recurring_payment:
+            _dict['recurringPayment'] = self.recurring_payment.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 BookTransactionRelationships from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "account": Relationship.from_dict(obj["account"]) if obj.get("account") is not None else None,
+            "customer": Relationship.from_dict(obj["customer"]) if obj.get("customer") is not None else None,
+            "customers": Relationship.from_dict(obj["customers"]) if obj.get("customers") is not None else None,
+            "counterpartyAccount": Relationship.from_dict(obj["counterpartyAccount"]) if obj.get("counterpartyAccount") is not None else None,
+            "counterpartyCustomer": Relationship.from_dict(obj["counterpartyCustomer"]) if obj.get("counterpartyCustomer") is not None else None,
+            "payment": Relationship.from_dict(obj["payment"]) if obj.get("payment") is not None else None,
+            "recurringPayment": Relationship.from_dict(obj["recurringPayment"]) if obj.get("recurringPayment") 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/business_annual_revenue_type.py

@@ -0,0 +1,40 @@
+# 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 json
+from enum import Enum
+from typing_extensions import Self
+
+
+class BusinessAnnualRevenueType(str, Enum):
+    """
+    The annual revenue of a business.
+    """
+
+    """
+    allowed enum values
+    """
+    UPTO250K = 'UpTo250k'
+    BETWEEN250KAND500K = 'Between250kAnd500k'
+    BETWEEN500KAND1M = 'Between500kAnd1m'
+    BETWEEN1MAND5M = 'Between1mAnd5m'
+    OVER5M = 'Over5m'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of BusinessAnnualRevenueType from a JSON string"""
+        return cls(json.loads(json_str))
+
+

unit_finance_sdk/models/business_application.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.business_application_attributes import BusinessApplicationAttributes
+from unit_finance_sdk.models.business_application_relationships import BusinessApplicationRelationships
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class BusinessApplication(BaseModel):
+    """
+    `BusinessApplication` is a JSON:API resource, top-level fields:
+    """ # noqa: E501
+    type: StrictStr
+    id: StrictStr
+    attributes: BusinessApplicationAttributes
+    relationships: Optional[BusinessApplicationRelationships] = 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(['businessApplication']):
+            raise ValueError("must be one of enum values ('businessApplication')")
+        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 BusinessApplication 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 BusinessApplication 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": BusinessApplicationAttributes.from_dict(obj["attributes"]) if obj.get("attributes") is not None else None,
+            "relationships": BusinessApplicationRelationships.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/business_application_attributes.py

@@ -0,0 +1,197 @@
+# 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, StrictBool, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from unit_finance_sdk.models.address_type import AddressType
+from unit_finance_sdk.models.annual_revenue_type import AnnualRevenueType
+from unit_finance_sdk.models.beneficial_owner_type import BeneficialOwnerType
+from unit_finance_sdk.models.business_contact_type import BusinessContactType
+from unit_finance_sdk.models.business_vertical_type import BusinessVerticalType
+from unit_finance_sdk.models.cash_flow_type import CashFlowType
+from unit_finance_sdk.models.industry_type import IndustryType
+from unit_finance_sdk.models.number_of_employees_type import NumberOfEmployeesType
+from unit_finance_sdk.models.officer_type import OfficerType
+from unit_finance_sdk.models.phone_type import PhoneType
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class BusinessApplicationAttributes(BaseModel):
+    """
+    BusinessApplicationAttributes
+    """ # noqa: E501
+    status: StrictStr = Field(description="One of AwaitingDocuments, PendingReview, Approved, Denied or Pending, see Application Statuses.")
+    message: StrictStr = Field(description="A message describing the BusinessApplication status.")
+    created_at: datetime = Field(description="The date the resource was created.", alias="createdAt")
+    updated_at: Optional[datetime] = Field(default=None, description="Optional. The date the resource was updated.", alias="updatedAt")
+    name: StrictStr = Field(description="Name of the business.")
+    dba: Optional[StrictStr] = Field(default=None, description="Optional. \"Doing business as\".")
+    address: AddressType = Field(description="Address of the business.")
+    operating_address: Optional[AddressType] = Field(default=None, description="Optional. The operating address of the business. Required when the address is of a registered agent or if any beneficial owner or officer is non-US.", alias="operatingAddress")
+    phone: PhoneType = Field(description="Phone of the business.")
+    state_of_incorporation: StrictStr = Field(description="Two letters representing a US state.", alias="stateOfIncorporation")
+    ein: StrictStr = Field(description="Business EIN (numbers only).")
+    industry: Optional[IndustryType] = Field(default=None, description="Optional. Business industry, if specified.")
+    entity_type: StrictStr = Field(description="The business entity type. Documented values are LLC, Partnership, PubliclyTradedCorporation, PrivatelyHeldCorporation and NotForProfitOrganization, but the live API also returns Corporation, so the documented list is not exhaustive. Kept as a free-form string (not a strict enum) to avoid breaking strict client deserialization on undocumented values.", alias="entityType")
+    website: Optional[StrictStr] = Field(default=None, description="Optional. Business's website.")
+    contact: BusinessContactType = Field(description="Primary contact of the business.")
+    officer: OfficerType = Field(description="Officer representing the business, must be the CEO, COO, CFO, President, BenefitsAdministrationOfficer, CIO, VP, AVP, Treasurer, Secretary, Controller, Manager, Partner or Member. The officer would need to go over KYC process and provide documents.")
+    beneficial_owners: List[BeneficialOwnerType] = Field(alias="beneficialOwners")
+    annual_revenue: Optional[AnnualRevenueType] = Field(default=None, description="Optional. Annual revenue of the business.", alias="annualRevenue")
+    number_of_employees: Optional[NumberOfEmployeesType] = Field(default=None, description="Optional. Number of employees of the business.", alias="numberOfEmployees")
+    cash_flow: Optional[CashFlowType] = Field(default=None, description="Optional. Cash flow of the business.", alias="cashFlow")
+    year_of_incorporation: Annotated[str, Field(strict=True)] = Field(description="Year of incorporation of the business.", alias="yearOfIncorporation")
+    countries_of_operation: Optional[List[StrictStr]] = Field(default=None, description="Optional. An array of two letter codes representing the countries of operation of the business.", alias="countriesOfOperation")
+    stock_symbol: Optional[StrictStr] = Field(default=None, description="Optional. The stock symbol (ticker) of the business.", alias="stockSymbol")
+    business_vertical: BusinessVerticalType = Field(description="The business vertical of the business.", alias="businessVertical")
+    ip: Optional[StrictStr] = Field(default=None, description="Optional. IP address of the end-customer creating the application. Both IPv4 and IPv6 formats are supported. Highly recommended as a fraud prevention measure, if the information is available when submitting the application.")
+    archived: StrictBool = Field(description="Indicates whether the application has been archived. Archived applications are read-only and no changes can be made to them. An application becomes archived once the corresponding customer is archived.")
+    tags: Dict[str, Any] = Field(description="See Tags.")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["status", "message", "createdAt", "updatedAt", "name", "dba", "address", "operatingAddress", "phone", "stateOfIncorporation", "ein", "industry", "entityType", "website", "contact", "officer", "beneficialOwners", "annualRevenue", "numberOfEmployees", "cashFlow", "yearOfIncorporation", "countriesOfOperation", "stockSymbol", "businessVertical", "ip", "archived", "tags"]
+
+    @field_validator('year_of_incorporation')
+    def year_of_incorporation_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not isinstance(value, str):
+            value = str(value)
+
+        if not re.match(r"^\d{4}$", value):
+            raise ValueError(r"must validate the regular expression /^\d{4}$/")
+        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 BusinessApplicationAttributes 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()
+        # override the default output from pydantic by calling `to_dict()` of operating_address
+        if self.operating_address:
+            _dict['operatingAddress'] = self.operating_address.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of phone
+        if self.phone:
+            _dict['phone'] = self.phone.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of contact
+        if self.contact:
+            _dict['contact'] = self.contact.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of officer
+        if self.officer:
+            _dict['officer'] = self.officer.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in beneficial_owners (list)
+        _items = []
+        if self.beneficial_owners:
+            for _item_beneficial_owners in self.beneficial_owners:
+                if _item_beneficial_owners:
+                    _items.append(_item_beneficial_owners.to_dict())
+            _dict['beneficialOwners'] = _items
+        # 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 BusinessApplicationAttributes from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "status": obj.get("status"),
+            "message": obj.get("message"),
+            "createdAt": obj.get("createdAt"),
+            "updatedAt": obj.get("updatedAt"),
+            "name": obj.get("name"),
+            "dba": obj.get("dba"),
+            "address": AddressType.from_dict(obj["address"]) if obj.get("address") is not None else None,
+            "operatingAddress": AddressType.from_dict(obj["operatingAddress"]) if obj.get("operatingAddress") is not None else None,
+            "phone": PhoneType.from_dict(obj["phone"]) if obj.get("phone") is not None else None,
+            "stateOfIncorporation": obj.get("stateOfIncorporation"),
+            "ein": obj.get("ein"),
+            "industry": obj.get("industry"),
+            "entityType": obj.get("entityType"),
+            "website": obj.get("website"),
+            "contact": BusinessContactType.from_dict(obj["contact"]) if obj.get("contact") is not None else None,
+            "officer": OfficerType.from_dict(obj["officer"]) if obj.get("officer") is not None else None,
+            "beneficialOwners": [BeneficialOwnerType.from_dict(_item) for _item in obj["beneficialOwners"]] if obj.get("beneficialOwners") is not None else None,
+            "annualRevenue": obj.get("annualRevenue"),
+            "numberOfEmployees": obj.get("numberOfEmployees"),
+            "cashFlow": obj.get("cashFlow"),
+            "yearOfIncorporation": obj.get("yearOfIncorporation"),
+            "countriesOfOperation": obj.get("countriesOfOperation"),
+            "stockSymbol": obj.get("stockSymbol"),
+            "businessVertical": obj.get("businessVertical"),
+            "ip": obj.get("ip"),
+            "archived": obj.get("archived"),
+            "tags": obj.get("tags")
+        })
+        # 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
+
+