lithic 0.6.0 → 0.7.0

data/rbi/lithic/models/auth_rules/v2_update_params.rbi

@@ -12,105 +12,45 @@ module Lithic
             T.any(Lithic::AuthRules::V2UpdateParams, Lithic::Internal::AnyHash)
           end
 
-        # 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
-
-        # Auth Rule Name
-        sig { returns(T.nilable(String)) }
-        attr_accessor :name
-
-        # The desired state of the Auth Rule.
-        #
-        # Note that only deactivating an Auth Rule through this endpoint is supported at
-        # this time. If you need to (re-)activate an Auth Rule the /promote endpoint
-        # should be used to promote a draft to the currently active version.
-        sig do
-          returns(T.nilable(Lithic::AuthRules::V2UpdateParams::State::OrSymbol))
-        end
-        attr_reader :state
+        sig { returns(String) }
+        attr_accessor :auth_rule_token
 
         sig do
-          params(state: Lithic::AuthRules::V2UpdateParams::State::OrSymbol).void
+          returns(
+            T.any(
+              Lithic::AuthRules::V2UpdateParams::Body::AccountLevelRule,
+              Lithic::AuthRules::V2UpdateParams::Body::CardLevelRule,
+              Lithic::AuthRules::V2UpdateParams::Body::ProgramLevelRule
+            )
+          )
         end
-        attr_writer :state
-
-        # Card tokens to which the Auth Rule applies.
-        sig { returns(T.nilable(T::Array[String])) }
-        attr_reader :card_tokens
-
-        sig { params(card_tokens: T::Array[String]).void }
-        attr_writer :card_tokens
-
-        # 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
-
-        # Whether the Auth Rule applies to all authorizations on the card program.
-        sig { returns(T.nilable(T::Boolean)) }
-        attr_reader :program_level
-
-        sig { params(program_level: T::Boolean).void }
-        attr_writer :program_level
+        attr_accessor :body
 
         sig do
           params(
-            account_tokens: T::Array[String],
-            business_account_tokens: T::Array[String],
-            name: T.nilable(String),
-            state: Lithic::AuthRules::V2UpdateParams::State::OrSymbol,
-            card_tokens: T::Array[String],
-            excluded_card_tokens: T::Array[String],
-            program_level: T::Boolean,
+            auth_rule_token: String,
+            body:
+              T.any(
+                Lithic::AuthRules::V2UpdateParams::Body::AccountLevelRule::OrHash,
+                Lithic::AuthRules::V2UpdateParams::Body::CardLevelRule::OrHash,
+                Lithic::AuthRules::V2UpdateParams::Body::ProgramLevelRule::OrHash
+              ),
             request_options: Lithic::RequestOptions::OrHash
           ).returns(T.attached_class)
         end
-        def self.new(
-          # Account tokens to which the Auth Rule applies.
-          account_tokens: nil,
-          # Business Account tokens to which the Auth Rule applies.
-          business_account_tokens: nil,
-          # Auth Rule Name
-          name: nil,
-          # The desired state of the Auth Rule.
-          #
-          # Note that only deactivating an Auth Rule through this endpoint is supported at
-          # this time. If you need to (re-)activate an Auth Rule the /promote endpoint
-          # should be used to promote a draft to the currently active version.
-          state: nil,
-          # Card tokens to which the Auth Rule applies.
-          card_tokens: nil,
-          # Card tokens to which the Auth Rule does not apply.
-          excluded_card_tokens: nil,
-          # Whether the Auth Rule applies to all authorizations on the card program.
-          program_level: nil,
-          request_options: {}
-        )
+        def self.new(auth_rule_token:, body:, request_options: {})
         end
 
         sig do
           override.returns(
             {
-              account_tokens: T::Array[String],
-              business_account_tokens: T::Array[String],
-              name: T.nilable(String),
-              state: Lithic::AuthRules::V2UpdateParams::State::OrSymbol,
-              card_tokens: T::Array[String],
-              excluded_card_tokens: T::Array[String],
-              program_level: T::Boolean,
+              auth_rule_token: String,
+              body:
+                T.any(
+                  Lithic::AuthRules::V2UpdateParams::Body::AccountLevelRule,
+                  Lithic::AuthRules::V2UpdateParams::Body::CardLevelRule,
+                  Lithic::AuthRules::V2UpdateParams::Body::ProgramLevelRule
+                ),
               request_options: Lithic::RequestOptions
             }
           )
@@ -118,32 +58,382 @@ module Lithic
         def to_hash
         end
 
-        # The desired state of the Auth Rule.
-        #
-        # Note that only deactivating an Auth Rule through this endpoint is supported at
-        # this time. If you need to (re-)activate an Auth Rule the /promote endpoint
-        # should be used to promote a draft to the currently active version.
-        module State
-          extend Lithic::Internal::Type::Enum
+        module Body
+          extend Lithic::Internal::Type::Union
 
-          TaggedSymbol =
+          Variants =
             T.type_alias do
-              T.all(Symbol, Lithic::AuthRules::V2UpdateParams::State)
+              T.any(
+                Lithic::AuthRules::V2UpdateParams::Body::AccountLevelRule,
+                Lithic::AuthRules::V2UpdateParams::Body::CardLevelRule,
+                Lithic::AuthRules::V2UpdateParams::Body::ProgramLevelRule
+              )
+            end
+
+          class AccountLevelRule < Lithic::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Lithic::AuthRules::V2UpdateParams::Body::AccountLevelRule,
+                  Lithic::Internal::AnyHash
+                )
+              end
+
+            # 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
+
+            # Auth Rule Name
+            sig { returns(T.nilable(String)) }
+            attr_accessor :name
+
+            # The desired state of the Auth Rule.
+            #
+            # Note that only deactivating an Auth Rule through this endpoint is supported at
+            # this time. If you need to (re-)activate an Auth Rule the /promote endpoint
+            # should be used to promote a draft to the currently active version.
+            sig do
+              returns(
+                T.nilable(
+                  Lithic::AuthRules::V2UpdateParams::Body::AccountLevelRule::State::OrSymbol
+                )
+              )
+            end
+            attr_reader :state
+
+            sig do
+              params(
+                state:
+                  Lithic::AuthRules::V2UpdateParams::Body::AccountLevelRule::State::OrSymbol
+              ).void
+            end
+            attr_writer :state
+
+            sig do
+              params(
+                account_tokens: T::Array[String],
+                business_account_tokens: T::Array[String],
+                name: T.nilable(String),
+                state:
+                  Lithic::AuthRules::V2UpdateParams::Body::AccountLevelRule::State::OrSymbol
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # Account tokens to which the Auth Rule applies.
+              account_tokens: nil,
+              # Business Account tokens to which the Auth Rule applies.
+              business_account_tokens: nil,
+              # Auth Rule Name
+              name: nil,
+              # The desired state of the Auth Rule.
+              #
+              # Note that only deactivating an Auth Rule through this endpoint is supported at
+              # this time. If you need to (re-)activate an Auth Rule the /promote endpoint
+              # should be used to promote a draft to the currently active version.
+              state: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  account_tokens: T::Array[String],
+                  business_account_tokens: T::Array[String],
+                  name: T.nilable(String),
+                  state:
+                    Lithic::AuthRules::V2UpdateParams::Body::AccountLevelRule::State::OrSymbol
+                }
+              )
+            end
+            def to_hash
+            end
+
+            # The desired state of the Auth Rule.
+            #
+            # Note that only deactivating an Auth Rule through this endpoint is supported at
+            # this time. If you need to (re-)activate an Auth Rule the /promote endpoint
+            # should be used to promote a draft to the currently active version.
+            module State
+              extend Lithic::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Lithic::AuthRules::V2UpdateParams::Body::AccountLevelRule::State
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              INACTIVE =
+                T.let(
+                  :INACTIVE,
+                  Lithic::AuthRules::V2UpdateParams::Body::AccountLevelRule::State::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Lithic::AuthRules::V2UpdateParams::Body::AccountLevelRule::State::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+          end
+
+          class CardLevelRule < Lithic::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Lithic::AuthRules::V2UpdateParams::Body::CardLevelRule,
+                  Lithic::Internal::AnyHash
+                )
+              end
+
+            # Card tokens to which the Auth Rule applies.
+            sig { returns(T.nilable(T::Array[String])) }
+            attr_reader :card_tokens
+
+            sig { params(card_tokens: T::Array[String]).void }
+            attr_writer :card_tokens
+
+            # Auth Rule Name
+            sig { returns(T.nilable(String)) }
+            attr_accessor :name
+
+            # The desired state of the Auth Rule.
+            #
+            # Note that only deactivating an Auth Rule through this endpoint is supported at
+            # this time. If you need to (re-)activate an Auth Rule the /promote endpoint
+            # should be used to promote a draft to the currently active version.
+            sig do
+              returns(
+                T.nilable(
+                  Lithic::AuthRules::V2UpdateParams::Body::CardLevelRule::State::OrSymbol
+                )
+              )
+            end
+            attr_reader :state
+
+            sig do
+              params(
+                state:
+                  Lithic::AuthRules::V2UpdateParams::Body::CardLevelRule::State::OrSymbol
+              ).void
+            end
+            attr_writer :state
+
+            sig do
+              params(
+                card_tokens: T::Array[String],
+                name: T.nilable(String),
+                state:
+                  Lithic::AuthRules::V2UpdateParams::Body::CardLevelRule::State::OrSymbol
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # Card tokens to which the Auth Rule applies.
+              card_tokens: nil,
+              # Auth Rule Name
+              name: nil,
+              # The desired state of the Auth Rule.
+              #
+              # Note that only deactivating an Auth Rule through this endpoint is supported at
+              # this time. If you need to (re-)activate an Auth Rule the /promote endpoint
+              # should be used to promote a draft to the currently active version.
+              state: nil
+            )
+            end
+
+            sig do
+              override.returns(
+                {
+                  card_tokens: T::Array[String],
+                  name: T.nilable(String),
+                  state:
+                    Lithic::AuthRules::V2UpdateParams::Body::CardLevelRule::State::OrSymbol
+                }
+              )
+            end
+            def to_hash
+            end
+
+            # The desired state of the Auth Rule.
+            #
+            # Note that only deactivating an Auth Rule through this endpoint is supported at
+            # this time. If you need to (re-)activate an Auth Rule the /promote endpoint
+            # should be used to promote a draft to the currently active version.
+            module State
+              extend Lithic::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Lithic::AuthRules::V2UpdateParams::Body::CardLevelRule::State
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              INACTIVE =
+                T.let(
+                  :INACTIVE,
+                  Lithic::AuthRules::V2UpdateParams::Body::CardLevelRule::State::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Lithic::AuthRules::V2UpdateParams::Body::CardLevelRule::State::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+          end
+
+          class ProgramLevelRule < Lithic::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  Lithic::AuthRules::V2UpdateParams::Body::ProgramLevelRule,
+                  Lithic::Internal::AnyHash
+                )
+              end
+
+            # 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
+
+            # Whether the Auth Rule applies to all authorizations on the card program.
+            sig { returns(T.nilable(T::Boolean)) }
+            attr_reader :program_level
+
+            sig { params(program_level: T::Boolean).void }
+            attr_writer :program_level
+
+            # The desired state of the Auth Rule.
+            #
+            # Note that only deactivating an Auth Rule through this endpoint is supported at
+            # this time. If you need to (re-)activate an Auth Rule the /promote endpoint
+            # should be used to promote a draft to the currently active version.
+            sig do
+              returns(
+                T.nilable(
+                  Lithic::AuthRules::V2UpdateParams::Body::ProgramLevelRule::State::OrSymbol
+                )
+              )
             end
-          OrSymbol = T.type_alias { T.any(Symbol, String) }
+            attr_reader :state
 
-          INACTIVE =
-            T.let(
-              :INACTIVE,
-              Lithic::AuthRules::V2UpdateParams::State::TaggedSymbol
+            sig do
+              params(
+                state:
+                  Lithic::AuthRules::V2UpdateParams::Body::ProgramLevelRule::State::OrSymbol
+              ).void
+            end
+            attr_writer :state
+
+            sig do
+              params(
+                excluded_card_tokens: T::Array[String],
+                name: T.nilable(String),
+                program_level: T::Boolean,
+                state:
+                  Lithic::AuthRules::V2UpdateParams::Body::ProgramLevelRule::State::OrSymbol
+              ).returns(T.attached_class)
+            end
+            def self.new(
+              # Card tokens to which the Auth Rule does not apply.
+              excluded_card_tokens: nil,
+              # Auth Rule Name
+              name: nil,
+              # Whether the Auth Rule applies to all authorizations on the card program.
+              program_level: nil,
+              # The desired state of the Auth Rule.
+              #
+              # Note that only deactivating an Auth Rule through this endpoint is supported at
+              # this time. If you need to (re-)activate an Auth Rule the /promote endpoint
+              # should be used to promote a draft to the currently active version.
+              state: nil
             )
+            end
+
+            sig do
+              override.returns(
+                {
+                  excluded_card_tokens: T::Array[String],
+                  name: T.nilable(String),
+                  program_level: T::Boolean,
+                  state:
+                    Lithic::AuthRules::V2UpdateParams::Body::ProgramLevelRule::State::OrSymbol
+                }
+              )
+            end
+            def to_hash
+            end
+
+            # The desired state of the Auth Rule.
+            #
+            # Note that only deactivating an Auth Rule through this endpoint is supported at
+            # this time. If you need to (re-)activate an Auth Rule the /promote endpoint
+            # should be used to promote a draft to the currently active version.
+            module State
+              extend Lithic::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    Lithic::AuthRules::V2UpdateParams::Body::ProgramLevelRule::State
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              INACTIVE =
+                T.let(
+                  :INACTIVE,
+                  Lithic::AuthRules::V2UpdateParams::Body::ProgramLevelRule::State::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    Lithic::AuthRules::V2UpdateParams::Body::ProgramLevelRule::State::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+          end
 
           sig do
             override.returns(
-              T::Array[Lithic::AuthRules::V2UpdateParams::State::TaggedSymbol]
+              T::Array[Lithic::AuthRules::V2UpdateParams::Body::Variants]
             )
           end
-          def self.values
+          def self.variants
           end
         end
       end

data/rbi/lithic/models/book_transfer_retrieve_params.rbi

@@ -11,15 +11,26 @@ module Lithic
           T.any(Lithic::BookTransferRetrieveParams, Lithic::Internal::AnyHash)
         end
 
+      sig { returns(String) }
+      attr_accessor :book_transfer_token
+
       sig do
-        params(request_options: Lithic::RequestOptions::OrHash).returns(
-          T.attached_class
-        )
+        params(
+          book_transfer_token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
-      def self.new(request_options: {})
+      def self.new(book_transfer_token:, request_options: {})
       end
 
-      sig { override.returns({ request_options: Lithic::RequestOptions }) }
+      sig do
+        override.returns(
+          {
+            book_transfer_token: String,
+            request_options: Lithic::RequestOptions
+          }
+        )
+      end
       def to_hash
       end
     end

data/rbi/lithic/models/book_transfer_retry_params.rbi

@@ -11,6 +11,9 @@ module Lithic
           T.any(Lithic::BookTransferRetryParams, Lithic::Internal::AnyHash)
         end
 
+      sig { returns(String) }
+      attr_accessor :book_transfer_token
+
       # Customer-provided token that will serve as an idempotency token. This token will
       # become the transaction token.
       sig { returns(String) }
@@ -18,11 +21,13 @@ module Lithic
 
       sig do
         params(
+          book_transfer_token: String,
           retry_token: String,
           request_options: Lithic::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
       def self.new(
+        book_transfer_token:,
         # Customer-provided token that will serve as an idempotency token. This token will
         # become the transaction token.
         retry_token:,
@@ -32,7 +37,11 @@ module Lithic
 
       sig do
         override.returns(
-          { retry_token: String, request_options: Lithic::RequestOptions }
+          {
+            book_transfer_token: String,
+            retry_token: String,
+            request_options: Lithic::RequestOptions
+          }
         )
       end
       def to_hash

data/rbi/lithic/models/book_transfer_reverse_params.rbi

@@ -11,6 +11,9 @@ module Lithic
           T.any(Lithic::BookTransferReverseParams, Lithic::Internal::AnyHash)
         end
 
+      sig { returns(String) }
+      attr_accessor :book_transfer_token
+
       # Optional descriptor for the reversal.
       sig { returns(T.nilable(String)) }
       attr_reader :memo
@@ -20,11 +23,13 @@ module Lithic
 
       sig do
         params(
+          book_transfer_token: String,
           memo: String,
           request_options: Lithic::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
       def self.new(
+        book_transfer_token:,
         # Optional descriptor for the reversal.
         memo: nil,
         request_options: {}
@@ -33,7 +38,11 @@ module Lithic
 
       sig do
         override.returns(
-          { memo: String, request_options: Lithic::RequestOptions }
+          {
+            book_transfer_token: String,
+            memo: String,
+            request_options: Lithic::RequestOptions
+          }
         )
       end
       def to_hash

data/rbi/lithic/models/card_bulk_order_retrieve_params.rbi

@@ -11,15 +11,23 @@ module Lithic
           T.any(Lithic::CardBulkOrderRetrieveParams, Lithic::Internal::AnyHash)
         end
 
+      sig { returns(String) }
+      attr_accessor :bulk_order_token
+
       sig do
-        params(request_options: Lithic::RequestOptions::OrHash).returns(
-          T.attached_class
-        )
+        params(
+          bulk_order_token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(T.attached_class)
       end
-      def self.new(request_options: {})
+      def self.new(bulk_order_token:, request_options: {})
       end
 
-      sig { override.returns({ request_options: Lithic::RequestOptions }) }
+      sig do
+        override.returns(
+          { bulk_order_token: String, request_options: Lithic::RequestOptions }
+        )
+      end
       def to_hash
       end
     end

data/rbi/lithic/models/card_bulk_order_update_params.rbi

@@ -11,17 +11,22 @@ module Lithic
           T.any(Lithic::CardBulkOrderUpdateParams, Lithic::Internal::AnyHash)
         end
 
+      sig { returns(String) }
+      attr_accessor :bulk_order_token
+
       # Status to update the bulk order to. Use LOCKED to finalize the order
       sig { returns(Lithic::CardBulkOrderUpdateParams::Status::OrSymbol) }
       attr_accessor :status
 
       sig do
         params(
+          bulk_order_token: String,
           status: Lithic::CardBulkOrderUpdateParams::Status::OrSymbol,
           request_options: Lithic::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
       def self.new(
+        bulk_order_token:,
         # Status to update the bulk order to. Use LOCKED to finalize the order
         status:,
         request_options: {}
@@ -31,6 +36,7 @@ module Lithic
       sig do
         override.returns(
           {
+            bulk_order_token: String,
             status: Lithic::CardBulkOrderUpdateParams::Status::OrSymbol,
             request_options: Lithic::RequestOptions
           }