lithic 0.14.0 → 0.16.0

data/rbi/lithic/models/transaction_monitoring/cases/file_list_params.rbi

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

data/rbi/lithic/models/transaction_monitoring/cases/file_retrieve_params.rbi

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

data/rbi/lithic/models/transaction_monitoring/cases/file_status.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      module Cases
+        # Lifecycle status of a case file:
+        #
+        # - `PENDING` - An upload URL has been issued and the file is awaiting upload
+        # - `READY` - The file has been uploaded and validated; a download URL is
+        #   available
+        # - `REJECTED` - File validation failed; see `failure_reason` for details
+        module FileStatus
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Lithic::TransactionMonitoring::Cases::FileStatus)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          PENDING =
+            T.let(
+              :PENDING,
+              Lithic::TransactionMonitoring::Cases::FileStatus::TaggedSymbol
+            )
+          READY =
+            T.let(
+              :READY,
+              Lithic::TransactionMonitoring::Cases::FileStatus::TaggedSymbol
+            )
+          REJECTED =
+            T.let(
+              :REJECTED,
+              Lithic::TransactionMonitoring::Cases::FileStatus::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::TransactionMonitoring::Cases::FileStatus::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/cases/upload_constraints.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      module Cases
+        class UploadConstraints < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::TransactionMonitoring::Cases::UploadConstraints,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # MIME types accepted for the upload
+          sig { returns(T::Array[String]) }
+          attr_accessor :accepted_mime_types
+
+          # Maximum accepted file size, in bytes
+          sig { returns(Integer) }
+          attr_accessor :max_size_bytes
+
+          # Constraints applied to a file upload, returned alongside the upload URL so
+          # clients can validate before uploading
+          sig do
+            params(
+              accepted_mime_types: T::Array[String],
+              max_size_bytes: Integer
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # MIME types accepted for the upload
+            accepted_mime_types:,
+            # Maximum accepted file size, in bytes
+            max_size_bytes:
+          )
+          end
+
+          sig do
+            override.returns(
+              { accepted_mime_types: T::Array[String], max_size_bytes: Integer }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/entity_type.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      # The type of entity associated with an account holder
+      module EntityType
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::TransactionMonitoring::EntityType)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        BENEFICIAL_OWNER_INDIVIDUAL =
+          T.let(
+            :BENEFICIAL_OWNER_INDIVIDUAL,
+            Lithic::TransactionMonitoring::EntityType::TaggedSymbol
+          )
+        CONTROL_PERSON =
+          T.let(
+            :CONTROL_PERSON,
+            Lithic::TransactionMonitoring::EntityType::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Lithic::TransactionMonitoring::EntityType::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/monitoring_case.rbi

@@ -0,0 +1,226 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      class MonitoringCase < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransactionMonitoring::MonitoringCase,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Globally unique identifier for the case
+        sig { returns(String) }
+        attr_accessor :token
+
+        # Identifier of the user the case is currently assigned to
+        sig { returns(T.nilable(String)) }
+        attr_accessor :assignee
+
+        # Date and time at which transaction collection stopped for the case
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :collection_stopped
+
+        # Date and time at which the case was created
+        sig { returns(Time) }
+        attr_accessor :created
+
+        # The entity a case is associated with
+        sig { returns(T.nilable(Lithic::TransactionMonitoring::CaseEntity)) }
+        attr_reader :entity
+
+        sig do
+          params(
+            entity: T.nilable(Lithic::TransactionMonitoring::CaseEntity::OrHash)
+          ).void
+        end
+        attr_writer :entity
+
+        # Whether the case still has transaction scopes pending resolution
+        sig { returns(T::Boolean) }
+        attr_accessor :pending_transactions
+
+        # Priority level of a case, controlling queue ordering and SLA urgency
+        sig do
+          returns(Lithic::TransactionMonitoring::CasePriority::TaggedSymbol)
+        end
+        attr_accessor :priority
+
+        # Token of the queue the case belongs to
+        sig { returns(String) }
+        attr_accessor :queue_token
+
+        # Outcome recorded when a case is resolved:
+        #
+        # - `CONFIRMED_FRAUD` - The reviewed activity was confirmed to be fraudulent
+        # - `SUSPICIOUS_ACTIVITY` - The activity is suspicious but not confirmed fraud
+        # - `FALSE_POSITIVE` - The activity was legitimate and the alert was a false
+        #   positive
+        # - `NO_ACTION_REQUIRED` - No further action is required
+        # - `ESCALATED_EXTERNAL` - The case was escalated to an external party
+        sig do
+          returns(
+            T.nilable(
+              Lithic::TransactionMonitoring::ResolutionOutcome::TaggedSymbol
+            )
+          )
+        end
+        attr_accessor :resolution
+
+        # Free-form notes describing the resolution
+        sig { returns(T.nilable(String)) }
+        attr_accessor :resolution_notes
+
+        # Date and time at which the case was resolved
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :resolved
+
+        # Token of the transaction monitoring rule that triggered the case
+        sig { returns(T.nilable(String)) }
+        attr_accessor :rule_token
+
+        # Deadline by which the case is expected to be resolved
+        sig { returns(T.nilable(Time)) }
+        attr_accessor :sla_deadline
+
+        # 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
+        sig { returns(Lithic::TransactionMonitoring::CaseStatus::TaggedSymbol) }
+        attr_accessor :status
+
+        # Arbitrary key-value metadata associated with the case
+        sig { returns(T::Hash[Symbol, String]) }
+        attr_accessor :tags
+
+        # Short, human-readable summary of the case
+        sig { returns(T.nilable(String)) }
+        attr_accessor :title
+
+        # Date and time at which the case was last updated
+        sig { returns(Time) }
+        attr_accessor :updated
+
+        # A transaction monitoring case
+        sig do
+          params(
+            token: String,
+            assignee: T.nilable(String),
+            collection_stopped: T.nilable(Time),
+            created: Time,
+            entity:
+              T.nilable(Lithic::TransactionMonitoring::CaseEntity::OrHash),
+            pending_transactions: T::Boolean,
+            priority: Lithic::TransactionMonitoring::CasePriority::OrSymbol,
+            queue_token: String,
+            resolution:
+              T.nilable(
+                Lithic::TransactionMonitoring::ResolutionOutcome::OrSymbol
+              ),
+            resolution_notes: T.nilable(String),
+            resolved: T.nilable(Time),
+            rule_token: T.nilable(String),
+            sla_deadline: T.nilable(Time),
+            status: Lithic::TransactionMonitoring::CaseStatus::OrSymbol,
+            tags: T::Hash[Symbol, String],
+            title: T.nilable(String),
+            updated: Time
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Globally unique identifier for the case
+          token:,
+          # Identifier of the user the case is currently assigned to
+          assignee:,
+          # Date and time at which transaction collection stopped for the case
+          collection_stopped:,
+          # Date and time at which the case was created
+          created:,
+          # The entity a case is associated with
+          entity:,
+          # Whether the case still has transaction scopes pending resolution
+          pending_transactions:,
+          # Priority level of a case, controlling queue ordering and SLA urgency
+          priority:,
+          # Token of the queue the case belongs to
+          queue_token:,
+          # Outcome recorded when a case is resolved:
+          #
+          # - `CONFIRMED_FRAUD` - The reviewed activity was confirmed to be fraudulent
+          # - `SUSPICIOUS_ACTIVITY` - The activity is suspicious but not confirmed fraud
+          # - `FALSE_POSITIVE` - The activity was legitimate and the alert was a false
+          #   positive
+          # - `NO_ACTION_REQUIRED` - No further action is required
+          # - `ESCALATED_EXTERNAL` - The case was escalated to an external party
+          resolution:,
+          # Free-form notes describing the resolution
+          resolution_notes:,
+          # Date and time at which the case was resolved
+          resolved:,
+          # Token of the transaction monitoring rule that triggered the case
+          rule_token:,
+          # Deadline by which the case is expected to be resolved
+          sla_deadline:,
+          # 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
+          status:,
+          # Arbitrary key-value metadata associated with the case
+          tags:,
+          # Short, human-readable summary of the case
+          title:,
+          # Date and time at which the case was last updated
+          updated:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              token: String,
+              assignee: T.nilable(String),
+              collection_stopped: T.nilable(Time),
+              created: Time,
+              entity: T.nilable(Lithic::TransactionMonitoring::CaseEntity),
+              pending_transactions: T::Boolean,
+              priority:
+                Lithic::TransactionMonitoring::CasePriority::TaggedSymbol,
+              queue_token: String,
+              resolution:
+                T.nilable(
+                  Lithic::TransactionMonitoring::ResolutionOutcome::TaggedSymbol
+                ),
+              resolution_notes: T.nilable(String),
+              resolved: T.nilable(Time),
+              rule_token: T.nilable(String),
+              sla_deadline: T.nilable(Time),
+              status: Lithic::TransactionMonitoring::CaseStatus::TaggedSymbol,
+              tags: T::Hash[Symbol, String],
+              title: T.nilable(String),
+              updated: Time
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/transaction_monitoring/queue.rbi

@@ -0,0 +1,189 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      class Queue < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransactionMonitoring::Queue,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        # Globally unique identifier for the queue
+        sig { returns(String) }
+        attr_accessor :token
+
+        # Number of cases in the queue, broken down by status. A status is omitted when
+        # the queue has no cases in that status
+        sig { returns(Lithic::TransactionMonitoring::Queue::CaseCounts) }
+        attr_reader :case_counts
+
+        sig do
+          params(
+            case_counts:
+              Lithic::TransactionMonitoring::Queue::CaseCounts::OrHash
+          ).void
+        end
+        attr_writer :case_counts
+
+        # Date and time at which the queue was created
+        sig { returns(Time) }
+        attr_accessor :created
+
+        # Optional description of the queue
+        sig { returns(T.nilable(String)) }
+        attr_accessor :description
+
+        # Human-readable name of the queue
+        sig { returns(String) }
+        attr_accessor :name
+
+        # Date and time at which the queue was last updated
+        sig { returns(Time) }
+        attr_accessor :updated
+
+        # A queue that groups transaction monitoring cases for review
+        sig do
+          params(
+            token: String,
+            case_counts:
+              Lithic::TransactionMonitoring::Queue::CaseCounts::OrHash,
+            created: Time,
+            description: T.nilable(String),
+            name: String,
+            updated: Time
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Globally unique identifier for the queue
+          token:,
+          # Number of cases in the queue, broken down by status. A status is omitted when
+          # the queue has no cases in that status
+          case_counts:,
+          # Date and time at which the queue was created
+          created:,
+          # Optional description of the queue
+          description:,
+          # Human-readable name of the queue
+          name:,
+          # Date and time at which the queue was last updated
+          updated:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              token: String,
+              case_counts: Lithic::TransactionMonitoring::Queue::CaseCounts,
+              created: Time,
+              description: T.nilable(String),
+              name: String,
+              updated: Time
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class CaseCounts < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::TransactionMonitoring::Queue::CaseCounts,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # Number of cases in the queue with status `ASSIGNED`
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :assigned
+
+          sig { params(assigned: Integer).void }
+          attr_writer :assigned
+
+          # Number of cases in the queue with status `CLOSED`
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :closed
+
+          sig { params(closed: Integer).void }
+          attr_writer :closed
+
+          # Number of cases in the queue with status `ESCALATED`
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :escalated
+
+          sig { params(escalated: Integer).void }
+          attr_writer :escalated
+
+          # Number of cases in the queue with status `IN_REVIEW`
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :in_review
+
+          sig { params(in_review: Integer).void }
+          attr_writer :in_review
+
+          # Number of cases in the queue with status `OPEN`
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :open_
+
+          sig { params(open_: Integer).void }
+          attr_writer :open_
+
+          # Number of cases in the queue with status `RESOLVED`
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :resolved
+
+          sig { params(resolved: Integer).void }
+          attr_writer :resolved
+
+          # Number of cases in the queue, broken down by status. A status is omitted when
+          # the queue has no cases in that status
+          sig do
+            params(
+              assigned: Integer,
+              closed: Integer,
+              escalated: Integer,
+              in_review: Integer,
+              open_: Integer,
+              resolved: Integer
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Number of cases in the queue with status `ASSIGNED`
+            assigned: nil,
+            # Number of cases in the queue with status `CLOSED`
+            closed: nil,
+            # Number of cases in the queue with status `ESCALATED`
+            escalated: nil,
+            # Number of cases in the queue with status `IN_REVIEW`
+            in_review: nil,
+            # Number of cases in the queue with status `OPEN`
+            open_: nil,
+            # Number of cases in the queue with status `RESOLVED`
+            resolved: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                assigned: Integer,
+                closed: Integer,
+                escalated: Integer,
+                in_review: Integer,
+                open_: Integer,
+                resolved: Integer
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end