lithic 0.1.0.pre.alpha.1

data/rbi/lib/lithic/models/external_bank_account_list_params.rbi

@@ -0,0 +1,177 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class ExternalBankAccountListParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :account_token
+
+      sig { params(account_token: String).void }
+      attr_writer :account_token
+
+      sig { returns(T.nilable(T::Array[Lithic::Models::ExternalBankAccountListParams::AccountType::OrSymbol])) }
+      attr_reader :account_types
+
+      sig { params(account_types: T::Array[Lithic::Models::ExternalBankAccountListParams::AccountType::OrSymbol]).void }
+      attr_writer :account_types
+
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :countries
+
+      sig { params(countries: T::Array[String]).void }
+      attr_writer :countries
+
+      # A cursor representing an item's token before which a page of results should end.
+      #   Used to retrieve the previous page of results before this item.
+      sig { returns(T.nilable(String)) }
+      attr_reader :ending_before
+
+      sig { params(ending_before: String).void }
+      attr_writer :ending_before
+
+      sig { returns(T.nilable(T::Array[Lithic::Models::OwnerType::OrSymbol])) }
+      attr_reader :owner_types
+
+      sig { params(owner_types: T::Array[Lithic::Models::OwnerType::OrSymbol]).void }
+      attr_writer :owner_types
+
+      # Page size (for pagination).
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :page_size
+
+      sig { params(page_size: Integer).void }
+      attr_writer :page_size
+
+      # A cursor representing an item's token after which a page of results should
+      #   begin. Used to retrieve the next page of results after this item.
+      sig { returns(T.nilable(String)) }
+      attr_reader :starting_after
+
+      sig { params(starting_after: String).void }
+      attr_writer :starting_after
+
+      sig { returns(T.nilable(T::Array[Lithic::Models::ExternalBankAccountListParams::State::OrSymbol])) }
+      attr_reader :states
+
+      sig { params(states: T::Array[Lithic::Models::ExternalBankAccountListParams::State::OrSymbol]).void }
+      attr_writer :states
+
+      sig { returns(T.nilable(T::Array[Lithic::Models::ExternalBankAccountListParams::VerificationState::OrSymbol])) }
+      attr_reader :verification_states
+
+      sig do
+        params(
+          verification_states: T::Array[Lithic::Models::ExternalBankAccountListParams::VerificationState::OrSymbol]
+        )
+          .void
+      end
+      attr_writer :verification_states
+
+      sig do
+        params(
+          account_token: String,
+          account_types: T::Array[Lithic::Models::ExternalBankAccountListParams::AccountType::OrSymbol],
+          countries: T::Array[String],
+          ending_before: String,
+          owner_types: T::Array[Lithic::Models::OwnerType::OrSymbol],
+          page_size: Integer,
+          starting_after: String,
+          states: T::Array[Lithic::Models::ExternalBankAccountListParams::State::OrSymbol],
+          verification_states: T::Array[Lithic::Models::ExternalBankAccountListParams::VerificationState::OrSymbol],
+          request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        account_token: nil,
+        account_types: nil,
+        countries: nil,
+        ending_before: nil,
+        owner_types: nil,
+        page_size: nil,
+        starting_after: nil,
+        states: nil,
+        verification_states: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              account_token: String,
+              account_types: T::Array[Lithic::Models::ExternalBankAccountListParams::AccountType::OrSymbol],
+              countries: T::Array[String],
+              ending_before: String,
+              owner_types: T::Array[Lithic::Models::OwnerType::OrSymbol],
+              page_size: Integer,
+              starting_after: String,
+              states: T::Array[Lithic::Models::ExternalBankAccountListParams::State::OrSymbol],
+              verification_states: T::Array[Lithic::Models::ExternalBankAccountListParams::VerificationState::OrSymbol],
+              request_options: Lithic::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+
+      module AccountType
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ExternalBankAccountListParams::AccountType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ExternalBankAccountListParams::AccountType::TaggedSymbol) }
+
+        CHECKING = T.let(:CHECKING, Lithic::Models::ExternalBankAccountListParams::AccountType::TaggedSymbol)
+        SAVINGS = T.let(:SAVINGS, Lithic::Models::ExternalBankAccountListParams::AccountType::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::ExternalBankAccountListParams::AccountType::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      module State
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ExternalBankAccountListParams::State) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ExternalBankAccountListParams::State::TaggedSymbol) }
+
+        ENABLED = T.let(:ENABLED, Lithic::Models::ExternalBankAccountListParams::State::TaggedSymbol)
+        CLOSED = T.let(:CLOSED, Lithic::Models::ExternalBankAccountListParams::State::TaggedSymbol)
+        PAUSED = T.let(:PAUSED, Lithic::Models::ExternalBankAccountListParams::State::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::ExternalBankAccountListParams::State::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      module VerificationState
+        extend Lithic::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::Models::ExternalBankAccountListParams::VerificationState) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ExternalBankAccountListParams::VerificationState::TaggedSymbol) }
+
+        PENDING = T.let(:PENDING, Lithic::Models::ExternalBankAccountListParams::VerificationState::TaggedSymbol)
+        ENABLED = T.let(:ENABLED, Lithic::Models::ExternalBankAccountListParams::VerificationState::TaggedSymbol)
+        FAILED_VERIFICATION =
+          T.let(
+            :FAILED_VERIFICATION,
+            Lithic::Models::ExternalBankAccountListParams::VerificationState::TaggedSymbol
+          )
+        INSUFFICIENT_FUNDS =
+          T.let(:INSUFFICIENT_FUNDS, Lithic::Models::ExternalBankAccountListParams::VerificationState::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::ExternalBankAccountListParams::VerificationState::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/external_bank_account_list_response.rbi

@@ -0,0 +1,324 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class ExternalBankAccountListResponse < Lithic::BaseModel
+      # A globally unique identifier for this record of an external bank account
+      #   association. If a program links an external bank account to more than one
+      #   end-user or to both the program and the end-user, then Lithic will return each
+      #   record of the association
+      sig { returns(String) }
+      attr_accessor :token
+
+      # The country that the bank account is located in using ISO 3166-1. We will only
+      #   accept USA bank accounts e.g., USA
+      sig { returns(String) }
+      attr_accessor :country
+
+      # An ISO 8601 string representing when this funding source was added to the Lithic
+      #   account.
+      sig { returns(Time) }
+      attr_accessor :created
+
+      # currency of the external account 3-character alphabetic ISO 4217 code
+      sig { returns(String) }
+      attr_accessor :currency
+
+      # The last 4 digits of the bank account. Derived by Lithic from the account number
+      #   passed
+      sig { returns(String) }
+      attr_accessor :last_four
+
+      # Legal Name of the business or individual who owns the external account. This
+      #   will appear in statements
+      sig { returns(String) }
+      attr_accessor :owner
+
+      # Owner Type
+      sig { returns(Lithic::Models::ExternalBankAccountListResponse::OwnerType::TaggedSymbol) }
+      attr_accessor :owner_type
+
+      # Routing Number
+      sig { returns(String) }
+      attr_accessor :routing_number
+
+      # Account State
+      sig { returns(Lithic::Models::ExternalBankAccountListResponse::State::TaggedSymbol) }
+      attr_accessor :state
+
+      # Account Type
+      sig { returns(Lithic::Models::ExternalBankAccountListResponse::Type::TaggedSymbol) }
+      attr_accessor :type
+
+      # The number of attempts at verification
+      sig { returns(Integer) }
+      attr_accessor :verification_attempts
+
+      # Verification Method
+      sig { returns(Lithic::Models::ExternalBankAccountListResponse::VerificationMethod::TaggedSymbol) }
+      attr_accessor :verification_method
+
+      # Verification State
+      sig { returns(Lithic::Models::ExternalBankAccountListResponse::VerificationState::TaggedSymbol) }
+      attr_accessor :verification_state
+
+      # Indicates which Lithic account the external account is associated with. For
+      #   external accounts that are associated with the program, account_token field
+      #   returned will be null
+      sig { returns(T.nilable(String)) }
+      attr_reader :account_token
+
+      sig { params(account_token: String).void }
+      attr_writer :account_token
+
+      # Address
+      sig { returns(T.nilable(Lithic::Models::ExternalBankAccountAddress)) }
+      attr_reader :address
+
+      sig { params(address: T.any(Lithic::Models::ExternalBankAccountAddress, Lithic::Util::AnyHash)).void }
+      attr_writer :address
+
+      # Optional field that helps identify bank accounts in receipts
+      sig { returns(T.nilable(String)) }
+      attr_reader :company_id
+
+      sig { params(company_id: String).void }
+      attr_writer :company_id
+
+      # Date of Birth of the Individual that owns the external bank account
+      sig { returns(T.nilable(Date)) }
+      attr_reader :dob
+
+      sig { params(dob: Date).void }
+      attr_writer :dob
+
+      # Doing Business As
+      sig { returns(T.nilable(String)) }
+      attr_reader :doing_business_as
+
+      sig { params(doing_business_as: String).void }
+      attr_writer :doing_business_as
+
+      # The financial account token of the operating account to fund the micro deposits
+      sig { returns(T.nilable(String)) }
+      attr_reader :financial_account_token
+
+      sig { params(financial_account_token: String).void }
+      attr_writer :financial_account_token
+
+      # The nickname for this External Bank Account
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      # User Defined ID
+      sig { returns(T.nilable(String)) }
+      attr_reader :user_defined_id
+
+      sig { params(user_defined_id: String).void }
+      attr_writer :user_defined_id
+
+      # Optional free text description of the reason for the failed verification. For
+      #   ACH micro-deposits returned, this field will display the reason return code sent
+      #   by the ACH network
+      sig { returns(T.nilable(String)) }
+      attr_reader :verification_failed_reason
+
+      sig { params(verification_failed_reason: String).void }
+      attr_writer :verification_failed_reason
+
+      sig do
+        params(
+          token: String,
+          country: String,
+          created: Time,
+          currency: String,
+          last_four: String,
+          owner: String,
+          owner_type: Lithic::Models::ExternalBankAccountListResponse::OwnerType::OrSymbol,
+          routing_number: String,
+          state: Lithic::Models::ExternalBankAccountListResponse::State::OrSymbol,
+          type: Lithic::Models::ExternalBankAccountListResponse::Type::OrSymbol,
+          verification_attempts: Integer,
+          verification_method: Lithic::Models::ExternalBankAccountListResponse::VerificationMethod::OrSymbol,
+          verification_state: Lithic::Models::ExternalBankAccountListResponse::VerificationState::OrSymbol,
+          account_token: String,
+          address: T.any(Lithic::Models::ExternalBankAccountAddress, Lithic::Util::AnyHash),
+          company_id: String,
+          dob: Date,
+          doing_business_as: String,
+          financial_account_token: String,
+          name: String,
+          user_defined_id: String,
+          verification_failed_reason: String
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        token:,
+        country:,
+        created:,
+        currency:,
+        last_four:,
+        owner:,
+        owner_type:,
+        routing_number:,
+        state:,
+        type:,
+        verification_attempts:,
+        verification_method:,
+        verification_state:,
+        account_token: nil,
+        address: nil,
+        company_id: nil,
+        dob: nil,
+        doing_business_as: nil,
+        financial_account_token: nil,
+        name: nil,
+        user_defined_id: nil,
+        verification_failed_reason: nil
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              token: String,
+              country: String,
+              created: Time,
+              currency: String,
+              last_four: String,
+              owner: String,
+              owner_type: Lithic::Models::ExternalBankAccountListResponse::OwnerType::TaggedSymbol,
+              routing_number: String,
+              state: Lithic::Models::ExternalBankAccountListResponse::State::TaggedSymbol,
+              type: Lithic::Models::ExternalBankAccountListResponse::Type::TaggedSymbol,
+              verification_attempts: Integer,
+              verification_method: Lithic::Models::ExternalBankAccountListResponse::VerificationMethod::TaggedSymbol,
+              verification_state: Lithic::Models::ExternalBankAccountListResponse::VerificationState::TaggedSymbol,
+              account_token: String,
+              address: Lithic::Models::ExternalBankAccountAddress,
+              company_id: String,
+              dob: Date,
+              doing_business_as: String,
+              financial_account_token: String,
+              name: String,
+              user_defined_id: String,
+              verification_failed_reason: String
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # Owner Type
+      module OwnerType
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ExternalBankAccountListResponse::OwnerType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ExternalBankAccountListResponse::OwnerType::TaggedSymbol) }
+
+        BUSINESS = T.let(:BUSINESS, Lithic::Models::ExternalBankAccountListResponse::OwnerType::TaggedSymbol)
+        INDIVIDUAL = T.let(:INDIVIDUAL, Lithic::Models::ExternalBankAccountListResponse::OwnerType::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::ExternalBankAccountListResponse::OwnerType::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      # Account State
+      module State
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ExternalBankAccountListResponse::State) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ExternalBankAccountListResponse::State::TaggedSymbol) }
+
+        ENABLED = T.let(:ENABLED, Lithic::Models::ExternalBankAccountListResponse::State::TaggedSymbol)
+        CLOSED = T.let(:CLOSED, Lithic::Models::ExternalBankAccountListResponse::State::TaggedSymbol)
+        PAUSED = T.let(:PAUSED, Lithic::Models::ExternalBankAccountListResponse::State::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::ExternalBankAccountListResponse::State::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      # Account Type
+      module Type
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ExternalBankAccountListResponse::Type) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ExternalBankAccountListResponse::Type::TaggedSymbol) }
+
+        CHECKING = T.let(:CHECKING, Lithic::Models::ExternalBankAccountListResponse::Type::TaggedSymbol)
+        SAVINGS = T.let(:SAVINGS, Lithic::Models::ExternalBankAccountListResponse::Type::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::ExternalBankAccountListResponse::Type::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      # Verification Method
+      module VerificationMethod
+        extend Lithic::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::Models::ExternalBankAccountListResponse::VerificationMethod) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ExternalBankAccountListResponse::VerificationMethod::TaggedSymbol) }
+
+        MANUAL =
+          T.let(:MANUAL, Lithic::Models::ExternalBankAccountListResponse::VerificationMethod::TaggedSymbol)
+        MICRO_DEPOSIT =
+          T.let(:MICRO_DEPOSIT, Lithic::Models::ExternalBankAccountListResponse::VerificationMethod::TaggedSymbol)
+        PLAID = T.let(:PLAID, Lithic::Models::ExternalBankAccountListResponse::VerificationMethod::TaggedSymbol)
+        PRENOTE =
+          T.let(:PRENOTE, Lithic::Models::ExternalBankAccountListResponse::VerificationMethod::TaggedSymbol)
+
+        sig do
+          override
+            .returns(T::Array[Lithic::Models::ExternalBankAccountListResponse::VerificationMethod::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+
+      # Verification State
+      module VerificationState
+        extend Lithic::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::Models::ExternalBankAccountListResponse::VerificationState) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ExternalBankAccountListResponse::VerificationState::TaggedSymbol) }
+
+        PENDING =
+          T.let(:PENDING, Lithic::Models::ExternalBankAccountListResponse::VerificationState::TaggedSymbol)
+        ENABLED =
+          T.let(:ENABLED, Lithic::Models::ExternalBankAccountListResponse::VerificationState::TaggedSymbol)
+        FAILED_VERIFICATION =
+          T.let(
+            :FAILED_VERIFICATION,
+            Lithic::Models::ExternalBankAccountListResponse::VerificationState::TaggedSymbol
+          )
+        INSUFFICIENT_FUNDS =
+          T.let(
+            :INSUFFICIENT_FUNDS,
+            Lithic::Models::ExternalBankAccountListResponse::VerificationState::TaggedSymbol
+          )
+
+        sig do
+          override
+            .returns(T::Array[Lithic::Models::ExternalBankAccountListResponse::VerificationState::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/external_bank_account_retrieve_params.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class ExternalBankAccountRetrieveParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      sig do
+        params(
+          request_options: T.any(
+            Lithic::RequestOptions,
+            Lithic::Util::AnyHash
+          )
+        ).returns(T.attached_class)
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({request_options: Lithic::RequestOptions}) }
+      def to_hash
+      end
+    end
+  end
+end