lithic 0.1.0.pre.alpha.22 → 0.1.0.pre.alpha.24

data/rbi/lithic/models/auth_rules/velocity_limit_params.rbi

@@ -4,21 +4,37 @@ module Lithic
   module Models
     module AuthRules
       class VelocityLimitParams < Lithic::Internal::Type::BaseModel
-        sig { returns(Lithic::Models::AuthRules::VelocityLimitParams::Filters) }
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::AuthRules::VelocityLimitParams,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Lithic::AuthRules::VelocityLimitParams::Filters) }
         attr_reader :filters
 
         sig do
-          params(filters: T.any(Lithic::Models::AuthRules::VelocityLimitParams::Filters, Lithic::Internal::AnyHash))
-            .void
+          params(
+            filters: Lithic::AuthRules::VelocityLimitParams::Filters::OrHash
+          ).void
         end
         attr_writer :filters
 
         # The size of the trailing window to calculate Spend Velocity over in seconds. The
         # minimum value is 10 seconds, and the maximum value is 2678400 seconds (31 days).
-        sig { returns(T.any(Integer, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::OrSymbol)) }
+        sig do
+          returns(
+            T.any(
+              Integer,
+              Lithic::AuthRules::VelocityLimitParamsPeriodWindow::OrSymbol
+            )
+          )
+        end
         attr_accessor :period
 
-        sig { returns(Lithic::Models::AuthRules::VelocityLimitParams::Scope::OrSymbol) }
+        sig { returns(Lithic::AuthRules::VelocityLimitParams::Scope::OrSymbol) }
         attr_accessor :scope
 
         # The maximum amount of spend velocity allowed in the period in minor units (the
@@ -37,13 +53,16 @@ module Lithic
 
         sig do
           params(
-            filters: T.any(Lithic::Models::AuthRules::VelocityLimitParams::Filters, Lithic::Internal::AnyHash),
-            period: T.any(Integer, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::OrSymbol),
-            scope: Lithic::Models::AuthRules::VelocityLimitParams::Scope::OrSymbol,
+            filters: Lithic::AuthRules::VelocityLimitParams::Filters::OrHash,
+            period:
+              T.any(
+                Integer,
+                Lithic::AuthRules::VelocityLimitParamsPeriodWindow::OrSymbol
+              ),
+            scope: Lithic::AuthRules::VelocityLimitParams::Scope::OrSymbol,
             limit_amount: T.nilable(Integer),
             limit_count: T.nilable(Integer)
-          )
-            .returns(T.attached_class)
+          ).returns(T.attached_class)
         end
         def self.new(
           filters:,
@@ -61,22 +80,36 @@ module Lithic
           # settled, or a force post (a transaction that settled without prior
           # authorization).
           limit_count: nil
-        ); end
+        )
+        end
+
         sig do
-          override
-            .returns(
-              {
-                filters: Lithic::Models::AuthRules::VelocityLimitParams::Filters,
-                period: T.any(Integer, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::OrSymbol),
-                scope: Lithic::Models::AuthRules::VelocityLimitParams::Scope::OrSymbol,
-                limit_amount: T.nilable(Integer),
-                limit_count: T.nilable(Integer)
-              }
-            )
+          override.returns(
+            {
+              filters: Lithic::AuthRules::VelocityLimitParams::Filters,
+              period:
+                T.any(
+                  Integer,
+                  Lithic::AuthRules::VelocityLimitParamsPeriodWindow::OrSymbol
+                ),
+              scope: Lithic::AuthRules::VelocityLimitParams::Scope::OrSymbol,
+              limit_amount: T.nilable(Integer),
+              limit_count: T.nilable(Integer)
+            }
+          )
+        end
+        def to_hash
         end
-        def to_hash; end
 
         class Filters < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::AuthRules::VelocityLimitParams::Filters,
+                Lithic::Internal::AnyHash
+              )
+            end
+
           # ISO-3166-1 alpha-3 Country Codes to exclude from the velocity calculation.
           # Transactions matching any of the provided will be excluded from the calculated
           # velocity.
@@ -105,8 +138,7 @@ module Lithic
               exclude_mccs: T.nilable(T::Array[String]),
               include_countries: T.nilable(T::Array[String]),
               include_mccs: T.nilable(T::Array[String])
-            )
-              .returns(T.attached_class)
+            ).returns(T.attached_class)
           end
           def self.new(
             # ISO-3166-1 alpha-3 Country Codes to exclude from the velocity calculation.
@@ -123,19 +155,21 @@ module Lithic
             # Merchant Category Codes to include in the velocity calculation. Transactions not
             # matching this MCC will not be included in the calculated velocity.
             include_mccs: nil
-          ); end
+          )
+          end
+
           sig do
-            override
-              .returns(
-                {
-                  exclude_countries: T.nilable(T::Array[String]),
-                  exclude_mccs: T.nilable(T::Array[String]),
-                  include_countries: T.nilable(T::Array[String]),
-                  include_mccs: T.nilable(T::Array[String])
-                }
-              )
+            override.returns(
+              {
+                exclude_countries: T.nilable(T::Array[String]),
+                exclude_mccs: T.nilable(T::Array[String]),
+                include_countries: T.nilable(T::Array[String]),
+                include_mccs: T.nilable(T::Array[String])
+              }
+            )
+          end
+          def to_hash
           end
-          def to_hash; end
         end
 
         # The size of the trailing window to calculate Spend Velocity over in seconds. The
@@ -143,21 +177,52 @@ module Lithic
         module Period
           extend Lithic::Internal::Type::Union
 
-          sig { override.returns([Integer, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol]) }
-          def self.variants; end
+          Variants =
+            T.type_alias do
+              T.any(
+                Integer,
+                Lithic::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol
+              )
+            end
+
+          sig do
+            override.returns(
+              T::Array[Lithic::AuthRules::VelocityLimitParams::Period::Variants]
+            )
+          end
+          def self.variants
+          end
         end
 
         module Scope
           extend Lithic::Internal::Type::Enum
 
-          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AuthRules::VelocityLimitParams::Scope) }
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Lithic::AuthRules::VelocityLimitParams::Scope)
+            end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          CARD = T.let(:CARD, Lithic::Models::AuthRules::VelocityLimitParams::Scope::TaggedSymbol)
-          ACCOUNT = T.let(:ACCOUNT, Lithic::Models::AuthRules::VelocityLimitParams::Scope::TaggedSymbol)
+          CARD =
+            T.let(
+              :CARD,
+              Lithic::AuthRules::VelocityLimitParams::Scope::TaggedSymbol
+            )
+          ACCOUNT =
+            T.let(
+              :ACCOUNT,
+              Lithic::AuthRules::VelocityLimitParams::Scope::TaggedSymbol
+            )
 
-          sig { override.returns(T::Array[Lithic::Models::AuthRules::VelocityLimitParams::Scope::TaggedSymbol]) }
-          def self.values; end
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::AuthRules::VelocityLimitParams::Scope::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
         end
       end
     end

data/rbi/lithic/models/auth_rules/velocity_limit_params_period_window.rbi

@@ -13,15 +13,37 @@ module Lithic
       module VelocityLimitParamsPeriodWindow
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::AuthRules::VelocityLimitParamsPeriodWindow)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        DAY = T.let(:DAY, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol)
-        WEEK = T.let(:WEEK, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol)
-        MONTH = T.let(:MONTH, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol)
+        DAY =
+          T.let(
+            :DAY,
+            Lithic::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol
+          )
+        WEEK =
+          T.let(
+            :WEEK,
+            Lithic::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol
+          )
+        MONTH =
+          T.let(
+            :MONTH,
+            Lithic::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
     end
   end

data/rbi/lithic/models/auth_stream_enrollment_retrieve_secret_params.rbi

@@ -6,18 +6,25 @@ module Lithic
       extend Lithic::Internal::Type::RequestParameters::Converter
       include Lithic::Internal::Type::RequestParameters
 
-      sig do
-        params(
-          request_options: T.any(
-            Lithic::RequestOptions,
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::AuthStreamEnrollmentRetrieveSecretParams,
             Lithic::Internal::AnyHash
           )
-        ).returns(T.attached_class)
+        end
+
+      sig do
+        params(request_options: Lithic::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
       end
-      def self.new(request_options: {}); end
 
-      sig { override.returns({request_options: Lithic::RequestOptions}) }
-      def to_hash; end
+      sig { override.returns({ request_options: Lithic::RequestOptions }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/lithic/models/auth_stream_enrollment_rotate_secret_params.rbi

@@ -6,18 +6,25 @@ module Lithic
       extend Lithic::Internal::Type::RequestParameters::Converter
       include Lithic::Internal::Type::RequestParameters
 
-      sig do
-        params(
-          request_options: T.any(
-            Lithic::RequestOptions,
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::AuthStreamEnrollmentRotateSecretParams,
             Lithic::Internal::AnyHash
           )
-        ).returns(T.attached_class)
+        end
+
+      sig do
+        params(request_options: Lithic::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
       end
-      def self.new(request_options: {}); end
 
-      sig { override.returns({request_options: Lithic::RequestOptions}) }
-      def to_hash; end
+      sig { override.returns({ request_options: Lithic::RequestOptions }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/lithic/models/auth_stream_secret.rbi

@@ -3,6 +3,11 @@
 module Lithic
   module Models
     class AuthStreamSecret < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::AuthStreamSecret, Lithic::Internal::AnyHash)
+        end
+
       # The shared HMAC ASA secret
       sig { returns(T.nilable(String)) }
       attr_reader :secret
@@ -14,9 +19,12 @@ module Lithic
       def self.new(
         # The shared HMAC ASA secret
         secret: nil
-      ); end
-      sig { override.returns({secret: String}) }
-      def to_hash; end
+      )
+      end
+
+      sig { override.returns({ secret: String }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/lithic/models/balance.rbi

@@ -3,6 +3,9 @@
 module Lithic
   module Models
     class Balance < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Lithic::Balance, 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
@@ -20,7 +23,7 @@ module Lithic
       attr_accessor :financial_account_token
 
       # Type of financial account.
-      sig { returns(Lithic::Models::Balance::FinancialAccountType::TaggedSymbol) }
+      sig { returns(Lithic::Balance::FinancialAccountType::TaggedSymbol) }
       attr_accessor :financial_account_type
 
       # Globally unique identifier for the last financial transaction event that
@@ -54,14 +57,14 @@ module Lithic
           created: Time,
           currency: String,
           financial_account_token: String,
-          financial_account_type: Lithic::Models::Balance::FinancialAccountType::OrSymbol,
+          financial_account_type:
+            Lithic::Balance::FinancialAccountType::OrSymbol,
           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 +91,51 @@ 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_token: String,
-              financial_account_type: Lithic::Models::Balance::FinancialAccountType::TaggedSymbol,
-              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_token: String,
+            financial_account_type:
+              Lithic::Balance::FinancialAccountType::TaggedSymbol,
+            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::Balance::FinancialAccountType) }
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::Balance::FinancialAccountType) }
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        ISSUING = T.let(:ISSUING, Lithic::Models::Balance::FinancialAccountType::TaggedSymbol)
-        OPERATING = T.let(:OPERATING, Lithic::Models::Balance::FinancialAccountType::TaggedSymbol)
-        RESERVE = T.let(:RESERVE, Lithic::Models::Balance::FinancialAccountType::TaggedSymbol)
+        ISSUING =
+          T.let(:ISSUING, Lithic::Balance::FinancialAccountType::TaggedSymbol)
+        OPERATING =
+          T.let(:OPERATING, Lithic::Balance::FinancialAccountType::TaggedSymbol)
+        RESERVE =
+          T.let(:RESERVE, Lithic::Balance::FinancialAccountType::TaggedSymbol)
 
-        sig { override.returns(T::Array[Lithic::Models::Balance::FinancialAccountType::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[Lithic::Balance::FinancialAccountType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
       end
     end
   end

data/rbi/lithic/models/balance_list_params.rbi

@@ -6,6 +6,11 @@ module Lithic
       extend Lithic::Internal::Type::RequestParameters::Converter
       include Lithic::Internal::Type::RequestParameters
 
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::BalanceListParams, Lithic::Internal::AnyHash)
+        end
+
       # List balances for all financial accounts of a given account_token.
       sig { returns(T.nilable(String)) }
       attr_reader :account_token
@@ -29,10 +34,19 @@ module Lithic
       attr_writer :business_account_token
 
       # List balances for a given Financial Account type.
-      sig { returns(T.nilable(Lithic::Models::BalanceListParams::FinancialAccountType::OrSymbol)) }
+      sig do
+        returns(
+          T.nilable(Lithic::BalanceListParams::FinancialAccountType::OrSymbol)
+        )
+      end
       attr_reader :financial_account_type
 
-      sig { params(financial_account_type: Lithic::Models::BalanceListParams::FinancialAccountType::OrSymbol).void }
+      sig do
+        params(
+          financial_account_type:
+            Lithic::BalanceListParams::FinancialAccountType::OrSymbol
+        ).void
+      end
       attr_writer :financial_account_type
 
       sig do
@@ -40,10 +54,10 @@ module Lithic
           account_token: String,
           balance_date: Time,
           business_account_token: String,
-          financial_account_type: Lithic::Models::BalanceListParams::FinancialAccountType::OrSymbol,
-          request_options: T.any(Lithic::RequestOptions, Lithic::Internal::AnyHash)
-        )
-          .returns(T.attached_class)
+          financial_account_type:
+            Lithic::BalanceListParams::FinancialAccountType::OrSymbol,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
       def self.new(
         # List balances for all financial accounts of a given account_token.
@@ -56,34 +70,59 @@ module Lithic
         # List balances for a given Financial Account type.
         financial_account_type: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       sig do
-        override
-          .returns(
-            {
-              account_token: String,
-              balance_date: Time,
-              business_account_token: String,
-              financial_account_type: Lithic::Models::BalanceListParams::FinancialAccountType::OrSymbol,
-              request_options: Lithic::RequestOptions
-            }
-          )
+        override.returns(
+          {
+            account_token: String,
+            balance_date: Time,
+            business_account_token: String,
+            financial_account_type:
+              Lithic::BalanceListParams::FinancialAccountType::OrSymbol,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
+      def to_hash
       end
-      def to_hash; end
 
       # List balances for a given Financial Account type.
       module FinancialAccountType
         extend Lithic::Internal::Type::Enum
 
-        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::BalanceListParams::FinancialAccountType) }
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::BalanceListParams::FinancialAccountType)
+          end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-        ISSUING = T.let(:ISSUING, Lithic::Models::BalanceListParams::FinancialAccountType::TaggedSymbol)
-        OPERATING = T.let(:OPERATING, Lithic::Models::BalanceListParams::FinancialAccountType::TaggedSymbol)
-        RESERVE = T.let(:RESERVE, Lithic::Models::BalanceListParams::FinancialAccountType::TaggedSymbol)
+        ISSUING =
+          T.let(
+            :ISSUING,
+            Lithic::BalanceListParams::FinancialAccountType::TaggedSymbol
+          )
+        OPERATING =
+          T.let(
+            :OPERATING,
+            Lithic::BalanceListParams::FinancialAccountType::TaggedSymbol
+          )
+        RESERVE =
+          T.let(
+            :RESERVE,
+            Lithic::BalanceListParams::FinancialAccountType::TaggedSymbol
+          )
 
-        sig { override.returns(T::Array[Lithic::Models::BalanceListParams::FinancialAccountType::TaggedSymbol]) }
-        def self.values; end
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::BalanceListParams::FinancialAccountType::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
       end
     end
   end