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

unit_finance_sdk/models/create_bulk_payment_request_data_inner.py

@@ -0,0 +1,179 @@
+# 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
+import pprint
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator
+from typing import Any, List, Optional
+from unit_finance_sdk.models.create_a_book_payment_data import CreateABookPaymentData
+from unit_finance_sdk.models.create_a_wire_payment_data import CreateAWirePaymentData
+from unit_finance_sdk.models.create_ach_payment_data import CreateACHPaymentData
+from unit_finance_sdk.models.create_ach_payment_existing_counterparty_data import CreateACHPaymentExistingCounterpartyData
+from unit_finance_sdk.models.create_ach_payment_plaid_token_data import CreateACHPaymentPlaidTokenData
+from pydantic import StrictStr, Field
+from typing import Union, List, Set, Optional, Dict
+from typing_extensions import Literal, Self
+
+CREATEBULKPAYMENTREQUESTDATAINNER_ONE_OF_SCHEMAS = ["CreateABookPaymentData", "CreateACHPaymentData", "CreateACHPaymentExistingCounterpartyData", "CreateACHPaymentPlaidTokenData", "CreateAWirePaymentData"]
+
+class CreateBulkPaymentRequestDataInner(BaseModel):
+    """
+    CreateBulkPaymentRequestDataInner
+    """
+    # data type: CreateACHPaymentData
+    oneof_schema_1_validator: Optional[CreateACHPaymentData] = None
+    # data type: CreateACHPaymentExistingCounterpartyData
+    oneof_schema_2_validator: Optional[CreateACHPaymentExistingCounterpartyData] = None
+    # data type: CreateACHPaymentPlaidTokenData
+    oneof_schema_3_validator: Optional[CreateACHPaymentPlaidTokenData] = None
+    # data type: CreateABookPaymentData
+    oneof_schema_4_validator: Optional[CreateABookPaymentData] = None
+    # data type: CreateAWirePaymentData
+    oneof_schema_5_validator: Optional[CreateAWirePaymentData] = None
+    actual_instance: Optional[Union[CreateABookPaymentData, CreateACHPaymentData, CreateACHPaymentExistingCounterpartyData, CreateACHPaymentPlaidTokenData, CreateAWirePaymentData]] = None
+    one_of_schemas: Set[str] = { "CreateABookPaymentData", "CreateACHPaymentData", "CreateACHPaymentExistingCounterpartyData", "CreateACHPaymentPlaidTokenData", "CreateAWirePaymentData" }
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args:
+            if len(args) > 1:
+                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
+            if kwargs:
+                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
+            super().__init__(actual_instance=args[0])
+        else:
+            super().__init__(**kwargs)
+
+    @field_validator('actual_instance')
+    def actual_instance_must_validate_oneof(cls, v):
+        instance = CreateBulkPaymentRequestDataInner.model_construct()
+        error_messages = []
+        match = 0
+        # validate data type: CreateACHPaymentData
+        if not isinstance(v, CreateACHPaymentData):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `CreateACHPaymentData`")
+        else:
+            match += 1
+        # validate data type: CreateACHPaymentExistingCounterpartyData
+        if not isinstance(v, CreateACHPaymentExistingCounterpartyData):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `CreateACHPaymentExistingCounterpartyData`")
+        else:
+            match += 1
+        # validate data type: CreateACHPaymentPlaidTokenData
+        if not isinstance(v, CreateACHPaymentPlaidTokenData):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `CreateACHPaymentPlaidTokenData`")
+        else:
+            match += 1
+        # validate data type: CreateABookPaymentData
+        if not isinstance(v, CreateABookPaymentData):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `CreateABookPaymentData`")
+        else:
+            match += 1
+        # validate data type: CreateAWirePaymentData
+        if not isinstance(v, CreateAWirePaymentData):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `CreateAWirePaymentData`")
+        else:
+            match += 1
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when setting `actual_instance` in CreateBulkPaymentRequestDataInner with oneOf schemas: CreateABookPaymentData, CreateACHPaymentData, CreateACHPaymentExistingCounterpartyData, CreateACHPaymentPlaidTokenData, CreateAWirePaymentData. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when setting `actual_instance` in CreateBulkPaymentRequestDataInner with oneOf schemas: CreateABookPaymentData, CreateACHPaymentData, CreateACHPaymentExistingCounterpartyData, CreateACHPaymentPlaidTokenData, CreateAWirePaymentData. Details: " + ", ".join(error_messages))
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: Union[str, Dict[str, Any]]) -> Self:
+        return cls.from_json(json.dumps(obj))
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Returns the object represented by the json string"""
+        instance = cls.model_construct()
+        error_messages = []
+        match = 0
+
+        # deserialize data into CreateACHPaymentData
+        try:
+            instance.actual_instance = CreateACHPaymentData.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into CreateACHPaymentExistingCounterpartyData
+        try:
+            instance.actual_instance = CreateACHPaymentExistingCounterpartyData.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into CreateACHPaymentPlaidTokenData
+        try:
+            instance.actual_instance = CreateACHPaymentPlaidTokenData.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into CreateABookPaymentData
+        try:
+            instance.actual_instance = CreateABookPaymentData.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        # deserialize data into CreateAWirePaymentData
+        try:
+            instance.actual_instance = CreateAWirePaymentData.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when deserializing the JSON string into CreateBulkPaymentRequestDataInner with oneOf schemas: CreateABookPaymentData, CreateACHPaymentData, CreateACHPaymentExistingCounterpartyData, CreateACHPaymentPlaidTokenData, CreateAWirePaymentData. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when deserializing the JSON string into CreateBulkPaymentRequestDataInner with oneOf schemas: CreateABookPaymentData, CreateACHPaymentData, CreateACHPaymentExistingCounterpartyData, CreateACHPaymentPlaidTokenData, CreateAWirePaymentData. Details: " + ", ".join(error_messages))
+        else:
+            return instance
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the actual instance"""
+        if self.actual_instance is None:
+            return "null"
+
+        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(self) -> Optional[Union[Dict[str, Any], CreateABookPaymentData, CreateACHPaymentData, CreateACHPaymentExistingCounterpartyData, CreateACHPaymentPlaidTokenData, CreateAWirePaymentData]]:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
+            return None
+
+        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
+            return self.actual_instance.to_dict()
+        else:
+            # primitive type
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())
+
+

unit_finance_sdk/models/create_business_application_data.py

@@ -0,0 +1,114 @@
+# 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
+from unit_finance_sdk.models.create_business_application_data_attributes import CreateBusinessApplicationDataAttributes
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CreateBusinessApplicationData(BaseModel):
+    """
+    CreateBusinessApplicationData
+    """ # noqa: E501
+    type: StrictStr
+    attributes: CreateBusinessApplicationDataAttributes
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["type", "attributes"]
+
+    @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 CreateBusinessApplicationData 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()
+        # 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 CreateBusinessApplicationData 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"),
+            "attributes": CreateBusinessApplicationDataAttributes.from_dict(obj["attributes"]) if obj.get("attributes") 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/create_business_application_data_attributes.py

@@ -0,0 +1,189 @@
+# 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.address_type import AddressType
+from unit_finance_sdk.models.beneficial_owner_request_type import BeneficialOwnerRequestType
+from unit_finance_sdk.models.business_annual_revenue_type import BusinessAnnualRevenueType
+from unit_finance_sdk.models.business_contact_type import BusinessContactType
+from unit_finance_sdk.models.business_number_of_employees_type import BusinessNumberOfEmployeesType
+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.device_fingerprint_type import DeviceFingerprintType
+from unit_finance_sdk.models.officer_request_type import OfficerRequestType
+from unit_finance_sdk.models.phone_type import PhoneType
+from unit_finance_sdk.models.requested_product_type import RequestedProductType
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CreateBusinessApplicationDataAttributes(BaseModel):
+    """
+    CreateBusinessApplicationDataAttributes
+    """ # noqa: E501
+    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. Must be a US address")
+    phone: PhoneType = Field(description="Phone number 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 sandbox also accepts Corporation, so the documented list is not exhaustive. Kept as a free-form string (not a strict enum) to avoid rejecting values the live API accepts.", alias="entityType")
+    website: Optional[StrictStr] = Field(description="A Valid website Url. Providing a null value is indicative of the business customer attesting that they do not have a website.")
+    contact: BusinessContactType = Field(description="Primary contact of the business. This person is the one that will have access to the account.")
+    officer: OfficerRequestType = Field(description="Officer representing the business (must be the CEO, COO, CFO, President, BenefitsAdministrationOfficer, CIO, VP, AVP, Treasurer, Secretary, Controller, Manager, Partner or Member). To onboard a business successfully, you must provide the officer's personal details.")
+    beneficial_owners: List[BeneficialOwnerRequestType] = Field(description="Array of beneficial owners in the business. Beneficial owners are all people that, directly or indirectly, own 25% or more of the business. To onboard a business successfully, you must provide each beneficial owner's personal details. If the business has no beneficial owners, the array should be empty.", alias="beneficialOwners")
+    annual_revenue: BusinessAnnualRevenueType = Field(description="Required if any of the officer / BeneficialOwner of the business have a non US nationality. Annual revenue of the business.", alias="annualRevenue")
+    number_of_employees: BusinessNumberOfEmployeesType = Field(description="Required if any of the officer / BeneficialOwner of the business have a non US nationality. Number of employees of the business.", alias="numberOfEmployees")
+    cash_flow: CashFlowType = Field(description="Required if any of the officer / BeneficialOwner of the business have a non US nationality. Cash flow of the business.", alias="cashFlow")
+    year_of_incorporation: StrictStr = Field(description="Required. Year of incorporation of the business as a 4-digit year string (e.g., \"2014\").", alias="yearOfIncorporation")
+    countries_of_operation: List[StrictStr] = Field(description="Required if any of the officer / BeneficialOwner of the business have a non US nationality. 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.")
+    tags: Optional[Dict[str, Any]] = Field(default=None, description="Optional. See Tags. Tags that will be copied to the customer that this application creates (see Tag Inheritance).")
+    idempotency_key: Optional[StrictStr] = Field(default=None, description="Optional. See Idempotency.", alias="idempotencyKey")
+    device_fingerprints: Optional[List[DeviceFingerprintType]] = Field(default=None, description="Optional. A list of device fingerprints for fraud and risk prevention (See Device Fingerprints).", alias="deviceFingerprints")
+    banks: Optional[List[StrictStr]] = Field(default=None, description="Optional. The name of the bank or banks that should be associated with this application. If not specified, the application will be associated with the Org's default bank (visible via Org Settings in the Dashboard).")
+    requested_products: Optional[List[RequestedProductType]] = Field(default=None, description="Optional. The product being applied for. Contact Unit to enable BillPay and Capital products.", alias="requestedProducts")
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["name", "dba", "address", "phone", "stateOfIncorporation", "ein", "entityType", "website", "contact", "officer", "beneficialOwners", "annualRevenue", "numberOfEmployees", "cashFlow", "yearOfIncorporation", "countriesOfOperation", "stockSymbol", "businessVertical", "ip", "tags", "idempotencyKey", "deviceFingerprints", "banks", "requestedProducts"]
+
+    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 CreateBusinessApplicationDataAttributes 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 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
+        # override the default output from pydantic by calling `to_dict()` of each item in device_fingerprints (list)
+        _items = []
+        if self.device_fingerprints:
+            for _item_device_fingerprints in self.device_fingerprints:
+                if _item_device_fingerprints:
+                    _items.append(_item_device_fingerprints.to_dict())
+            _dict['deviceFingerprints'] = _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
+
+        # set to None if website (nullable) is None
+        # and model_fields_set contains the field
+        if self.website is None and "website" in self.model_fields_set:
+            _dict['website'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of CreateBusinessApplicationDataAttributes from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "dba": obj.get("dba"),
+            "address": AddressType.from_dict(obj["address"]) if obj.get("address") 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"),
+            "website": obj.get("website"),
+            "contact": BusinessContactType.from_dict(obj["contact"]) if obj.get("contact") is not None else None,
+            "officer": OfficerRequestType.from_dict(obj["officer"]) if obj.get("officer") is not None else None,
+            "beneficialOwners": [BeneficialOwnerRequestType.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"),
+            "tags": obj.get("tags"),
+            "idempotencyKey": obj.get("idempotencyKey"),
+            "deviceFingerprints": [DeviceFingerprintType.from_dict(_item) for _item in obj["deviceFingerprints"]] if obj.get("deviceFingerprints") is not None else None,
+            "banks": obj.get("banks"),
+            "requestedProducts": obj.get("requestedProducts")
+        })
+        # 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/create_business_application_request.py

@@ -0,0 +1,105 @@
+# 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
+from typing import Any, ClassVar, Dict, List
+from unit_finance_sdk.models.create_business_application_data import CreateBusinessApplicationData
+from typing import Optional, Set
+from typing_extensions import Self
+from pydantic_core import to_jsonable_python
+
+class CreateBusinessApplicationRequest(BaseModel):
+    """
+    CreateBusinessApplicationRequest
+    """ # noqa: E501
+    data: CreateBusinessApplicationData
+    additional_properties: Dict[str, Any] = {}
+    __properties: ClassVar[List[str]] = ["data"]
+
+    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 CreateBusinessApplicationRequest 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 data
+        if self.data:
+            _dict['data'] = self.data.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 CreateBusinessApplicationRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "data": CreateBusinessApplicationData.from_dict(obj["data"]) if obj.get("data") 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
+
+