lithic 0.1.0.pre.alpha.22 → 0.1.0.pre.alpha.23

data/rbi/lithic/models/card_spend_limits.rbi

@@ -3,55 +3,67 @@
 module Lithic
   module Models
     class CardSpendLimits < Lithic::Internal::Type::BaseModel
-      sig { returns(Lithic::Models::CardSpendLimits::AvailableSpendLimit) }
+      OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
+      sig { returns(Lithic::CardSpendLimits::AvailableSpendLimit) }
       attr_reader :available_spend_limit
 
       sig do
         params(
-          available_spend_limit: T.any(Lithic::Models::CardSpendLimits::AvailableSpendLimit, Lithic::Internal::AnyHash)
-        )
-          .void
+          available_spend_limit:
+            Lithic::CardSpendLimits::AvailableSpendLimit::OrHash
+        ).void
       end
       attr_writer :available_spend_limit
 
-      sig { returns(T.nilable(Lithic::Models::CardSpendLimits::SpendLimit)) }
+      sig { returns(T.nilable(Lithic::CardSpendLimits::SpendLimit)) }
       attr_reader :spend_limit
 
-      sig { params(spend_limit: T.any(Lithic::Models::CardSpendLimits::SpendLimit, Lithic::Internal::AnyHash)).void }
+      sig do
+        params(spend_limit: Lithic::CardSpendLimits::SpendLimit::OrHash).void
+      end
       attr_writer :spend_limit
 
-      sig { returns(T.nilable(Lithic::Models::CardSpendLimits::SpendVelocity)) }
+      sig { returns(T.nilable(Lithic::CardSpendLimits::SpendVelocity)) }
       attr_reader :spend_velocity
 
       sig do
-        params(spend_velocity: T.any(Lithic::Models::CardSpendLimits::SpendVelocity, Lithic::Internal::AnyHash))
-          .void
+        params(
+          spend_velocity: Lithic::CardSpendLimits::SpendVelocity::OrHash
+        ).void
       end
       attr_writer :spend_velocity
 
       sig do
         params(
-          available_spend_limit: T.any(Lithic::Models::CardSpendLimits::AvailableSpendLimit, Lithic::Internal::AnyHash),
-          spend_limit: T.any(Lithic::Models::CardSpendLimits::SpendLimit, Lithic::Internal::AnyHash),
-          spend_velocity: T.any(Lithic::Models::CardSpendLimits::SpendVelocity, Lithic::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          available_spend_limit:
+            Lithic::CardSpendLimits::AvailableSpendLimit::OrHash,
+          spend_limit: Lithic::CardSpendLimits::SpendLimit::OrHash,
+          spend_velocity: Lithic::CardSpendLimits::SpendVelocity::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        available_spend_limit:,
+        spend_limit: nil,
+        spend_velocity: nil
+      )
       end
-      def self.new(available_spend_limit:, spend_limit: nil, spend_velocity: nil); end
 
       sig do
-        override
-          .returns(
-            {
-              available_spend_limit: Lithic::Models::CardSpendLimits::AvailableSpendLimit,
-              spend_limit: Lithic::Models::CardSpendLimits::SpendLimit,
-              spend_velocity: Lithic::Models::CardSpendLimits::SpendVelocity
-            }
-          )
+        override.returns(
+          {
+            available_spend_limit: Lithic::CardSpendLimits::AvailableSpendLimit,
+            spend_limit: Lithic::CardSpendLimits::SpendLimit,
+            spend_velocity: Lithic::CardSpendLimits::SpendVelocity
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       class AvailableSpendLimit < Lithic::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         # The available spend limit (in cents) relative to the annual limit configured on
         # the Card (e.g. 100000 would be a $1,000 limit).
         sig { returns(T.nilable(Integer)) }
@@ -76,7 +88,11 @@ module Lithic
         sig { params(monthly: Integer).void }
         attr_writer :monthly
 
-        sig { params(annually: Integer, forever: Integer, monthly: Integer).returns(T.attached_class) }
+        sig do
+          params(annually: Integer, forever: Integer, monthly: Integer).returns(
+            T.attached_class
+          )
+        end
         def self.new(
           # The available spend limit (in cents) relative to the annual limit configured on
           # the Card (e.g. 100000 would be a $1,000 limit).
@@ -87,12 +103,21 @@ module Lithic
           # The available spend limit (in cents) relative to the monthly limit configured on
           # the Card.
           monthly: nil
-        ); end
-        sig { override.returns({annually: Integer, forever: Integer, monthly: Integer}) }
-        def to_hash; end
+        )
+        end
+
+        sig do
+          override.returns(
+            { annually: Integer, forever: Integer, monthly: Integer }
+          )
+        end
+        def to_hash
+        end
       end
 
       class SpendLimit < Lithic::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         # The configured annual spend limit (in cents) on the Card.
         sig { returns(T.nilable(Integer)) }
         attr_reader :annually
@@ -114,7 +139,11 @@ module Lithic
         sig { params(monthly: Integer).void }
         attr_writer :monthly
 
-        sig { params(annually: Integer, forever: Integer, monthly: Integer).returns(T.attached_class) }
+        sig do
+          params(annually: Integer, forever: Integer, monthly: Integer).returns(
+            T.attached_class
+          )
+        end
         def self.new(
           # The configured annual spend limit (in cents) on the Card.
           annually: nil,
@@ -122,12 +151,21 @@ module Lithic
           forever: nil,
           # The configured monthly spend limit (in cents) on the Card.
           monthly: nil
-        ); end
-        sig { override.returns({annually: Integer, forever: Integer, monthly: Integer}) }
-        def to_hash; end
+        )
+        end
+
+        sig do
+          override.returns(
+            { annually: Integer, forever: Integer, monthly: Integer }
+          )
+        end
+        def to_hash
+        end
       end
 
       class SpendVelocity < Lithic::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         # Current annual spend velocity (in cents) on the Card. Present if annual spend
         # limit is set.
         sig { returns(T.nilable(Integer)) }
@@ -152,7 +190,11 @@ module Lithic
         sig { params(monthly: Integer).void }
         attr_writer :monthly
 
-        sig { params(annually: Integer, forever: Integer, monthly: Integer).returns(T.attached_class) }
+        sig do
+          params(annually: Integer, forever: Integer, monthly: Integer).returns(
+            T.attached_class
+          )
+        end
         def self.new(
           # Current annual spend velocity (in cents) on the Card. Present if annual spend
           # limit is set.
@@ -163,9 +205,16 @@ module Lithic
           # Current monthly spend velocity (in cents) on the Card. Present if monthly spend
           # limit is set.
           monthly: nil
-        ); end
-        sig { override.returns({annually: Integer, forever: Integer, monthly: Integer}) }
-        def to_hash; end
+        )
+        end
+
+        sig do
+          override.returns(
+            { annually: Integer, forever: Integer, monthly: Integer }
+          )
+        end
+        def to_hash
+        end
       end
     end
   end

data/rbi/lithic/models/card_update_params.rbi

@@ -6,6 +6,8 @@ module Lithic
       extend Lithic::Internal::Type::RequestParameters::Converter
       include Lithic::Internal::Type::RequestParameters
 
+      OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
       # 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
@@ -34,10 +36,12 @@ module Lithic
 
       # 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)) }
+      sig { returns(T.nilable(Lithic::CardUpdateParams::PinStatus::OrSymbol)) }
       attr_reader :pin_status
 
-      sig { params(pin_status: Lithic::Models::CardUpdateParams::PinStatus::OrSymbol).void }
+      sig do
+        params(pin_status: Lithic::CardUpdateParams::PinStatus::OrSymbol).void
+      end
       attr_writer :pin_status
 
       # Amount (in cents) to limit approved authorizations (e.g. 100000 would be a
@@ -63,10 +67,12 @@ module Lithic
       #   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)) }
+      sig { returns(T.nilable(Lithic::SpendLimitDuration::OrSymbol)) }
       attr_reader :spend_limit_duration
 
-      sig { params(spend_limit_duration: Lithic::Models::SpendLimitDuration::OrSymbol).void }
+      sig do
+        params(spend_limit_duration: Lithic::SpendLimitDuration::OrSymbol).void
+      end
       attr_writer :spend_limit_duration
 
       # Card state values:
@@ -77,10 +83,10 @@ module Lithic
       #   parameters).
       # - `PAUSED` - Card will decline authorizations, but can be resumed at a later
       #   time.
-      sig { returns(T.nilable(Lithic::Models::CardUpdateParams::State::OrSymbol)) }
+      sig { returns(T.nilable(Lithic::CardUpdateParams::State::OrSymbol)) }
       attr_reader :state
 
-      sig { params(state: Lithic::Models::CardUpdateParams::State::OrSymbol).void }
+      sig { params(state: Lithic::CardUpdateParams::State::OrSymbol).void }
       attr_writer :state
 
       sig do
@@ -88,13 +94,12 @@ module Lithic
           digital_card_art_token: String,
           memo: String,
           pin: String,
-          pin_status: Lithic::Models::CardUpdateParams::PinStatus::OrSymbol,
+          pin_status: Lithic::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::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          spend_limit_duration: Lithic::SpendLimitDuration::OrSymbol,
+          state: Lithic::CardUpdateParams::State::OrSymbol,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # Specifies the digital card art to be displayed in the user’s digital wallet
@@ -140,36 +145,44 @@ module Lithic
         #   time.
         state: nil,
         request_options: {}
-      ); end
+      )
+      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
-            }
-          )
+        override.returns(
+          {
+            digital_card_art_token: String,
+            memo: String,
+            pin: String,
+            pin_status: Lithic::CardUpdateParams::PinStatus::OrSymbol,
+            spend_limit: Integer,
+            spend_limit_duration: Lithic::SpendLimitDuration::OrSymbol,
+            state: Lithic::CardUpdateParams::State::OrSymbol,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
       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::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::CardUpdateParams::PinStatus) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::CardUpdateParams::PinStatus) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        OK = T.let(:OK, Lithic::Models::CardUpdateParams::PinStatus::TaggedSymbol)
+        OK = T.let(:OK, Lithic::CardUpdateParams::PinStatus::TaggedSymbol)
 
-        sig { override.returns(T::Array[Lithic::Models::CardUpdateParams::PinStatus::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[Lithic::CardUpdateParams::PinStatus::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
 
       # Card state values:
@@ -183,15 +196,21 @@ module Lithic
       module State
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::CardUpdateParams::State) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::CardUpdateParams::State) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        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)
+        CLOSED = T.let(:CLOSED, Lithic::CardUpdateParams::State::TaggedSymbol)
+        OPEN = T.let(:OPEN, Lithic::CardUpdateParams::State::TaggedSymbol)
+        PAUSED = T.let(:PAUSED, Lithic::CardUpdateParams::State::TaggedSymbol)
 
-        sig { override.returns(T::Array[Lithic::Models::CardUpdateParams::State::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[Lithic::CardUpdateParams::State::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
     end
   end

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

@@ -7,6 +7,8 @@ module Lithic
         extend Lithic::Internal::Type::RequestParameters::Converter
         include Lithic::Internal::Type::RequestParameters
 
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         # Cardholder to retrieve aggregate balances for.
         sig { returns(T.nilable(String)) }
         attr_reader :account_token
@@ -25,9 +27,8 @@ module Lithic
           params(
             account_token: String,
             business_account_token: String,
-            request_options: T.any(Lithic::RequestOptions, Lithic::Internal::AnyHash)
-          )
-            .returns(T.attached_class)
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(T.attached_class)
         end
         def self.new(
           # Cardholder to retrieve aggregate balances for.
@@ -35,16 +36,20 @@ module Lithic
           # Business to retrieve aggregate balances for.
           business_account_token: nil,
           request_options: {}
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns({
-                       account_token: String,
-                       business_account_token: String,
-                       request_options: Lithic::RequestOptions
-                     })
+          override.returns(
+            {
+              account_token: String,
+              business_account_token: String,
+              request_options: Lithic::RequestOptions
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
     end
   end

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

@@ -4,6 +4,8 @@ module Lithic
   module Models
     module Cards
       class AggregateBalanceListResponse < Lithic::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         # Funds available for spend in the currency's smallest unit (e.g., cents for USD)
         sig { returns(Integer) }
         attr_accessor :available_amount
@@ -56,8 +58,7 @@ module Lithic
             pending_amount: Integer,
             total_amount: Integer,
             updated: Time
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # Funds available for spend in the currency's smallest unit (e.g., cents for USD)
@@ -82,24 +83,26 @@ module Lithic
           total_amount:,
           # Date and time for when the balance was last updated.
           updated:
-        ); end
+        )
+        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
-              }
-            )
+          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
-        def to_hash; end
       end
     end
   end

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

@@ -7,6 +7,8 @@ module Lithic
         extend Lithic::Internal::Type::RequestParameters::Converter
         include Lithic::Internal::Type::RequestParameters
 
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         # UTC date of the balance to retrieve. Defaults to latest available balance
         sig { returns(T.nilable(Time)) }
         attr_reader :balance_date
@@ -27,9 +29,8 @@ module Lithic
           params(
             balance_date: Time,
             last_transaction_event_token: String,
-            request_options: T.any(Lithic::RequestOptions, Lithic::Internal::AnyHash)
-          )
-            .returns(T.attached_class)
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(T.attached_class)
         end
         def self.new(
           # UTC date of the balance to retrieve. Defaults to latest available balance
@@ -39,18 +40,20 @@ module Lithic
           # decreased by $5
           last_transaction_event_token: nil,
           request_options: {}
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                balance_date: Time,
-                last_transaction_event_token: String,
-                request_options: Lithic::RequestOptions
-              }
-            )
+          override.returns(
+            {
+              balance_date: Time,
+              last_transaction_event_token: String,
+              request_options: Lithic::RequestOptions
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
     end
   end

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

@@ -4,6 +4,8 @@ module Lithic
   module Models
     module Cards
       class BalanceListResponse < Lithic::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         # Globally unique identifier for the financial account that holds this balance.
         sig { returns(String) }
         attr_accessor :token
@@ -41,7 +43,11 @@ module Lithic
         attr_accessor :total_amount
 
         # Type of financial account.
-        sig { returns(Lithic::Models::Cards::BalanceListResponse::Type::TaggedSymbol) }
+        sig do
+          returns(
+            Lithic::Models::Cards::BalanceListResponse::Type::TaggedSymbol
+          )
+        end
         attr_accessor :type
 
         # Date and time for when the balance was last updated.
@@ -61,8 +67,7 @@ module Lithic
             total_amount: Integer,
             type: Lithic::Models::Cards::BalanceListResponse::Type::OrSymbol,
             updated: Time
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # Globally unique identifier for the financial account that holds this balance.
@@ -89,39 +94,64 @@ module Lithic
           type:,
           # Date and time for when the balance was last updated.
           updated:
-        ); end
+        )
+        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
-              }
-            )
+          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
-        def to_hash; end
 
         # Type of financial account.
         module Type
           extend Lithic::Internal::Type::Enum
 
-          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::Cards::BalanceListResponse::Type) }
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Lithic::Models::Cards::BalanceListResponse::Type)
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          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)
+          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
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::Models::Cards::BalanceListResponse::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
         end
       end
     end