lithic 0.14.0 → 0.16.0

data/rbi/lithic/models/transaction_monitoring/case_update_params.rbi

@@ -0,0 +1,201 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      class CaseUpdateParams < Lithic::Internal::Type::BaseModel
+        extend Lithic::Internal::Type::RequestParameters::Converter
+        include Lithic::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::TransactionMonitoring::CaseUpdateParams,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :case_token
+
+        # 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
+
+        # New assignee for the case, or `null` to unassign
+        sig { returns(T.nilable(String)) }
+        attr_accessor :assignee
+
+        # Priority level of a case, controlling queue ordering and SLA urgency
+        sig do
+          returns(
+            T.nilable(Lithic::TransactionMonitoring::CasePriority::OrSymbol)
+          )
+        end
+        attr_reader :priority
+
+        sig do
+          params(
+            priority: Lithic::TransactionMonitoring::CasePriority::OrSymbol
+          ).void
+        end
+        attr_writer :priority
+
+        # 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::OrSymbol
+            )
+          )
+        end
+        attr_reader :resolution
+
+        sig do
+          params(
+            resolution:
+              Lithic::TransactionMonitoring::ResolutionOutcome::OrSymbol
+          ).void
+        end
+        attr_writer :resolution
+
+        # Notes describing the resolution
+        sig { returns(T.nilable(String)) }
+        attr_reader :resolution_notes
+
+        sig { params(resolution_notes: String).void }
+        attr_writer :resolution_notes
+
+        # New SLA deadline for the case, or `null` to clear it
+        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 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
+
+        # Arbitrary key-value metadata to set on the case
+        sig { returns(T.nilable(T::Hash[Symbol, String])) }
+        attr_reader :tags
+
+        sig { params(tags: T::Hash[Symbol, String]).void }
+        attr_writer :tags
+
+        # New title for the case, or `null` to clear it
+        sig { returns(T.nilable(String)) }
+        attr_accessor :title
+
+        sig do
+          params(
+            case_token: String,
+            actor_token: String,
+            assignee: T.nilable(String),
+            priority: Lithic::TransactionMonitoring::CasePriority::OrSymbol,
+            resolution:
+              Lithic::TransactionMonitoring::ResolutionOutcome::OrSymbol,
+            resolution_notes: String,
+            sla_deadline: T.nilable(Time),
+            status: Lithic::TransactionMonitoring::CaseStatus::OrSymbol,
+            tags: T::Hash[Symbol, String],
+            title: T.nilable(String),
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          case_token:,
+          # 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,
+          # New assignee for the case, or `null` to unassign
+          assignee: nil,
+          # Priority level of a case, controlling queue ordering and SLA urgency
+          priority: nil,
+          # 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: nil,
+          # Notes describing the resolution
+          resolution_notes: nil,
+          # New SLA deadline for the case, or `null` to clear it
+          sla_deadline: nil,
+          # 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: nil,
+          # Arbitrary key-value metadata to set on the case
+          tags: nil,
+          # New title for the case, or `null` to clear it
+          title: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              case_token: String,
+              actor_token: String,
+              assignee: T.nilable(String),
+              priority: Lithic::TransactionMonitoring::CasePriority::OrSymbol,
+              resolution:
+                Lithic::TransactionMonitoring::ResolutionOutcome::OrSymbol,
+              resolution_notes: String,
+              sla_deadline: T.nilable(Time),
+              status: Lithic::TransactionMonitoring::CaseStatus::OrSymbol,
+              tags: T::Hash[Symbol, String],
+              title: T.nilable(String),
+              request_options: Lithic::RequestOptions
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,188 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      CaseFile = Cases::CaseFile
+
+      module Cases
+        class CaseFile < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::TransactionMonitoring::Cases::CaseFile,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # Globally unique identifier for the file
+          sig { returns(String) }
+          attr_accessor :token
+
+          # Date and time at which the file record was created
+          sig { returns(Time) }
+          attr_accessor :created
+
+          # Presigned URL the client uses to download the file
+          sig { returns(T.nilable(String)) }
+          attr_accessor :download_url
+
+          # Date and time at which the download URL expires
+          sig { returns(T.nilable(Time)) }
+          attr_accessor :download_url_expires
+
+          # Reason the file was rejected, when applicable
+          sig { returns(T.nilable(String)) }
+          attr_accessor :failure_reason
+
+          # MIME type of the file, available once the file is ready
+          sig { returns(T.nilable(String)) }
+          attr_accessor :mime_type
+
+          # Name of the file
+          sig { returns(String) }
+          attr_accessor :name
+
+          # Size of the file in bytes, available once the file is ready
+          sig { returns(T.nilable(Integer)) }
+          attr_accessor :size_bytes
+
+          # 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
+          sig do
+            returns(
+              Lithic::TransactionMonitoring::Cases::FileStatus::TaggedSymbol
+            )
+          end
+          attr_accessor :status
+
+          # Date and time at which the file record was last updated
+          sig { returns(Time) }
+          attr_accessor :updated
+
+          # Constraints applied to a file upload, returned alongside the upload URL so
+          # clients can validate before uploading
+          sig do
+            returns(
+              T.nilable(Lithic::TransactionMonitoring::Cases::UploadConstraints)
+            )
+          end
+          attr_reader :upload_constraints
+
+          sig do
+            params(
+              upload_constraints:
+                T.nilable(
+                  Lithic::TransactionMonitoring::Cases::UploadConstraints::OrHash
+                )
+            ).void
+          end
+          attr_writer :upload_constraints
+
+          # Presigned URL the client uses to upload the file
+          sig { returns(T.nilable(String)) }
+          attr_accessor :upload_url
+
+          # Date and time at which the upload URL expires
+          sig { returns(T.nilable(Time)) }
+          attr_accessor :upload_url_expires
+
+          # A file attached to a case. Status-dependent fields are always present but may be
+          # `null`:
+          #
+          # - `upload_url`, `upload_url_expires`, and `upload_constraints` are populated
+          #   when `status` is `PENDING` or `REJECTED`
+          # - `download_url` and `download_url_expires` are populated when `status` is
+          #   `READY`
+          # - `failure_reason` is populated when `status` is `REJECTED`
+          sig do
+            params(
+              token: String,
+              created: Time,
+              download_url: T.nilable(String),
+              download_url_expires: T.nilable(Time),
+              failure_reason: T.nilable(String),
+              mime_type: T.nilable(String),
+              name: String,
+              size_bytes: T.nilable(Integer),
+              status:
+                Lithic::TransactionMonitoring::Cases::FileStatus::OrSymbol,
+              updated: Time,
+              upload_constraints:
+                T.nilable(
+                  Lithic::TransactionMonitoring::Cases::UploadConstraints::OrHash
+                ),
+              upload_url: T.nilable(String),
+              upload_url_expires: T.nilable(Time)
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Globally unique identifier for the file
+            token:,
+            # Date and time at which the file record was created
+            created:,
+            # Presigned URL the client uses to download the file
+            download_url:,
+            # Date and time at which the download URL expires
+            download_url_expires:,
+            # Reason the file was rejected, when applicable
+            failure_reason:,
+            # MIME type of the file, available once the file is ready
+            mime_type:,
+            # Name of the file
+            name:,
+            # Size of the file in bytes, available once the file is ready
+            size_bytes:,
+            # 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
+            status:,
+            # Date and time at which the file record was last updated
+            updated:,
+            # Constraints applied to a file upload, returned alongside the upload URL so
+            # clients can validate before uploading
+            upload_constraints:,
+            # Presigned URL the client uses to upload the file
+            upload_url:,
+            # Date and time at which the upload URL expires
+            upload_url_expires:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                token: String,
+                created: Time,
+                download_url: T.nilable(String),
+                download_url_expires: T.nilable(Time),
+                failure_reason: T.nilable(String),
+                mime_type: T.nilable(String),
+                name: String,
+                size_bytes: T.nilable(Integer),
+                status:
+                  Lithic::TransactionMonitoring::Cases::FileStatus::TaggedSymbol,
+                updated: Time,
+                upload_constraints:
+                  T.nilable(
+                    Lithic::TransactionMonitoring::Cases::UploadConstraints
+                  ),
+                upload_url: T.nilable(String),
+                upload_url_expires: T.nilable(Time)
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module TransactionMonitoring
+      module Cases
+        class CommentCreateParams < 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::CommentCreateParams,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          sig { returns(String) }
+          attr_accessor :case_token
+
+          # 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: String,
+              actor_token: String,
+              request_options: Lithic::RequestOptions::OrHash
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            case_token:,
+            # 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: 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/comment_delete_params.rbi

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

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