lithic 0.15.0 → 0.16.0

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

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

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

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

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

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

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

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

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

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

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

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

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