lithic 0.5.0 → 0.7.0

data/rbi/lithic/models/account_holder_update_response.rbi

@@ -36,18 +36,6 @@ module Lithic
         sig { params(account_token: String).void }
         attr_writer :account_token
 
-        # Deprecated.
-        sig { returns(T.nilable(T::Array[Lithic::KYBBusinessEntity])) }
-        attr_reader :beneficial_owner_entities
-
-        sig do
-          params(
-            beneficial_owner_entities:
-              T::Array[Lithic::KYBBusinessEntity::OrHash]
-          ).void
-        end
-        attr_writer :beneficial_owner_entities
-
         # Only present when user_type == "BUSINESS". You must submit a list of all direct
         # and indirect individuals with 25% or more ownership in the company. A maximum of
         # 4 beneficial owners can be submitted. If no individual owns 25% of the company
@@ -313,8 +301,6 @@ module Lithic
           params(
             token: String,
             account_token: String,
-            beneficial_owner_entities:
-              T::Array[Lithic::KYBBusinessEntity::OrHash],
             beneficial_owner_individuals:
               T::Array[
                 Lithic::Models::AccountHolderUpdateResponse::KYBKYCPatchResponse::BeneficialOwnerIndividual::OrHash
@@ -352,8 +338,6 @@ module Lithic
           token: nil,
           # Globally unique identifier for the account.
           account_token: nil,
-          # Deprecated.
-          beneficial_owner_entities: nil,
           # Only present when user_type == "BUSINESS". You must submit a list of all direct
           # and indirect individuals with 25% or more ownership in the company. A maximum of
           # 4 beneficial owners can be submitted. If no individual owns 25% of the company
@@ -436,7 +420,6 @@ module Lithic
             {
               token: String,
               account_token: String,
-              beneficial_owner_entities: T::Array[Lithic::KYBBusinessEntity],
               beneficial_owner_individuals:
                 T::Array[
                   Lithic::Models::AccountHolderUpdateResponse::KYBKYCPatchResponse::BeneficialOwnerIndividual

data/rbi/lithic/models/account_holder_updated_webhook_event.rbi

@@ -155,18 +155,6 @@ module Lithic
               )
             end
 
-          # Deprecated.
-          sig { returns(T.nilable(T::Array[Lithic::KYBBusinessEntity])) }
-          attr_reader :beneficial_owner_entities
-
-          sig do
-            params(
-              beneficial_owner_entities:
-                T::Array[Lithic::KYBBusinessEntity::OrHash]
-            ).void
-          end
-          attr_writer :beneficial_owner_entities
-
           # You must submit a list of all direct and indirect individuals with 25% or more
           # ownership in the company. A maximum of 4 beneficial owners can be submitted. If
           # no individual owns 25% of the company you do not need to send beneficial owner
@@ -232,8 +220,6 @@ module Lithic
           # Original request to update the account holder.
           sig do
             params(
-              beneficial_owner_entities:
-                T::Array[Lithic::KYBBusinessEntity::OrHash],
               beneficial_owner_individuals:
                 T::Array[
                   Lithic::AccountHolderUpdatedWebhookEvent::KYBPayload::UpdateRequest::BeneficialOwnerIndividual::OrHash
@@ -244,8 +230,6 @@ module Lithic
             ).returns(T.attached_class)
           end
           def self.new(
-            # Deprecated.
-            beneficial_owner_entities: nil,
             # You must submit a list of all direct and indirect individuals with 25% or more
             # ownership in the company. A maximum of 4 beneficial owners can be submitted. If
             # no individual owns 25% of the company you do not need to send beneficial owner
@@ -271,7 +255,6 @@ module Lithic
           sig do
             override.returns(
               {
-                beneficial_owner_entities: T::Array[Lithic::KYBBusinessEntity],
                 beneficial_owner_individuals:
                   T::Array[
                     Lithic::AccountHolderUpdatedWebhookEvent::KYBPayload::UpdateRequest::BeneficialOwnerIndividual

data/rbi/lithic/models/account_holder_upload_document_params.rbi

@@ -14,6 +14,9 @@ module Lithic
           )
         end
 
+      sig { returns(String) }
+      attr_accessor :account_holder_token
+
       # The type of document to upload
       sig do
         returns(
@@ -28,6 +31,7 @@ module Lithic
 
       sig do
         params(
+          account_holder_token: String,
           document_type:
             Lithic::AccountHolderUploadDocumentParams::DocumentType::OrSymbol,
           entity_token: String,
@@ -35,6 +39,7 @@ module Lithic
         ).returns(T.attached_class)
       end
       def self.new(
+        account_holder_token:,
         # The type of document to upload
         document_type:,
         # Globally unique identifier for the entity.
@@ -46,6 +51,7 @@ module Lithic
       sig do
         override.returns(
           {
+            account_holder_token: String,
             document_type:
               Lithic::AccountHolderUploadDocumentParams::DocumentType::OrSymbol,
             entity_token: String,

data/rbi/lithic/models/account_holders/account_holder_entity.rbi

@@ -0,0 +1,296 @@
+# typed: strong
+
+module Lithic
+  module Models
+    AccountHolderEntity = AccountHolders::AccountHolderEntity
+
+    module AccountHolders
+      class AccountHolderEntity < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::AccountHolders::AccountHolderEntity,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Globally unique identifier for the entity
+        sig { returns(String) }
+        attr_accessor :token
+
+        # Globally unique identifier for the account holder
+        sig { returns(String) }
+        attr_accessor :account_holder_token
+
+        # Individual's current address
+        sig { returns(Lithic::AccountHolders::AccountHolderEntity::Address) }
+        attr_reader :address
+
+        sig do
+          params(
+            address:
+              Lithic::AccountHolders::AccountHolderEntity::Address::OrHash
+          ).void
+        end
+        attr_writer :address
+
+        # Individual's date of birth, as an RFC 3339 date
+        sig { returns(T.nilable(String)) }
+        attr_accessor :dob
+
+        # Individual's email address
+        sig { returns(T.nilable(String)) }
+        attr_accessor :email
+
+        # Individual's first name, as it appears on government-issued identity documents
+        sig { returns(T.nilable(String)) }
+        attr_accessor :first_name
+
+        # Individual's last name, as it appears on government-issued identity documents
+        sig { returns(T.nilable(String)) }
+        attr_accessor :last_name
+
+        # Individual's phone number, entered in E.164 format
+        sig { returns(T.nilable(String)) }
+        attr_accessor :phone_number
+
+        # The status of the entity
+        sig do
+          returns(
+            Lithic::AccountHolders::AccountHolderEntity::Status::TaggedSymbol
+          )
+        end
+        attr_accessor :status
+
+        # The type of entity
+        sig do
+          returns(
+            Lithic::AccountHolders::AccountHolderEntity::Type::TaggedSymbol
+          )
+        end
+        attr_accessor :type
+
+        # Information about an entity associated with an account holder
+        sig do
+          params(
+            token: String,
+            account_holder_token: String,
+            address:
+              Lithic::AccountHolders::AccountHolderEntity::Address::OrHash,
+            dob: T.nilable(String),
+            email: T.nilable(String),
+            first_name: T.nilable(String),
+            last_name: T.nilable(String),
+            phone_number: T.nilable(String),
+            status:
+              Lithic::AccountHolders::AccountHolderEntity::Status::OrSymbol,
+            type: Lithic::AccountHolders::AccountHolderEntity::Type::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Globally unique identifier for the entity
+          token:,
+          # Globally unique identifier for the account holder
+          account_holder_token:,
+          # Individual's current address
+          address:,
+          # Individual's date of birth, as an RFC 3339 date
+          dob:,
+          # Individual's email address
+          email:,
+          # Individual's first name, as it appears on government-issued identity documents
+          first_name:,
+          # Individual's last name, as it appears on government-issued identity documents
+          last_name:,
+          # Individual's phone number, entered in E.164 format
+          phone_number:,
+          # The status of the entity
+          status:,
+          # The type of entity
+          type:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              token: String,
+              account_holder_token: String,
+              address: Lithic::AccountHolders::AccountHolderEntity::Address,
+              dob: T.nilable(String),
+              email: T.nilable(String),
+              first_name: T.nilable(String),
+              last_name: T.nilable(String),
+              phone_number: T.nilable(String),
+              status:
+                Lithic::AccountHolders::AccountHolderEntity::Status::TaggedSymbol,
+              type:
+                Lithic::AccountHolders::AccountHolderEntity::Type::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Address < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::AccountHolders::AccountHolderEntity::Address,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # Valid deliverable address (no PO boxes).
+          sig { returns(String) }
+          attr_accessor :address1
+
+          # Name of city.
+          sig { returns(String) }
+          attr_accessor :city
+
+          # Valid country code. Only USA is currently supported, entered in uppercase ISO
+          # 3166-1 alpha-3 three-character format.
+          sig { returns(String) }
+          attr_accessor :country
+
+          # Valid postal code. Only USA ZIP codes are currently supported, entered as a
+          # five-digit ZIP or nine-digit ZIP+4.
+          sig { returns(String) }
+          attr_accessor :postal_code
+
+          # Valid state code. Only USA state codes are currently supported, entered in
+          # uppercase ISO 3166-2 two-character format.
+          sig { returns(String) }
+          attr_accessor :state
+
+          # Unit or apartment number (if applicable).
+          sig { returns(T.nilable(String)) }
+          attr_reader :address2
+
+          sig { params(address2: String).void }
+          attr_writer :address2
+
+          # Individual's current address
+          sig do
+            params(
+              address1: String,
+              city: String,
+              country: String,
+              postal_code: String,
+              state: String,
+              address2: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Valid deliverable address (no PO boxes).
+            address1:,
+            # Name of city.
+            city:,
+            # Valid country code. Only USA is currently supported, entered in uppercase ISO
+            # 3166-1 alpha-3 three-character format.
+            country:,
+            # Valid postal code. Only USA ZIP codes are currently supported, entered as a
+            # five-digit ZIP or nine-digit ZIP+4.
+            postal_code:,
+            # Valid state code. Only USA state codes are currently supported, entered in
+            # uppercase ISO 3166-2 two-character format.
+            state:,
+            # Unit or apartment number (if applicable).
+            address2: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                address1: String,
+                city: String,
+                country: String,
+                postal_code: String,
+                state: String,
+                address2: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        # The status of the entity
+        module Status
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Lithic::AccountHolders::AccountHolderEntity::Status)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ACCEPTED =
+            T.let(
+              :ACCEPTED,
+              Lithic::AccountHolders::AccountHolderEntity::Status::TaggedSymbol
+            )
+          INACTIVE =
+            T.let(
+              :INACTIVE,
+              Lithic::AccountHolders::AccountHolderEntity::Status::TaggedSymbol
+            )
+          PENDING_REVIEW =
+            T.let(
+              :PENDING_REVIEW,
+              Lithic::AccountHolders::AccountHolderEntity::Status::TaggedSymbol
+            )
+          REJECTED =
+            T.let(
+              :REJECTED,
+              Lithic::AccountHolders::AccountHolderEntity::Status::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::AccountHolders::AccountHolderEntity::Status::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        # The type of entity
+        module Type
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Lithic::AccountHolders::AccountHolderEntity::Type)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          BENEFICIAL_OWNER_INDIVIDUAL =
+            T.let(
+              :BENEFICIAL_OWNER_INDIVIDUAL,
+              Lithic::AccountHolders::AccountHolderEntity::Type::TaggedSymbol
+            )
+          CONTROL_PERSON =
+            T.let(
+              :CONTROL_PERSON,
+              Lithic::AccountHolders::AccountHolderEntity::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::AccountHolders::AccountHolderEntity::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/account_holders/entity_create_params.rbi

@@ -0,0 +1,248 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module AccountHolders
+      class EntityCreateParams < Lithic::Internal::Type::BaseModel
+        extend Lithic::Internal::Type::RequestParameters::Converter
+        include Lithic::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::AccountHolders::EntityCreateParams,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :account_holder_token
+
+        # Individual's current address - PO boxes, UPS drops, and FedEx drops are not
+        # acceptable; APO/FPO are acceptable. Only USA addresses are currently supported.
+        sig { returns(Lithic::AccountHolders::EntityCreateParams::Address) }
+        attr_reader :address
+
+        sig do
+          params(
+            address: Lithic::AccountHolders::EntityCreateParams::Address::OrHash
+          ).void
+        end
+        attr_writer :address
+
+        # Individual's date of birth, as an RFC 3339 date.
+        sig { returns(String) }
+        attr_accessor :dob
+
+        # Individual's email address. If utilizing Lithic for chargeback processing, this
+        # customer email address may be used to communicate dispute status and resolution.
+        sig { returns(String) }
+        attr_accessor :email
+
+        # Individual's first name, as it appears on government-issued identity documents.
+        sig { returns(String) }
+        attr_accessor :first_name
+
+        # Government-issued identification number (required for identity verification and
+        # compliance with banking regulations). Social Security Numbers (SSN) and
+        # Individual Taxpayer Identification Numbers (ITIN) are currently supported,
+        # entered as full nine-digits, with or without hyphens
+        sig { returns(String) }
+        attr_accessor :government_id
+
+        # Individual's last name, as it appears on government-issued identity documents.
+        sig { returns(String) }
+        attr_accessor :last_name
+
+        # Individual's phone number, entered in E.164 format.
+        sig { returns(String) }
+        attr_accessor :phone_number
+
+        # The type of entity to create on the account holder
+        sig do
+          returns(Lithic::AccountHolders::EntityCreateParams::Type::OrSymbol)
+        end
+        attr_accessor :type
+
+        sig do
+          params(
+            account_holder_token: String,
+            address:
+              Lithic::AccountHolders::EntityCreateParams::Address::OrHash,
+            dob: String,
+            email: String,
+            first_name: String,
+            government_id: String,
+            last_name: String,
+            phone_number: String,
+            type: Lithic::AccountHolders::EntityCreateParams::Type::OrSymbol,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          account_holder_token:,
+          # Individual's current address - PO boxes, UPS drops, and FedEx drops are not
+          # acceptable; APO/FPO are acceptable. Only USA addresses are currently supported.
+          address:,
+          # Individual's date of birth, as an RFC 3339 date.
+          dob:,
+          # Individual's email address. If utilizing Lithic for chargeback processing, this
+          # customer email address may be used to communicate dispute status and resolution.
+          email:,
+          # Individual's first name, as it appears on government-issued identity documents.
+          first_name:,
+          # Government-issued identification number (required for identity verification and
+          # compliance with banking regulations). Social Security Numbers (SSN) and
+          # Individual Taxpayer Identification Numbers (ITIN) are currently supported,
+          # entered as full nine-digits, with or without hyphens
+          government_id:,
+          # Individual's last name, as it appears on government-issued identity documents.
+          last_name:,
+          # Individual's phone number, entered in E.164 format.
+          phone_number:,
+          # The type of entity to create on the account holder
+          type:,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              account_holder_token: String,
+              address: Lithic::AccountHolders::EntityCreateParams::Address,
+              dob: String,
+              email: String,
+              first_name: String,
+              government_id: String,
+              last_name: String,
+              phone_number: String,
+              type: Lithic::AccountHolders::EntityCreateParams::Type::OrSymbol,
+              request_options: Lithic::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Address < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::AccountHolders::EntityCreateParams::Address,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # Valid deliverable address (no PO boxes).
+          sig { returns(String) }
+          attr_accessor :address1
+
+          # Name of city.
+          sig { returns(String) }
+          attr_accessor :city
+
+          # Valid country code. Only USA is currently supported, entered in uppercase ISO
+          # 3166-1 alpha-3 three-character format.
+          sig { returns(String) }
+          attr_accessor :country
+
+          # Valid postal code. Only USA ZIP codes are currently supported, entered as a
+          # five-digit ZIP or nine-digit ZIP+4.
+          sig { returns(String) }
+          attr_accessor :postal_code
+
+          # Valid state code. Only USA state codes are currently supported, entered in
+          # uppercase ISO 3166-2 two-character format.
+          sig { returns(String) }
+          attr_accessor :state
+
+          # Unit or apartment number (if applicable).
+          sig { returns(T.nilable(String)) }
+          attr_reader :address2
+
+          sig { params(address2: String).void }
+          attr_writer :address2
+
+          # Individual's current address - PO boxes, UPS drops, and FedEx drops are not
+          # acceptable; APO/FPO are acceptable. Only USA addresses are currently supported.
+          sig do
+            params(
+              address1: String,
+              city: String,
+              country: String,
+              postal_code: String,
+              state: String,
+              address2: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Valid deliverable address (no PO boxes).
+            address1:,
+            # Name of city.
+            city:,
+            # Valid country code. Only USA is currently supported, entered in uppercase ISO
+            # 3166-1 alpha-3 three-character format.
+            country:,
+            # Valid postal code. Only USA ZIP codes are currently supported, entered as a
+            # five-digit ZIP or nine-digit ZIP+4.
+            postal_code:,
+            # Valid state code. Only USA state codes are currently supported, entered in
+            # uppercase ISO 3166-2 two-character format.
+            state:,
+            # Unit or apartment number (if applicable).
+            address2: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                address1: String,
+                city: String,
+                country: String,
+                postal_code: String,
+                state: String,
+                address2: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        # The type of entity to create on the account holder
+        module Type
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Lithic::AccountHolders::EntityCreateParams::Type)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          BENEFICIAL_OWNER_INDIVIDUAL =
+            T.let(
+              :BENEFICIAL_OWNER_INDIVIDUAL,
+              Lithic::AccountHolders::EntityCreateParams::Type::TaggedSymbol
+            )
+          CONTROL_PERSON =
+            T.let(
+              :CONTROL_PERSON,
+              Lithic::AccountHolders::EntityCreateParams::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::AccountHolders::EntityCreateParams::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end