lithic 0.1.0.pre.alpha.1

data/rbi/lib/lithic/client.rbi

@@ -0,0 +1,143 @@
+# typed: strong
+
+module Lithic
+  class Client < Lithic::BaseClient
+    DEFAULT_MAX_RETRIES = 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS = T.let(60.0, Float)
+
+    DEFAULT_INITIAL_RETRY_DELAY = T.let(0.5, Float)
+
+    DEFAULT_MAX_RETRY_DELAY = T.let(8.0, Float)
+
+    ENVIRONMENTS =
+      T.let(
+        {production: "https://api.lithic.com", sandbox: "https://sandbox.lithic.com"},
+        T::Hash[Symbol, String]
+      )
+
+    sig { returns(String) }
+    attr_reader :api_key
+
+    sig { returns(Lithic::Resources::Accounts) }
+    attr_reader :accounts
+
+    sig { returns(Lithic::Resources::AccountHolders) }
+    attr_reader :account_holders
+
+    sig { returns(Lithic::Resources::AuthRules) }
+    attr_reader :auth_rules
+
+    sig { returns(Lithic::Resources::AuthStreamEnrollment) }
+    attr_reader :auth_stream_enrollment
+
+    sig { returns(Lithic::Resources::TokenizationDecisioning) }
+    attr_reader :tokenization_decisioning
+
+    sig { returns(Lithic::Resources::Tokenizations) }
+    attr_reader :tokenizations
+
+    sig { returns(Lithic::Resources::Cards) }
+    attr_reader :cards
+
+    sig { returns(Lithic::Resources::Balances) }
+    attr_reader :balances
+
+    sig { returns(Lithic::Resources::AggregateBalances) }
+    attr_reader :aggregate_balances
+
+    sig { returns(Lithic::Resources::Disputes) }
+    attr_reader :disputes
+
+    sig { returns(Lithic::Resources::Events) }
+    attr_reader :events
+
+    sig { returns(Lithic::Resources::Transfers) }
+    attr_reader :transfers
+
+    sig { returns(Lithic::Resources::FinancialAccounts) }
+    attr_reader :financial_accounts
+
+    sig { returns(Lithic::Resources::Transactions) }
+    attr_reader :transactions
+
+    sig { returns(Lithic::Resources::ResponderEndpoints) }
+    attr_reader :responder_endpoints
+
+    sig { returns(Lithic::Resources::ExternalBankAccounts) }
+    attr_reader :external_bank_accounts
+
+    sig { returns(Lithic::Resources::Payments) }
+    attr_reader :payments
+
+    sig { returns(Lithic::Resources::ThreeDS) }
+    attr_reader :three_ds
+
+    sig { returns(Lithic::Resources::Reports) }
+    attr_reader :reports
+
+    sig { returns(Lithic::Resources::CardPrograms) }
+    attr_reader :card_programs
+
+    sig { returns(Lithic::Resources::DigitalCardArt) }
+    attr_reader :digital_card_art
+
+    sig { returns(Lithic::Resources::BookTransfers) }
+    attr_reader :book_transfers
+
+    sig { returns(Lithic::Resources::CreditProducts) }
+    attr_reader :credit_products
+
+    sig { returns(Lithic::Resources::ExternalPayments) }
+    attr_reader :external_payments
+
+    sig { returns(Lithic::Resources::ManagementOperations) }
+    attr_reader :management_operations
+
+    # Status of api
+    sig do
+      params(request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)))
+        .returns(Lithic::Models::APIStatus)
+    end
+    def api_status(request_options: {})
+    end
+
+    # @api private
+    sig { override.returns(T::Hash[String, String]) }
+    private def auth_headers
+    end
+
+    # Creates and returns a new client for interacting with the API.
+    sig do
+      params(
+        environment: NilClass,
+        base_url: T.nilable(String),
+        api_key: T.nilable(String),
+        max_retries: Integer,
+        timeout: Float,
+        initial_retry_delay: Float,
+        max_retry_delay: Float
+      )
+        .returns(T.attached_class)
+    end
+    def self.new(
+      # Specifies the environment to use for the API.
+      #
+      #   Each environment maps to a different base URL:
+      #
+      #   - `production` corresponds to `https://api.lithic.com`
+      #   - `sandbox` corresponds to `https://sandbox.lithic.com`
+      environment: nil,
+      # Override the default base URL for the API, e.g., `"https://api.example.com/v2/"`
+      base_url: nil,
+      # Defaults to `ENV["LITHIC_API_KEY"]`
+      api_key: ENV["LITHIC_API_KEY"],
+      # Max number of retries to attempt after a failed retryable request.
+      max_retries: DEFAULT_MAX_RETRIES,
+      timeout: DEFAULT_TIMEOUT_IN_SECONDS,
+      initial_retry_delay: DEFAULT_INITIAL_RETRY_DELAY,
+      max_retry_delay: DEFAULT_MAX_RETRY_DELAY
+    )
+    end
+  end
+end

data/rbi/lib/lithic/cursor_page.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Lithic
+  class CursorPage
+    include Lithic::BasePage
+
+    Elem = type_member
+
+    sig { returns(T.nilable(T::Array[Elem])) }
+    attr_accessor :data
+
+    sig { returns(T::Boolean) }
+    attr_accessor :has_more
+
+    sig { returns(String) }
+    def inspect
+    end
+  end
+end

data/rbi/lib/lithic/errors.rbi

@@ -0,0 +1,144 @@
+# typed: strong
+
+module Lithic
+  class Error < StandardError
+    sig { returns(T.nilable(StandardError)) }
+    attr_accessor :cause
+  end
+
+  class ConversionError < Lithic::Error
+  end
+
+  class APIError < Lithic::Error
+    sig { returns(URI::Generic) }
+    attr_accessor :url
+
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :status
+
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :body
+
+    # @api private
+    sig do
+      params(
+        url: URI::Generic,
+        status: T.nilable(Integer),
+        body: T.nilable(Object),
+        request: NilClass,
+        response: NilClass,
+        message: T.nilable(String)
+      )
+        .returns(T.attached_class)
+    end
+    def self.new(url:, status: nil, body: nil, request: nil, response: nil, message: nil)
+    end
+  end
+
+  class APIConnectionError < Lithic::APIError
+    sig { void }
+    attr_accessor :status
+
+    sig { void }
+    attr_accessor :body
+
+    # @api private
+    sig do
+      params(
+        url: URI::Generic,
+        status: NilClass,
+        body: NilClass,
+        request: NilClass,
+        response: NilClass,
+        message: T.nilable(String)
+      )
+        .returns(T.attached_class)
+    end
+    def self.new(url:, status: nil, body: nil, request: nil, response: nil, message: "Connection error.")
+    end
+  end
+
+  class APITimeoutError < Lithic::APIConnectionError
+    # @api private
+    sig do
+      params(
+        url: URI::Generic,
+        status: NilClass,
+        body: NilClass,
+        request: NilClass,
+        response: NilClass,
+        message: T.nilable(String)
+      )
+        .returns(T.attached_class)
+    end
+    def self.new(url:, status: nil, body: nil, request: nil, response: nil, message: "Request timed out.")
+    end
+  end
+
+  class APIStatusError < Lithic::APIError
+    # @api private
+    sig do
+      params(
+        url: URI::Generic,
+        status: Integer,
+        body: T.nilable(Object),
+        request: NilClass,
+        response: NilClass,
+        message: T.nilable(String)
+      )
+        .returns(T.attached_class)
+    end
+    def self.for(url:, status:, body:, request:, response:, message: nil)
+    end
+
+    sig { returns(Integer) }
+    attr_accessor :status
+
+    # @api private
+    sig do
+      params(
+        url: URI::Generic,
+        status: Integer,
+        body: T.nilable(Object),
+        request: NilClass,
+        response: NilClass,
+        message: T.nilable(String)
+      )
+        .returns(T.attached_class)
+    end
+    def self.new(url:, status:, body:, request:, response:, message: nil)
+    end
+  end
+
+  class BadRequestError < Lithic::APIStatusError
+    HTTP_STATUS = 400
+  end
+
+  class AuthenticationError < Lithic::APIStatusError
+    HTTP_STATUS = 401
+  end
+
+  class PermissionDeniedError < Lithic::APIStatusError
+    HTTP_STATUS = 403
+  end
+
+  class NotFoundError < Lithic::APIStatusError
+    HTTP_STATUS = 404
+  end
+
+  class ConflictError < Lithic::APIStatusError
+    HTTP_STATUS = 409
+  end
+
+  class UnprocessableEntityError < Lithic::APIStatusError
+    HTTP_STATUS = 422
+  end
+
+  class RateLimitError < Lithic::APIStatusError
+    HTTP_STATUS = 429
+  end
+
+  class InternalServerError < Lithic::APIStatusError
+    HTTP_STATUS = T.let((500..), T::Range[Integer])
+  end
+end

data/rbi/lib/lithic/extern.rbi

@@ -0,0 +1,7 @@
+# typed: strong
+
+module Lithic
+  # @api private
+  module Extern
+  end
+end

data/rbi/lib/lithic/models/account.rbi

@@ -0,0 +1,273 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class Account < Lithic::BaseModel
+      # Globally unique identifier for the account. This is the same as the
+      #   account_token returned by the enroll endpoint. If using this parameter, do not
+      #   include pagination.
+      sig { returns(String) }
+      attr_accessor :token
+
+      # Timestamp of when the account was created. For accounts created before
+      #   2023-05-11, this field will be null.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :created
+
+      # Spend limit information for the user containing the daily, monthly, and lifetime
+      #   spend limit of the account. Any charges to a card owned by this account will be
+      #   declined once their transaction volume has surpassed the value in the applicable
+      #   time limit (rolling). A lifetime limit of 0 indicates that the lifetime limit
+      #   feature is disabled.
+      sig { returns(Lithic::Models::Account::SpendLimit) }
+      attr_reader :spend_limit
+
+      sig { params(spend_limit: T.any(Lithic::Models::Account::SpendLimit, Lithic::Util::AnyHash)).void }
+      attr_writer :spend_limit
+
+      # Account state:
+      #
+      #   - `ACTIVE` - Account is able to transact and create new cards.
+      #   - `PAUSED` - Account will not be able to transact or create new cards. It can be
+      #     set back to `ACTIVE`.
+      #   - `CLOSED` - Account will not be able to transact or create new cards. `CLOSED`
+      #     accounts are also unable to be transitioned to `ACTIVE` or `PAUSED` states.
+      #     `CLOSED` accounts result from failing to pass KYB/KYC or Lithic closing for
+      #     risk/compliance reasons. Please contact
+      #     [support@lithic.com](mailto:support@lithic.com) if you believe this was in
+      #     error.
+      sig { returns(Lithic::Models::Account::State::TaggedSymbol) }
+      attr_accessor :state
+
+      sig { returns(T.nilable(Lithic::Models::Account::AccountHolder)) }
+      attr_reader :account_holder
+
+      sig { params(account_holder: T.any(Lithic::Models::Account::AccountHolder, Lithic::Util::AnyHash)).void }
+      attr_writer :account_holder
+
+      # List of identifiers for the Auth Rule(s) that are applied on the account. This
+      #   field is deprecated and will no longer be populated in the `account_holder`
+      #   object. The key will be removed from the schema in a future release. Use the
+      #   `/auth_rules` endpoints to fetch Auth Rule information instead.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :auth_rule_tokens
+
+      sig { params(auth_rule_tokens: T::Array[String]).void }
+      attr_writer :auth_rule_tokens
+
+      # 3-character alphabetic ISO 4217 code for the currency of the cardholder.
+      sig { returns(T.nilable(String)) }
+      attr_reader :cardholder_currency
+
+      sig { params(cardholder_currency: String).void }
+      attr_writer :cardholder_currency
+
+      sig { returns(T.nilable(Lithic::Models::Account::VerificationAddress)) }
+      attr_reader :verification_address
+
+      sig do
+        params(verification_address: T.any(Lithic::Models::Account::VerificationAddress, Lithic::Util::AnyHash))
+          .void
+      end
+      attr_writer :verification_address
+
+      sig do
+        params(
+          token: String,
+          created: T.nilable(Time),
+          spend_limit: T.any(Lithic::Models::Account::SpendLimit, Lithic::Util::AnyHash),
+          state: Lithic::Models::Account::State::OrSymbol,
+          account_holder: T.any(Lithic::Models::Account::AccountHolder, Lithic::Util::AnyHash),
+          auth_rule_tokens: T::Array[String],
+          cardholder_currency: String,
+          verification_address: T.any(Lithic::Models::Account::VerificationAddress, Lithic::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        token:,
+        created:,
+        spend_limit:,
+        state:,
+        account_holder: nil,
+        auth_rule_tokens: nil,
+        cardholder_currency: nil,
+        verification_address: nil
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              token: String,
+              created: T.nilable(Time),
+              spend_limit: Lithic::Models::Account::SpendLimit,
+              state: Lithic::Models::Account::State::TaggedSymbol,
+              account_holder: Lithic::Models::Account::AccountHolder,
+              auth_rule_tokens: T::Array[String],
+              cardholder_currency: String,
+              verification_address: Lithic::Models::Account::VerificationAddress
+            }
+          )
+      end
+      def to_hash
+      end
+
+      class SpendLimit < Lithic::BaseModel
+        # Daily spend limit (in cents).
+        sig { returns(Integer) }
+        attr_accessor :daily
+
+        # Total spend limit over account lifetime (in cents).
+        sig { returns(Integer) }
+        attr_accessor :lifetime
+
+        # Monthly spend limit (in cents).
+        sig { returns(Integer) }
+        attr_accessor :monthly
+
+        # Spend limit information for the user containing the daily, monthly, and lifetime
+        #   spend limit of the account. Any charges to a card owned by this account will be
+        #   declined once their transaction volume has surpassed the value in the applicable
+        #   time limit (rolling). A lifetime limit of 0 indicates that the lifetime limit
+        #   feature is disabled.
+        sig { params(daily: Integer, lifetime: Integer, monthly: Integer).returns(T.attached_class) }
+        def self.new(daily:, lifetime:, monthly:)
+        end
+
+        sig { override.returns({daily: Integer, lifetime: Integer, monthly: Integer}) }
+        def to_hash
+        end
+      end
+
+      # Account state:
+      #
+      #   - `ACTIVE` - Account is able to transact and create new cards.
+      #   - `PAUSED` - Account will not be able to transact or create new cards. It can be
+      #     set back to `ACTIVE`.
+      #   - `CLOSED` - Account will not be able to transact or create new cards. `CLOSED`
+      #     accounts are also unable to be transitioned to `ACTIVE` or `PAUSED` states.
+      #     `CLOSED` accounts result from failing to pass KYB/KYC or Lithic closing for
+      #     risk/compliance reasons. Please contact
+      #     [support@lithic.com](mailto:support@lithic.com) if you believe this was in
+      #     error.
+      module State
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::Account::State) }
+        OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::Account::State::TaggedSymbol) }
+
+        ACTIVE = T.let(:ACTIVE, Lithic::Models::Account::State::TaggedSymbol)
+        PAUSED = T.let(:PAUSED, Lithic::Models::Account::State::TaggedSymbol)
+        CLOSED = T.let(:CLOSED, Lithic::Models::Account::State::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::Account::State::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      class AccountHolder < Lithic::BaseModel
+        # Globally unique identifier for the account holder.
+        sig { returns(String) }
+        attr_accessor :token
+
+        # Only applicable for customers using the KYC-Exempt workflow to enroll authorized
+        #   users of businesses. Account_token of the enrolled business associated with an
+        #   enrolled AUTHORIZED_USER individual.
+        sig { returns(String) }
+        attr_accessor :business_account_token
+
+        # Email address.
+        sig { returns(String) }
+        attr_accessor :email
+
+        # Phone number of the individual.
+        sig { returns(String) }
+        attr_accessor :phone_number
+
+        sig do
+          params(token: String, business_account_token: String, email: String, phone_number: String)
+            .returns(T.attached_class)
+        end
+        def self.new(token:, business_account_token:, email:, phone_number:)
+        end
+
+        sig do
+          override.returns(
+            {
+              token: String,
+              business_account_token: String,
+              email: String,
+              phone_number: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class VerificationAddress < Lithic::BaseModel
+        # Valid deliverable address (no PO boxes).
+        sig { returns(String) }
+        attr_accessor :address1
+
+        # City name.
+        sig { returns(String) }
+        attr_accessor :city
+
+        # Country name. Only USA is currently supported.
+        sig { returns(String) }
+        attr_accessor :country
+
+        # Valid postal code. Only USA postal codes (ZIP codes) are currently supported,
+        #   entered as a five-digit postal code or nine-digit postal code (ZIP+4) using the
+        #   format 12345-1234.
+        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
+
+        sig do
+          params(
+            address1: String,
+            city: String,
+            country: String,
+            postal_code: String,
+            state: String,
+            address2: String
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(address1:, city:, country:, postal_code:, state:, 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
+    end
+  end
+end

data/rbi/lib/lithic/models/account_financial_account_type.rbi

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Lithic
+  module Models
+    # Type of account financial account
+    module AccountFinancialAccountType
+      extend Lithic::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AccountFinancialAccountType) }
+      OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::AccountFinancialAccountType::TaggedSymbol) }
+
+      ISSUING = T.let(:ISSUING, Lithic::Models::AccountFinancialAccountType::TaggedSymbol)
+      OPERATING = T.let(:OPERATING, Lithic::Models::AccountFinancialAccountType::TaggedSymbol)
+
+      sig { override.returns(T::Array[Lithic::Models::AccountFinancialAccountType::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end