lithic 0.15.0 → 0.17.0

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

@@ -0,0 +1,77 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      module Cases
+        class CommentUpdateParams < 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::CommentUpdateParams,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :case_token
+
+          sig { returns(String) }
+          attr_accessor :comment_token
+
+          # New text of the comment
+          sig { returns(String) }
+          attr_accessor :comment
+
+          # Optional client-provided identifier for the actor performing this action,
+          # recorded on the resulting activity entry. This value is supplied by the client
+          # (for example, your own internal user ID) and is not authenticated by Lithic
+          sig { returns(T.nilable(String)) }
+          attr_reader :actor_token
+
+          sig { params(actor_token: String).void }
+          attr_writer :actor_token
+
+          sig do
+            params(
+              case_token: String,
+              comment_token: String,
+              comment: String,
+              actor_token: String,
+              request_options: Lithic::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            case_token:,
+            comment_token:,
+            # New text of the comment
+            comment:,
+            # Optional client-provided identifier for the actor performing this action,
+            # recorded on the resulting activity entry. This value is supplied by the client
+            # (for example, your own internal user ID) and is not authenticated by Lithic
+            actor_token: nil,
+            request_options: {}
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                case_token: String,
+                comment_token: String,
+                comment: String,
+                actor_token: String,
+                request_options: Lithic::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      module Cases
+        class FileCreateParams < 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::FileCreateParams,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :case_token
+
+          # Name of the file to upload
+          sig { returns(String) }
+          attr_accessor :name
+
+          sig do
+            params(
+              case_token: String,
+              name: String,
+              request_options: Lithic::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            case_token:,
+            # Name of the file to upload
+            name:,
+            request_options: {}
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                case_token: String,
+                name: String,
+                request_options: Lithic::RequestOptions
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      module Cases
+        class FileDeleteParams < 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::FileDeleteParams,
+                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_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