lithic 0.10.0 → 0.12.0

data/rbi/lithic/models/auth_rules/report_stats.rbi

@@ -10,86 +10,44 @@ module Lithic
           end
 
         # A mapping of action types to the number of times that action was returned by
-        # this rule during the relevant period. Actions are the possible outcomes of a
+        # this version during the relevant period. Actions are the possible outcomes of a
         # rule evaluation, such as DECLINE, CHALLENGE, REQUIRE_TFA, etc. In case rule
         # didn't trigger any action, it's counted under NO_ACTION key.
-        sig { returns(T.nilable(T::Hash[Symbol, Integer])) }
-        attr_reader :action_counts
+        sig { returns(T::Hash[Symbol, Integer]) }
+        attr_accessor :action_counts
 
-        sig { params(action_counts: T::Hash[Symbol, Integer]).void }
-        attr_writer :action_counts
+        # Example events and their outcomes for this version.
+        sig { returns(T::Array[Lithic::AuthRules::ReportStats::Example]) }
+        attr_accessor :examples
 
-        # The total number of historical transactions approved by this rule during the
-        # relevant period, or the number of transactions that would have been approved if
-        # the rule was evaluated in shadow mode.
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :approved
+        # The evaluation mode of this version during the reported period.
+        sig { returns(Lithic::AuthRules::ReportStats::State::TaggedSymbol) }
+        attr_accessor :state
 
-        sig { params(approved: Integer).void }
-        attr_writer :approved
-
-        # The total number of historical transactions challenged by this rule during the
-        # relevant period, or the number of transactions that would have been challenged
-        # if the rule was evaluated in shadow mode. Currently applicable only for 3DS Auth
-        # Rules.
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :challenged
-
-        sig { params(challenged: Integer).void }
-        attr_writer :challenged
-
-        # The total number of historical transactions declined by this rule during the
-        # relevant period, or the number of transactions that would have been declined if
-        # the rule was evaluated in shadow mode.
-        sig { returns(T.nilable(Integer)) }
-        attr_reader :declined
-
-        sig { params(declined: Integer).void }
-        attr_writer :declined
-
-        # Example events and their outcomes.
-        sig do
-          returns(T.nilable(T::Array[Lithic::AuthRules::ReportStats::Example]))
-        end
-        attr_reader :examples
-
-        sig do
-          params(
-            examples: T::Array[Lithic::AuthRules::ReportStats::Example::OrHash]
-          ).void
-        end
-        attr_writer :examples
+        # The rule version number.
+        sig { returns(Integer) }
+        attr_accessor :version
 
         sig do
           params(
             action_counts: T::Hash[Symbol, Integer],
-            approved: Integer,
-            challenged: Integer,
-            declined: Integer,
-            examples: T::Array[Lithic::AuthRules::ReportStats::Example::OrHash]
+            examples: T::Array[Lithic::AuthRules::ReportStats::Example::OrHash],
+            state: Lithic::AuthRules::ReportStats::State::OrSymbol,
+            version: Integer
           ).returns(T.attached_class)
         end
         def self.new(
           # A mapping of action types to the number of times that action was returned by
-          # this rule during the relevant period. Actions are the possible outcomes of a
+          # this version during the relevant period. Actions are the possible outcomes of a
           # rule evaluation, such as DECLINE, CHALLENGE, REQUIRE_TFA, etc. In case rule
           # didn't trigger any action, it's counted under NO_ACTION key.
-          action_counts: nil,
-          # The total number of historical transactions approved by this rule during the
-          # relevant period, or the number of transactions that would have been approved if
-          # the rule was evaluated in shadow mode.
-          approved: nil,
-          # The total number of historical transactions challenged by this rule during the
-          # relevant period, or the number of transactions that would have been challenged
-          # if the rule was evaluated in shadow mode. Currently applicable only for 3DS Auth
-          # Rules.
-          challenged: nil,
-          # The total number of historical transactions declined by this rule during the
-          # relevant period, or the number of transactions that would have been declined if
-          # the rule was evaluated in shadow mode.
-          declined: nil,
-          # Example events and their outcomes.
-          examples: nil
+          action_counts:,
+          # Example events and their outcomes for this version.
+          examples:,
+          # The evaluation mode of this version during the reported period.
+          state:,
+          # The rule version number.
+          version:
         )
         end
 
@@ -97,10 +55,9 @@ module Lithic
           override.returns(
             {
               action_counts: T::Hash[Symbol, Integer],
-              approved: Integer,
-              challenged: Integer,
-              declined: Integer,
-              examples: T::Array[Lithic::AuthRules::ReportStats::Example]
+              examples: T::Array[Lithic::AuthRules::ReportStats::Example],
+              state: Lithic::AuthRules::ReportStats::State::TaggedSymbol,
+              version: Integer
             }
           )
         end
@@ -116,74 +73,27 @@ module Lithic
               )
             end
 
-          # The actions taken by the rule for this event.
+          # The actions taken by this version for this event.
           sig do
             returns(
-              T.nilable(
-                T::Array[
-                  Lithic::AuthRules::ReportStats::Example::Action::Variants
-                ]
-              )
+              T::Array[
+                Lithic::AuthRules::ReportStats::Example::Action::Variants
+              ]
             )
           end
-          attr_reader :actions
-
-          sig do
-            params(
-              actions:
-                T::Array[
-                  T.any(
-                    Lithic::AuthRules::ReportStats::Example::Action::DeclineActionAuthorization::OrHash,
-                    Lithic::AuthRules::ReportStats::Example::Action::ChallengeActionAuthorization::OrHash,
-                    Lithic::AuthRules::ReportStats::Example::Action::ResultAuthentication3DSAction::OrHash,
-                    Lithic::AuthRules::ReportStats::Example::Action::DeclineActionTokenization::OrHash,
-                    Lithic::AuthRules::ReportStats::Example::Action::RequireTfaAction::OrHash,
-                    Lithic::AuthRules::ReportStats::Example::Action::ApproveActionACH::OrHash,
-                    Lithic::AuthRules::ReportStats::Example::Action::ReturnAction::OrHash
-                  )
-                ]
-            ).void
-          end
-          attr_writer :actions
-
-          # Whether the rule would have approved the request.
-          sig { returns(T.nilable(T::Boolean)) }
-          attr_reader :approved
-
-          sig { params(approved: T::Boolean).void }
-          attr_writer :approved
-
-          # The decision made by the rule for this event.
-          sig do
-            returns(
-              T.nilable(
-                Lithic::AuthRules::ReportStats::Example::Decision::TaggedSymbol
-              )
-            )
-          end
-          attr_reader :decision
-
-          sig do
-            params(
-              decision:
-                Lithic::AuthRules::ReportStats::Example::Decision::OrSymbol
-            ).void
-          end
-          attr_writer :decision
+          attr_accessor :actions
 
           # The event token.
-          sig { returns(T.nilable(String)) }
-          attr_reader :event_token
-
-          sig { params(event_token: String).void }
-          attr_writer :event_token
+          sig { returns(String) }
+          attr_accessor :event_token
 
           # The timestamp of the event.
-          sig { returns(T.nilable(Time)) }
-          attr_reader :timestamp
+          sig { returns(Time) }
+          attr_accessor :timestamp
 
-          sig { params(timestamp: Time).void }
-          attr_writer :timestamp
+          # The token of the transaction associated with the event
+          sig { returns(T.nilable(String)) }
+          attr_accessor :transaction_token
 
           sig do
             params(
@@ -199,24 +109,20 @@ module Lithic
                     Lithic::AuthRules::ReportStats::Example::Action::ReturnAction::OrHash
                   )
                 ],
-              approved: T::Boolean,
-              decision:
-                Lithic::AuthRules::ReportStats::Example::Decision::OrSymbol,
               event_token: String,
-              timestamp: Time
+              timestamp: Time,
+              transaction_token: T.nilable(String)
             ).returns(T.attached_class)
           end
           def self.new(
-            # The actions taken by the rule for this event.
-            actions: nil,
-            # Whether the rule would have approved the request.
-            approved: nil,
-            # The decision made by the rule for this event.
-            decision: nil,
+            # The actions taken by this version for this event.
+            actions:,
             # The event token.
-            event_token: nil,
+            event_token:,
             # The timestamp of the event.
-            timestamp: nil
+            timestamp:,
+            # The token of the transaction associated with the event
+            transaction_token: nil
           )
           end
 
@@ -227,11 +133,9 @@ module Lithic
                   T::Array[
                     Lithic::AuthRules::ReportStats::Example::Action::Variants
                   ],
-                approved: T::Boolean,
-                decision:
-                  Lithic::AuthRules::ReportStats::Example::Decision::TaggedSymbol,
                 event_token: String,
-                timestamp: Time
+                timestamp: Time,
+                transaction_token: T.nilable(String)
               }
             )
           end
@@ -1710,42 +1614,34 @@ module Lithic
             def self.variants
             end
           end
+        end
 
-          # The decision made by the rule for this event.
-          module Decision
-            extend Lithic::Internal::Type::Enum
-
-            TaggedSymbol =
-              T.type_alias do
-                T.all(Symbol, Lithic::AuthRules::ReportStats::Example::Decision)
-              end
-            OrSymbol = T.type_alias { T.any(Symbol, String) }
+        # The evaluation mode of this version during the reported period.
+        module State
+          extend Lithic::Internal::Type::Enum
 
-            APPROVED =
-              T.let(
-                :APPROVED,
-                Lithic::AuthRules::ReportStats::Example::Decision::TaggedSymbol
-              )
-            DECLINED =
-              T.let(
-                :DECLINED,
-                Lithic::AuthRules::ReportStats::Example::Decision::TaggedSymbol
-              )
-            CHALLENGED =
-              T.let(
-                :CHALLENGED,
-                Lithic::AuthRules::ReportStats::Example::Decision::TaggedSymbol
-              )
-
-            sig do
-              override.returns(
-                T::Array[
-                  Lithic::AuthRules::ReportStats::Example::Decision::TaggedSymbol
-                ]
-              )
-            end
-            def self.values
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Lithic::AuthRules::ReportStats::State)
             end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          ACTIVE =
+            T.let(:ACTIVE, Lithic::AuthRules::ReportStats::State::TaggedSymbol)
+          SHADOW =
+            T.let(:SHADOW, Lithic::AuthRules::ReportStats::State::TaggedSymbol)
+          INACTIVE =
+            T.let(
+              :INACTIVE,
+              Lithic::AuthRules::ReportStats::State::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[Lithic::AuthRules::ReportStats::State::TaggedSymbol]
+            )
+          end
+          def self.values
           end
         end
       end

data/rbi/lithic/models/auth_rules/rule_feature.rbi

@@ -24,6 +24,10 @@ module Lithic
       # - `SPEND_VELOCITY`: Spend velocity data for the card or account. Requires
       #   `scope`, `period`, and optionally `filters` to configure the velocity
       #   calculation. Available for AUTHORIZATION event stream rules.
+      # - `TRANSACTION_HISTORY_SIGNALS`: Behavioral feature state derived from the
+      #   entity's transaction history. Requires `scope` to specify whether to load
+      #   card, account, or business account history. Available for AUTHORIZATION event
+      #   stream rules.
       module RuleFeature
         extend Lithic::Internal::Type::Union
 
@@ -37,7 +41,8 @@ module Lithic
               Lithic::AuthRules::RuleFeature::CardFeature,
               Lithic::AuthRules::RuleFeature::AccountHolderFeature,
               Lithic::AuthRules::RuleFeature::IPMetadataFeature,
-              Lithic::AuthRules::RuleFeature::SpendVelocityFeature
+              Lithic::AuthRules::RuleFeature::SpendVelocityFeature,
+              Lithic::AuthRules::RuleFeature::TransactionHistorySignalsFeature
             )
           end
 
@@ -403,6 +408,104 @@ module Lithic
           end
         end
 
+        class TransactionHistorySignalsFeature < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::AuthRules::RuleFeature::TransactionHistorySignalsFeature,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # The entity scope to load transaction history signals for.
+          sig do
+            returns(
+              Lithic::AuthRules::RuleFeature::TransactionHistorySignalsFeature::Scope::OrSymbol
+            )
+          end
+          attr_accessor :scope
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The variable name for this feature in the rule function signature
+          sig { returns(T.nilable(String)) }
+          attr_reader :name
+
+          sig { params(name: String).void }
+          attr_writer :name
+
+          sig do
+            params(
+              scope:
+                Lithic::AuthRules::RuleFeature::TransactionHistorySignalsFeature::Scope::OrSymbol,
+              name: String,
+              type: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The entity scope to load transaction history signals for.
+            scope:,
+            # The variable name for this feature in the rule function signature
+            name: nil,
+            type: :TRANSACTION_HISTORY_SIGNALS
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                scope:
+                  Lithic::AuthRules::RuleFeature::TransactionHistorySignalsFeature::Scope::OrSymbol,
+                type: Symbol,
+                name: String
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # The entity scope to load transaction history signals for.
+          module Scope
+            extend Lithic::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  Lithic::AuthRules::RuleFeature::TransactionHistorySignalsFeature::Scope
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            CARD =
+              T.let(
+                :CARD,
+                Lithic::AuthRules::RuleFeature::TransactionHistorySignalsFeature::Scope::TaggedSymbol
+              )
+            ACCOUNT =
+              T.let(
+                :ACCOUNT,
+                Lithic::AuthRules::RuleFeature::TransactionHistorySignalsFeature::Scope::TaggedSymbol
+              )
+            BUSINESS_ACCOUNT =
+              T.let(
+                :BUSINESS_ACCOUNT,
+                Lithic::AuthRules::RuleFeature::TransactionHistorySignalsFeature::Scope::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  Lithic::AuthRules::RuleFeature::TransactionHistorySignalsFeature::Scope::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
         sig do
           override.returns(T::Array[Lithic::AuthRules::RuleFeature::Variants])
         end

data/rbi/lithic/models/auth_rules/typescript_code_parameters.rbi

@@ -30,7 +30,8 @@ module Lithic
                 Lithic::AuthRules::RuleFeature::CardFeature,
                 Lithic::AuthRules::RuleFeature::AccountHolderFeature,
                 Lithic::AuthRules::RuleFeature::IPMetadataFeature,
-                Lithic::AuthRules::RuleFeature::SpendVelocityFeature
+                Lithic::AuthRules::RuleFeature::SpendVelocityFeature,
+                Lithic::AuthRules::RuleFeature::TransactionHistorySignalsFeature
               )
             ]
           )
@@ -51,7 +52,8 @@ module Lithic
                   Lithic::AuthRules::RuleFeature::CardFeature::OrHash,
                   Lithic::AuthRules::RuleFeature::AccountHolderFeature::OrHash,
                   Lithic::AuthRules::RuleFeature::IPMetadataFeature::OrHash,
-                  Lithic::AuthRules::RuleFeature::SpendVelocityFeature::OrHash
+                  Lithic::AuthRules::RuleFeature::SpendVelocityFeature::OrHash,
+                  Lithic::AuthRules::RuleFeature::TransactionHistorySignalsFeature::OrHash
                 )
               ]
           ).returns(T.attached_class)
@@ -80,7 +82,8 @@ module Lithic
                     Lithic::AuthRules::RuleFeature::CardFeature,
                     Lithic::AuthRules::RuleFeature::AccountHolderFeature,
                     Lithic::AuthRules::RuleFeature::IPMetadataFeature,
-                    Lithic::AuthRules::RuleFeature::SpendVelocityFeature
+                    Lithic::AuthRules::RuleFeature::SpendVelocityFeature,
+                    Lithic::AuthRules::RuleFeature::TransactionHistorySignalsFeature
                   )
                 ]
             }

data/rbi/lithic/models/auth_rules/v2_list_results_response.rbi

@@ -68,6 +68,10 @@ module Lithic
           sig { returns(Integer) }
           attr_accessor :rule_version
 
+          # The token of the transaction that triggered the rule evaluation
+          sig { returns(T.nilable(String)) }
+          attr_accessor :transaction_token
+
           sig do
             params(
               token: String,
@@ -84,6 +88,7 @@ module Lithic
               mode:
                 Lithic::Models::AuthRules::V2ListResultsResponse::AuthorizationResult::Mode::OrSymbol,
               rule_version: Integer,
+              transaction_token: T.nilable(String),
               event_stream: Symbol
             ).returns(T.attached_class)
           end
@@ -102,6 +107,8 @@ module Lithic
             mode:,
             # Version of the rule that was evaluated
             rule_version:,
+            # The token of the transaction that triggered the rule evaluation
+            transaction_token:,
             # The event stream during which the rule was evaluated
             event_stream: :AUTHORIZATION
           )
@@ -121,7 +128,8 @@ module Lithic
                 event_token: String,
                 mode:
                   Lithic::Models::AuthRules::V2ListResultsResponse::AuthorizationResult::Mode::TaggedSymbol,
-                rule_version: Integer
+                rule_version: Integer,
+                transaction_token: T.nilable(String)
               }
             )
           end
@@ -719,6 +727,10 @@ module Lithic
           sig { returns(Integer) }
           attr_accessor :rule_version
 
+          # The token of the transaction that triggered the rule evaluation
+          sig { returns(T.nilable(String)) }
+          attr_accessor :transaction_token
+
           sig do
             params(
               token: String,
@@ -732,6 +744,7 @@ module Lithic
               mode:
                 Lithic::Models::AuthRules::V2ListResultsResponse::Authentication3DSResult::Mode::OrSymbol,
               rule_version: Integer,
+              transaction_token: T.nilable(String),
               event_stream: Symbol
             ).returns(T.attached_class)
           end
@@ -750,6 +763,8 @@ module Lithic
             mode:,
             # Version of the rule that was evaluated
             rule_version:,
+            # The token of the transaction that triggered the rule evaluation
+            transaction_token:,
             # The event stream during which the rule was evaluated
             event_stream: :THREE_DS_AUTHENTICATION
           )
@@ -769,7 +784,8 @@ module Lithic
                 event_token: String,
                 mode:
                   Lithic::Models::AuthRules::V2ListResultsResponse::Authentication3DSResult::Mode::TaggedSymbol,
-                rule_version: Integer
+                rule_version: Integer,
+                transaction_token: T.nilable(String)
               }
             )
           end
@@ -947,6 +963,10 @@ module Lithic
           sig { returns(Integer) }
           attr_accessor :rule_version
 
+          # The token of the transaction that triggered the rule evaluation
+          sig { returns(T.nilable(String)) }
+          attr_accessor :transaction_token
+
           sig do
             params(
               token: String,
@@ -963,6 +983,7 @@ module Lithic
               mode:
                 Lithic::Models::AuthRules::V2ListResultsResponse::TokenizationResult::Mode::OrSymbol,
               rule_version: Integer,
+              transaction_token: T.nilable(String),
               event_stream: Symbol
             ).returns(T.attached_class)
           end
@@ -981,6 +1002,8 @@ module Lithic
             mode:,
             # Version of the rule that was evaluated
             rule_version:,
+            # The token of the transaction that triggered the rule evaluation
+            transaction_token:,
             # The event stream during which the rule was evaluated
             event_stream: :TOKENIZATION
           )
@@ -1000,7 +1023,8 @@ module Lithic
                 event_token: String,
                 mode:
                   Lithic::Models::AuthRules::V2ListResultsResponse::TokenizationResult::Mode::TaggedSymbol,
-                rule_version: Integer
+                rule_version: Integer,
+                transaction_token: T.nilable(String)
               }
             )
           end
@@ -1522,6 +1546,10 @@ module Lithic
           sig { returns(Integer) }
           attr_accessor :rule_version
 
+          # The token of the transaction that triggered the rule evaluation
+          sig { returns(T.nilable(String)) }
+          attr_accessor :transaction_token
+
           sig do
             params(
               token: String,
@@ -1539,7 +1567,8 @@ module Lithic
               event_token: String,
               mode:
                 Lithic::Models::AuthRules::V2ListResultsResponse::ACHResult::Mode::OrSymbol,
-              rule_version: Integer
+              rule_version: Integer,
+              transaction_token: T.nilable(String)
             ).returns(T.attached_class)
           end
           def self.new(
@@ -1558,7 +1587,9 @@ module Lithic
             # The state of the Auth Rule
             mode:,
             # Version of the rule that was evaluated
-            rule_version:
+            rule_version:,
+            # The token of the transaction that triggered the rule evaluation
+            transaction_token:
           )
           end
 
@@ -1577,7 +1608,8 @@ module Lithic
                 event_token: String,
                 mode:
                   Lithic::Models::AuthRules::V2ListResultsResponse::ACHResult::Mode::TaggedSymbol,
-                rule_version: Integer
+                rule_version: Integer,
+                transaction_token: T.nilable(String)
               }
             )
           end