lithic 0.6.0 → 0.7.0

data/rbi/lithic/models/auth_rules/v2_create_params.rbi

@@ -12,155 +12,40 @@ module Lithic
             T.any(Lithic::AuthRules::V2CreateParams, Lithic::Internal::AnyHash)
           end
 
-        # Parameters for the Auth Rule
         sig do
           returns(
             T.any(
-              Lithic::AuthRules::ConditionalBlockParameters,
-              Lithic::AuthRules::VelocityLimitParams,
-              Lithic::AuthRules::MerchantLockParameters,
-              Lithic::AuthRules::Conditional3DSActionParameters,
-              Lithic::AuthRules::ConditionalAuthorizationActionParameters,
-              Lithic::AuthRules::ConditionalACHActionParameters,
-              Lithic::AuthRules::ConditionalTokenizationActionParameters
+              Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule,
+              Lithic::AuthRules::V2CreateParams::Body::CardLevelRule,
+              Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule
             )
           )
         end
-        attr_accessor :parameters
-
-        # The type of Auth Rule. For certain rule types, this determines the event stream
-        # during which it will be evaluated. For rules that can be applied to one of
-        # several event streams, the effective one is defined by the separate
-        # `event_stream` field.
-        #
-        # - `CONDITIONAL_BLOCK`: Deprecated. Use `CONDITIONAL_ACTION` instead.
-        #   AUTHORIZATION event stream.
-        # - `VELOCITY_LIMIT`: AUTHORIZATION event stream.
-        # - `MERCHANT_LOCK`: AUTHORIZATION event stream.
-        # - `CONDITIONAL_ACTION`: AUTHORIZATION, THREE_DS_AUTHENTICATION, TOKENIZATION,
-        #   ACH_CREDIT_RECEIPT, or ACH_DEBIT_RECEIPT event stream.
-        sig { returns(Lithic::AuthRules::V2CreateParams::Type::OrSymbol) }
-        attr_accessor :type
-
-        # Account tokens to which the Auth Rule applies.
-        sig { returns(T.nilable(T::Array[String])) }
-        attr_reader :account_tokens
-
-        sig { params(account_tokens: T::Array[String]).void }
-        attr_writer :account_tokens
-
-        # Business Account tokens to which the Auth Rule applies.
-        sig { returns(T.nilable(T::Array[String])) }
-        attr_reader :business_account_tokens
-
-        sig { params(business_account_tokens: T::Array[String]).void }
-        attr_writer :business_account_tokens
-
-        # The event stream during which the rule will be evaluated.
-        sig { returns(T.nilable(Lithic::AuthRules::EventStream::OrSymbol)) }
-        attr_reader :event_stream
-
-        sig do
-          params(event_stream: Lithic::AuthRules::EventStream::OrSymbol).void
-        end
-        attr_writer :event_stream
-
-        # Auth Rule Name
-        sig { returns(T.nilable(String)) }
-        attr_accessor :name
-
-        # Card tokens to which the Auth Rule applies.
-        sig { returns(T::Array[String]) }
-        attr_accessor :card_tokens
-
-        # Whether the Auth Rule applies to all authorizations on the card program.
-        sig { returns(T::Boolean) }
-        attr_accessor :program_level
-
-        # Card tokens to which the Auth Rule does not apply.
-        sig { returns(T.nilable(T::Array[String])) }
-        attr_reader :excluded_card_tokens
-
-        sig { params(excluded_card_tokens: T::Array[String]).void }
-        attr_writer :excluded_card_tokens
+        attr_accessor :body
 
         sig do
           params(
-            parameters:
+            body:
               T.any(
-                Lithic::AuthRules::ConditionalBlockParameters::OrHash,
-                Lithic::AuthRules::VelocityLimitParams::OrHash,
-                Lithic::AuthRules::MerchantLockParameters::OrHash,
-                Lithic::AuthRules::Conditional3DSActionParameters::OrHash,
-                Lithic::AuthRules::ConditionalAuthorizationActionParameters::OrHash,
-                Lithic::AuthRules::ConditionalACHActionParameters::OrHash,
-                Lithic::AuthRules::ConditionalTokenizationActionParameters::OrHash
+                Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule::OrHash,
+                Lithic::AuthRules::V2CreateParams::Body::CardLevelRule::OrHash,
+                Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule::OrHash
               ),
-            type: Lithic::AuthRules::V2CreateParams::Type::OrSymbol,
-            card_tokens: T::Array[String],
-            program_level: T::Boolean,
-            account_tokens: T::Array[String],
-            business_account_tokens: T::Array[String],
-            event_stream: Lithic::AuthRules::EventStream::OrSymbol,
-            name: T.nilable(String),
-            excluded_card_tokens: T::Array[String],
             request_options: Lithic::RequestOptions::OrHash
           ).returns(T.attached_class)
         end
-        def self.new(
-          # Parameters for the Auth Rule
-          parameters:,
-          # The type of Auth Rule. For certain rule types, this determines the event stream
-          # during which it will be evaluated. For rules that can be applied to one of
-          # several event streams, the effective one is defined by the separate
-          # `event_stream` field.
-          #
-          # - `CONDITIONAL_BLOCK`: Deprecated. Use `CONDITIONAL_ACTION` instead.
-          #   AUTHORIZATION event stream.
-          # - `VELOCITY_LIMIT`: AUTHORIZATION event stream.
-          # - `MERCHANT_LOCK`: AUTHORIZATION event stream.
-          # - `CONDITIONAL_ACTION`: AUTHORIZATION, THREE_DS_AUTHENTICATION, TOKENIZATION,
-          #   ACH_CREDIT_RECEIPT, or ACH_DEBIT_RECEIPT event stream.
-          type:,
-          # Card tokens to which the Auth Rule applies.
-          card_tokens:,
-          # Whether the Auth Rule applies to all authorizations on the card program.
-          program_level:,
-          # Account tokens to which the Auth Rule applies.
-          account_tokens: nil,
-          # Business Account tokens to which the Auth Rule applies.
-          business_account_tokens: nil,
-          # The event stream during which the rule will be evaluated.
-          event_stream: nil,
-          # Auth Rule Name
-          name: nil,
-          # Card tokens to which the Auth Rule does not apply.
-          excluded_card_tokens: nil,
-          request_options: {}
-        )
+        def self.new(body:, request_options: {})
         end
 
         sig do
           override.returns(
             {
-              parameters:
+              body:
                 T.any(
-                  Lithic::AuthRules::ConditionalBlockParameters,
-                  Lithic::AuthRules::VelocityLimitParams,
-                  Lithic::AuthRules::MerchantLockParameters,
-                  Lithic::AuthRules::Conditional3DSActionParameters,
-                  Lithic::AuthRules::ConditionalAuthorizationActionParameters,
-                  Lithic::AuthRules::ConditionalACHActionParameters,
-                  Lithic::AuthRules::ConditionalTokenizationActionParameters
+                  Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule,
+                  Lithic::AuthRules::V2CreateParams::Body::CardLevelRule,
+                  Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule
                 ),
-              type: Lithic::AuthRules::V2CreateParams::Type::OrSymbol,
-              account_tokens: T::Array[String],
-              business_account_tokens: T::Array[String],
-              event_stream: Lithic::AuthRules::EventStream::OrSymbol,
-              name: T.nilable(String),
-              card_tokens: T::Array[String],
-              program_level: T::Boolean,
-              excluded_card_tokens: T::Array[String],
               request_options: Lithic::RequestOptions
             }
           )
@@ -168,79 +53,688 @@ module Lithic
         def to_hash
         end
 
-        # Parameters for the Auth Rule
-        module Parameters
+        module Body
           extend Lithic::Internal::Type::Union
 
           Variants =
             T.type_alias do
               T.any(
-                Lithic::AuthRules::ConditionalBlockParameters,
-                Lithic::AuthRules::VelocityLimitParams,
-                Lithic::AuthRules::MerchantLockParameters,
-                Lithic::AuthRules::Conditional3DSActionParameters,
-                Lithic::AuthRules::ConditionalAuthorizationActionParameters,
-                Lithic::AuthRules::ConditionalACHActionParameters,
-                Lithic::AuthRules::ConditionalTokenizationActionParameters
+                Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule,
+                Lithic::AuthRules::V2CreateParams::Body::CardLevelRule,
+                Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule
               )
             end
 
-          sig do
-            override.returns(
-              T::Array[Lithic::AuthRules::V2CreateParams::Parameters::Variants]
+          class AccountLevelRule < Lithic::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule,
+                  Lithic::Internal::AnyHash
+                )
+              end
+
+            # Parameters for the Auth Rule
+            sig do
+              returns(
+                T.any(
+                  Lithic::AuthRules::ConditionalBlockParameters,
+                  Lithic::AuthRules::VelocityLimitParams,
+                  Lithic::AuthRules::MerchantLockParameters,
+                  Lithic::AuthRules::Conditional3DSActionParameters,
+                  Lithic::AuthRules::ConditionalAuthorizationActionParameters,
+                  Lithic::AuthRules::ConditionalACHActionParameters,
+                  Lithic::AuthRules::ConditionalTokenizationActionParameters
+                )
+              )
+            end
+            attr_accessor :parameters
+
+            # The type of Auth Rule. For certain rule types, this determines the event stream
+            # during which it will be evaluated. For rules that can be applied to one of
+            # several event streams, the effective one is defined by the separate
+            # `event_stream` field.
+            #
+            # - `CONDITIONAL_BLOCK`: Deprecated. Use `CONDITIONAL_ACTION` instead.
+            #   AUTHORIZATION event stream.
+            # - `VELOCITY_LIMIT`: AUTHORIZATION event stream.
+            # - `MERCHANT_LOCK`: AUTHORIZATION event stream.
+            # - `CONDITIONAL_ACTION`: AUTHORIZATION, THREE_DS_AUTHENTICATION, TOKENIZATION,
+            #   ACH_CREDIT_RECEIPT, or ACH_DEBIT_RECEIPT event stream.
+            sig do
+              returns(
+                Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule::Type::OrSymbol
+              )
+            end
+            attr_accessor :type
+
+            # Account tokens to which the Auth Rule applies.
+            sig { returns(T.nilable(T::Array[String])) }
+            attr_reader :account_tokens
+
+            sig { params(account_tokens: T::Array[String]).void }
+            attr_writer :account_tokens
+
+            # Business Account tokens to which the Auth Rule applies.
+            sig { returns(T.nilable(T::Array[String])) }
+            attr_reader :business_account_tokens
+
+            sig { params(business_account_tokens: T::Array[String]).void }
+            attr_writer :business_account_tokens
+
+            # The event stream during which the rule will be evaluated.
+            sig { returns(T.nilable(Lithic::AuthRules::EventStream::OrSymbol)) }
+            attr_reader :event_stream
+
+            sig do
+              params(
+                event_stream: Lithic::AuthRules::EventStream::OrSymbol
+              ).void
+            end
+            attr_writer :event_stream
+
+            # Auth Rule Name
+            sig { returns(T.nilable(String)) }
+            attr_accessor :name
+
+            sig do
+              params(
+                parameters:
+                  T.any(
+                    Lithic::AuthRules::ConditionalBlockParameters::OrHash,
+                    Lithic::AuthRules::VelocityLimitParams::OrHash,
+                    Lithic::AuthRules::MerchantLockParameters::OrHash,
+                    Lithic::AuthRules::Conditional3DSActionParameters::OrHash,
+                    Lithic::AuthRules::ConditionalAuthorizationActionParameters::OrHash,
+                    Lithic::AuthRules::ConditionalACHActionParameters::OrHash,
+                    Lithic::AuthRules::ConditionalTokenizationActionParameters::OrHash
+                  ),
+                type:
+                  Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule::Type::OrSymbol,
+                account_tokens: T::Array[String],
+                business_account_tokens: T::Array[String],
+                event_stream: Lithic::AuthRules::EventStream::OrSymbol,
+                name: T.nilable(String)
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # Parameters for the Auth Rule
+              parameters:,
+              # The type of Auth Rule. For certain rule types, this determines the event stream
+              # during which it will be evaluated. For rules that can be applied to one of
+              # several event streams, the effective one is defined by the separate
+              # `event_stream` field.
+              #
+              # - `CONDITIONAL_BLOCK`: Deprecated. Use `CONDITIONAL_ACTION` instead.
+              #   AUTHORIZATION event stream.
+              # - `VELOCITY_LIMIT`: AUTHORIZATION event stream.
+              # - `MERCHANT_LOCK`: AUTHORIZATION event stream.
+              # - `CONDITIONAL_ACTION`: AUTHORIZATION, THREE_DS_AUTHENTICATION, TOKENIZATION,
+              #   ACH_CREDIT_RECEIPT, or ACH_DEBIT_RECEIPT event stream.
+              type:,
+              # Account tokens to which the Auth Rule applies.
+              account_tokens: nil,
+              # Business Account tokens to which the Auth Rule applies.
+              business_account_tokens: nil,
+              # The event stream during which the rule will be evaluated.
+              event_stream: nil,
+              # Auth Rule Name
+              name: nil
             )
+            end
+
+            sig do
+              override.returns(
+                {
+                  parameters:
+                    T.any(
+                      Lithic::AuthRules::ConditionalBlockParameters,
+                      Lithic::AuthRules::VelocityLimitParams,
+                      Lithic::AuthRules::MerchantLockParameters,
+                      Lithic::AuthRules::Conditional3DSActionParameters,
+                      Lithic::AuthRules::ConditionalAuthorizationActionParameters,
+                      Lithic::AuthRules::ConditionalACHActionParameters,
+                      Lithic::AuthRules::ConditionalTokenizationActionParameters
+                    ),
+                  type:
+                    Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule::Type::OrSymbol,
+                  account_tokens: T::Array[String],
+                  business_account_tokens: T::Array[String],
+                  event_stream: Lithic::AuthRules::EventStream::OrSymbol,
+                  name: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
+            end
+
+            # Parameters for the Auth Rule
+            module Parameters
+              extend Lithic::Internal::Type::Union
+
+              Variants =
+                T.type_alias do
+                  T.any(
+                    Lithic::AuthRules::ConditionalBlockParameters,
+                    Lithic::AuthRules::VelocityLimitParams,
+                    Lithic::AuthRules::MerchantLockParameters,
+                    Lithic::AuthRules::Conditional3DSActionParameters,
+                    Lithic::AuthRules::ConditionalAuthorizationActionParameters,
+                    Lithic::AuthRules::ConditionalACHActionParameters,
+                    Lithic::AuthRules::ConditionalTokenizationActionParameters
+                  )
+                end
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule::Parameters::Variants
+                  ]
+                )
+              end
+              def self.variants
+              end
+            end
+
+            # The type of Auth Rule. For certain rule types, this determines the event stream
+            # during which it will be evaluated. For rules that can be applied to one of
+            # several event streams, the effective one is defined by the separate
+            # `event_stream` field.
+            #
+            # - `CONDITIONAL_BLOCK`: Deprecated. Use `CONDITIONAL_ACTION` instead.
+            #   AUTHORIZATION event stream.
+            # - `VELOCITY_LIMIT`: AUTHORIZATION event stream.
+            # - `MERCHANT_LOCK`: AUTHORIZATION event stream.
+            # - `CONDITIONAL_ACTION`: AUTHORIZATION, THREE_DS_AUTHENTICATION, TOKENIZATION,
+            #   ACH_CREDIT_RECEIPT, or ACH_DEBIT_RECEIPT event stream.
+            module Type
+              extend Lithic::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule::Type
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              CONDITIONAL_BLOCK =
+                T.let(
+                  :CONDITIONAL_BLOCK,
+                  Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule::Type::TaggedSymbol
+                )
+              VELOCITY_LIMIT =
+                T.let(
+                  :VELOCITY_LIMIT,
+                  Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule::Type::TaggedSymbol
+                )
+              MERCHANT_LOCK =
+                T.let(
+                  :MERCHANT_LOCK,
+                  Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule::Type::TaggedSymbol
+                )
+              CONDITIONAL_ACTION =
+                T.let(
+                  :CONDITIONAL_ACTION,
+                  Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule::Type::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule::Type::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
           end
-          def self.variants
-          end
-        end
 
-        # The type of Auth Rule. For certain rule types, this determines the event stream
-        # during which it will be evaluated. For rules that can be applied to one of
-        # several event streams, the effective one is defined by the separate
-        # `event_stream` field.
-        #
-        # - `CONDITIONAL_BLOCK`: Deprecated. Use `CONDITIONAL_ACTION` instead.
-        #   AUTHORIZATION event stream.
-        # - `VELOCITY_LIMIT`: AUTHORIZATION event stream.
-        # - `MERCHANT_LOCK`: AUTHORIZATION event stream.
-        # - `CONDITIONAL_ACTION`: AUTHORIZATION, THREE_DS_AUTHENTICATION, TOKENIZATION,
-        #   ACH_CREDIT_RECEIPT, or ACH_DEBIT_RECEIPT event stream.
-        module Type
-          extend Lithic::Internal::Type::Enum
-
-          TaggedSymbol =
-            T.type_alias do
-              T.all(Symbol, Lithic::AuthRules::V2CreateParams::Type)
+          class CardLevelRule < Lithic::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Lithic::AuthRules::V2CreateParams::Body::CardLevelRule,
+                  Lithic::Internal::AnyHash
+                )
+              end
+
+            # Card tokens to which the Auth Rule applies.
+            sig { returns(T::Array[String]) }
+            attr_accessor :card_tokens
+
+            # Parameters for the Auth Rule
+            sig do
+              returns(
+                T.any(
+                  Lithic::AuthRules::ConditionalBlockParameters,
+                  Lithic::AuthRules::VelocityLimitParams,
+                  Lithic::AuthRules::MerchantLockParameters,
+                  Lithic::AuthRules::Conditional3DSActionParameters,
+                  Lithic::AuthRules::ConditionalAuthorizationActionParameters,
+                  Lithic::AuthRules::ConditionalACHActionParameters,
+                  Lithic::AuthRules::ConditionalTokenizationActionParameters
+                )
+              )
             end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
+            attr_accessor :parameters
 
-          CONDITIONAL_BLOCK =
-            T.let(
-              :CONDITIONAL_BLOCK,
-              Lithic::AuthRules::V2CreateParams::Type::TaggedSymbol
-            )
-          VELOCITY_LIMIT =
-            T.let(
-              :VELOCITY_LIMIT,
-              Lithic::AuthRules::V2CreateParams::Type::TaggedSymbol
-            )
-          MERCHANT_LOCK =
-            T.let(
-              :MERCHANT_LOCK,
-              Lithic::AuthRules::V2CreateParams::Type::TaggedSymbol
+            # The type of Auth Rule. For certain rule types, this determines the event stream
+            # during which it will be evaluated. For rules that can be applied to one of
+            # several event streams, the effective one is defined by the separate
+            # `event_stream` field.
+            #
+            # - `CONDITIONAL_BLOCK`: Deprecated. Use `CONDITIONAL_ACTION` instead.
+            #   AUTHORIZATION event stream.
+            # - `VELOCITY_LIMIT`: AUTHORIZATION event stream.
+            # - `MERCHANT_LOCK`: AUTHORIZATION event stream.
+            # - `CONDITIONAL_ACTION`: AUTHORIZATION, THREE_DS_AUTHENTICATION, TOKENIZATION,
+            #   ACH_CREDIT_RECEIPT, or ACH_DEBIT_RECEIPT event stream.
+            sig do
+              returns(
+                Lithic::AuthRules::V2CreateParams::Body::CardLevelRule::Type::OrSymbol
+              )
+            end
+            attr_accessor :type
+
+            # The event stream during which the rule will be evaluated.
+            sig { returns(T.nilable(Lithic::AuthRules::EventStream::OrSymbol)) }
+            attr_reader :event_stream
+
+            sig do
+              params(
+                event_stream: Lithic::AuthRules::EventStream::OrSymbol
+              ).void
+            end
+            attr_writer :event_stream
+
+            # Auth Rule Name
+            sig { returns(T.nilable(String)) }
+            attr_accessor :name
+
+            sig do
+              params(
+                card_tokens: T::Array[String],
+                parameters:
+                  T.any(
+                    Lithic::AuthRules::ConditionalBlockParameters::OrHash,
+                    Lithic::AuthRules::VelocityLimitParams::OrHash,
+                    Lithic::AuthRules::MerchantLockParameters::OrHash,
+                    Lithic::AuthRules::Conditional3DSActionParameters::OrHash,
+                    Lithic::AuthRules::ConditionalAuthorizationActionParameters::OrHash,
+                    Lithic::AuthRules::ConditionalACHActionParameters::OrHash,
+                    Lithic::AuthRules::ConditionalTokenizationActionParameters::OrHash
+                  ),
+                type:
+                  Lithic::AuthRules::V2CreateParams::Body::CardLevelRule::Type::OrSymbol,
+                event_stream: Lithic::AuthRules::EventStream::OrSymbol,
+                name: T.nilable(String)
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # Card tokens to which the Auth Rule applies.
+              card_tokens:,
+              # Parameters for the Auth Rule
+              parameters:,
+              # The type of Auth Rule. For certain rule types, this determines the event stream
+              # during which it will be evaluated. For rules that can be applied to one of
+              # several event streams, the effective one is defined by the separate
+              # `event_stream` field.
+              #
+              # - `CONDITIONAL_BLOCK`: Deprecated. Use `CONDITIONAL_ACTION` instead.
+              #   AUTHORIZATION event stream.
+              # - `VELOCITY_LIMIT`: AUTHORIZATION event stream.
+              # - `MERCHANT_LOCK`: AUTHORIZATION event stream.
+              # - `CONDITIONAL_ACTION`: AUTHORIZATION, THREE_DS_AUTHENTICATION, TOKENIZATION,
+              #   ACH_CREDIT_RECEIPT, or ACH_DEBIT_RECEIPT event stream.
+              type:,
+              # The event stream during which the rule will be evaluated.
+              event_stream: nil,
+              # Auth Rule Name
+              name: nil
             )
-          CONDITIONAL_ACTION =
-            T.let(
-              :CONDITIONAL_ACTION,
-              Lithic::AuthRules::V2CreateParams::Type::TaggedSymbol
+            end
+
+            sig do
+              override.returns(
+                {
+                  card_tokens: T::Array[String],
+                  parameters:
+                    T.any(
+                      Lithic::AuthRules::ConditionalBlockParameters,
+                      Lithic::AuthRules::VelocityLimitParams,
+                      Lithic::AuthRules::MerchantLockParameters,
+                      Lithic::AuthRules::Conditional3DSActionParameters,
+                      Lithic::AuthRules::ConditionalAuthorizationActionParameters,
+                      Lithic::AuthRules::ConditionalACHActionParameters,
+                      Lithic::AuthRules::ConditionalTokenizationActionParameters
+                    ),
+                  type:
+                    Lithic::AuthRules::V2CreateParams::Body::CardLevelRule::Type::OrSymbol,
+                  event_stream: Lithic::AuthRules::EventStream::OrSymbol,
+                  name: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
+            end
+
+            # Parameters for the Auth Rule
+            module Parameters
+              extend Lithic::Internal::Type::Union
+
+              Variants =
+                T.type_alias do
+                  T.any(
+                    Lithic::AuthRules::ConditionalBlockParameters,
+                    Lithic::AuthRules::VelocityLimitParams,
+                    Lithic::AuthRules::MerchantLockParameters,
+                    Lithic::AuthRules::Conditional3DSActionParameters,
+                    Lithic::AuthRules::ConditionalAuthorizationActionParameters,
+                    Lithic::AuthRules::ConditionalACHActionParameters,
+                    Lithic::AuthRules::ConditionalTokenizationActionParameters
+                  )
+                end
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Lithic::AuthRules::V2CreateParams::Body::CardLevelRule::Parameters::Variants
+                  ]
+                )
+              end
+              def self.variants
+              end
+            end
+
+            # The type of Auth Rule. For certain rule types, this determines the event stream
+            # during which it will be evaluated. For rules that can be applied to one of
+            # several event streams, the effective one is defined by the separate
+            # `event_stream` field.
+            #
+            # - `CONDITIONAL_BLOCK`: Deprecated. Use `CONDITIONAL_ACTION` instead.
+            #   AUTHORIZATION event stream.
+            # - `VELOCITY_LIMIT`: AUTHORIZATION event stream.
+            # - `MERCHANT_LOCK`: AUTHORIZATION event stream.
+            # - `CONDITIONAL_ACTION`: AUTHORIZATION, THREE_DS_AUTHENTICATION, TOKENIZATION,
+            #   ACH_CREDIT_RECEIPT, or ACH_DEBIT_RECEIPT event stream.
+            module Type
+              extend Lithic::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Lithic::AuthRules::V2CreateParams::Body::CardLevelRule::Type
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              CONDITIONAL_BLOCK =
+                T.let(
+                  :CONDITIONAL_BLOCK,
+                  Lithic::AuthRules::V2CreateParams::Body::CardLevelRule::Type::TaggedSymbol
+                )
+              VELOCITY_LIMIT =
+                T.let(
+                  :VELOCITY_LIMIT,
+                  Lithic::AuthRules::V2CreateParams::Body::CardLevelRule::Type::TaggedSymbol
+                )
+              MERCHANT_LOCK =
+                T.let(
+                  :MERCHANT_LOCK,
+                  Lithic::AuthRules::V2CreateParams::Body::CardLevelRule::Type::TaggedSymbol
+                )
+              CONDITIONAL_ACTION =
+                T.let(
+                  :CONDITIONAL_ACTION,
+                  Lithic::AuthRules::V2CreateParams::Body::CardLevelRule::Type::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Lithic::AuthRules::V2CreateParams::Body::CardLevelRule::Type::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+          end
+
+          class ProgramLevelRule < Lithic::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule,
+                  Lithic::Internal::AnyHash
+                )
+              end
+
+            # Parameters for the Auth Rule
+            sig do
+              returns(
+                T.any(
+                  Lithic::AuthRules::ConditionalBlockParameters,
+                  Lithic::AuthRules::VelocityLimitParams,
+                  Lithic::AuthRules::MerchantLockParameters,
+                  Lithic::AuthRules::Conditional3DSActionParameters,
+                  Lithic::AuthRules::ConditionalAuthorizationActionParameters,
+                  Lithic::AuthRules::ConditionalACHActionParameters,
+                  Lithic::AuthRules::ConditionalTokenizationActionParameters
+                )
+              )
+            end
+            attr_accessor :parameters
+
+            # Whether the Auth Rule applies to all authorizations on the card program.
+            sig { returns(T::Boolean) }
+            attr_accessor :program_level
+
+            # The type of Auth Rule. For certain rule types, this determines the event stream
+            # during which it will be evaluated. For rules that can be applied to one of
+            # several event streams, the effective one is defined by the separate
+            # `event_stream` field.
+            #
+            # - `CONDITIONAL_BLOCK`: Deprecated. Use `CONDITIONAL_ACTION` instead.
+            #   AUTHORIZATION event stream.
+            # - `VELOCITY_LIMIT`: AUTHORIZATION event stream.
+            # - `MERCHANT_LOCK`: AUTHORIZATION event stream.
+            # - `CONDITIONAL_ACTION`: AUTHORIZATION, THREE_DS_AUTHENTICATION, TOKENIZATION,
+            #   ACH_CREDIT_RECEIPT, or ACH_DEBIT_RECEIPT event stream.
+            sig do
+              returns(
+                Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule::Type::OrSymbol
+              )
+            end
+            attr_accessor :type
+
+            # The event stream during which the rule will be evaluated.
+            sig { returns(T.nilable(Lithic::AuthRules::EventStream::OrSymbol)) }
+            attr_reader :event_stream
+
+            sig do
+              params(
+                event_stream: Lithic::AuthRules::EventStream::OrSymbol
+              ).void
+            end
+            attr_writer :event_stream
+
+            # Card tokens to which the Auth Rule does not apply.
+            sig { returns(T.nilable(T::Array[String])) }
+            attr_reader :excluded_card_tokens
+
+            sig { params(excluded_card_tokens: T::Array[String]).void }
+            attr_writer :excluded_card_tokens
+
+            # Auth Rule Name
+            sig { returns(T.nilable(String)) }
+            attr_accessor :name
+
+            sig do
+              params(
+                parameters:
+                  T.any(
+                    Lithic::AuthRules::ConditionalBlockParameters::OrHash,
+                    Lithic::AuthRules::VelocityLimitParams::OrHash,
+                    Lithic::AuthRules::MerchantLockParameters::OrHash,
+                    Lithic::AuthRules::Conditional3DSActionParameters::OrHash,
+                    Lithic::AuthRules::ConditionalAuthorizationActionParameters::OrHash,
+                    Lithic::AuthRules::ConditionalACHActionParameters::OrHash,
+                    Lithic::AuthRules::ConditionalTokenizationActionParameters::OrHash
+                  ),
+                program_level: T::Boolean,
+                type:
+                  Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule::Type::OrSymbol,
+                event_stream: Lithic::AuthRules::EventStream::OrSymbol,
+                excluded_card_tokens: T::Array[String],
+                name: T.nilable(String)
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # Parameters for the Auth Rule
+              parameters:,
+              # Whether the Auth Rule applies to all authorizations on the card program.
+              program_level:,
+              # The type of Auth Rule. For certain rule types, this determines the event stream
+              # during which it will be evaluated. For rules that can be applied to one of
+              # several event streams, the effective one is defined by the separate
+              # `event_stream` field.
+              #
+              # - `CONDITIONAL_BLOCK`: Deprecated. Use `CONDITIONAL_ACTION` instead.
+              #   AUTHORIZATION event stream.
+              # - `VELOCITY_LIMIT`: AUTHORIZATION event stream.
+              # - `MERCHANT_LOCK`: AUTHORIZATION event stream.
+              # - `CONDITIONAL_ACTION`: AUTHORIZATION, THREE_DS_AUTHENTICATION, TOKENIZATION,
+              #   ACH_CREDIT_RECEIPT, or ACH_DEBIT_RECEIPT event stream.
+              type:,
+              # The event stream during which the rule will be evaluated.
+              event_stream: nil,
+              # Card tokens to which the Auth Rule does not apply.
+              excluded_card_tokens: nil,
+              # Auth Rule Name
+              name: nil
             )
+            end
+
+            sig do
+              override.returns(
+                {
+                  parameters:
+                    T.any(
+                      Lithic::AuthRules::ConditionalBlockParameters,
+                      Lithic::AuthRules::VelocityLimitParams,
+                      Lithic::AuthRules::MerchantLockParameters,
+                      Lithic::AuthRules::Conditional3DSActionParameters,
+                      Lithic::AuthRules::ConditionalAuthorizationActionParameters,
+                      Lithic::AuthRules::ConditionalACHActionParameters,
+                      Lithic::AuthRules::ConditionalTokenizationActionParameters
+                    ),
+                  program_level: T::Boolean,
+                  type:
+                    Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule::Type::OrSymbol,
+                  event_stream: Lithic::AuthRules::EventStream::OrSymbol,
+                  excluded_card_tokens: T::Array[String],
+                  name: T.nilable(String)
+                }
+              )
+            end
+            def to_hash
+            end
+
+            # Parameters for the Auth Rule
+            module Parameters
+              extend Lithic::Internal::Type::Union
+
+              Variants =
+                T.type_alias do
+                  T.any(
+                    Lithic::AuthRules::ConditionalBlockParameters,
+                    Lithic::AuthRules::VelocityLimitParams,
+                    Lithic::AuthRules::MerchantLockParameters,
+                    Lithic::AuthRules::Conditional3DSActionParameters,
+                    Lithic::AuthRules::ConditionalAuthorizationActionParameters,
+                    Lithic::AuthRules::ConditionalACHActionParameters,
+                    Lithic::AuthRules::ConditionalTokenizationActionParameters
+                  )
+                end
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule::Parameters::Variants
+                  ]
+                )
+              end
+              def self.variants
+              end
+            end
+
+            # The type of Auth Rule. For certain rule types, this determines the event stream
+            # during which it will be evaluated. For rules that can be applied to one of
+            # several event streams, the effective one is defined by the separate
+            # `event_stream` field.
+            #
+            # - `CONDITIONAL_BLOCK`: Deprecated. Use `CONDITIONAL_ACTION` instead.
+            #   AUTHORIZATION event stream.
+            # - `VELOCITY_LIMIT`: AUTHORIZATION event stream.
+            # - `MERCHANT_LOCK`: AUTHORIZATION event stream.
+            # - `CONDITIONAL_ACTION`: AUTHORIZATION, THREE_DS_AUTHENTICATION, TOKENIZATION,
+            #   ACH_CREDIT_RECEIPT, or ACH_DEBIT_RECEIPT event stream.
+            module Type
+              extend Lithic::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule::Type
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              CONDITIONAL_BLOCK =
+                T.let(
+                  :CONDITIONAL_BLOCK,
+                  Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule::Type::TaggedSymbol
+                )
+              VELOCITY_LIMIT =
+                T.let(
+                  :VELOCITY_LIMIT,
+                  Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule::Type::TaggedSymbol
+                )
+              MERCHANT_LOCK =
+                T.let(
+                  :MERCHANT_LOCK,
+                  Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule::Type::TaggedSymbol
+                )
+              CONDITIONAL_ACTION =
+                T.let(
+                  :CONDITIONAL_ACTION,
+                  Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule::Type::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule::Type::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+          end
 
           sig do
             override.returns(
-              T::Array[Lithic::AuthRules::V2CreateParams::Type::TaggedSymbol]
+              T::Array[Lithic::AuthRules::V2CreateParams::Body::Variants]
             )
           end
-          def self.values
+          def self.variants
           end
         end
       end