lithic 0.1.0.pre.alpha.1

data/rbi/lib/lithic/models/card_update_params.rbi

@@ -0,0 +1,168 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class CardUpdateParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      # Specifies the digital card art to be displayed in the user’s digital wallet
+      #   after tokenization. This artwork must be approved by Mastercard and configured
+      #   by Lithic to use. See
+      #   [Flexible Card Art Guide](https://docs.lithic.com/docs/about-digital-wallets#flexible-card-art).
+      sig { returns(T.nilable(String)) }
+      attr_reader :digital_card_art_token
+
+      sig { params(digital_card_art_token: String).void }
+      attr_writer :digital_card_art_token
+
+      # Friendly name to identify the card.
+      sig { returns(T.nilable(String)) }
+      attr_reader :memo
+
+      sig { params(memo: String).void }
+      attr_writer :memo
+
+      # Encrypted PIN block (in base64). Only applies to cards of type `PHYSICAL` and
+      #   `VIRTUAL`. Changing PIN also resets PIN status to `OK`. See
+      #   [Encrypted PIN Block](https://docs.lithic.com/docs/cards#encrypted-pin-block).
+      sig { returns(T.nilable(String)) }
+      attr_reader :pin
+
+      sig { params(pin: String).void }
+      attr_writer :pin
+
+      # Indicates if a card is blocked due a PIN status issue (e.g. excessive incorrect
+      #   attempts). Can only be set to `OK` to unblock a card.
+      sig { returns(T.nilable(Lithic::Models::CardUpdateParams::PinStatus::OrSymbol)) }
+      attr_reader :pin_status
+
+      sig { params(pin_status: Lithic::Models::CardUpdateParams::PinStatus::OrSymbol).void }
+      attr_writer :pin_status
+
+      # Amount (in cents) to limit approved authorizations (e.g. 100000 would be a
+      #   $1,000 limit). Transaction requests above the spend limit will be declined. Note
+      #   that a spend limit of 0 is effectively no limit, and should only be used to
+      #   reset or remove a prior limit. Only a limit of 1 or above will result in
+      #   declined transactions due to checks against the card limit.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :spend_limit
+
+      sig { params(spend_limit: Integer).void }
+      attr_writer :spend_limit
+
+      # Spend limit duration values:
+      #
+      #   - `ANNUALLY` - Card will authorize transactions up to spend limit for the
+      #     trailing year.
+      #   - `FOREVER` - Card will authorize only up to spend limit for the entire lifetime
+      #     of the card.
+      #   - `MONTHLY` - Card will authorize transactions up to spend limit for the
+      #     trailing month. To support recurring monthly payments, which can occur on
+      #     different day every month, the time window we consider for monthly velocity
+      #     starts 6 days after the current calendar date one month prior.
+      #   - `TRANSACTION` - Card will authorize multiple transactions if each individual
+      #     transaction is under the spend limit.
+      sig { returns(T.nilable(Lithic::Models::SpendLimitDuration::OrSymbol)) }
+      attr_reader :spend_limit_duration
+
+      sig { params(spend_limit_duration: Lithic::Models::SpendLimitDuration::OrSymbol).void }
+      attr_writer :spend_limit_duration
+
+      # Card state values:
+      #
+      #   - `CLOSED` - Card will no longer approve authorizations. Closing a card cannot
+      #     be undone.
+      #   - `OPEN` - Card will approve authorizations (if they match card and account
+      #     parameters).
+      #   - `PAUSED` - Card will decline authorizations, but can be resumed at a later
+      #     time.
+      sig { returns(T.nilable(Lithic::Models::CardUpdateParams::State::OrSymbol)) }
+      attr_reader :state
+
+      sig { params(state: Lithic::Models::CardUpdateParams::State::OrSymbol).void }
+      attr_writer :state
+
+      sig do
+        params(
+          digital_card_art_token: String,
+          memo: String,
+          pin: String,
+          pin_status: Lithic::Models::CardUpdateParams::PinStatus::OrSymbol,
+          spend_limit: Integer,
+          spend_limit_duration: Lithic::Models::SpendLimitDuration::OrSymbol,
+          state: Lithic::Models::CardUpdateParams::State::OrSymbol,
+          request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        digital_card_art_token: nil,
+        memo: nil,
+        pin: nil,
+        pin_status: nil,
+        spend_limit: nil,
+        spend_limit_duration: nil,
+        state: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              digital_card_art_token: String,
+              memo: String,
+              pin: String,
+              pin_status: Lithic::Models::CardUpdateParams::PinStatus::OrSymbol,
+              spend_limit: Integer,
+              spend_limit_duration: Lithic::Models::SpendLimitDuration::OrSymbol,
+              state: Lithic::Models::CardUpdateParams::State::OrSymbol,
+              request_options: Lithic::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # Indicates if a card is blocked due a PIN status issue (e.g. excessive incorrect
+      #   attempts). Can only be set to `OK` to unblock a card.
+      module PinStatus
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::CardUpdateParams::PinStatus) }
+        OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::CardUpdateParams::PinStatus::TaggedSymbol) }
+
+        OK = T.let(:OK, Lithic::Models::CardUpdateParams::PinStatus::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::CardUpdateParams::PinStatus::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      # Card state values:
+      #
+      #   - `CLOSED` - Card will no longer approve authorizations. Closing a card cannot
+      #     be undone.
+      #   - `OPEN` - Card will approve authorizations (if they match card and account
+      #     parameters).
+      #   - `PAUSED` - Card will decline authorizations, but can be resumed at a later
+      #     time.
+      module State
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::CardUpdateParams::State) }
+        OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::CardUpdateParams::State::TaggedSymbol) }
+
+        CLOSED = T.let(:CLOSED, Lithic::Models::CardUpdateParams::State::TaggedSymbol)
+        OPEN = T.let(:OPEN, Lithic::Models::CardUpdateParams::State::TaggedSymbol)
+        PAUSED = T.let(:PAUSED, Lithic::Models::CardUpdateParams::State::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::CardUpdateParams::State::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/cards/aggregate_balance_list_params.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module Cards
+      class AggregateBalanceListParams < Lithic::BaseModel
+        extend Lithic::RequestParameters::Converter
+        include Lithic::RequestParameters
+
+        # Cardholder to retrieve aggregate balances for.
+        sig { returns(T.nilable(String)) }
+        attr_reader :account_token
+
+        sig { params(account_token: String).void }
+        attr_writer :account_token
+
+        # Business to retrieve aggregate balances for.
+        sig { returns(T.nilable(String)) }
+        attr_reader :business_account_token
+
+        sig { params(business_account_token: String).void }
+        attr_writer :business_account_token
+
+        sig do
+          params(
+            account_token: String,
+            business_account_token: String,
+            request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(account_token: nil, business_account_token: nil, request_options: {})
+        end
+
+        sig do
+          override
+            .returns({
+                       account_token: String,
+                       business_account_token: String,
+                       request_options: Lithic::RequestOptions
+                     })
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/cards/aggregate_balance_list_response.rbi

@@ -0,0 +1,96 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module Cards
+      class AggregateBalanceListResponse < Lithic::BaseModel
+        # Funds available for spend in the currency's smallest unit (e.g., cents for USD)
+        sig { returns(Integer) }
+        attr_accessor :available_amount
+
+        # Date and time for when the balance was first created.
+        sig { returns(Time) }
+        attr_accessor :created
+
+        # 3-character alphabetic ISO 4217 code for the local currency of the balance.
+        sig { returns(String) }
+        attr_accessor :currency
+
+        # Globally unique identifier for the card that had its balance updated most
+        #   recently
+        sig { returns(String) }
+        attr_accessor :last_card_token
+
+        # Globally unique identifier for the last transaction event that impacted this
+        #   balance
+        sig { returns(String) }
+        attr_accessor :last_transaction_event_token
+
+        # Globally unique identifier for the last transaction that impacted this balance
+        sig { returns(String) }
+        attr_accessor :last_transaction_token
+
+        # Funds not available for spend due to card authorizations or pending ACH release.
+        #   Shown in the currency's smallest unit (e.g., cents for USD)
+        sig { returns(Integer) }
+        attr_accessor :pending_amount
+
+        # The sum of available and pending balance in the currency's smallest unit (e.g.,
+        #   cents for USD)
+        sig { returns(Integer) }
+        attr_accessor :total_amount
+
+        # Date and time for when the balance was last updated.
+        sig { returns(Time) }
+        attr_accessor :updated
+
+        # Card Aggregate Balance across all end-user accounts
+        sig do
+          params(
+            available_amount: Integer,
+            created: Time,
+            currency: String,
+            last_card_token: String,
+            last_transaction_event_token: String,
+            last_transaction_token: String,
+            pending_amount: Integer,
+            total_amount: Integer,
+            updated: Time
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          available_amount:,
+          created:,
+          currency:,
+          last_card_token:,
+          last_transaction_event_token:,
+          last_transaction_token:,
+          pending_amount:,
+          total_amount:,
+          updated:
+        )
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                available_amount: Integer,
+                created: Time,
+                currency: String,
+                last_card_token: String,
+                last_transaction_event_token: String,
+                last_transaction_token: String,
+                pending_amount: Integer,
+                total_amount: Integer,
+                updated: Time
+              }
+            )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/cards/balance_list_params.rbi

@@ -0,0 +1,52 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module Cards
+      class BalanceListParams < Lithic::BaseModel
+        extend Lithic::RequestParameters::Converter
+        include Lithic::RequestParameters
+
+        # UTC date of the balance to retrieve. Defaults to latest available balance
+        sig { returns(T.nilable(Time)) }
+        attr_reader :balance_date
+
+        sig { params(balance_date: Time).void }
+        attr_writer :balance_date
+
+        # 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
+        sig { returns(T.nilable(String)) }
+        attr_reader :last_transaction_event_token
+
+        sig { params(last_transaction_event_token: String).void }
+        attr_writer :last_transaction_event_token
+
+        sig do
+          params(
+            balance_date: Time,
+            last_transaction_event_token: String,
+            request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(balance_date: nil, last_transaction_event_token: nil, request_options: {})
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                balance_date: Time,
+                last_transaction_event_token: String,
+                request_options: Lithic::RequestOptions
+              }
+            )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/cards/balance_list_response.rbi

@@ -0,0 +1,119 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module Cards
+      class BalanceListResponse < Lithic::BaseModel
+        # Globally unique identifier for the financial account that holds this balance.
+        sig { returns(String) }
+        attr_accessor :token
+
+        # Funds available for spend in the currency's smallest unit (e.g., cents for USD)
+        sig { returns(Integer) }
+        attr_accessor :available_amount
+
+        # Date and time for when the balance was first created.
+        sig { returns(Time) }
+        attr_accessor :created
+
+        # 3-character alphabetic ISO 4217 code for the local currency of the balance.
+        sig { returns(String) }
+        attr_accessor :currency
+
+        # Globally unique identifier for the last financial transaction event that
+        #   impacted this balance.
+        sig { returns(String) }
+        attr_accessor :last_transaction_event_token
+
+        # Globally unique identifier for the last financial transaction that impacted this
+        #   balance.
+        sig { returns(String) }
+        attr_accessor :last_transaction_token
+
+        # Funds not available for spend due to card authorizations or pending ACH release.
+        #   Shown in the currency's smallest unit (e.g., cents for USD).
+        sig { returns(Integer) }
+        attr_accessor :pending_amount
+
+        # The sum of available and pending balance in the currency's smallest unit (e.g.,
+        #   cents for USD).
+        sig { returns(Integer) }
+        attr_accessor :total_amount
+
+        # Type of financial account.
+        sig { returns(Lithic::Models::Cards::BalanceListResponse::Type::TaggedSymbol) }
+        attr_accessor :type
+
+        # Date and time for when the balance was last updated.
+        sig { returns(Time) }
+        attr_accessor :updated
+
+        # Balance of a Financial Account
+        sig do
+          params(
+            token: String,
+            available_amount: Integer,
+            created: Time,
+            currency: String,
+            last_transaction_event_token: String,
+            last_transaction_token: String,
+            pending_amount: Integer,
+            total_amount: Integer,
+            type: Lithic::Models::Cards::BalanceListResponse::Type::OrSymbol,
+            updated: Time
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          token:,
+          available_amount:,
+          created:,
+          currency:,
+          last_transaction_event_token:,
+          last_transaction_token:,
+          pending_amount:,
+          total_amount:,
+          type:,
+          updated:
+        )
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                token: String,
+                available_amount: Integer,
+                created: Time,
+                currency: String,
+                last_transaction_event_token: String,
+                last_transaction_token: String,
+                pending_amount: Integer,
+                total_amount: Integer,
+                type: Lithic::Models::Cards::BalanceListResponse::Type::TaggedSymbol,
+                updated: Time
+              }
+            )
+        end
+        def to_hash
+        end
+
+        # Type of financial account.
+        module Type
+          extend Lithic::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::Cards::BalanceListResponse::Type) }
+          OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::Cards::BalanceListResponse::Type::TaggedSymbol) }
+
+          ISSUING = T.let(:ISSUING, Lithic::Models::Cards::BalanceListResponse::Type::TaggedSymbol)
+          OPERATING = T.let(:OPERATING, Lithic::Models::Cards::BalanceListResponse::Type::TaggedSymbol)
+          RESERVE = T.let(:RESERVE, Lithic::Models::Cards::BalanceListResponse::Type::TaggedSymbol)
+
+          sig { override.returns(T::Array[Lithic::Models::Cards::BalanceListResponse::Type::TaggedSymbol]) }
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/cards/financial_transaction_list_params.rbi

@@ -0,0 +1,164 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module Cards
+      class FinancialTransactionListParams < Lithic::BaseModel
+        extend Lithic::RequestParameters::Converter
+        include Lithic::RequestParameters
+
+        # Date string in RFC 3339 format. Only entries created after the specified time
+        #   will be included. UTC time zone.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :begin_
+
+        sig { params(begin_: Time).void }
+        attr_writer :begin_
+
+        # Financial Transaction category to be returned.
+        sig { returns(T.nilable(Lithic::Models::Cards::FinancialTransactionListParams::Category::OrSymbol)) }
+        attr_reader :category
+
+        sig { params(category: Lithic::Models::Cards::FinancialTransactionListParams::Category::OrSymbol).void }
+        attr_writer :category
+
+        # Date string in RFC 3339 format. Only entries created before the specified time
+        #   will be included. UTC time zone.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :end_
+
+        sig { params(end_: Time).void }
+        attr_writer :end_
+
+        # 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
+
+        # Financial Transaction result to be returned.
+        sig { returns(T.nilable(Lithic::Models::Cards::FinancialTransactionListParams::Result::OrSymbol)) }
+        attr_reader :result
+
+        sig { params(result: Lithic::Models::Cards::FinancialTransactionListParams::Result::OrSymbol).void }
+        attr_writer :result
+
+        # 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
+
+        # Financial Transaction status to be returned.
+        sig { returns(T.nilable(Lithic::Models::Cards::FinancialTransactionListParams::Status::OrSymbol)) }
+        attr_reader :status
+
+        sig { params(status: Lithic::Models::Cards::FinancialTransactionListParams::Status::OrSymbol).void }
+        attr_writer :status
+
+        sig do
+          params(
+            begin_: Time,
+            category: Lithic::Models::Cards::FinancialTransactionListParams::Category::OrSymbol,
+            end_: Time,
+            ending_before: String,
+            result: Lithic::Models::Cards::FinancialTransactionListParams::Result::OrSymbol,
+            starting_after: String,
+            status: Lithic::Models::Cards::FinancialTransactionListParams::Status::OrSymbol,
+            request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          begin_: nil,
+          category: nil,
+          end_: nil,
+          ending_before: nil,
+          result: nil,
+          starting_after: nil,
+          status: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                begin_: Time,
+                category: Lithic::Models::Cards::FinancialTransactionListParams::Category::OrSymbol,
+                end_: Time,
+                ending_before: String,
+                result: Lithic::Models::Cards::FinancialTransactionListParams::Result::OrSymbol,
+                starting_after: String,
+                status: Lithic::Models::Cards::FinancialTransactionListParams::Status::OrSymbol,
+                request_options: Lithic::RequestOptions
+              }
+            )
+        end
+        def to_hash
+        end
+
+        # Financial Transaction category to be returned.
+        module Category
+          extend Lithic::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Lithic::Models::Cards::FinancialTransactionListParams::Category) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, Lithic::Models::Cards::FinancialTransactionListParams::Category::TaggedSymbol) }
+
+          CARD = T.let(:CARD, Lithic::Models::Cards::FinancialTransactionListParams::Category::TaggedSymbol)
+          TRANSFER =
+            T.let(:TRANSFER, Lithic::Models::Cards::FinancialTransactionListParams::Category::TaggedSymbol)
+
+          sig { override.returns(T::Array[Lithic::Models::Cards::FinancialTransactionListParams::Category::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+        # Financial Transaction result to be returned.
+        module Result
+          extend Lithic::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Lithic::Models::Cards::FinancialTransactionListParams::Result) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, Lithic::Models::Cards::FinancialTransactionListParams::Result::TaggedSymbol) }
+
+          APPROVED = T.let(:APPROVED, Lithic::Models::Cards::FinancialTransactionListParams::Result::TaggedSymbol)
+          DECLINED = T.let(:DECLINED, Lithic::Models::Cards::FinancialTransactionListParams::Result::TaggedSymbol)
+
+          sig { override.returns(T::Array[Lithic::Models::Cards::FinancialTransactionListParams::Result::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+        # Financial Transaction status to be returned.
+        module Status
+          extend Lithic::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Lithic::Models::Cards::FinancialTransactionListParams::Status) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, Lithic::Models::Cards::FinancialTransactionListParams::Status::TaggedSymbol) }
+
+          DECLINED = T.let(:DECLINED, Lithic::Models::Cards::FinancialTransactionListParams::Status::TaggedSymbol)
+          EXPIRED = T.let(:EXPIRED, Lithic::Models::Cards::FinancialTransactionListParams::Status::TaggedSymbol)
+          PENDING = T.let(:PENDING, Lithic::Models::Cards::FinancialTransactionListParams::Status::TaggedSymbol)
+          RETURNED = T.let(:RETURNED, Lithic::Models::Cards::FinancialTransactionListParams::Status::TaggedSymbol)
+          SETTLED = T.let(:SETTLED, Lithic::Models::Cards::FinancialTransactionListParams::Status::TaggedSymbol)
+          VOIDED = T.let(:VOIDED, Lithic::Models::Cards::FinancialTransactionListParams::Status::TaggedSymbol)
+
+          sig { override.returns(T::Array[Lithic::Models::Cards::FinancialTransactionListParams::Status::TaggedSymbol]) }
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/cards/financial_transaction_retrieve_params.rbi

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

data/rbi/lib/lithic/models/carrier.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class Carrier < Lithic::BaseModel
+      # QR code url to display on the card carrier
+      sig { returns(T.nilable(String)) }
+      attr_reader :qr_code_url
+
+      sig { params(qr_code_url: String).void }
+      attr_writer :qr_code_url
+
+      sig { params(qr_code_url: String).returns(T.attached_class) }
+      def self.new(qr_code_url: nil)
+      end
+
+      sig { override.returns({qr_code_url: String}) }
+      def to_hash
+      end
+    end
+  end
+end