lithic 0.1.0.pre.alpha.1

data/rbi/lib/lithic/resources/external_bank_accounts.rbi

@@ -0,0 +1,193 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class ExternalBankAccounts
+      sig { returns(Lithic::Resources::ExternalBankAccounts::MicroDeposits) }
+      attr_reader :micro_deposits
+
+      # Creates an external bank account within a program or Lithic account.
+      sig do
+        params(
+          account_number: String,
+          country: String,
+          currency: String,
+          financial_account_token: String,
+          owner: String,
+          owner_type: Lithic::Models::OwnerType::OrSymbol,
+          routing_number: String,
+          type: Lithic::Models::ExternalBankAccountCreateParams::Type::OrSymbol,
+          verification_method: Lithic::Models::ExternalBankAccountCreateParams::VerificationMethod::OrSymbol,
+          processor_token: String,
+          account_token: String,
+          address: T.any(Lithic::Models::ExternalBankAccountAddress, Lithic::Util::AnyHash),
+          company_id: String,
+          dob: Date,
+          doing_business_as: String,
+          name: String,
+          user_defined_id: String,
+          verification_enforcement: T::Boolean,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::ExternalBankAccountCreateResponse)
+      end
+      def create(
+        # Account Number
+        account_number:,
+        # The country that the bank account is located in using ISO 3166-1. We will only
+        #   accept USA bank accounts e.g., USA
+        country:,
+        # currency of the external account 3-character alphabetic ISO 4217 code
+        currency:,
+        # The financial account token of the operating account to fund the micro deposits
+        financial_account_token:,
+        # Legal Name of the business or individual who owns the external account. This
+        #   will appear in statements
+        owner:,
+        # Owner Type
+        owner_type:,
+        # Routing Number
+        routing_number:,
+        # Account Type
+        type:,
+        # Verification Method
+        verification_method:,
+        processor_token:,
+        # 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
+        account_token: nil,
+        # Address
+        address: nil,
+        # Optional field that helps identify bank accounts in receipts
+        company_id: nil,
+        # Date of Birth of the Individual that owns the external bank account
+        dob: nil,
+        # Doing Business As
+        doing_business_as: nil,
+        # The nickname for this External Bank Account
+        name: nil,
+        # User Defined ID
+        user_defined_id: nil,
+        verification_enforcement: nil,
+        request_options: {}
+      )
+      end
+
+      # Get the external bank account by token.
+      sig do
+        params(
+          external_bank_account_token: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::ExternalBankAccountRetrieveResponse)
+      end
+      def retrieve(external_bank_account_token, request_options: {})
+      end
+
+      # Update the external bank account by token.
+      sig do
+        params(
+          external_bank_account_token: String,
+          address: T.any(Lithic::Models::ExternalBankAccountAddress, Lithic::Util::AnyHash),
+          company_id: String,
+          dob: Date,
+          doing_business_as: String,
+          name: String,
+          owner: String,
+          owner_type: Lithic::Models::OwnerType::OrSymbol,
+          type: Lithic::Models::ExternalBankAccountUpdateParams::Type::OrSymbol,
+          user_defined_id: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::ExternalBankAccountUpdateResponse)
+      end
+      def update(
+        external_bank_account_token,
+        # Address
+        address: nil,
+        # Optional field that helps identify bank accounts in receipts
+        company_id: nil,
+        # Date of Birth of the Individual that owns the external bank account
+        dob: nil,
+        # Doing Business As
+        doing_business_as: nil,
+        # The nickname for this External Bank Account
+        name: nil,
+        # Legal Name of the business or individual who owns the external account. This
+        #   will appear in statements
+        owner: nil,
+        # Owner Type
+        owner_type: nil,
+        type: nil,
+        # User Defined ID
+        user_defined_id: nil,
+        request_options: {}
+      )
+      end
+
+      # List all the external bank accounts for the provided search criteria.
+      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.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::CursorPage[Lithic::Models::ExternalBankAccountListResponse])
+      end
+      def list(
+        account_token: nil,
+        account_types: nil,
+        countries: nil,
+        # 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.
+        ending_before: nil,
+        owner_types: nil,
+        # Page size (for pagination).
+        page_size: nil,
+        # 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.
+        starting_after: nil,
+        states: nil,
+        verification_states: nil,
+        request_options: {}
+      )
+      end
+
+      # Retry external bank account micro deposit verification.
+      sig do
+        params(
+          external_bank_account_token: String,
+          financial_account_token: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::ExternalBankAccountRetryMicroDepositsResponse)
+      end
+      def retry_micro_deposits(external_bank_account_token, financial_account_token: nil, request_options: {})
+      end
+
+      # Retry external bank account prenote verification.
+      sig do
+        params(
+          external_bank_account_token: String,
+          financial_account_token: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::ExternalBankAccountRetryPrenoteResponse)
+      end
+      def retry_prenote(external_bank_account_token, financial_account_token: nil, request_options: {})
+      end
+
+      sig { params(client: Lithic::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/lib/lithic/resources/external_payments.rbi

@@ -0,0 +1,180 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class ExternalPayments
+      # Create external payment
+      sig do
+        params(
+          amount: Integer,
+          category: Lithic::Models::ExternalPaymentCreateParams::Category::OrSymbol,
+          effective_date: Date,
+          financial_account_token: String,
+          payment_type: Lithic::Models::ExternalPaymentCreateParams::PaymentType::OrSymbol,
+          token: String,
+          memo: String,
+          progress_to: Lithic::Models::ExternalPaymentCreateParams::ProgressTo::OrSymbol,
+          user_defined_id: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::ExternalPayment)
+      end
+      def create(
+        amount:,
+        category:,
+        effective_date:,
+        financial_account_token:,
+        payment_type:,
+        token: nil,
+        memo: nil,
+        progress_to: nil,
+        user_defined_id: nil,
+        request_options: {}
+      )
+      end
+
+      # Get external payment
+      sig do
+        params(
+          external_payment_token: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::ExternalPayment)
+      end
+      def retrieve(
+        # Globally unique identifier for the external payment
+        external_payment_token,
+        request_options: {}
+      )
+      end
+
+      # List external payments
+      sig do
+        params(
+          begin_: Time,
+          business_account_token: String,
+          category: Lithic::Models::ExternalPaymentListParams::Category::OrSymbol,
+          end_: Time,
+          ending_before: String,
+          financial_account_token: String,
+          page_size: Integer,
+          result: Lithic::Models::ExternalPaymentListParams::Result::OrSymbol,
+          starting_after: String,
+          status: Lithic::Models::ExternalPaymentListParams::Status::OrSymbol,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::CursorPage[Lithic::Models::ExternalPayment])
+      end
+      def list(
+        # Date string in RFC 3339 format. Only entries created after the specified time
+        #   will be included. UTC time zone.
+        begin_: nil,
+        business_account_token: nil,
+        # External Payment category to be returned.
+        category: nil,
+        # Date string in RFC 3339 format. Only entries created before the specified time
+        #   will be included. UTC time zone.
+        end_: nil,
+        # 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.
+        ending_before: nil,
+        # Globally unique identifier for the financial account or card that will send the
+        #   funds. Accepted type dependent on the program's use case.
+        financial_account_token: nil,
+        # Page size (for pagination).
+        page_size: nil,
+        # External Payment result to be returned.
+        result: nil,
+        # 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.
+        starting_after: nil,
+        # Book transfer status to be returned.
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      # Cancel external payment
+      sig do
+        params(
+          external_payment_token: String,
+          effective_date: Date,
+          memo: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::ExternalPayment)
+      end
+      def cancel(
+        # Globally unique identifier for the external payment
+        external_payment_token,
+        effective_date:,
+        memo: nil,
+        request_options: {}
+      )
+      end
+
+      # Release external payment
+      sig do
+        params(
+          external_payment_token: String,
+          effective_date: Date,
+          memo: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::ExternalPayment)
+      end
+      def release(
+        # Globally unique identifier for the external payment
+        external_payment_token,
+        effective_date:,
+        memo: nil,
+        request_options: {}
+      )
+      end
+
+      # Reverse external payment
+      sig do
+        params(
+          external_payment_token: String,
+          effective_date: Date,
+          memo: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::ExternalPayment)
+      end
+      def reverse(
+        # Globally unique identifier for the external payment
+        external_payment_token,
+        effective_date:,
+        memo: nil,
+        request_options: {}
+      )
+      end
+
+      # Settle external payment
+      sig do
+        params(
+          external_payment_token: String,
+          effective_date: Date,
+          memo: String,
+          progress_to: Lithic::Models::ExternalPaymentSettleParams::ProgressTo::OrSymbol,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::ExternalPayment)
+      end
+      def settle(
+        # Globally unique identifier for the external payment
+        external_payment_token,
+        effective_date:,
+        memo: nil,
+        progress_to: nil,
+        request_options: {}
+      )
+      end
+
+      sig { params(client: Lithic::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/lib/lithic/resources/financial_accounts/balances.rbi

@@ -0,0 +1,36 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class FinancialAccounts
+      class Balances
+        # Get the balances for a given financial account.
+        sig do
+          params(
+            financial_account_token: String,
+            balance_date: Time,
+            last_transaction_event_token: String,
+            request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+          )
+            .returns(Lithic::SinglePage[Lithic::Models::FinancialAccounts::BalanceListResponse])
+        end
+        def list(
+          # Globally unique identifier for financial account.
+          financial_account_token,
+          # UTC date of the balance to retrieve. Defaults to latest available balance
+          balance_date: nil,
+          # Balance after a given financial event occured. For example, passing the
+          #   event_token of a $5 CARD_CLEARING financial event will return a balance
+          #   decreased by $5
+          last_transaction_event_token: nil,
+          request_options: {}
+        )
+        end
+
+        sig { params(client: Lithic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/resources/financial_accounts/credit_configuration.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class FinancialAccounts
+      class CreditConfiguration
+        # Get an Account's credit configuration
+        sig do
+          params(
+            financial_account_token: String,
+            request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+          )
+            .returns(Lithic::Models::FinancialAccounts::FinancialAccountCreditConfig)
+        end
+        def retrieve(
+          # Globally unique identifier for financial account.
+          financial_account_token,
+          request_options: {}
+        )
+        end
+
+        # Update an account's credit configuration
+        sig do
+          params(
+            financial_account_token: String,
+            credit_limit: Integer,
+            credit_product_token: String,
+            external_bank_account_token: String,
+            tier: String,
+            request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+          )
+            .returns(Lithic::Models::FinancialAccounts::FinancialAccountCreditConfig)
+        end
+        def update(
+          # Globally unique identifier for financial account.
+          financial_account_token,
+          credit_limit: nil,
+          # Globally unique identifier for the credit product
+          credit_product_token: nil,
+          external_bank_account_token: nil,
+          # Tier to assign to a financial account
+          tier: nil,
+          request_options: {}
+        )
+        end
+
+        sig { params(client: Lithic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/resources/financial_accounts/financial_transactions.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class FinancialAccounts
+      class FinancialTransactions
+        # Get the financial transaction for the provided token.
+        sig do
+          params(
+            financial_transaction_token: String,
+            financial_account_token: String,
+            request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+          )
+            .returns(Lithic::Models::FinancialTransaction)
+        end
+        def retrieve(
+          # Globally unique identifier for financial transaction token.
+          financial_transaction_token,
+          # Globally unique identifier for financial account.
+          financial_account_token:,
+          request_options: {}
+        )
+        end
+
+        # List the financial transactions for a given financial account.
+        sig do
+          params(
+            financial_account_token: String,
+            begin_: Time,
+            category: Lithic::Models::FinancialAccounts::FinancialTransactionListParams::Category::OrSymbol,
+            end_: Time,
+            ending_before: String,
+            result: Lithic::Models::FinancialAccounts::FinancialTransactionListParams::Result::OrSymbol,
+            starting_after: String,
+            status: Lithic::Models::FinancialAccounts::FinancialTransactionListParams::Status::OrSymbol,
+            request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+          )
+            .returns(Lithic::SinglePage[Lithic::Models::FinancialTransaction])
+        end
+        def list(
+          # Globally unique identifier for financial account.
+          financial_account_token,
+          # Date string in RFC 3339 format. Only entries created after the specified time
+          #   will be included. UTC time zone.
+          begin_: nil,
+          # Financial Transaction category to be returned.
+          category: nil,
+          # Date string in RFC 3339 format. Only entries created before the specified time
+          #   will be included. UTC time zone.
+          end_: nil,
+          # 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.
+          ending_before: nil,
+          # Financial Transaction result to be returned.
+          result: nil,
+          # 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.
+          starting_after: nil,
+          # Financial Transaction status to be returned.
+          status: nil,
+          request_options: {}
+        )
+        end
+
+        sig { params(client: Lithic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/resources/financial_accounts/loan_tapes.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class FinancialAccounts
+      class LoanTapes
+        # Get a specific loan tape for a given financial account.
+        sig do
+          params(
+            loan_tape_token: String,
+            financial_account_token: String,
+            request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+          )
+            .returns(Lithic::Models::FinancialAccounts::LoanTape)
+        end
+        def retrieve(
+          # Globally unique identifier for loan tape.
+          loan_tape_token,
+          # Globally unique identifier for financial account.
+          financial_account_token:,
+          request_options: {}
+        )
+        end
+
+        # List the loan tapes for a given financial account.
+        sig do
+          params(
+            financial_account_token: String,
+            begin_: Date,
+            end_: Date,
+            ending_before: String,
+            page_size: Integer,
+            starting_after: String,
+            request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+          )
+            .returns(Lithic::CursorPage[Lithic::Models::FinancialAccounts::LoanTape])
+        end
+        def list(
+          # Globally unique identifier for financial account.
+          financial_account_token,
+          # Date string in RFC 3339 format. Only entries created after the specified date
+          #   will be included.
+          begin_: nil,
+          # Date string in RFC 3339 format. Only entries created before the specified date
+          #   will be included.
+          end_: nil,
+          # 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.
+          ending_before: nil,
+          # Page size (for pagination).
+          page_size: nil,
+          # 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.
+          starting_after: nil,
+          request_options: {}
+        )
+        end
+
+        sig { params(client: Lithic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/resources/financial_accounts/statements/line_items.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class FinancialAccounts
+      class Statements
+        class LineItems
+          # List the line items for a given statement within a given financial account.
+          sig do
+            params(
+              statement_token: String,
+              financial_account_token: String,
+              ending_before: String,
+              page_size: Integer,
+              starting_after: String,
+              request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+            )
+              .returns(Lithic::CursorPage[Lithic::Models::FinancialAccounts::Statements::StatementLineItems::Data])
+          end
+          def list(
+            # Path param: Globally unique identifier for statements.
+            statement_token,
+            # Path param: Globally unique identifier for financial account.
+            financial_account_token:,
+            # Query param: 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.
+            ending_before: nil,
+            # Query param: Page size (for pagination).
+            page_size: nil,
+            # Query param: 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.
+            starting_after: nil,
+            request_options: {}
+          )
+          end
+
+          sig { params(client: Lithic::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end