lithic 0.1.0.pre.alpha.1

data/rbi/lib/lithic/models/address_update.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class AddressUpdate < Lithic::BaseModel
+      # Valid deliverable address (no PO boxes).
+      sig { returns(T.nilable(String)) }
+      attr_reader :address1
+
+      sig { params(address1: String).void }
+      attr_writer :address1
+
+      # Unit or apartment number (if applicable).
+      sig { returns(T.nilable(String)) }
+      attr_reader :address2
+
+      sig { params(address2: String).void }
+      attr_writer :address2
+
+      # Name of city.
+      sig { returns(T.nilable(String)) }
+      attr_reader :city
+
+      sig { params(city: String).void }
+      attr_writer :city
+
+      # Valid country code. Only USA is currently supported, entered in uppercase ISO
+      #   3166-1 alpha-3 three-character format.
+      sig { returns(T.nilable(String)) }
+      attr_reader :country
+
+      sig { params(country: String).void }
+      attr_writer :country
+
+      # Valid postal code. Only USA ZIP codes are currently supported, entered as a
+      #   five-digit ZIP or nine-digit ZIP+4.
+      sig { returns(T.nilable(String)) }
+      attr_reader :postal_code
+
+      sig { params(postal_code: String).void }
+      attr_writer :postal_code
+
+      # Valid state code. Only USA state codes are currently supported, entered in
+      #   uppercase ISO 3166-2 two-character format.
+      sig { returns(T.nilable(String)) }
+      attr_reader :state
+
+      sig { params(state: String).void }
+      attr_writer :state
+
+      sig do
+        params(
+          address1: String,
+          address2: String,
+          city: String,
+          country: String,
+          postal_code: String,
+          state: String
+        )
+          .returns(T.attached_class)
+      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
+            }
+          )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/aggregate_balance.rbi

@@ -0,0 +1,118 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class AggregateBalance < 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
+
+      # Type of financial account
+      sig { returns(Lithic::Models::AggregateBalance::FinancialAccountType::TaggedSymbol) }
+      attr_accessor :financial_account_type
+
+      # Globally unique identifier for the financial account that had its balance
+      #   updated most recently
+      sig { returns(String) }
+      attr_accessor :last_financial_account_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
+
+      # Aggregate Balance across all end-user accounts
+      sig do
+        params(
+          available_amount: Integer,
+          created: Time,
+          currency: String,
+          financial_account_type: Lithic::Models::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)
+      end
+      def self.new(
+        available_amount:,
+        created:,
+        currency:,
+        financial_account_type:,
+        last_financial_account_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,
+              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
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # Type of financial account
+      module FinancialAccountType
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AggregateBalance::FinancialAccountType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::AggregateBalance::FinancialAccountType::TaggedSymbol) }
+
+        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)
+
+        sig { override.returns(T::Array[Lithic::Models::AggregateBalance::FinancialAccountType::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class AggregateBalanceListParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      # Get the aggregate balance for a given Financial Account type.
+      sig { returns(T.nilable(Lithic::Models::AggregateBalanceListParams::FinancialAccountType::OrSymbol)) }
+      attr_reader :financial_account_type
+
+      sig do
+        params(financial_account_type: Lithic::Models::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::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(financial_account_type: nil, request_options: {})
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              financial_account_type: Lithic::Models::AggregateBalanceListParams::FinancialAccountType::OrSymbol,
+              request_options: Lithic::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # Get the aggregate balance for a given Financial Account type.
+      module FinancialAccountType
+        extend Lithic::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::Models::AggregateBalanceListParams::FinancialAccountType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::AggregateBalanceListParams::FinancialAccountType::TaggedSymbol) }
+
+        ISSUING = T.let(:ISSUING, Lithic::Models::AggregateBalanceListParams::FinancialAccountType::TaggedSymbol)
+        OPERATING =
+          T.let(:OPERATING, Lithic::Models::AggregateBalanceListParams::FinancialAccountType::TaggedSymbol)
+        RESERVE = T.let(:RESERVE, Lithic::Models::AggregateBalanceListParams::FinancialAccountType::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::AggregateBalanceListParams::FinancialAccountType::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/api_status.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class APIStatus < Lithic::BaseModel
+      sig { returns(T.nilable(String)) }
+      attr_reader :message
+
+      sig { params(message: String).void }
+      attr_writer :message
+
+      sig { params(message: String).returns(T.attached_class) }
+      def self.new(message: nil)
+      end
+
+      sig { override.returns({message: String}) }
+      def to_hash
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module AuthRules
+      class AuthRule < Lithic::BaseModel
+        # 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) }
+        attr_accessor :state
+
+        # Array of account_token(s) identifying the accounts that the Auth Rule applies
+        #   to. Note that only this field or `card_tokens` can be provided for a given Auth
+        #   Rule.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :account_tokens
+
+        sig { params(account_tokens: T::Array[String]).void }
+        attr_writer :account_tokens
+
+        # Countries in which the Auth Rule permits transactions. Note that Lithic
+        #   maintains a list of countries in which all transactions are blocked; "allowing"
+        #   those countries in an Auth Rule does not override the Lithic-wide restrictions.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :allowed_countries
+
+        sig { params(allowed_countries: T::Array[String]).void }
+        attr_writer :allowed_countries
+
+        # Merchant category codes for which the Auth Rule permits transactions.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :allowed_mcc
+
+        sig { params(allowed_mcc: T::Array[String]).void }
+        attr_writer :allowed_mcc
+
+        # Countries in which the Auth Rule automatically declines transactions.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :blocked_countries
+
+        sig { params(blocked_countries: T::Array[String]).void }
+        attr_writer :blocked_countries
+
+        # Merchant category codes for which the Auth Rule automatically declines
+        #   transactions.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :blocked_mcc
+
+        sig { params(blocked_mcc: T::Array[String]).void }
+        attr_writer :blocked_mcc
+
+        # Array of card_token(s) identifying the cards that the Auth Rule applies to. Note
+        #   that only this field or `account_tokens` can be provided for a given Auth Rule.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :card_tokens
+
+        sig { params(card_tokens: T::Array[String]).void }
+        attr_writer :card_tokens
+
+        # Boolean indicating whether the Auth Rule is applied at the program level.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :program_level
+
+        sig { params(program_level: T::Boolean).void }
+        attr_writer :program_level
+
+        sig do
+          params(
+            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
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          token:,
+          state:,
+          account_tokens: nil,
+          allowed_countries: nil,
+          allowed_mcc: nil,
+          blocked_countries: nil,
+          blocked_mcc: nil,
+          card_tokens: nil,
+          program_level: nil
+        )
+        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
+              }
+            )
+        end
+        def to_hash
+        end
+
+        # Indicates whether the Auth Rule is ACTIVE or INACTIVE
+        module State
+          extend Lithic::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AuthRules::AuthRule::State) }
+          OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::AuthRules::AuthRule::State::TaggedSymbol) }
+
+          ACTIVE = T.let(:ACTIVE, Lithic::Models::AuthRules::AuthRule::State::TaggedSymbol)
+          INACTIVE = T.let(:INACTIVE, Lithic::Models::AuthRules::AuthRule::State::TaggedSymbol)
+
+          sig { override.returns(T::Array[Lithic::Models::AuthRules::AuthRule::State::TaggedSymbol]) }
+          def self.values
+          end
+        end
+      end
+    end
+
+    AuthRule = AuthRules::AuthRule
+  end
+end

data/rbi/lib/lithic/models/auth_rules/auth_rule_condition.rbi

@@ -0,0 +1,137 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module AuthRules
+      class AuthRuleCondition < Lithic::BaseModel
+        # The attribute to target.
+        #
+        #   The following attributes may be targeted:
+        #
+        #   - `MCC`: A four-digit number listed in ISO 18245. An MCC is used to classify a
+        #     business by the types of goods or services it provides.
+        #   - `COUNTRY`: Country of entity of card acceptor. Possible values are: (1) all
+        #     ISO 3166-1 alpha-3 country codes, (2) QZZ for Kosovo, and (3) ANT for
+        #     Netherlands Antilles.
+        #   - `CURRENCY`: 3-character alphabetic ISO 4217 code for the merchant currency of
+        #     the transaction.
+        #   - `MERCHANT_ID`: Unique alphanumeric identifier for the payment card acceptor
+        #     (merchant).
+        #   - `DESCRIPTOR`: Short description of card acceptor.
+        #   - `LIABILITY_SHIFT`: Indicates whether chargeback liability shift to the issuer
+        #     applies to the transaction. Valid values are `NONE`, `3DS_AUTHENTICATED`, or
+        #     `TOKEN_AUTHENTICATED`.
+        #   - `PAN_ENTRY_MODE`: The method by which the cardholder's primary account number
+        #     (PAN) was entered. Valid values are `AUTO_ENTRY`, `BAR_CODE`, `CONTACTLESS`,
+        #     `ECOMMERCE`, `ERROR_KEYED`, `ERROR_MAGNETIC_STRIPE`, `ICC`, `KEY_ENTERED`,
+        #     `MAGNETIC_STRIPE`, `MANUAL`, `OCR`, `SECURE_CARDLESS`, `UNSPECIFIED`,
+        #     `UNKNOWN`, `CREDENTIAL_ON_FILE`, or `ECOMMERCE`.
+        #   - `TRANSACTION_AMOUNT`: The base transaction amount (in cents) plus the acquirer
+        #     fee field in the settlement/cardholder billing currency. This is the amount
+        #     the issuer should authorize against unless the issuer is paying the acquirer
+        #     fee on behalf of the cardholder.
+        #   - `RISK_SCORE`: Network-provided score assessing risk level associated with a
+        #     given authorization. Scores are on a range of 0-999, with 0 representing the
+        #     lowest risk and 999 representing the highest risk. For Visa transactions,
+        #     where the raw score has a range of 0-99, Lithic will normalize the score by
+        #     multiplying the raw score by 10x.
+        #   - `CARD_TRANSACTION_COUNT_15M`: The number of transactions on the card in the
+        #     trailing 15 minutes before the authorization.
+        #   - `CARD_TRANSACTION_COUNT_1H`: The number of transactions on the card in the
+        #     trailing hour up and until the authorization.
+        #   - `CARD_TRANSACTION_COUNT_24H`: The number of transactions on the card in the
+        #     trailing 24 hours up and until the authorization.
+        #   - `CARD_STATE`: The current state of the card associated with the transaction.
+        #     Valid values are `CLOSED`, `OPEN`, `PAUSED`, `PENDING_ACTIVATION`,
+        #     `PENDING_FULFILLMENT`.
+        #   - `PIN_ENTERED`: Indicates whether a PIN was entered during the transaction.
+        #     Valid values are `TRUE`, `FALSE`.
+        #   - `PIN_STATUS`: The current state of card's PIN. Valid values are `NOT_SET`,
+        #     `OK`, `BLOCKED`.
+        #   - `WALLET_TYPE`: For transactions using a digital wallet token, indicates the
+        #     source of the token. Valid values are `APPLE_PAY`, `GOOGLE_PAY`,
+        #     `SAMSUNG_PAY`, `MASTERPASS`, `MERCHANT`, `OTHER`, `NONE`.
+        sig { returns(T.nilable(Lithic::Models::AuthRules::ConditionalAttribute::OrSymbol)) }
+        attr_reader :attribute
+
+        sig { params(attribute: Lithic::Models::AuthRules::ConditionalAttribute::OrSymbol).void }
+        attr_writer :attribute
+
+        # The operation to apply to the attribute
+        sig { returns(T.nilable(Lithic::Models::AuthRules::AuthRuleCondition::Operation::OrSymbol)) }
+        attr_reader :operation
+
+        sig { params(operation: Lithic::Models::AuthRules::AuthRuleCondition::Operation::OrSymbol).void }
+        attr_writer :operation
+
+        # A regex string, to be used with `MATCHES` or `DOES_NOT_MATCH`
+        sig { returns(T.nilable(T.any(String, Integer, T::Array[String]))) }
+        attr_reader :value
+
+        sig { params(value: T.any(String, Integer, T::Array[String])).void }
+        attr_writer :value
+
+        sig do
+          params(
+            attribute: Lithic::Models::AuthRules::ConditionalAttribute::OrSymbol,
+            operation: Lithic::Models::AuthRules::AuthRuleCondition::Operation::OrSymbol,
+            value: T.any(String, Integer, T::Array[String])
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(attribute: nil, operation: nil, value: nil)
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                attribute: Lithic::Models::AuthRules::ConditionalAttribute::OrSymbol,
+                operation: Lithic::Models::AuthRules::AuthRuleCondition::Operation::OrSymbol,
+                value: T.any(String, Integer, T::Array[String])
+              }
+            )
+        end
+        def to_hash
+        end
+
+        # The operation to apply to the attribute
+        module Operation
+          extend Lithic::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AuthRules::AuthRuleCondition::Operation) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol) }
+
+          IS_ONE_OF = T.let(:IS_ONE_OF, Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol)
+          IS_NOT_ONE_OF =
+            T.let(:IS_NOT_ONE_OF, Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol)
+          MATCHES = T.let(:MATCHES, Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol)
+          DOES_NOT_MATCH =
+            T.let(:DOES_NOT_MATCH, Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol)
+          IS_GREATER_THAN =
+            T.let(:IS_GREATER_THAN, Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol)
+          IS_LESS_THAN =
+            T.let(:IS_LESS_THAN, Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol)
+
+          sig { override.returns(T::Array[Lithic::Models::AuthRules::AuthRuleCondition::Operation::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+        # A regex string, to be used with `MATCHES` or `DOES_NOT_MATCH`
+        module Value
+          extend Lithic::Union
+
+          StringArray = T.let(Lithic::ArrayOf[String], Lithic::Converter)
+
+          sig { override.returns([String, Integer, T::Array[String]]) }
+          def self.variants
+          end
+        end
+      end
+    end
+
+    AuthRuleCondition = AuthRules::AuthRuleCondition
+  end
+end

data/rbi/lib/lithic/models/auth_rules/conditional_attribute.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module AuthRules
+      # The attribute to target.
+      #
+      #   The following attributes may be targeted:
+      #
+      #   - `MCC`: A four-digit number listed in ISO 18245. An MCC is used to classify a
+      #     business by the types of goods or services it provides.
+      #   - `COUNTRY`: Country of entity of card acceptor. Possible values are: (1) all
+      #     ISO 3166-1 alpha-3 country codes, (2) QZZ for Kosovo, and (3) ANT for
+      #     Netherlands Antilles.
+      #   - `CURRENCY`: 3-character alphabetic ISO 4217 code for the merchant currency of
+      #     the transaction.
+      #   - `MERCHANT_ID`: Unique alphanumeric identifier for the payment card acceptor
+      #     (merchant).
+      #   - `DESCRIPTOR`: Short description of card acceptor.
+      #   - `LIABILITY_SHIFT`: Indicates whether chargeback liability shift to the issuer
+      #     applies to the transaction. Valid values are `NONE`, `3DS_AUTHENTICATED`, or
+      #     `TOKEN_AUTHENTICATED`.
+      #   - `PAN_ENTRY_MODE`: The method by which the cardholder's primary account number
+      #     (PAN) was entered. Valid values are `AUTO_ENTRY`, `BAR_CODE`, `CONTACTLESS`,
+      #     `ECOMMERCE`, `ERROR_KEYED`, `ERROR_MAGNETIC_STRIPE`, `ICC`, `KEY_ENTERED`,
+      #     `MAGNETIC_STRIPE`, `MANUAL`, `OCR`, `SECURE_CARDLESS`, `UNSPECIFIED`,
+      #     `UNKNOWN`, `CREDENTIAL_ON_FILE`, or `ECOMMERCE`.
+      #   - `TRANSACTION_AMOUNT`: The base transaction amount (in cents) plus the acquirer
+      #     fee field in the settlement/cardholder billing currency. This is the amount
+      #     the issuer should authorize against unless the issuer is paying the acquirer
+      #     fee on behalf of the cardholder.
+      #   - `RISK_SCORE`: Network-provided score assessing risk level associated with a
+      #     given authorization. Scores are on a range of 0-999, with 0 representing the
+      #     lowest risk and 999 representing the highest risk. For Visa transactions,
+      #     where the raw score has a range of 0-99, Lithic will normalize the score by
+      #     multiplying the raw score by 10x.
+      #   - `CARD_TRANSACTION_COUNT_15M`: The number of transactions on the card in the
+      #     trailing 15 minutes before the authorization.
+      #   - `CARD_TRANSACTION_COUNT_1H`: The number of transactions on the card in the
+      #     trailing hour up and until the authorization.
+      #   - `CARD_TRANSACTION_COUNT_24H`: The number of transactions on the card in the
+      #     trailing 24 hours up and until the authorization.
+      #   - `CARD_STATE`: The current state of the card associated with the transaction.
+      #     Valid values are `CLOSED`, `OPEN`, `PAUSED`, `PENDING_ACTIVATION`,
+      #     `PENDING_FULFILLMENT`.
+      #   - `PIN_ENTERED`: Indicates whether a PIN was entered during the transaction.
+      #     Valid values are `TRUE`, `FALSE`.
+      #   - `PIN_STATUS`: The current state of card's PIN. Valid values are `NOT_SET`,
+      #     `OK`, `BLOCKED`.
+      #   - `WALLET_TYPE`: For transactions using a digital wallet token, indicates the
+      #     source of the token. Valid values are `APPLE_PAY`, `GOOGLE_PAY`,
+      #     `SAMSUNG_PAY`, `MASTERPASS`, `MERCHANT`, `OTHER`, `NONE`.
+      module ConditionalAttribute
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AuthRules::ConditionalAttribute) }
+        OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol) }
+
+        MCC = T.let(:MCC, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        COUNTRY = T.let(:COUNTRY, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        CURRENCY = T.let(:CURRENCY, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        MERCHANT_ID = T.let(:MERCHANT_ID, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        DESCRIPTOR = T.let(:DESCRIPTOR, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        LIABILITY_SHIFT = T.let(:LIABILITY_SHIFT, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        PAN_ENTRY_MODE = T.let(:PAN_ENTRY_MODE, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        TRANSACTION_AMOUNT =
+          T.let(:TRANSACTION_AMOUNT, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        RISK_SCORE = T.let(:RISK_SCORE, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        CARD_TRANSACTION_COUNT_15_M =
+          T.let(:CARD_TRANSACTION_COUNT_15M, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        CARD_TRANSACTION_COUNT_1_H =
+          T.let(:CARD_TRANSACTION_COUNT_1H, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        CARD_TRANSACTION_COUNT_24_H =
+          T.let(:CARD_TRANSACTION_COUNT_24H, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        CARD_STATE = T.let(:CARD_STATE, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        PIN_ENTERED = T.let(:PIN_ENTERED, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        PIN_STATUS = T.let(:PIN_STATUS, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+        WALLET_TYPE = T.let(:WALLET_TYPE, Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::AuthRules::ConditionalAttribute::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/auth_rules/conditional_block_parameters.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module AuthRules
+      class ConditionalBlockParameters < Lithic::BaseModel
+        sig { returns(T::Array[Lithic::Models::AuthRules::AuthRuleCondition]) }
+        attr_accessor :conditions
+
+        sig do
+          params(conditions: T::Array[T.any(Lithic::Models::AuthRules::AuthRuleCondition, Lithic::Util::AnyHash)])
+            .returns(T.attached_class)
+        end
+        def self.new(conditions:)
+        end
+
+        sig { override.returns({conditions: T::Array[Lithic::Models::AuthRules::AuthRuleCondition]}) }
+        def to_hash
+        end
+      end
+    end
+  end
+end