lithic 0.1.0.pre.alpha.1

data/rbi/lib/lithic/models/dispute_list_evidences_params.rbi

@@ -0,0 +1,79 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class DisputeListEvidencesParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      # Date string in RFC 3339 format. Only entries created after the specified time
+      #   will be included. UTC time zone.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :begin_
+
+      sig { params(begin_: Time).void }
+      attr_writer :begin_
+
+      # Date string in RFC 3339 format. Only entries created before the specified time
+      #   will be included. UTC time zone.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :end_
+
+      sig { params(end_: Time).void }
+      attr_writer :end_
+
+      # A cursor representing an item's token before which a page of results should end.
+      #   Used to retrieve the previous page of results before this item.
+      sig { returns(T.nilable(String)) }
+      attr_reader :ending_before
+
+      sig { params(ending_before: String).void }
+      attr_writer :ending_before
+
+      # 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(
+          begin_: Time,
+          end_: Time,
+          ending_before: String,
+          page_size: Integer,
+          starting_after: String,
+          request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(begin_: nil, end_: nil, ending_before: nil, page_size: nil, starting_after: nil, request_options: {})
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              begin_: Time,
+              end_: Time,
+              ending_before: String,
+              page_size: Integer,
+              starting_after: String,
+              request_options: Lithic::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/dispute_list_params.rbi

@@ -0,0 +1,127 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class DisputeListParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      # Date string in RFC 3339 format. Only entries created after the specified time
+      #   will be included. UTC time zone.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :begin_
+
+      sig { params(begin_: Time).void }
+      attr_writer :begin_
+
+      # Date string in RFC 3339 format. Only entries created before the specified time
+      #   will be included. UTC time zone.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :end_
+
+      sig { params(end_: Time).void }
+      attr_writer :end_
+
+      # A cursor representing an item's token before which a page of results should end.
+      #   Used to retrieve the previous page of results before this item.
+      sig { returns(T.nilable(String)) }
+      attr_reader :ending_before
+
+      sig { params(ending_before: String).void }
+      attr_writer :ending_before
+
+      # 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
+
+      # List disputes of a specific status.
+      sig { returns(T.nilable(Lithic::Models::DisputeListParams::Status::OrSymbol)) }
+      attr_reader :status
+
+      sig { params(status: Lithic::Models::DisputeListParams::Status::OrSymbol).void }
+      attr_writer :status
+
+      # Transaction tokens to filter by.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :transaction_tokens
+
+      sig { params(transaction_tokens: T::Array[String]).void }
+      attr_writer :transaction_tokens
+
+      sig do
+        params(
+          begin_: Time,
+          end_: Time,
+          ending_before: String,
+          page_size: Integer,
+          starting_after: String,
+          status: Lithic::Models::DisputeListParams::Status::OrSymbol,
+          transaction_tokens: T::Array[String],
+          request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        begin_: nil,
+        end_: nil,
+        ending_before: nil,
+        page_size: nil,
+        starting_after: nil,
+        status: nil,
+        transaction_tokens: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              begin_: Time,
+              end_: Time,
+              ending_before: String,
+              page_size: Integer,
+              starting_after: String,
+              status: Lithic::Models::DisputeListParams::Status::OrSymbol,
+              transaction_tokens: T::Array[String],
+              request_options: Lithic::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # List disputes of a specific status.
+      module Status
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::DisputeListParams::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::DisputeListParams::Status::TaggedSymbol) }
+
+        ARBITRATION = T.let(:ARBITRATION, Lithic::Models::DisputeListParams::Status::TaggedSymbol)
+        CASE_CLOSED = T.let(:CASE_CLOSED, Lithic::Models::DisputeListParams::Status::TaggedSymbol)
+        CASE_WON = T.let(:CASE_WON, Lithic::Models::DisputeListParams::Status::TaggedSymbol)
+        NEW = T.let(:NEW, Lithic::Models::DisputeListParams::Status::TaggedSymbol)
+        PENDING_CUSTOMER = T.let(:PENDING_CUSTOMER, Lithic::Models::DisputeListParams::Status::TaggedSymbol)
+        PREARBITRATION = T.let(:PREARBITRATION, Lithic::Models::DisputeListParams::Status::TaggedSymbol)
+        REPRESENTMENT = T.let(:REPRESENTMENT, Lithic::Models::DisputeListParams::Status::TaggedSymbol)
+        SUBMITTED = T.let(:SUBMITTED, Lithic::Models::DisputeListParams::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::DisputeListParams::Status::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/dispute_retrieve_evidence_params.rbi

@@ -0,0 +1,24 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class DisputeRetrieveEvidenceParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      sig { returns(String) }
+      attr_accessor :dispute_token
+
+      sig do
+        params(dispute_token: String, request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+          .returns(T.attached_class)
+      end
+      def self.new(dispute_token:, request_options: {})
+      end
+
+      sig { override.returns({dispute_token: String, request_options: Lithic::RequestOptions}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/dispute_retrieve_params.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class DisputeRetrieveParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      sig do
+        params(
+          request_options: T.any(
+            Lithic::RequestOptions,
+            Lithic::Util::AnyHash
+          )
+        ).returns(T.attached_class)
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({request_options: Lithic::RequestOptions}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/dispute_update_params.rbi

@@ -0,0 +1,100 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class DisputeUpdateParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      # Amount to dispute
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :amount
+
+      sig { params(amount: Integer).void }
+      attr_writer :amount
+
+      # Date the customer filed the dispute
+      sig { returns(T.nilable(Time)) }
+      attr_reader :customer_filed_date
+
+      sig { params(customer_filed_date: Time).void }
+      attr_writer :customer_filed_date
+
+      # Customer description of dispute
+      sig { returns(T.nilable(String)) }
+      attr_reader :customer_note
+
+      sig { params(customer_note: String).void }
+      attr_writer :customer_note
+
+      # Reason for dispute
+      sig { returns(T.nilable(Lithic::Models::DisputeUpdateParams::Reason::OrSymbol)) }
+      attr_reader :reason
+
+      sig { params(reason: Lithic::Models::DisputeUpdateParams::Reason::OrSymbol).void }
+      attr_writer :reason
+
+      sig do
+        params(
+          amount: Integer,
+          customer_filed_date: Time,
+          customer_note: String,
+          reason: Lithic::Models::DisputeUpdateParams::Reason::OrSymbol,
+          request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(amount: nil, customer_filed_date: nil, customer_note: nil, reason: nil, request_options: {})
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              amount: Integer,
+              customer_filed_date: Time,
+              customer_note: String,
+              reason: Lithic::Models::DisputeUpdateParams::Reason::OrSymbol,
+              request_options: Lithic::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # Reason for dispute
+      module Reason
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::DisputeUpdateParams::Reason) }
+        OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol) }
+
+        ATM_CASH_MISDISPENSE =
+          T.let(:ATM_CASH_MISDISPENSE, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol)
+        CANCELLED = T.let(:CANCELLED, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol)
+        DUPLICATED = T.let(:DUPLICATED, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol)
+        FRAUD_CARD_NOT_PRESENT =
+          T.let(:FRAUD_CARD_NOT_PRESENT, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol)
+        FRAUD_CARD_PRESENT =
+          T.let(:FRAUD_CARD_PRESENT, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol)
+        FRAUD_OTHER = T.let(:FRAUD_OTHER, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol)
+        GOODS_SERVICES_NOT_AS_DESCRIBED =
+          T.let(:GOODS_SERVICES_NOT_AS_DESCRIBED, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol)
+        GOODS_SERVICES_NOT_RECEIVED =
+          T.let(:GOODS_SERVICES_NOT_RECEIVED, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol)
+        INCORRECT_AMOUNT = T.let(:INCORRECT_AMOUNT, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol)
+        MISSING_AUTH = T.let(:MISSING_AUTH, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol)
+        OTHER = T.let(:OTHER, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol)
+        PROCESSING_ERROR = T.let(:PROCESSING_ERROR, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol)
+        RECURRING_TRANSACTION_NOT_CANCELLED =
+          T.let(:RECURRING_TRANSACTION_NOT_CANCELLED, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol)
+        REFUND_NOT_PROCESSED =
+          T.let(:REFUND_NOT_PROCESSED, Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::DisputeUpdateParams::Reason::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/document.rbi

@@ -0,0 +1,283 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class Document < Lithic::BaseModel
+      # Globally unique identifier for the document.
+      sig { returns(String) }
+      attr_accessor :token
+
+      # Globally unique identifier for the account holder.
+      sig { returns(String) }
+      attr_accessor :account_holder_token
+
+      # Type of documentation to be submitted for verification of an account holder
+      sig { returns(Lithic::Models::Document::DocumentType::TaggedSymbol) }
+      attr_accessor :document_type
+
+      # Globally unique identifier for an entity.
+      sig { returns(String) }
+      attr_accessor :entity_token
+
+      # Represents a single image of the document to upload.
+      sig { returns(T::Array[Lithic::Models::Document::RequiredDocumentUpload]) }
+      attr_accessor :required_document_uploads
+
+      # Describes the document and the required document image uploads required to
+      #   re-run KYC
+      sig do
+        params(
+          token: String,
+          account_holder_token: String,
+          document_type: Lithic::Models::Document::DocumentType::OrSymbol,
+          entity_token: String,
+          required_document_uploads: T::Array[T.any(Lithic::Models::Document::RequiredDocumentUpload, Lithic::Util::AnyHash)]
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(token:, account_holder_token:, document_type:, entity_token:, required_document_uploads:)
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              token: String,
+              account_holder_token: String,
+              document_type: Lithic::Models::Document::DocumentType::TaggedSymbol,
+              entity_token: String,
+              required_document_uploads: T::Array[Lithic::Models::Document::RequiredDocumentUpload]
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # Type of documentation to be submitted for verification of an account holder
+      module DocumentType
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::Document::DocumentType) }
+        OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::Document::DocumentType::TaggedSymbol) }
+
+        DRIVERS_LICENSE = T.let(:DRIVERS_LICENSE, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        PASSPORT = T.let(:PASSPORT, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        PASSPORT_CARD = T.let(:PASSPORT_CARD, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        EIN_LETTER = T.let(:EIN_LETTER, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        TAX_RETURN = T.let(:TAX_RETURN, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        OPERATING_AGREEMENT = T.let(:OPERATING_AGREEMENT, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        CERTIFICATE_OF_FORMATION =
+          T.let(:CERTIFICATE_OF_FORMATION, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        CERTIFICATE_OF_GOOD_STANDING =
+          T.let(:CERTIFICATE_OF_GOOD_STANDING, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        ARTICLES_OF_INCORPORATION =
+          T.let(:ARTICLES_OF_INCORPORATION, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        ARTICLES_OF_ORGANIZATION =
+          T.let(:ARTICLES_OF_ORGANIZATION, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        BYLAWS = T.let(:BYLAWS, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        GOVERNMENT_BUSINESS_LICENSE =
+          T.let(:GOVERNMENT_BUSINESS_LICENSE, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        PARTNERSHIP_AGREEMENT =
+          T.let(:PARTNERSHIP_AGREEMENT, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        SS4_FORM = T.let(:SS4_FORM, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        BANK_STATEMENT = T.let(:BANK_STATEMENT, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        UTILITY_BILL_STATEMENT =
+          T.let(:UTILITY_BILL_STATEMENT, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        SSN_CARD = T.let(:SSN_CARD, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        ITIN_LETTER = T.let(:ITIN_LETTER, Lithic::Models::Document::DocumentType::TaggedSymbol)
+        FINCEN_BOI_REPORT = T.let(:FINCEN_BOI_REPORT, Lithic::Models::Document::DocumentType::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::Document::DocumentType::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      class RequiredDocumentUpload < Lithic::BaseModel
+        # Globally unique identifier for the document upload.
+        sig { returns(String) }
+        attr_accessor :token
+
+        # A list of status reasons associated with a KYB account holder that have been
+        #   satisfied by the document upload
+        sig { returns(T::Array[String]) }
+        attr_accessor :accepted_entity_status_reasons
+
+        # When the document upload was created
+        sig { returns(Time) }
+        attr_accessor :created
+
+        # Type of image to upload.
+        sig { returns(Lithic::Models::Document::RequiredDocumentUpload::ImageType::TaggedSymbol) }
+        attr_accessor :image_type
+
+        # A list of status reasons associated with a KYB account holder that have not been
+        #   satisfied by the document upload
+        sig { returns(T::Array[String]) }
+        attr_accessor :rejected_entity_status_reasons
+
+        # Status of an account holder's document upload.
+        sig { returns(Lithic::Models::Document::RequiredDocumentUpload::Status::TaggedSymbol) }
+        attr_accessor :status
+
+        # Reasons for document image upload status.
+        sig { returns(T::Array[Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol]) }
+        attr_accessor :status_reasons
+
+        # When the document upload was last updated
+        sig { returns(Time) }
+        attr_accessor :updated
+
+        # URL to upload document image to.
+        #
+        #   Note that the upload URLs expire after 7 days. If an upload URL expires, you can
+        #   refresh the URLs by retrieving the document upload from
+        #   `GET /account_holders/{account_holder_token}/documents`.
+        sig { returns(String) }
+        attr_accessor :upload_url
+
+        # Represents a single image of the document to upload.
+        sig do
+          params(
+            token: String,
+            accepted_entity_status_reasons: T::Array[String],
+            created: Time,
+            image_type: Lithic::Models::Document::RequiredDocumentUpload::ImageType::OrSymbol,
+            rejected_entity_status_reasons: T::Array[String],
+            status: Lithic::Models::Document::RequiredDocumentUpload::Status::OrSymbol,
+            status_reasons: T::Array[Lithic::Models::Document::RequiredDocumentUpload::StatusReason::OrSymbol],
+            updated: Time,
+            upload_url: String
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          token:,
+          accepted_entity_status_reasons:,
+          created:,
+          image_type:,
+          rejected_entity_status_reasons:,
+          status:,
+          status_reasons:,
+          updated:,
+          upload_url:
+        )
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                token: String,
+                accepted_entity_status_reasons: T::Array[String],
+                created: Time,
+                image_type: Lithic::Models::Document::RequiredDocumentUpload::ImageType::TaggedSymbol,
+                rejected_entity_status_reasons: T::Array[String],
+                status: Lithic::Models::Document::RequiredDocumentUpload::Status::TaggedSymbol,
+                status_reasons: T::Array[Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol],
+                updated: Time,
+                upload_url: String
+              }
+            )
+        end
+        def to_hash
+        end
+
+        # Type of image to upload.
+        module ImageType
+          extend Lithic::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Lithic::Models::Document::RequiredDocumentUpload::ImageType) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, Lithic::Models::Document::RequiredDocumentUpload::ImageType::TaggedSymbol) }
+
+          FRONT = T.let(:FRONT, Lithic::Models::Document::RequiredDocumentUpload::ImageType::TaggedSymbol)
+          BACK = T.let(:BACK, Lithic::Models::Document::RequiredDocumentUpload::ImageType::TaggedSymbol)
+
+          sig { override.returns(T::Array[Lithic::Models::Document::RequiredDocumentUpload::ImageType::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+        # Status of an account holder's document upload.
+        module Status
+          extend Lithic::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::Document::RequiredDocumentUpload::Status) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, Lithic::Models::Document::RequiredDocumentUpload::Status::TaggedSymbol) }
+
+          ACCEPTED = T.let(:ACCEPTED, Lithic::Models::Document::RequiredDocumentUpload::Status::TaggedSymbol)
+          REJECTED = T.let(:REJECTED, Lithic::Models::Document::RequiredDocumentUpload::Status::TaggedSymbol)
+          PENDING_UPLOAD =
+            T.let(:PENDING_UPLOAD, Lithic::Models::Document::RequiredDocumentUpload::Status::TaggedSymbol)
+          UPLOADED = T.let(:UPLOADED, Lithic::Models::Document::RequiredDocumentUpload::Status::TaggedSymbol)
+          PARTIAL_APPROVAL =
+            T.let(:PARTIAL_APPROVAL, Lithic::Models::Document::RequiredDocumentUpload::Status::TaggedSymbol)
+
+          sig { override.returns(T::Array[Lithic::Models::Document::RequiredDocumentUpload::Status::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+        # The status reasons for an account holder document upload that is not ACCEPTED
+        module StatusReason
+          extend Lithic::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Lithic::Models::Document::RequiredDocumentUpload::StatusReason) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol) }
+
+          DOCUMENT_MISSING_REQUIRED_DATA =
+            T.let(
+              :DOCUMENT_MISSING_REQUIRED_DATA,
+              Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol
+            )
+          DOCUMENT_UPLOAD_TOO_BLURRY =
+            T.let(
+              :DOCUMENT_UPLOAD_TOO_BLURRY,
+              Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol
+            )
+          FILE_SIZE_TOO_LARGE =
+            T.let(:FILE_SIZE_TOO_LARGE, Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol)
+          INVALID_DOCUMENT_TYPE =
+            T.let(
+              :INVALID_DOCUMENT_TYPE,
+              Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol
+            )
+          INVALID_DOCUMENT_UPLOAD =
+            T.let(
+              :INVALID_DOCUMENT_UPLOAD,
+              Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol
+            )
+          INVALID_ENTITY =
+            T.let(:INVALID_ENTITY, Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol)
+          DOCUMENT_EXPIRED =
+            T.let(:DOCUMENT_EXPIRED, Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol)
+          DOCUMENT_ISSUED_GREATER_THAN_30_DAYS =
+            T.let(
+              :DOCUMENT_ISSUED_GREATER_THAN_30_DAYS,
+              Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol
+            )
+          DOCUMENT_TYPE_NOT_SUPPORTED =
+            T.let(
+              :DOCUMENT_TYPE_NOT_SUPPORTED,
+              Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol
+            )
+          UNKNOWN_FAILURE_REASON =
+            T.let(
+              :UNKNOWN_FAILURE_REASON,
+              Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol
+            )
+          UNKNOWN_ERROR =
+            T.let(:UNKNOWN_ERROR, Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol)
+
+          sig { override.returns(T::Array[Lithic::Models::Document::RequiredDocumentUpload::StatusReason::TaggedSymbol]) }
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end