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

data/rbi/lithic/models/account_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) }
+
       # Amount (in cents) for the account's daily spend limit (e.g. 100000 would be a
       # $1,000 limit). By default the daily spend limit is set to $1,250.
       sig { returns(T.nilable(Integer)) }
@@ -36,24 +38,26 @@ module Lithic
       attr_writer :monthly_spend_limit
 
       # Account states.
-      sig { returns(T.nilable(Lithic::Models::AccountUpdateParams::State::OrSymbol)) }
+      sig { returns(T.nilable(Lithic::AccountUpdateParams::State::OrSymbol)) }
       attr_reader :state
 
-      sig { params(state: Lithic::Models::AccountUpdateParams::State::OrSymbol).void }
+      sig { params(state: Lithic::AccountUpdateParams::State::OrSymbol).void }
       attr_writer :state
 
       # Address used during Address Verification Service (AVS) checks during
       # transactions if enabled via Auth Rules. This field is deprecated as AVS checks
       # are no longer supported by Authorization Rules. The field will be removed from
       # the schema in a future release.
-      sig { returns(T.nilable(Lithic::Models::AccountUpdateParams::VerificationAddress)) }
+      sig do
+        returns(T.nilable(Lithic::AccountUpdateParams::VerificationAddress))
+      end
       attr_reader :verification_address
 
       sig do
         params(
-          verification_address: T.any(Lithic::Models::AccountUpdateParams::VerificationAddress, Lithic::Internal::AnyHash)
-        )
-          .void
+          verification_address:
+            Lithic::AccountUpdateParams::VerificationAddress::OrHash
+        ).void
       end
       attr_writer :verification_address
 
@@ -62,11 +66,11 @@ module Lithic
           daily_spend_limit: Integer,
           lifetime_spend_limit: Integer,
           monthly_spend_limit: Integer,
-          state: Lithic::Models::AccountUpdateParams::State::OrSymbol,
-          verification_address: T.any(Lithic::Models::AccountUpdateParams::VerificationAddress, Lithic::Internal::AnyHash),
-          request_options: T.any(Lithic::RequestOptions, Lithic::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          state: Lithic::AccountUpdateParams::State::OrSymbol,
+          verification_address:
+            Lithic::AccountUpdateParams::VerificationAddress::OrHash,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # Amount (in cents) for the account's daily spend limit (e.g. 100000 would be a
@@ -91,37 +95,50 @@ module Lithic
         # the schema in a future release.
         verification_address: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              daily_spend_limit: Integer,
-              lifetime_spend_limit: Integer,
-              monthly_spend_limit: Integer,
-              state: Lithic::Models::AccountUpdateParams::State::OrSymbol,
-              verification_address: Lithic::Models::AccountUpdateParams::VerificationAddress,
-              request_options: Lithic::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            daily_spend_limit: Integer,
+            lifetime_spend_limit: Integer,
+            monthly_spend_limit: Integer,
+            state: Lithic::AccountUpdateParams::State::OrSymbol,
+            verification_address:
+              Lithic::AccountUpdateParams::VerificationAddress,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       # Account states.
       module State
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AccountUpdateParams::State) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::AccountUpdateParams::State) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        ACTIVE = T.let(:ACTIVE, Lithic::Models::AccountUpdateParams::State::TaggedSymbol)
-        PAUSED = T.let(:PAUSED, Lithic::Models::AccountUpdateParams::State::TaggedSymbol)
+        ACTIVE =
+          T.let(:ACTIVE, Lithic::AccountUpdateParams::State::TaggedSymbol)
+        PAUSED =
+          T.let(:PAUSED, Lithic::AccountUpdateParams::State::TaggedSymbol)
 
-        sig { override.returns(T::Array[Lithic::Models::AccountUpdateParams::State::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[Lithic::AccountUpdateParams::State::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
 
       class VerificationAddress < Lithic::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         sig { returns(T.nilable(String)) }
         attr_reader :address1
 
@@ -170,25 +187,32 @@ module Lithic
             country: String,
             postal_code: String,
             state: String
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          address1: nil,
+          address2: nil,
+          city: nil,
+          country: nil,
+          postal_code: nil,
+          state: nil
+        )
         end
-        def self.new(address1: nil, address2: nil, city: nil, country: nil, postal_code: nil, state: nil); end
 
         sig do
-          override
-            .returns(
-              {
-                address1: String,
-                address2: String,
-                city: String,
-                country: String,
-                postal_code: String,
-                state: String
-              }
-            )
+          override.returns(
+            {
+              address1: String,
+              address2: String,
+              city: String,
+              country: String,
+              postal_code: String,
+              state: String
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
       end
     end
   end

data/rbi/lithic/models/address.rbi

@@ -3,6 +3,8 @@
 module Lithic
   module Models
     class Address < Lithic::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
       # Valid deliverable address (no PO boxes).
       sig { returns(String) }
       attr_accessor :address1
@@ -43,8 +45,7 @@ module Lithic
           postal_code: String,
           state: String,
           address2: String
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         # Valid deliverable address (no PO boxes).
@@ -64,21 +65,23 @@ module Lithic
         state:,
         # Unit or apartment number (if applicable).
         address2: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              address1: String,
-              city: String,
-              country: String,
-              postal_code: String,
-              state: String,
-              address2: String
-            }
-          )
+        override.returns(
+          {
+            address1: String,
+            city: String,
+            country: String,
+            postal_code: String,
+            state: String,
+            address2: String
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
     end
   end
 end

data/rbi/lithic/models/address_update.rbi

@@ -3,6 +3,8 @@
 module Lithic
   module Models
     class AddressUpdate < Lithic::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
       # Valid deliverable address (no PO boxes).
       sig { returns(T.nilable(String)) }
       attr_reader :address1
@@ -56,8 +58,7 @@ module Lithic
           country: String,
           postal_code: String,
           state: String
-        )
-          .returns(T.attached_class)
+        ).returns(T.attached_class)
       end
       def self.new(
         # Valid deliverable address (no PO boxes).
@@ -75,21 +76,23 @@ module Lithic
         # Valid state code. Only USA state codes are currently supported, entered in
         # uppercase ISO 3166-2 two-character format.
         state: nil
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              address1: String,
-              address2: String,
-              city: String,
-              country: String,
-              postal_code: String,
-              state: String
-            }
-          )
+        override.returns(
+          {
+            address1: String,
+            address2: String,
+            city: String,
+            country: String,
+            postal_code: String,
+            state: String
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
     end
   end
 end

data/rbi/lithic/models/aggregate_balance.rbi

@@ -3,6 +3,8 @@
 module Lithic
   module Models
     class AggregateBalance < 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
@@ -16,7 +18,9 @@ module Lithic
       attr_accessor :currency
 
       # Type of financial account
-      sig { returns(Lithic::Models::AggregateBalance::FinancialAccountType::TaggedSymbol) }
+      sig do
+        returns(Lithic::AggregateBalance::FinancialAccountType::TaggedSymbol)
+      end
       attr_accessor :financial_account_type
 
       # Globally unique identifier for the financial account that had its balance
@@ -53,15 +57,15 @@ module Lithic
           available_amount: Integer,
           created: Time,
           currency: String,
-          financial_account_type: Lithic::Models::AggregateBalance::FinancialAccountType::OrSymbol,
+          financial_account_type:
+            Lithic::AggregateBalance::FinancialAccountType::OrSymbol,
           last_financial_account_token: String,
           last_transaction_event_token: String,
           last_transaction_token: String,
           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)
@@ -88,39 +92,64 @@ 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,
-              financial_account_type: Lithic::Models::AggregateBalance::FinancialAccountType::TaggedSymbol,
-              last_financial_account_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,
+            financial_account_type:
+              Lithic::AggregateBalance::FinancialAccountType::TaggedSymbol,
+            last_financial_account_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
 
       # Type of financial account
       module FinancialAccountType
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AggregateBalance::FinancialAccountType) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::AggregateBalance::FinancialAccountType)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        ISSUING = T.let(:ISSUING, Lithic::Models::AggregateBalance::FinancialAccountType::TaggedSymbol)
-        OPERATING = T.let(:OPERATING, Lithic::Models::AggregateBalance::FinancialAccountType::TaggedSymbol)
-        RESERVE = T.let(:RESERVE, Lithic::Models::AggregateBalance::FinancialAccountType::TaggedSymbol)
+        ISSUING =
+          T.let(
+            :ISSUING,
+            Lithic::AggregateBalance::FinancialAccountType::TaggedSymbol
+          )
+        OPERATING =
+          T.let(
+            :OPERATING,
+            Lithic::AggregateBalance::FinancialAccountType::TaggedSymbol
+          )
+        RESERVE =
+          T.let(
+            :RESERVE,
+            Lithic::AggregateBalance::FinancialAccountType::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::AggregateBalance::FinancialAccountType::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::AggregateBalance::FinancialAccountType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
     end
   end

data/rbi/lithic/models/aggregate_balance_list_params.rbi

@@ -6,54 +6,90 @@ 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) }
+
       # Get the aggregate balance for a given Financial Account type.
-      sig { returns(T.nilable(Lithic::Models::AggregateBalanceListParams::FinancialAccountType::OrSymbol)) }
+      sig do
+        returns(
+          T.nilable(
+            Lithic::AggregateBalanceListParams::FinancialAccountType::OrSymbol
+          )
+        )
+      end
       attr_reader :financial_account_type
 
       sig do
-        params(financial_account_type: Lithic::Models::AggregateBalanceListParams::FinancialAccountType::OrSymbol)
-          .void
+        params(
+          financial_account_type:
+            Lithic::AggregateBalanceListParams::FinancialAccountType::OrSymbol
+        ).void
       end
       attr_writer :financial_account_type
 
       sig do
         params(
-          financial_account_type: Lithic::Models::AggregateBalanceListParams::FinancialAccountType::OrSymbol,
-          request_options: T.any(Lithic::RequestOptions, Lithic::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          financial_account_type:
+            Lithic::AggregateBalanceListParams::FinancialAccountType::OrSymbol,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # Get the aggregate balance for a given Financial Account type.
         financial_account_type: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              financial_account_type: Lithic::Models::AggregateBalanceListParams::FinancialAccountType::OrSymbol,
-              request_options: Lithic::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            financial_account_type:
+              Lithic::AggregateBalanceListParams::FinancialAccountType::OrSymbol,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       # Get the aggregate balance for a given Financial Account type.
       module FinancialAccountType
         extend Lithic::Internal::Type::Enum
 
         TaggedSymbol =
-          T.type_alias { T.all(Symbol, Lithic::Models::AggregateBalanceListParams::FinancialAccountType) }
+          T.type_alias do
+            T.all(
+              Symbol,
+              Lithic::AggregateBalanceListParams::FinancialAccountType
+            )
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        ISSUING = T.let(:ISSUING, Lithic::Models::AggregateBalanceListParams::FinancialAccountType::TaggedSymbol)
+        ISSUING =
+          T.let(
+            :ISSUING,
+            Lithic::AggregateBalanceListParams::FinancialAccountType::TaggedSymbol
+          )
         OPERATING =
-          T.let(:OPERATING, Lithic::Models::AggregateBalanceListParams::FinancialAccountType::TaggedSymbol)
-        RESERVE = T.let(:RESERVE, Lithic::Models::AggregateBalanceListParams::FinancialAccountType::TaggedSymbol)
+          T.let(
+            :OPERATING,
+            Lithic::AggregateBalanceListParams::FinancialAccountType::TaggedSymbol
+          )
+        RESERVE =
+          T.let(
+            :RESERVE,
+            Lithic::AggregateBalanceListParams::FinancialAccountType::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::AggregateBalanceListParams::FinancialAccountType::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::AggregateBalanceListParams::FinancialAccountType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
     end
   end

data/rbi/lithic/models/api_status.rbi

@@ -3,6 +3,8 @@
 module Lithic
   module Models
     class APIStatus < Lithic::Internal::Type::BaseModel
+      OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
       sig { returns(T.nilable(String)) }
       attr_reader :message
 
@@ -10,10 +12,12 @@ module Lithic
       attr_writer :message
 
       sig { params(message: String).returns(T.attached_class) }
-      def self.new(message: nil); end
+      def self.new(message: nil)
+      end
 
-      sig { override.returns({message: String}) }
-      def to_hash; end
+      sig { override.returns({ message: String }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/lithic/models/auth_rules/auth_rule.rbi

@@ -6,12 +6,14 @@ module Lithic
 
     module AuthRules
       class AuthRule < Lithic::Internal::Type::BaseModel
+        OrHash = T.type_alias { T.any(T.self_type, Lithic::Internal::AnyHash) }
+
         # Globally unique identifier.
         sig { returns(String) }
         attr_accessor :token
 
         # Indicates whether the Auth Rule is ACTIVE or INACTIVE
-        sig { returns(Lithic::Models::AuthRules::AuthRule::State::OrSymbol) }
+        sig { returns(Lithic::AuthRules::AuthRule::State::OrSymbol) }
         attr_accessor :state
 
         # Array of account_token(s) identifying the accounts that the Auth Rule applies
@@ -72,7 +74,7 @@ module Lithic
         sig do
           params(
             token: String,
-            state: Lithic::Models::AuthRules::AuthRule::State::OrSymbol,
+            state: Lithic::AuthRules::AuthRule::State::OrSymbol,
             account_tokens: T::Array[String],
             allowed_countries: T::Array[String],
             allowed_mcc: T::Array[String],
@@ -80,8 +82,7 @@ module Lithic
             blocked_mcc: T::Array[String],
             card_tokens: T::Array[String],
             program_level: T::Boolean
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           # Globally unique identifier.
@@ -108,37 +109,47 @@ module Lithic
           card_tokens: nil,
           # Boolean indicating whether the Auth Rule is applied at the program level.
           program_level: nil
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                token: String,
-                state: Lithic::Models::AuthRules::AuthRule::State::OrSymbol,
-                account_tokens: T::Array[String],
-                allowed_countries: T::Array[String],
-                allowed_mcc: T::Array[String],
-                blocked_countries: T::Array[String],
-                blocked_mcc: T::Array[String],
-                card_tokens: T::Array[String],
-                program_level: T::Boolean
-              }
-            )
+          override.returns(
+            {
+              token: String,
+              state: Lithic::AuthRules::AuthRule::State::OrSymbol,
+              account_tokens: T::Array[String],
+              allowed_countries: T::Array[String],
+              allowed_mcc: T::Array[String],
+              blocked_countries: T::Array[String],
+              blocked_mcc: T::Array[String],
+              card_tokens: T::Array[String],
+              program_level: T::Boolean
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         # Indicates whether the Auth Rule is ACTIVE or INACTIVE
         module State
           extend Lithic::Internal::Type::Enum
 
-          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AuthRules::AuthRule::State) }
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Lithic::AuthRules::AuthRule::State) }
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          ACTIVE = T.let(:ACTIVE, Lithic::Models::AuthRules::AuthRule::State::TaggedSymbol)
-          INACTIVE = T.let(:INACTIVE, Lithic::Models::AuthRules::AuthRule::State::TaggedSymbol)
+          ACTIVE =
+            T.let(:ACTIVE, Lithic::AuthRules::AuthRule::State::TaggedSymbol)
+          INACTIVE =
+            T.let(:INACTIVE, Lithic::AuthRules::AuthRule::State::TaggedSymbol)
 
-          sig { override.returns(T::Array[Lithic::Models::AuthRules::AuthRule::State::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[Lithic::AuthRules::AuthRule::State::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
         end
       end
     end