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

unit_finance_sdk/models/business_application_relationships.py

@@ -0,0 +1,131 @@
+# 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 unit_finance_sdk.models.to_many_relationship import ToManyRelationship
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class BusinessApplicationRelationships(BaseModel):
+    """
+    BusinessApplicationRelationships
+    """ # noqa: E501
+    org: Optional[Relationship] = None
+    customer: Optional[Relationship] = None
+    officer: Optional[Relationship] = None
+    beneficial_owners: Optional[ToManyRelationship] = Field(default=None, alias="beneficialOwners")
+    documents: Optional[ToManyRelationship] = None
+    application_form: Optional[Relationship] = Field(default=None, alias="applicationForm")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["org", "customer", "officer", "beneficialOwners", "documents", "applicationForm"]
+
+    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 BusinessApplicationRelationships 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 org
+        if self.org:
+            _dict['org'] = self.org.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 officer
+        if self.officer:
+            _dict['officer'] = self.officer.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of beneficial_owners
+        if self.beneficial_owners:
+            _dict['beneficialOwners'] = self.beneficial_owners.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of documents
+        if self.documents:
+            _dict['documents'] = self.documents.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of application_form
+        if self.application_form:
+            _dict['applicationForm'] = self.application_form.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 BusinessApplicationRelationships from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "org": Relationship.from_dict(obj["org"]) if obj.get("org") is not None else None,
+            "customer": Relationship.from_dict(obj["customer"]) if obj.get("customer") is not None else None,
+            "officer": Relationship.from_dict(obj["officer"]) if obj.get("officer") is not None else None,
+            "beneficialOwners": ToManyRelationship.from_dict(obj["beneficialOwners"]) if obj.get("beneficialOwners") is not None else None,
+            "documents": ToManyRelationship.from_dict(obj["documents"]) if obj.get("documents") is not None else None,
+            "applicationForm": Relationship.from_dict(obj["applicationForm"]) if obj.get("applicationForm") 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_contact_type.py

@@ -0,0 +1,115 @@
+# 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, Optional
+from unit_finance_sdk.models.full_name_type import FullNameType
+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 BusinessContactType(BaseModel):
+    """
+    BusinessContactType
+    """ # noqa: E501
+    full_name: FullNameType = Field(description="Full name of the contact.", alias="fullName")
+    email: StrictStr = Field(description="The contact's email address.")
+    phone: PhoneType = Field(description="The contact's phone number.")
+    jwt_subject: Optional[StrictStr] = Field(default=None, description="Optional. See this section for more information.", alias="jwtSubject")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["fullName", "email", "phone", "jwtSubject"]
+
+    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 BusinessContactType 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 full_name
+        if self.full_name:
+            _dict['fullName'] = self.full_name.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of phone
+        if self.phone:
+            _dict['phone'] = self.phone.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 BusinessContactType from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "fullName": FullNameType.from_dict(obj["fullName"]) if obj.get("fullName") is not None else None,
+            "email": obj.get("email"),
+            "phone": PhoneType.from_dict(obj["phone"]) if obj.get("phone") is not None else None,
+            "jwtSubject": obj.get("jwtSubject")
+        })
+        # 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_credit_card.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 pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from unit_finance_sdk.models.cash_deposit_barcode_relationships import CashDepositBarcodeRelationships
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class BusinessCreditCard(BaseModel):
+    """
+    `BusinessCreditCard` is a JSON:API resource returned by the Create Business Credit Card operation.
+    """ # noqa: E501
+    type: StrictStr
+    id: StrictStr
+    attributes: Dict[str, Any] = Field(description="Attributes of the business credit card.")
+    relationships: Optional[CashDepositBarcodeRelationships] = 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(['businessCreditCard']):
+            raise ValueError("must be one of enum values ('businessCreditCard')")
+        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 BusinessCreditCard 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 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 BusinessCreditCard 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": obj.get("attributes"),
+            "relationships": CashDepositBarcodeRelationships.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_customer.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_customer_attributes import BusinessCustomerAttributes
+from unit_finance_sdk.models.business_customer_relationships import BusinessCustomerRelationships
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class BusinessCustomer(BaseModel):
+    """
+    BusinessCustomer
+    """ # noqa: E501
+    type: StrictStr
+    id: StrictStr
+    attributes: BusinessCustomerAttributes
+    relationships: Optional[BusinessCustomerRelationships] = 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(['businessCustomer']):
+            raise ValueError("must be one of enum values ('businessCustomer')")
+        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 BusinessCustomer 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 BusinessCustomer 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": BusinessCustomerAttributes.from_dict(obj["attributes"]) if obj.get("attributes") is not None else None,
+            "relationships": BusinessCustomerRelationships.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_customer_attributes.py

@@ -0,0 +1,188 @@
+# 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, 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.authorized_user_type import AuthorizedUserType
+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.number_of_employees_type import NumberOfEmployeesType
+from unit_finance_sdk.models.phone_type import PhoneType
+from unit_finance_sdk.models.product_type import ProductType
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class BusinessCustomerAttributes(BaseModel):
+    """
+    BusinessCustomerAttributes
+    """ # noqa: E501
+    created_at: datetime = Field(description="The date the resource was created.", alias="createdAt")
+    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.", 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).")
+    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")
+    contact: BusinessContactType = Field(description="Primary contact of the business.")
+    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")
+    business_vertical: Optional[BusinessVerticalType] = Field(default=None, description="Optional. Business vertical of the business.", alias="businessVertical")
+    cash_flow: Optional[CashFlowType] = Field(default=None, description="Optional. Cash flow of the business.", alias="cashFlow")
+    countries_of_operation: Optional[List[Annotated[str, Field(min_length=2, strict=True, max_length=2)]]] = Field(default=None, description="Optional. Countries where the business operates.", alias="countriesOfOperation")
+    website: Optional[StrictStr] = Field(default=None, description="Optional. Business's website.")
+    stock_symbol: Optional[StrictStr] = Field(default=None, description="Optional. The stock symbol (ticker) of the business.", alias="stockSymbol")
+    year_of_incorporation: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="Optional. Year of incorporation of the business.", alias="yearOfIncorporation")
+    authorized_users: List[AuthorizedUserType] = Field(description="Array of authorized users. An authorized user is someone who can participate in the One Time Password (OTP) authentication process.", alias="authorizedUsers")
+    status: StrictStr = Field(description="Status of the customer, either Active or Archived. You can't do any write operations on an Archived customer.")
+    eligible_products: Optional[List[ProductType]] = Field(default=None, description="Optional. The products that the customer is eligible for.", alias="eligibleProducts")
+    archive_reason: Optional[StrictStr] = Field(default=None, description="Optional, only if the customer status is Archived. The reason the customer was archived, can be one of ByBank, Inactive, FraudACHActivity, FraudCardActivity, FraudCheckActivity, FraudApplicationHistory, FraudAccountActivity, FraudClientIdentified, FraudLinkedToFraudulentCustomer.", alias="archiveReason")
+    tags: Dict[str, Any] = Field(description="See Tags. Inherited from the application tags (see Tag Inheritance).")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["createdAt", "name", "dba", "address", "operatingAddress", "phone", "stateOfIncorporation", "ein", "entityType", "contact", "annualRevenue", "numberOfEmployees", "businessVertical", "cashFlow", "countriesOfOperation", "website", "stockSymbol", "yearOfIncorporation", "authorizedUsers", "status", "eligibleProducts", "archiveReason", "tags"]
+
+    @field_validator('year_of_incorporation')
+    def year_of_incorporation_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if value is None:
+            return value
+
+        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 BusinessCustomerAttributes 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 each item in authorized_users (list)
+        _items = []
+        if self.authorized_users:
+            for _item_authorized_users in self.authorized_users:
+                if _item_authorized_users:
+                    _items.append(_item_authorized_users.to_dict())
+            _dict['authorizedUsers'] = _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 BusinessCustomerAttributes 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"),
+            "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"),
+            "entityType": obj.get("entityType"),
+            "contact": BusinessContactType.from_dict(obj["contact"]) if obj.get("contact") is not None else None,
+            "annualRevenue": obj.get("annualRevenue"),
+            "numberOfEmployees": obj.get("numberOfEmployees"),
+            "businessVertical": obj.get("businessVertical"),
+            "cashFlow": obj.get("cashFlow"),
+            "countriesOfOperation": obj.get("countriesOfOperation"),
+            "website": obj.get("website"),
+            "stockSymbol": obj.get("stockSymbol"),
+            "yearOfIncorporation": obj.get("yearOfIncorporation"),
+            "authorizedUsers": [AuthorizedUserType.from_dict(_item) for _item in obj["authorizedUsers"]] if obj.get("authorizedUsers") is not None else None,
+            "status": obj.get("status"),
+            "eligibleProducts": obj.get("eligibleProducts"),
+            "archiveReason": obj.get("archiveReason"),
+            "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
+
+