lithic 0.6.0 → 0.8.0

data/rbi/lithic/models/hold.rbi

@@ -0,0 +1,183 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class Hold < Lithic::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(Lithic::Hold, Lithic::Internal::AnyHash) }
+
+      # Unique identifier for the transaction
+      sig { returns(String) }
+      attr_accessor :token
+
+      # ISO 8601 timestamp of when the transaction was created
+      sig { returns(Time) }
+      attr_accessor :created
+
+      # Status of a hold transaction
+      sig { returns(Lithic::Hold::Status::TaggedSymbol) }
+      attr_accessor :status
+
+      # ISO 8601 timestamp of when the transaction was last updated
+      sig { returns(Time) }
+      attr_accessor :updated
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :currency
+
+      sig { params(currency: String).void }
+      attr_writer :currency
+
+      sig { returns(T.nilable(T::Array[Lithic::HoldEvent])) }
+      attr_reader :events
+
+      sig { params(events: T::Array[Lithic::HoldEvent::OrHash]).void }
+      attr_writer :events
+
+      # When the hold will auto-expire if not resolved
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :expiration_datetime
+
+      # HOLD - Hold Transaction
+      sig { returns(T.nilable(Lithic::Hold::Family::TaggedSymbol)) }
+      attr_reader :family
+
+      sig { params(family: Lithic::Hold::Family::OrSymbol).void }
+      attr_writer :family
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :financial_account_token
+
+      sig { params(financial_account_token: String).void }
+      attr_writer :financial_account_token
+
+      # Current pending amount (0 when resolved)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :pending_amount
+
+      sig { params(pending_amount: Integer).void }
+      attr_writer :pending_amount
+
+      sig { returns(T.nilable(Lithic::Hold::Result::TaggedSymbol)) }
+      attr_reader :result
+
+      sig { params(result: Lithic::Hold::Result::OrSymbol).void }
+      attr_writer :result
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :user_defined_id
+
+      # A hold transaction representing reserved funds on a financial account. Holds
+      # move funds from available to pending balance in anticipation of future payments.
+      # They can be resolved via settlement (linked to payment), manual release, or
+      # expiration.
+      sig do
+        params(
+          token: String,
+          created: Time,
+          status: Lithic::Hold::Status::OrSymbol,
+          updated: Time,
+          currency: String,
+          events: T::Array[Lithic::HoldEvent::OrHash],
+          expiration_datetime: T.nilable(Time),
+          family: Lithic::Hold::Family::OrSymbol,
+          financial_account_token: String,
+          pending_amount: Integer,
+          result: Lithic::Hold::Result::OrSymbol,
+          user_defined_id: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier for the transaction
+        token:,
+        # ISO 8601 timestamp of when the transaction was created
+        created:,
+        # Status of a hold transaction
+        status:,
+        # ISO 8601 timestamp of when the transaction was last updated
+        updated:,
+        currency: nil,
+        events: nil,
+        # When the hold will auto-expire if not resolved
+        expiration_datetime: nil,
+        # HOLD - Hold Transaction
+        family: nil,
+        financial_account_token: nil,
+        # Current pending amount (0 when resolved)
+        pending_amount: nil,
+        result: nil,
+        user_defined_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            token: String,
+            created: Time,
+            status: Lithic::Hold::Status::TaggedSymbol,
+            updated: Time,
+            currency: String,
+            events: T::Array[Lithic::HoldEvent],
+            expiration_datetime: T.nilable(Time),
+            family: Lithic::Hold::Family::TaggedSymbol,
+            financial_account_token: String,
+            pending_amount: Integer,
+            result: Lithic::Hold::Result::TaggedSymbol,
+            user_defined_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Status of a hold transaction
+      module Status
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Hold::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PENDING = T.let(:PENDING, Lithic::Hold::Status::TaggedSymbol)
+        SETTLED = T.let(:SETTLED, Lithic::Hold::Status::TaggedSymbol)
+        EXPIRED = T.let(:EXPIRED, Lithic::Hold::Status::TaggedSymbol)
+        VOIDED = T.let(:VOIDED, Lithic::Hold::Status::TaggedSymbol)
+        DECLINED = T.let(:DECLINED, Lithic::Hold::Status::TaggedSymbol)
+        REVERSED = T.let(:REVERSED, Lithic::Hold::Status::TaggedSymbol)
+        CANCELED = T.let(:CANCELED, Lithic::Hold::Status::TaggedSymbol)
+        RETURNED = T.let(:RETURNED, Lithic::Hold::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Hold::Status::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      # HOLD - Hold Transaction
+      module Family
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Hold::Family) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        HOLD = T.let(:HOLD, Lithic::Hold::Family::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Hold::Family::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      module Result
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Hold::Result) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        APPROVED = T.let(:APPROVED, Lithic::Hold::Result::TaggedSymbol)
+        DECLINED = T.let(:DECLINED, Lithic::Hold::Result::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Hold::Result::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/hold_create_params.rbi

@@ -0,0 +1,90 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class HoldCreateParams < Lithic::Internal::Type::BaseModel
+      extend Lithic::Internal::Type::RequestParameters::Converter
+      include Lithic::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::HoldCreateParams, Lithic::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :financial_account_token
+
+      # Amount to hold in cents
+      sig { returns(Integer) }
+      attr_accessor :amount
+
+      # Customer-provided token for idempotency. Becomes the hold token.
+      sig { returns(T.nilable(String)) }
+      attr_reader :token
+
+      sig { params(token: String).void }
+      attr_writer :token
+
+      # When the hold should auto-expire
+      sig { returns(T.nilable(Time)) }
+      attr_reader :expiration_datetime
+
+      sig { params(expiration_datetime: Time).void }
+      attr_writer :expiration_datetime
+
+      # Reason for the hold
+      sig { returns(T.nilable(String)) }
+      attr_accessor :memo
+
+      # User-provided identifier for the hold
+      sig { returns(T.nilable(String)) }
+      attr_reader :user_defined_id
+
+      sig { params(user_defined_id: String).void }
+      attr_writer :user_defined_id
+
+      sig do
+        params(
+          financial_account_token: String,
+          amount: Integer,
+          token: String,
+          expiration_datetime: Time,
+          memo: T.nilable(String),
+          user_defined_id: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        financial_account_token:,
+        # Amount to hold in cents
+        amount:,
+        # Customer-provided token for idempotency. Becomes the hold token.
+        token: nil,
+        # When the hold should auto-expire
+        expiration_datetime: nil,
+        # Reason for the hold
+        memo: nil,
+        # User-provided identifier for the hold
+        user_defined_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            financial_account_token: String,
+            amount: Integer,
+            token: String,
+            expiration_datetime: Time,
+            memo: T.nilable(String),
+            user_defined_id: String,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/hold_event.rbi

@@ -0,0 +1,148 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class HoldEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Lithic::HoldEvent, Lithic::Internal::AnyHash) }
+
+      sig { returns(String) }
+      attr_accessor :token
+
+      # Amount in cents
+      sig { returns(Integer) }
+      attr_accessor :amount
+
+      sig { returns(Time) }
+      attr_accessor :created
+
+      sig { returns(T::Array[Lithic::HoldEvent::DetailedResult::TaggedSymbol]) }
+      attr_accessor :detailed_results
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :memo
+
+      sig { returns(Lithic::HoldEvent::Result::TaggedSymbol) }
+      attr_accessor :result
+
+      # Transaction token of the payment that settled this hold (only populated for
+      # HOLD_SETTLED events)
+      sig { returns(T.nilable(String)) }
+      attr_accessor :settling_transaction_token
+
+      # Type of hold lifecycle event
+      sig { returns(Lithic::HoldEvent::Type::TaggedSymbol) }
+      attr_accessor :type
+
+      # Event representing a lifecycle change to a hold
+      sig do
+        params(
+          token: String,
+          amount: Integer,
+          created: Time,
+          detailed_results:
+            T::Array[Lithic::HoldEvent::DetailedResult::OrSymbol],
+          memo: T.nilable(String),
+          result: Lithic::HoldEvent::Result::OrSymbol,
+          settling_transaction_token: T.nilable(String),
+          type: Lithic::HoldEvent::Type::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        token:,
+        # Amount in cents
+        amount:,
+        created:,
+        detailed_results:,
+        memo:,
+        result:,
+        # Transaction token of the payment that settled this hold (only populated for
+        # HOLD_SETTLED events)
+        settling_transaction_token:,
+        # Type of hold lifecycle event
+        type:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            token: String,
+            amount: Integer,
+            created: Time,
+            detailed_results:
+              T::Array[Lithic::HoldEvent::DetailedResult::TaggedSymbol],
+            memo: T.nilable(String),
+            result: Lithic::HoldEvent::Result::TaggedSymbol,
+            settling_transaction_token: T.nilable(String),
+            type: Lithic::HoldEvent::Type::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module DetailedResult
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::HoldEvent::DetailedResult) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        APPROVED =
+          T.let(:APPROVED, Lithic::HoldEvent::DetailedResult::TaggedSymbol)
+        INSUFFICIENT_FUNDS =
+          T.let(
+            :INSUFFICIENT_FUNDS,
+            Lithic::HoldEvent::DetailedResult::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Lithic::HoldEvent::DetailedResult::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module Result
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::HoldEvent::Result) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        APPROVED = T.let(:APPROVED, Lithic::HoldEvent::Result::TaggedSymbol)
+        DECLINED = T.let(:DECLINED, Lithic::HoldEvent::Result::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Lithic::HoldEvent::Result::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+
+      # Type of hold lifecycle event
+      module Type
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::HoldEvent::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        HOLD_INITIATED =
+          T.let(:HOLD_INITIATED, Lithic::HoldEvent::Type::TaggedSymbol)
+        HOLD_VOIDED = T.let(:HOLD_VOIDED, Lithic::HoldEvent::Type::TaggedSymbol)
+        HOLD_EXPIRED =
+          T.let(:HOLD_EXPIRED, Lithic::HoldEvent::Type::TaggedSymbol)
+        HOLD_SETTLED =
+          T.let(:HOLD_SETTLED, Lithic::HoldEvent::Type::TaggedSymbol)
+
+        sig do
+          override.returns(T::Array[Lithic::HoldEvent::Type::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/hold_list_params.rbi

@@ -0,0 +1,137 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class HoldListParams < Lithic::Internal::Type::BaseModel
+      extend Lithic::Internal::Type::RequestParameters::Converter
+      include Lithic::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::HoldListParams, Lithic::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :financial_account_token
+
+      # 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_
+
+      # 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
+
+      # 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
+
+      # Hold status to filter by.
+      sig { returns(T.nilable(Lithic::HoldListParams::Status::OrSymbol)) }
+      attr_reader :status
+
+      sig { params(status: Lithic::HoldListParams::Status::OrSymbol).void }
+      attr_writer :status
+
+      sig do
+        params(
+          financial_account_token: String,
+          begin_: Time,
+          end_: Time,
+          ending_before: String,
+          page_size: Integer,
+          starting_after: String,
+          status: Lithic::HoldListParams::Status::OrSymbol,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        financial_account_token:,
+        # Date string in RFC 3339 format. Only entries created after the specified time
+        # will be included. UTC time zone.
+        begin_: 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,
+        # 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,
+        # Hold status to filter by.
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            financial_account_token: String,
+            begin_: Time,
+            end_: Time,
+            ending_before: String,
+            page_size: Integer,
+            starting_after: String,
+            status: Lithic::HoldListParams::Status::OrSymbol,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Hold status to filter by.
+      module Status
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::HoldListParams::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PENDING = T.let(:PENDING, Lithic::HoldListParams::Status::TaggedSymbol)
+        SETTLED = T.let(:SETTLED, Lithic::HoldListParams::Status::TaggedSymbol)
+        EXPIRED = T.let(:EXPIRED, Lithic::HoldListParams::Status::TaggedSymbol)
+        VOIDED = T.let(:VOIDED, Lithic::HoldListParams::Status::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Lithic::HoldListParams::Status::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/hold_retrieve_params.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class HoldRetrieveParams < Lithic::Internal::Type::BaseModel
+      extend Lithic::Internal::Type::RequestParameters::Converter
+      include Lithic::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::HoldRetrieveParams, Lithic::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :hold_token
+
+      sig do
+        params(
+          hold_token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(hold_token:, request_options: {})
+      end
+
+      sig do
+        override.returns(
+          { hold_token: String, request_options: Lithic::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/hold_void_params.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class HoldVoidParams < Lithic::Internal::Type::BaseModel
+      extend Lithic::Internal::Type::RequestParameters::Converter
+      include Lithic::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::HoldVoidParams, Lithic::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :hold_token
+
+      # Reason for voiding the hold
+      sig { returns(T.nilable(String)) }
+      attr_accessor :memo
+
+      sig do
+        params(
+          hold_token: String,
+          memo: T.nilable(String),
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        hold_token:,
+        # Reason for voiding the hold
+        memo: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            hold_token: String,
+            memo: T.nilable(String),
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/instance_financial_account_type.rbi

@@ -45,6 +45,11 @@ module Lithic
           :PROGRAM_BANK_ACCOUNTS_PAYABLE,
           Lithic::InstanceFinancialAccountType::TaggedSymbol
         )
+      EARLY_DIRECT_DEPOSIT_FLOAT =
+        T.let(
+          :EARLY_DIRECT_DEPOSIT_FLOAT,
+          Lithic::InstanceFinancialAccountType::TaggedSymbol
+        )
 
       sig do
         override.returns(