lithic 0.15.0 → 0.17.0

data/rbi/lithic/models/transaction_monitoring/case_entity.rbi

@@ -0,0 +1,101 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      class CaseEntity < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransactionMonitoring::CaseEntity,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Globally unique identifier for the associated entity
+        sig { returns(String) }
+        attr_accessor :entity_token
+
+        # The type of entity a case is associated with:
+        #
+        # - `CARD` - The case is associated with a card
+        # - `ACCOUNT` - The case is associated with an account
+        sig do
+          returns(
+            Lithic::TransactionMonitoring::CaseEntity::EntityType::TaggedSymbol
+          )
+        end
+        attr_accessor :entity_type
+
+        # The entity a case is associated with
+        sig do
+          params(
+            entity_token: String,
+            entity_type:
+              Lithic::TransactionMonitoring::CaseEntity::EntityType::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Globally unique identifier for the associated entity
+          entity_token:,
+          # The type of entity a case is associated with:
+          #
+          # - `CARD` - The case is associated with a card
+          # - `ACCOUNT` - The case is associated with an account
+          entity_type:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              entity_token: String,
+              entity_type:
+                Lithic::TransactionMonitoring::CaseEntity::EntityType::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # The type of entity a case is associated with:
+        #
+        # - `CARD` - The case is associated with a card
+        # - `ACCOUNT` - The case is associated with an account
+        module EntityType
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Lithic::TransactionMonitoring::CaseEntity::EntityType
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          CARD =
+            T.let(
+              :CARD,
+              Lithic::TransactionMonitoring::CaseEntity::EntityType::TaggedSymbol
+            )
+          ACCOUNT =
+            T.let(
+              :ACCOUNT,
+              Lithic::TransactionMonitoring::CaseEntity::EntityType::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::TransactionMonitoring::CaseEntity::EntityType::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/case_list_activity_params.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      class CaseListActivityParams < Lithic::Internal::Type::BaseModel
+        extend Lithic::Internal::Type::RequestParameters::Converter
+        include Lithic::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransactionMonitoring::CaseListActivityParams,
+              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_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