lithic 0.4.0 → 0.6.0

data/rbi/lithic/models/account_holder_update_response.rbi

@@ -179,6 +179,14 @@ module Lithic
         end
         attr_writer :individual
 
+        # Only present when user_type == "BUSINESS". 6-digit North American Industry
+        # Classification System (NAICS) code for the business.
+        sig { returns(T.nilable(String)) }
+        attr_reader :naics_code
+
+        sig { params(naics_code: String).void }
+        attr_writer :naics_code
+
         # Only present when user_type == "BUSINESS". User-submitted description of the
         # business.
         sig { returns(T.nilable(String)) }
@@ -257,8 +265,8 @@ module Lithic
         # attribute will be present.
         #
         # If the type is "BUSINESS" then the "business_entity", "control_person",
-        # "beneficial_owner_individuals", "nature_of_business", and "website_url"
-        # attributes will be present.
+        # "beneficial_owner_individuals", "naics_code", "nature_of_business", and
+        # "website_url" attributes will be present.
         sig do
           returns(
             T.nilable(
@@ -322,6 +330,7 @@ module Lithic
             external_id: String,
             individual:
               Lithic::Models::AccountHolderUpdateResponse::KYBKYCPatchResponse::Individual::OrHash,
+            naics_code: String,
             nature_of_business: String,
             phone_number: String,
             required_documents: T::Array[Lithic::RequiredDocument::OrHash],
@@ -386,6 +395,9 @@ module Lithic
           # Only present when user_type == "INDIVIDUAL". Information about the individual
           # for which the account is being opened and KYC is being run.
           individual: nil,
+          # Only present when user_type == "BUSINESS". 6-digit North American Industry
+          # Classification System (NAICS) code for the business.
+          naics_code: nil,
           # Only present when user_type == "BUSINESS". User-submitted description of the
           # business.
           nature_of_business: nil,
@@ -409,8 +421,8 @@ module Lithic
           # attribute will be present.
           #
           # If the type is "BUSINESS" then the "business_entity", "control_person",
-          # "beneficial_owner_individuals", "nature_of_business", and "website_url"
-          # attributes will be present.
+          # "beneficial_owner_individuals", "naics_code", "nature_of_business", and
+          # "website_url" attributes will be present.
           user_type: nil,
           # Information about the most recent identity verification attempt
           verification_application: nil,
@@ -440,6 +452,7 @@ module Lithic
               external_id: String,
               individual:
                 Lithic::Models::AccountHolderUpdateResponse::KYBKYCPatchResponse::Individual,
+              naics_code: String,
               nature_of_business: String,
               phone_number: String,
               required_documents: T::Array[Lithic::RequiredDocument],
@@ -1298,8 +1311,8 @@ module Lithic
         # attribute will be present.
         #
         # If the type is "BUSINESS" then the "business_entity", "control_person",
-        # "beneficial_owner_individuals", "nature_of_business", and "website_url"
-        # attributes will be present.
+        # "beneficial_owner_individuals", "naics_code", "nature_of_business", and
+        # "website_url" attributes will be present.
         module UserType
           extend Lithic::Internal::Type::Enum
 

data/rbi/lithic/models/account_holder_updated_webhook_event.rbi

@@ -70,6 +70,14 @@ module Lithic
         sig { params(external_id: String).void }
         attr_writer :external_id
 
+        # 6-digit North American Industry Classification System (NAICS) code for the
+        # business. Only present if naics_code was included in the update request.
+        sig { returns(T.nilable(String)) }
+        attr_reader :naics_code
+
+        sig { params(naics_code: String).void }
+        attr_writer :naics_code
+
         # Short description of the company's line of business (i.e., what does the company
         # do?).
         sig { returns(T.nilable(String)) }
@@ -94,6 +102,7 @@ module Lithic
             event_type:
               Lithic::AccountHolderUpdatedWebhookEvent::KYBPayload::EventType::OrSymbol,
             external_id: String,
+            naics_code: String,
             nature_of_business: String,
             website_url: String
           ).returns(T.attached_class)
@@ -108,6 +117,9 @@ module Lithic
           # A user provided id that can be used to link an account holder with an external
           # system
           external_id: nil,
+          # 6-digit North American Industry Classification System (NAICS) code for the
+          # business. Only present if naics_code was included in the update request.
+          naics_code: nil,
           # Short description of the company's line of business (i.e., what does the company
           # do?).
           nature_of_business: nil,
@@ -125,6 +137,7 @@ module Lithic
               event_type:
                 Lithic::AccountHolderUpdatedWebhookEvent::KYBPayload::EventType::TaggedSymbol,
               external_id: String,
+              naics_code: String,
               nature_of_business: String,
               website_url: 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,242 @@
+# 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
+
+        # 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(
+            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(
+          # 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(
+            {
+              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