lithic 0.14.0 → 0.16.0

data/rbi/lithic/models/transaction_monitoring/case_list_params.rbi

@@ -0,0 +1,220 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      class CaseListParams < Lithic::Internal::Type::BaseModel
+        extend Lithic::Internal::Type::RequestParameters::Converter
+        include Lithic::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransactionMonitoring::CaseListParams,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Only return cases that include transactions on the provided account.
+        sig { returns(T.nilable(String)) }
+        attr_reader :account_token
+
+        sig { params(account_token: String).void }
+        attr_writer :account_token
+
+        # Only return cases assigned to the provided value. Pass an empty string to return
+        # only unassigned cases.
+        sig { returns(T.nilable(String)) }
+        attr_reader :assignee
+
+        sig { params(assignee: String).void }
+        attr_writer :assignee
+
+        # Date string in RFC 3339 format. Only entries created after the specified time
+        # will be included. UTC time zone.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :begin_
+
+        sig { params(begin_: Time).void }
+        attr_writer :begin_
+
+        # Only return cases that include transactions on the provided card.
+        sig { returns(T.nilable(String)) }
+        attr_reader :card_token
+
+        sig { params(card_token: String).void }
+        attr_writer :card_token
+
+        # Date string in RFC 3339 format. Only entries created before the specified time
+        # will be included. UTC time zone.
+        sig { returns(T.nilable(Time)) }
+        attr_reader :end_
+
+        sig { params(end_: Time).void }
+        attr_writer :end_
+
+        # A cursor representing an item's token before which a page of results should end.
+        # Used to retrieve the previous page of results before this item.
+        sig { returns(T.nilable(String)) }
+        attr_reader :ending_before
+
+        sig { params(ending_before: String).void }
+        attr_writer :ending_before
+
+        # Only return cases associated with the provided entity.
+        sig { returns(T.nilable(String)) }
+        attr_reader :entity_token
+
+        sig { params(entity_token: String).void }
+        attr_writer :entity_token
+
+        # Page size (for pagination).
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :page_size
+
+        sig { params(page_size: Integer).void }
+        attr_writer :page_size
+
+        # Only return cases belonging to the provided queue.
+        sig { returns(T.nilable(String)) }
+        attr_reader :queue_token
+
+        sig { params(queue_token: String).void }
+        attr_writer :queue_token
+
+        # Only return cases triggered by the provided transaction monitoring rule.
+        sig { returns(T.nilable(String)) }
+        attr_reader :rule_token
+
+        sig { params(rule_token: String).void }
+        attr_writer :rule_token
+
+        # Sort order for the returned cases.
+        sig do
+          returns(
+            T.nilable(Lithic::TransactionMonitoring::CaseSortOrder::OrSymbol)
+          )
+        end
+        attr_reader :sort_by
+
+        sig do
+          params(
+            sort_by: Lithic::TransactionMonitoring::CaseSortOrder::OrSymbol
+          ).void
+        end
+        attr_writer :sort_by
+
+        # A cursor representing an item's token after which a page of results should
+        # begin. Used to retrieve the next page of results after this item.
+        sig { returns(T.nilable(String)) }
+        attr_reader :starting_after
+
+        sig { params(starting_after: String).void }
+        attr_writer :starting_after
+
+        # Only return cases with the provided status.
+        sig do
+          returns(
+            T.nilable(Lithic::TransactionMonitoring::CaseStatus::OrSymbol)
+          )
+        end
+        attr_reader :status
+
+        sig do
+          params(
+            status: Lithic::TransactionMonitoring::CaseStatus::OrSymbol
+          ).void
+        end
+        attr_writer :status
+
+        # Only return cases that include the provided transaction.
+        sig { returns(T.nilable(String)) }
+        attr_reader :transaction_token
+
+        sig { params(transaction_token: String).void }
+        attr_writer :transaction_token
+
+        sig do
+          params(
+            account_token: String,
+            assignee: String,
+            begin_: Time,
+            card_token: String,
+            end_: Time,
+            ending_before: String,
+            entity_token: String,
+            page_size: Integer,
+            queue_token: String,
+            rule_token: String,
+            sort_by: Lithic::TransactionMonitoring::CaseSortOrder::OrSymbol,
+            starting_after: String,
+            status: Lithic::TransactionMonitoring::CaseStatus::OrSymbol,
+            transaction_token: String,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Only return cases that include transactions on the provided account.
+          account_token: nil,
+          # Only return cases assigned to the provided value. Pass an empty string to return
+          # only unassigned cases.
+          assignee: nil,
+          # Date string in RFC 3339 format. Only entries created after the specified time
+          # will be included. UTC time zone.
+          begin_: nil,
+          # Only return cases that include transactions on the provided card.
+          card_token: nil,
+          # Date string in RFC 3339 format. Only entries created before the specified time
+          # will be included. UTC time zone.
+          end_: nil,
+          # A cursor representing an item's token before which a page of results should end.
+          # Used to retrieve the previous page of results before this item.
+          ending_before: nil,
+          # Only return cases associated with the provided entity.
+          entity_token: nil,
+          # Page size (for pagination).
+          page_size: nil,
+          # Only return cases belonging to the provided queue.
+          queue_token: nil,
+          # Only return cases triggered by the provided transaction monitoring rule.
+          rule_token: nil,
+          # Sort order for the returned cases.
+          sort_by: nil,
+          # A cursor representing an item's token after which a page of results should
+          # begin. Used to retrieve the next page of results after this item.
+          starting_after: nil,
+          # Only return cases with the provided status.
+          status: nil,
+          # Only return cases that include the provided transaction.
+          transaction_token: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              account_token: String,
+              assignee: String,
+              begin_: Time,
+              card_token: String,
+              end_: Time,
+              ending_before: String,
+              entity_token: String,
+              page_size: Integer,
+              queue_token: String,
+              rule_token: String,
+              sort_by: Lithic::TransactionMonitoring::CaseSortOrder::OrSymbol,
+              starting_after: String,
+              status: Lithic::TransactionMonitoring::CaseStatus::OrSymbol,
+              transaction_token: String,
+              request_options: Lithic::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/case_list_transactions_params.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      class CaseListTransactionsParams < Lithic::Internal::Type::BaseModel
+        extend Lithic::Internal::Type::RequestParameters::Converter
+        include Lithic::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransactionMonitoring::CaseListTransactionsParams,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :case_token
+
+        # A cursor representing an item's token before which a page of results should end.
+        # Used to retrieve the previous page of results before this item.
+        sig { returns(T.nilable(String)) }
+        attr_reader :ending_before
+
+        sig { params(ending_before: String).void }
+        attr_writer :ending_before
+
+        # Page size (for pagination).
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :page_size
+
+        sig { params(page_size: Integer).void }
+        attr_writer :page_size
+
+        # A cursor representing an item's token after which a page of results should
+        # begin. Used to retrieve the next page of results after this item.
+        sig { returns(T.nilable(String)) }
+        attr_reader :starting_after
+
+        sig { params(starting_after: String).void }
+        attr_writer :starting_after
+
+        sig do
+          params(
+            case_token: String,
+            ending_before: String,
+            page_size: Integer,
+            starting_after: String,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          case_token:,
+          # A cursor representing an item's token before which a page of results should end.
+          # Used to retrieve the previous page of results before this item.
+          ending_before: nil,
+          # Page size (for pagination).
+          page_size: nil,
+          # A cursor representing an item's token after which a page of results should
+          # begin. Used to retrieve the next page of results after this item.
+          starting_after: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              case_token: String,
+              ending_before: String,
+              page_size: Integer,
+              starting_after: String,
+              request_options: Lithic::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/case_priority.rbi

@@ -0,0 +1,44 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      # Priority level of a case, controlling queue ordering and SLA urgency
+      module CasePriority
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::TransactionMonitoring::CasePriority)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        LOW =
+          T.let(:LOW, Lithic::TransactionMonitoring::CasePriority::TaggedSymbol)
+        MEDIUM =
+          T.let(
+            :MEDIUM,
+            Lithic::TransactionMonitoring::CasePriority::TaggedSymbol
+          )
+        HIGH =
+          T.let(
+            :HIGH,
+            Lithic::TransactionMonitoring::CasePriority::TaggedSymbol
+          )
+        CRITICAL =
+          T.let(
+            :CRITICAL,
+            Lithic::TransactionMonitoring::CasePriority::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Lithic::TransactionMonitoring::CasePriority::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/case_retrieve_cards_params.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      class CaseRetrieveCardsParams < Lithic::Internal::Type::BaseModel
+        extend Lithic::Internal::Type::RequestParameters::Converter
+        include Lithic::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransactionMonitoring::CaseRetrieveCardsParams,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :case_token
+
+        sig do
+          params(
+            case_token: String,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(case_token:, request_options: {})
+        end
+
+        sig do
+          override.returns(
+            { case_token: String, request_options: Lithic::RequestOptions }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/case_retrieve_cards_response.rbi

@@ -0,0 +1,15 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      CaseRetrieveCardsResponse =
+        T.let(
+          Lithic::Internal::Type::ArrayOf[
+            Lithic::TransactionMonitoring::CaseCard
+          ],
+          Lithic::Internal::Type::Converter
+        )
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/case_retrieve_params.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      class CaseRetrieveParams < Lithic::Internal::Type::BaseModel
+        extend Lithic::Internal::Type::RequestParameters::Converter
+        include Lithic::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransactionMonitoring::CaseRetrieveParams,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :case_token
+
+        sig do
+          params(
+            case_token: String,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(case_token:, request_options: {})
+        end
+
+        sig do
+          override.returns(
+            { case_token: String, request_options: Lithic::RequestOptions }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/case_sort_order.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      # Sort order for listing cases. Defaults to `CREATED_DESC` (newest first):
+      #
+      # - `CREATED_ASC` - Oldest first
+      # - `CREATED_DESC` - Newest first
+      # - `PRIORITY_DESC` - Highest priority first
+      # - `PRIORITY_ASC` - Lowest priority first
+      # - `STATUS_DESC` - Furthest workflow stage first
+      # - `STATUS_ASC` - Earliest workflow stage first
+      module CaseSortOrder
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::TransactionMonitoring::CaseSortOrder)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        CREATED_ASC =
+          T.let(
+            :CREATED_ASC,
+            Lithic::TransactionMonitoring::CaseSortOrder::TaggedSymbol
+          )
+        CREATED_DESC =
+          T.let(
+            :CREATED_DESC,
+            Lithic::TransactionMonitoring::CaseSortOrder::TaggedSymbol
+          )
+        PRIORITY_DESC =
+          T.let(
+            :PRIORITY_DESC,
+            Lithic::TransactionMonitoring::CaseSortOrder::TaggedSymbol
+          )
+        PRIORITY_ASC =
+          T.let(
+            :PRIORITY_ASC,
+            Lithic::TransactionMonitoring::CaseSortOrder::TaggedSymbol
+          )
+        STATUS_DESC =
+          T.let(
+            :STATUS_DESC,
+            Lithic::TransactionMonitoring::CaseSortOrder::TaggedSymbol
+          )
+        STATUS_ASC =
+          T.let(
+            :STATUS_ASC,
+            Lithic::TransactionMonitoring::CaseSortOrder::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Lithic::TransactionMonitoring::CaseSortOrder::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/case_status.rbi

@@ -0,0 +1,63 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      # Status of a case as it progresses through the review workflow:
+      #
+      # - `OPEN` - The case has been created and is still collecting matching
+      #   transactions
+      # - `ASSIGNED` - An analyst has been assigned and transaction collection has
+      #   stopped
+      # - `IN_REVIEW` - The case is actively being investigated
+      # - `ESCALATED` - The case has been reviewed and requires additional oversight
+      # - `RESOLVED` - A determination has been made and a resolution recorded
+      # - `CLOSED` - The case is finalized
+      module CaseStatus
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::TransactionMonitoring::CaseStatus)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        OPEN =
+          T.let(:OPEN, Lithic::TransactionMonitoring::CaseStatus::TaggedSymbol)
+        ASSIGNED =
+          T.let(
+            :ASSIGNED,
+            Lithic::TransactionMonitoring::CaseStatus::TaggedSymbol
+          )
+        IN_REVIEW =
+          T.let(
+            :IN_REVIEW,
+            Lithic::TransactionMonitoring::CaseStatus::TaggedSymbol
+          )
+        ESCALATED =
+          T.let(
+            :ESCALATED,
+            Lithic::TransactionMonitoring::CaseStatus::TaggedSymbol
+          )
+        RESOLVED =
+          T.let(
+            :RESOLVED,
+            Lithic::TransactionMonitoring::CaseStatus::TaggedSymbol
+          )
+        CLOSED =
+          T.let(
+            :CLOSED,
+            Lithic::TransactionMonitoring::CaseStatus::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Lithic::TransactionMonitoring::CaseStatus::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/case_transaction.rbi

@@ -0,0 +1,75 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      class CaseTransaction < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransactionMonitoring::CaseTransaction,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Globally unique identifier for the transaction
+        sig { returns(String) }
+        attr_accessor :token
+
+        # Token of the account the transaction belongs to
+        sig { returns(String) }
+        attr_accessor :account_token
+
+        # Date and time at which the transaction was added to the case
+        sig { returns(Time) }
+        attr_accessor :added_at
+
+        # Token of the card the transaction was made on
+        sig { returns(String) }
+        attr_accessor :card_token
+
+        # Date and time at which the transaction was created
+        sig { returns(Time) }
+        attr_accessor :transaction_created_at
+
+        # A single transaction associated with a case
+        sig do
+          params(
+            token: String,
+            account_token: String,
+            added_at: Time,
+            card_token: String,
+            transaction_created_at: Time
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Globally unique identifier for the transaction
+          token:,
+          # Token of the account the transaction belongs to
+          account_token:,
+          # Date and time at which the transaction was added to the case
+          added_at:,
+          # Token of the card the transaction was made on
+          card_token:,
+          # Date and time at which the transaction was created
+          transaction_created_at:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              token: String,
+              account_token: String,
+              added_at: Time,
+              card_token: String,
+              transaction_created_at: Time
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end