lithic 0.1.0.pre.alpha.21 → 0.1.0.pre.alpha.23

data/rbi/lithic/models/instance_financial_account_type.rbi

@@ -6,23 +6,46 @@ module Lithic
     module InstanceFinancialAccountType
       extend Lithic::Internal::Type::Enum
 
-      TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::InstanceFinancialAccountType) }
+      TaggedSymbol =
+        T.type_alias { T.all(Symbol, Lithic::InstanceFinancialAccountType) }
       OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-      ISSUING = T.let(:ISSUING, Lithic::Models::InstanceFinancialAccountType::TaggedSymbol)
-      RESERVE = T.let(:RESERVE, Lithic::Models::InstanceFinancialAccountType::TaggedSymbol)
-      OPERATING = T.let(:OPERATING, Lithic::Models::InstanceFinancialAccountType::TaggedSymbol)
-      CHARGED_OFF_FEES = T.let(:CHARGED_OFF_FEES, Lithic::Models::InstanceFinancialAccountType::TaggedSymbol)
+      ISSUING =
+        T.let(:ISSUING, Lithic::InstanceFinancialAccountType::TaggedSymbol)
+      RESERVE =
+        T.let(:RESERVE, Lithic::InstanceFinancialAccountType::TaggedSymbol)
+      OPERATING =
+        T.let(:OPERATING, Lithic::InstanceFinancialAccountType::TaggedSymbol)
+      CHARGED_OFF_FEES =
+        T.let(
+          :CHARGED_OFF_FEES,
+          Lithic::InstanceFinancialAccountType::TaggedSymbol
+        )
       CHARGED_OFF_INTEREST =
-        T.let(:CHARGED_OFF_INTEREST, Lithic::Models::InstanceFinancialAccountType::TaggedSymbol)
+        T.let(
+          :CHARGED_OFF_INTEREST,
+          Lithic::InstanceFinancialAccountType::TaggedSymbol
+        )
       CHARGED_OFF_PRINCIPAL =
-        T.let(:CHARGED_OFF_PRINCIPAL, Lithic::Models::InstanceFinancialAccountType::TaggedSymbol)
-      SECURITY = T.let(:SECURITY, Lithic::Models::InstanceFinancialAccountType::TaggedSymbol)
+        T.let(
+          :CHARGED_OFF_PRINCIPAL,
+          Lithic::InstanceFinancialAccountType::TaggedSymbol
+        )
+      SECURITY =
+        T.let(:SECURITY, Lithic::InstanceFinancialAccountType::TaggedSymbol)
       PROGRAM_RECEIVABLES =
-        T.let(:PROGRAM_RECEIVABLES, Lithic::Models::InstanceFinancialAccountType::TaggedSymbol)
+        T.let(
+          :PROGRAM_RECEIVABLES,
+          Lithic::InstanceFinancialAccountType::TaggedSymbol
+        )
 
-      sig { override.returns(T::Array[Lithic::Models::InstanceFinancialAccountType::TaggedSymbol]) }
-      def self.values; end
+      sig do
+        override.returns(
+          T::Array[Lithic::InstanceFinancialAccountType::TaggedSymbol]
+        )
+      end
+      def self.values
+      end
     end
   end
 end

data/rbi/lithic/models/kyb.rbi

@@ -3,21 +3,23 @@
 module Lithic
   module Models
     class KYB < Lithic::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
       # 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
       # information. See
       # [FinCEN requirements](https://www.fincen.gov/sites/default/files/shared/CDD_Rev6.7_Sept_2017_Certificate.pdf)
       # (Section I) for more background on individuals that should be included.
-      sig { returns(T::Array[Lithic::Models::KYB::BeneficialOwnerIndividual]) }
+      sig { returns(T::Array[Lithic::KYB::BeneficialOwnerIndividual]) }
       attr_accessor :beneficial_owner_individuals
 
       # Information for business for which the account is being opened and KYB is being
       # run.
-      sig { returns(Lithic::Models::KYB::BusinessEntity) }
+      sig { returns(Lithic::KYB::BusinessEntity) }
       attr_reader :business_entity
 
-      sig { params(business_entity: T.any(Lithic::Models::KYB::BusinessEntity, Lithic::Internal::AnyHash)).void }
+      sig { params(business_entity: Lithic::KYB::BusinessEntity::OrHash).void }
       attr_writer :business_entity
 
       # An individual with significant responsibility for managing the legal entity
@@ -28,10 +30,10 @@ module Lithic
       # could also be a beneficial owner listed above. See
       # [FinCEN requirements](https://www.fincen.gov/sites/default/files/shared/CDD_Rev6.7_Sept_2017_Certificate.pdf)
       # (Section II) for more background.
-      sig { returns(Lithic::Models::KYB::ControlPerson) }
+      sig { returns(Lithic::KYB::ControlPerson) }
       attr_reader :control_person
 
-      sig { params(control_person: T.any(Lithic::Models::KYB::ControlPerson, Lithic::Internal::AnyHash)).void }
+      sig { params(control_person: Lithic::KYB::ControlPerson::OrHash).void }
       attr_writer :control_person
 
       # Short description of the company's line of business (i.e., what does the company
@@ -46,18 +48,18 @@ module Lithic
       attr_accessor :tos_timestamp
 
       # Specifies the type of KYB workflow to run.
-      sig { returns(Lithic::Models::KYB::Workflow::OrSymbol) }
+      sig { returns(Lithic::KYB::Workflow::OrSymbol) }
       attr_accessor :workflow
 
       # Deprecated.
-      sig { returns(T.nilable(T::Array[Lithic::Models::KYB::BeneficialOwnerEntity])) }
+      sig { returns(T.nilable(T::Array[Lithic::KYB::BeneficialOwnerEntity])) }
       attr_reader :beneficial_owner_entities
 
       sig do
         params(
-          beneficial_owner_entities: T::Array[T.any(Lithic::Models::KYB::BeneficialOwnerEntity, Lithic::Internal::AnyHash)]
-        )
-          .void
+          beneficial_owner_entities:
+            T::Array[Lithic::KYB::BeneficialOwnerEntity::OrHash]
+        ).void
       end
       attr_writer :beneficial_owner_entities
 
@@ -88,18 +90,19 @@ module Lithic
 
       sig do
         params(
-          beneficial_owner_individuals: T::Array[T.any(Lithic::Models::KYB::BeneficialOwnerIndividual, Lithic::Internal::AnyHash)],
-          business_entity: T.any(Lithic::Models::KYB::BusinessEntity, Lithic::Internal::AnyHash),
-          control_person: T.any(Lithic::Models::KYB::ControlPerson, Lithic::Internal::AnyHash),
+          beneficial_owner_individuals:
+            T::Array[Lithic::KYB::BeneficialOwnerIndividual::OrHash],
+          business_entity: Lithic::KYB::BusinessEntity::OrHash,
+          control_person: Lithic::KYB::ControlPerson::OrHash,
           nature_of_business: String,
           tos_timestamp: String,
-          workflow: Lithic::Models::KYB::Workflow::OrSymbol,
-          beneficial_owner_entities: T::Array[T.any(Lithic::Models::KYB::BeneficialOwnerEntity, Lithic::Internal::AnyHash)],
+          workflow: Lithic::KYB::Workflow::OrSymbol,
+          beneficial_owner_entities:
+            T::Array[Lithic::KYB::BeneficialOwnerEntity::OrHash],
           external_id: String,
           kyb_passed_timestamp: String,
           website_url: String
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         # You must submit a list of all direct and indirect individuals with 25% or more
@@ -142,33 +145,39 @@ module Lithic
         kyb_passed_timestamp: nil,
         # Company website URL.
         website_url: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              beneficial_owner_individuals: T::Array[Lithic::Models::KYB::BeneficialOwnerIndividual],
-              business_entity: Lithic::Models::KYB::BusinessEntity,
-              control_person: Lithic::Models::KYB::ControlPerson,
-              nature_of_business: String,
-              tos_timestamp: String,
-              workflow: Lithic::Models::KYB::Workflow::OrSymbol,
-              beneficial_owner_entities: T::Array[Lithic::Models::KYB::BeneficialOwnerEntity],
-              external_id: String,
-              kyb_passed_timestamp: String,
-              website_url: String
-            }
-          )
+        override.returns(
+          {
+            beneficial_owner_individuals:
+              T::Array[Lithic::KYB::BeneficialOwnerIndividual],
+            business_entity: Lithic::KYB::BusinessEntity,
+            control_person: Lithic::KYB::ControlPerson,
+            nature_of_business: String,
+            tos_timestamp: String,
+            workflow: Lithic::KYB::Workflow::OrSymbol,
+            beneficial_owner_entities:
+              T::Array[Lithic::KYB::BeneficialOwnerEntity],
+            external_id: String,
+            kyb_passed_timestamp: String,
+            website_url: String
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       class BeneficialOwnerIndividual < Lithic::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         # 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::Models::Address) }
+        sig { returns(Lithic::Address) }
         attr_reader :address
 
-        sig { params(address: T.any(Lithic::Models::Address, Lithic::Internal::AnyHash)).void }
+        sig { params(address: Lithic::Address::OrHash).void }
         attr_writer :address
 
         # Individual's date of birth, as an RFC 3339 date.
@@ -205,15 +214,14 @@ module Lithic
         # Individuals associated with a KYB application. Phone number is optional.
         sig do
           params(
-            address: T.any(Lithic::Models::Address, Lithic::Internal::AnyHash),
+            address: Lithic::Address::OrHash,
             dob: String,
             email: String,
             first_name: String,
             government_id: String,
             last_name: String,
             phone_number: String
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # Individual's current address - PO boxes, UPS drops, and FedEx drops are not
@@ -235,31 +243,35 @@ module Lithic
           last_name:,
           # Individual's phone number, entered in E.164 format.
           phone_number: nil
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                address: Lithic::Models::Address,
-                dob: String,
-                email: String,
-                first_name: String,
-                government_id: String,
-                last_name: String,
-                phone_number: String
-              }
-            )
+          override.returns(
+            {
+              address: Lithic::Address,
+              dob: String,
+              email: String,
+              first_name: String,
+              government_id: String,
+              last_name: String,
+              phone_number: String
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
 
       class BusinessEntity < Lithic::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         # Business's physical address - PO boxes, UPS drops, and FedEx drops are not
         # acceptable; APO/FPO are acceptable.
-        sig { returns(Lithic::Models::Address) }
+        sig { returns(Lithic::Address) }
         attr_reader :address
 
-        sig { params(address: T.any(Lithic::Models::Address, Lithic::Internal::AnyHash)).void }
+        sig { params(address: Lithic::Address::OrHash).void }
         attr_writer :address
 
         # Government-issued identification number. US Federal Employer Identification
@@ -296,14 +308,13 @@ module Lithic
         # run.
         sig do
           params(
-            address: T.any(Lithic::Models::Address, Lithic::Internal::AnyHash),
+            address: Lithic::Address::OrHash,
             government_id: String,
             legal_business_name: String,
             phone_numbers: T::Array[String],
             dba_business_name: String,
             parent_company: String
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # Business's physical address - PO boxes, UPS drops, and FedEx drops are not
@@ -323,30 +334,34 @@ module Lithic
           dba_business_name: nil,
           # Parent company name (if applicable).
           parent_company: nil
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                address: Lithic::Models::Address,
-                government_id: String,
-                legal_business_name: String,
-                phone_numbers: T::Array[String],
-                dba_business_name: String,
-                parent_company: String
-              }
-            )
+          override.returns(
+            {
+              address: Lithic::Address,
+              government_id: String,
+              legal_business_name: String,
+              phone_numbers: T::Array[String],
+              dba_business_name: String,
+              parent_company: String
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
 
       class ControlPerson < Lithic::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         # 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::Models::Address) }
+        sig { returns(Lithic::Address) }
         attr_reader :address
 
-        sig { params(address: T.any(Lithic::Models::Address, Lithic::Internal::AnyHash)).void }
+        sig { params(address: Lithic::Address::OrHash).void }
         attr_writer :address
 
         # Individual's date of birth, as an RFC 3339 date.
@@ -390,15 +405,14 @@ module Lithic
         # (Section II) for more background.
         sig do
           params(
-            address: T.any(Lithic::Models::Address, Lithic::Internal::AnyHash),
+            address: Lithic::Address::OrHash,
             dob: String,
             email: String,
             first_name: String,
             government_id: String,
             last_name: String,
             phone_number: String
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # Individual's current address - PO boxes, UPS drops, and FedEx drops are not
@@ -420,45 +434,50 @@ module Lithic
           last_name:,
           # Individual's phone number, entered in E.164 format.
           phone_number: nil
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                address: Lithic::Models::Address,
-                dob: String,
-                email: String,
-                first_name: String,
-                government_id: String,
-                last_name: String,
-                phone_number: String
-              }
-            )
+          override.returns(
+            {
+              address: Lithic::Address,
+              dob: String,
+              email: String,
+              first_name: String,
+              government_id: String,
+              last_name: String,
+              phone_number: String
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
 
       # Specifies the type of KYB workflow to run.
       module Workflow
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::KYB::Workflow) }
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::KYB::Workflow) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        KYB_BASIC = T.let(:KYB_BASIC, Lithic::Models::KYB::Workflow::TaggedSymbol)
-        KYB_BYO = T.let(:KYB_BYO, Lithic::Models::KYB::Workflow::TaggedSymbol)
+        KYB_BASIC = T.let(:KYB_BASIC, Lithic::KYB::Workflow::TaggedSymbol)
+        KYB_BYO = T.let(:KYB_BYO, Lithic::KYB::Workflow::TaggedSymbol)
 
-        sig { override.returns(T::Array[Lithic::Models::KYB::Workflow::TaggedSymbol]) }
-        def self.values; end
+        sig { override.returns(T::Array[Lithic::KYB::Workflow::TaggedSymbol]) }
+        def self.values
+        end
       end
 
       class BeneficialOwnerEntity < Lithic::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         # Business's physical address - PO boxes, UPS drops, and FedEx drops are not
         # acceptable; APO/FPO are acceptable.
-        sig { returns(Lithic::Models::Address) }
+        sig { returns(Lithic::Address) }
         attr_reader :address
 
-        sig { params(address: T.any(Lithic::Models::Address, Lithic::Internal::AnyHash)).void }
+        sig { params(address: Lithic::Address::OrHash).void }
         attr_writer :address
 
         # Government-issued identification number. US Federal Employer Identification
@@ -493,14 +512,13 @@ module Lithic
 
         sig do
           params(
-            address: T.any(Lithic::Models::Address, Lithic::Internal::AnyHash),
+            address: Lithic::Address::OrHash,
             government_id: String,
             legal_business_name: String,
             phone_numbers: T::Array[String],
             dba_business_name: String,
             parent_company: String
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # Business's physical address - PO boxes, UPS drops, and FedEx drops are not
@@ -520,21 +538,23 @@ module Lithic
           dba_business_name: nil,
           # Parent company name (if applicable).
           parent_company: nil
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                address: Lithic::Models::Address,
-                government_id: String,
-                legal_business_name: String,
-                phone_numbers: T::Array[String],
-                dba_business_name: String,
-                parent_company: String
-              }
-            )
+          override.returns(
+            {
+              address: Lithic::Address,
+              government_id: String,
+              legal_business_name: String,
+              phone_numbers: T::Array[String],
+              dba_business_name: String,
+              parent_company: String
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
     end
   end

data/rbi/lithic/models/kyb_business_entity.rbi

@@ -3,12 +3,14 @@
 module Lithic
   module Models
     class KYBBusinessEntity < Lithic::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
       # Business''s physical address - PO boxes, UPS drops, and FedEx drops are not
       # acceptable; APO/FPO are acceptable.
-      sig { returns(Lithic::Models::KYBBusinessEntity::Address) }
+      sig { returns(Lithic::KYBBusinessEntity::Address) }
       attr_reader :address
 
-      sig { params(address: T.any(Lithic::Models::KYBBusinessEntity::Address, Lithic::Internal::AnyHash)).void }
+      sig { params(address: Lithic::KYBBusinessEntity::Address::OrHash).void }
       attr_writer :address
 
       # Government-issued identification number. US Federal Employer Identification
@@ -43,14 +45,13 @@ module Lithic
 
       sig do
         params(
-          address: T.any(Lithic::Models::KYBBusinessEntity::Address, Lithic::Internal::AnyHash),
+          address: Lithic::KYBBusinessEntity::Address::OrHash,
           government_id: String,
           legal_business_name: String,
           phone_numbers: T::Array[String],
           dba_business_name: String,
           parent_company: String
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         # Business''s physical address - PO boxes, UPS drops, and FedEx drops are not
@@ -70,23 +71,27 @@ module Lithic
         dba_business_name: nil,
         # Parent company name (if applicable).
         parent_company: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              address: Lithic::Models::KYBBusinessEntity::Address,
-              government_id: String,
-              legal_business_name: String,
-              phone_numbers: T::Array[String],
-              dba_business_name: String,
-              parent_company: String
-            }
-          )
+        override.returns(
+          {
+            address: Lithic::KYBBusinessEntity::Address,
+            government_id: String,
+            legal_business_name: String,
+            phone_numbers: T::Array[String],
+            dba_business_name: String,
+            parent_company: String
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       class Address < Lithic::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         # Valid deliverable address (no PO boxes).
         sig { returns(String) }
         attr_accessor :address1
@@ -127,8 +132,7 @@ module Lithic
             postal_code: String,
             state: String,
             address2: String
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # Valid deliverable address (no PO boxes).
@@ -146,21 +150,23 @@ module Lithic
           state:,
           # Unit or apartment number (if applicable).
           address2: nil
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                address1: String,
-                city: String,
-                country: String,
-                postal_code: String,
-                state: String,
-                address2: String
-              }
-            )
+          override.returns(
+            {
+              address1: String,
+              city: String,
+              country: String,
+              postal_code: String,
+              state: String,
+              address2: String
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
     end
   end