lithic 0.1.0.pre.alpha.1

data/rbi/lib/lithic/models/kyc.rbi

@@ -0,0 +1,158 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class KYC < Lithic::BaseModel
+      # Information on individual for whom the account is being opened and KYC is being
+      #   run.
+      sig { returns(Lithic::Models::KYC::Individual) }
+      attr_reader :individual
+
+      sig { params(individual: T.any(Lithic::Models::KYC::Individual, Lithic::Util::AnyHash)).void }
+      attr_writer :individual
+
+      # An RFC 3339 timestamp indicating when the account holder accepted the applicable
+      #   legal agreements (e.g., cardholder terms) as agreed upon during API customer's
+      #   implementation with Lithic.
+      sig { returns(String) }
+      attr_accessor :tos_timestamp
+
+      # Specifies the type of KYC workflow to run.
+      sig { returns(Lithic::Models::KYC::Workflow::OrSymbol) }
+      attr_accessor :workflow
+
+      # A user provided id that can be used to link an account holder with an external
+      #   system
+      sig { returns(T.nilable(String)) }
+      attr_reader :external_id
+
+      sig { params(external_id: String).void }
+      attr_writer :external_id
+
+      # An RFC 3339 timestamp indicating when precomputed KYC was completed on the
+      #   individual with a pass result.
+      #
+      #   This field is required only if workflow type is `KYC_BYO`.
+      sig { returns(T.nilable(String)) }
+      attr_reader :kyc_passed_timestamp
+
+      sig { params(kyc_passed_timestamp: String).void }
+      attr_writer :kyc_passed_timestamp
+
+      sig do
+        params(
+          individual: T.any(Lithic::Models::KYC::Individual, Lithic::Util::AnyHash),
+          tos_timestamp: String,
+          workflow: Lithic::Models::KYC::Workflow::OrSymbol,
+          external_id: String,
+          kyc_passed_timestamp: String
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(individual:, tos_timestamp:, workflow:, external_id: nil, kyc_passed_timestamp: nil)
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              individual: Lithic::Models::KYC::Individual,
+              tos_timestamp: String,
+              workflow: Lithic::Models::KYC::Workflow::OrSymbol,
+              external_id: String,
+              kyc_passed_timestamp: String
+            }
+          )
+      end
+      def to_hash
+      end
+
+      class Individual < Lithic::BaseModel
+        # Individual's current address - PO boxes, UPS drops, and FedEx drops are not
+        #   acceptable; APO/FPO are acceptable. Only USA addresses are currently supported.
+        sig { returns(Lithic::Models::Address) }
+        attr_reader :address
+
+        sig { params(address: T.any(Lithic::Models::Address, Lithic::Util::AnyHash)).void }
+        attr_writer :address
+
+        # Individual's date of birth, as an RFC 3339 date.
+        sig { returns(String) }
+        attr_accessor :dob
+
+        # Individual's email address. If utilizing Lithic for chargeback processing, this
+        #   customer email address may be used to communicate dispute status and resolution.
+        sig { returns(String) }
+        attr_accessor :email
+
+        # Individual's first name, as it appears on government-issued identity documents.
+        sig { returns(String) }
+        attr_accessor :first_name
+
+        # Government-issued identification number (required for identity verification and
+        #   compliance with banking regulations). Social Security Numbers (SSN) and
+        #   Individual Taxpayer Identification Numbers (ITIN) are currently supported,
+        #   entered as full nine-digits, with or without hyphens
+        sig { returns(String) }
+        attr_accessor :government_id
+
+        # Individual's last name, as it appears on government-issued identity documents.
+        sig { returns(String) }
+        attr_accessor :last_name
+
+        # Individual's phone number, entered in E.164 format.
+        sig { returns(String) }
+        attr_accessor :phone_number
+
+        # Information on individual for whom the account is being opened and KYC is being
+        #   run.
+        sig do
+          params(
+            address: T.any(Lithic::Models::Address, Lithic::Util::AnyHash),
+            dob: String,
+            email: String,
+            first_name: String,
+            government_id: String,
+            last_name: String,
+            phone_number: String
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(address:, dob:, email:, first_name:, government_id:, last_name:, phone_number:)
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                address: Lithic::Models::Address,
+                dob: String,
+                email: String,
+                first_name: String,
+                government_id: String,
+                last_name: String,
+                phone_number: String
+              }
+            )
+        end
+        def to_hash
+        end
+      end
+
+      # Specifies the type of KYC workflow to run.
+      module Workflow
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::KYC::Workflow) }
+        OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::KYC::Workflow::TaggedSymbol) }
+
+        KYC_BASIC = T.let(:KYC_BASIC, Lithic::Models::KYC::Workflow::TaggedSymbol)
+        KYC_BYO = T.let(:KYC_BYO, Lithic::Models::KYC::Workflow::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::KYC::Workflow::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/kyc_exempt.rbi

@@ -0,0 +1,131 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class KYCExempt < Lithic::BaseModel
+      # KYC Exempt user's current address - PO boxes, UPS drops, and FedEx drops are not
+      #   acceptable; APO/FPO are acceptable.
+      sig { returns(Lithic::Models::Address) }
+      attr_reader :address
+
+      sig { params(address: T.any(Lithic::Models::Address, Lithic::Util::AnyHash)).void }
+      attr_writer :address
+
+      # The KYC Exempt user's email
+      sig { returns(String) }
+      attr_accessor :email
+
+      # The KYC Exempt user's first name
+      sig { returns(String) }
+      attr_accessor :first_name
+
+      # Specifies the type of KYC Exempt user
+      sig { returns(Lithic::Models::KYCExempt::KYCExemptionType::OrSymbol) }
+      attr_accessor :kyc_exemption_type
+
+      # The KYC Exempt user's last name
+      sig { returns(String) }
+      attr_accessor :last_name
+
+      # The KYC Exempt user's phone number, entered in E.164 format.
+      sig { returns(String) }
+      attr_accessor :phone_number
+
+      # Specifies the workflow type. This must be 'KYC_EXEMPT'
+      sig { returns(Lithic::Models::KYCExempt::Workflow::OrSymbol) }
+      attr_accessor :workflow
+
+      # Only applicable for customers using the KYC-Exempt workflow to enroll authorized
+      #   users of businesses. Pass the account_token of the enrolled business associated
+      #   with the AUTHORIZED_USER in this field.
+      sig { returns(T.nilable(String)) }
+      attr_reader :business_account_token
+
+      sig { params(business_account_token: String).void }
+      attr_writer :business_account_token
+
+      # A user provided id that can be used to link an account holder with an external
+      #   system
+      sig { returns(T.nilable(String)) }
+      attr_reader :external_id
+
+      sig { params(external_id: String).void }
+      attr_writer :external_id
+
+      sig do
+        params(
+          address: T.any(Lithic::Models::Address, Lithic::Util::AnyHash),
+          email: String,
+          first_name: String,
+          kyc_exemption_type: Lithic::Models::KYCExempt::KYCExemptionType::OrSymbol,
+          last_name: String,
+          phone_number: String,
+          workflow: Lithic::Models::KYCExempt::Workflow::OrSymbol,
+          business_account_token: String,
+          external_id: String
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        address:,
+        email:,
+        first_name:,
+        kyc_exemption_type:,
+        last_name:,
+        phone_number:,
+        workflow:,
+        business_account_token: nil,
+        external_id: nil
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              address: Lithic::Models::Address,
+              email: String,
+              first_name: String,
+              kyc_exemption_type: Lithic::Models::KYCExempt::KYCExemptionType::OrSymbol,
+              last_name: String,
+              phone_number: String,
+              workflow: Lithic::Models::KYCExempt::Workflow::OrSymbol,
+              business_account_token: String,
+              external_id: String
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # Specifies the type of KYC Exempt user
+      module KYCExemptionType
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::KYCExempt::KYCExemptionType) }
+        OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::KYCExempt::KYCExemptionType::TaggedSymbol) }
+
+        AUTHORIZED_USER = T.let(:AUTHORIZED_USER, Lithic::Models::KYCExempt::KYCExemptionType::TaggedSymbol)
+        PREPAID_CARD_USER = T.let(:PREPAID_CARD_USER, Lithic::Models::KYCExempt::KYCExemptionType::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::KYCExempt::KYCExemptionType::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      # Specifies the workflow type. This must be 'KYC_EXEMPT'
+      module Workflow
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::KYCExempt::Workflow) }
+        OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::KYCExempt::Workflow::TaggedSymbol) }
+
+        KYC_EXEMPT = T.let(:KYC_EXEMPT, Lithic::Models::KYCExempt::Workflow::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::KYCExempt::Workflow::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/management_operation_create_params.rbi

@@ -0,0 +1,190 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class ManagementOperationCreateParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      sig { returns(Integer) }
+      attr_accessor :amount
+
+      sig { returns(Lithic::Models::ManagementOperationCreateParams::Category::OrSymbol) }
+      attr_accessor :category
+
+      sig { returns(Lithic::Models::ManagementOperationCreateParams::Direction::OrSymbol) }
+      attr_accessor :direction
+
+      sig { returns(Date) }
+      attr_accessor :effective_date
+
+      sig { returns(Lithic::Models::ManagementOperationCreateParams::EventType::OrSymbol) }
+      attr_accessor :event_type
+
+      sig { returns(String) }
+      attr_accessor :financial_account_token
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :token
+
+      sig { params(token: String).void }
+      attr_writer :token
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :memo
+
+      sig { params(memo: String).void }
+      attr_writer :memo
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :subtype
+
+      sig { params(subtype: String).void }
+      attr_writer :subtype
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :user_defined_id
+
+      sig { params(user_defined_id: String).void }
+      attr_writer :user_defined_id
+
+      sig do
+        params(
+          amount: Integer,
+          category: Lithic::Models::ManagementOperationCreateParams::Category::OrSymbol,
+          direction: Lithic::Models::ManagementOperationCreateParams::Direction::OrSymbol,
+          effective_date: Date,
+          event_type: Lithic::Models::ManagementOperationCreateParams::EventType::OrSymbol,
+          financial_account_token: String,
+          token: String,
+          memo: String,
+          subtype: String,
+          user_defined_id: String,
+          request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        amount:,
+        category:,
+        direction:,
+        effective_date:,
+        event_type:,
+        financial_account_token:,
+        token: nil,
+        memo: nil,
+        subtype: nil,
+        user_defined_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              amount: Integer,
+              category: Lithic::Models::ManagementOperationCreateParams::Category::OrSymbol,
+              direction: Lithic::Models::ManagementOperationCreateParams::Direction::OrSymbol,
+              effective_date: Date,
+              event_type: Lithic::Models::ManagementOperationCreateParams::EventType::OrSymbol,
+              financial_account_token: String,
+              token: String,
+              memo: String,
+              subtype: String,
+              user_defined_id: String,
+              request_options: Lithic::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+
+      module Category
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationCreateParams::Category) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ManagementOperationCreateParams::Category::TaggedSymbol) }
+
+        MANAGEMENT_FEE =
+          T.let(:MANAGEMENT_FEE, Lithic::Models::ManagementOperationCreateParams::Category::TaggedSymbol)
+        MANAGEMENT_DISPUTE =
+          T.let(:MANAGEMENT_DISPUTE, Lithic::Models::ManagementOperationCreateParams::Category::TaggedSymbol)
+        MANAGEMENT_REWARD =
+          T.let(:MANAGEMENT_REWARD, Lithic::Models::ManagementOperationCreateParams::Category::TaggedSymbol)
+        MANAGEMENT_ADJUSTMENT =
+          T.let(:MANAGEMENT_ADJUSTMENT, Lithic::Models::ManagementOperationCreateParams::Category::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::ManagementOperationCreateParams::Category::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      module Direction
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationCreateParams::Direction) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ManagementOperationCreateParams::Direction::TaggedSymbol) }
+
+        CREDIT = T.let(:CREDIT, Lithic::Models::ManagementOperationCreateParams::Direction::TaggedSymbol)
+        DEBIT = T.let(:DEBIT, Lithic::Models::ManagementOperationCreateParams::Direction::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::ManagementOperationCreateParams::Direction::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      module EventType
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationCreateParams::EventType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol) }
+
+        CASH_BACK = T.let(:CASH_BACK, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+        CURRENCY_CONVERSION =
+          T.let(:CURRENCY_CONVERSION, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+        INTEREST = T.let(:INTEREST, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+        LATE_PAYMENT =
+          T.let(:LATE_PAYMENT, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+        BILLING_ERROR =
+          T.let(:BILLING_ERROR, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+        PROVISIONAL_CREDIT =
+          T.let(:PROVISIONAL_CREDIT, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+        LOSS_WRITE_OFF =
+          T.let(:LOSS_WRITE_OFF, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+        CASH_BACK_REVERSAL =
+          T.let(:CASH_BACK_REVERSAL, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+        CURRENCY_CONVERSION_REVERSAL =
+          T.let(
+            :CURRENCY_CONVERSION_REVERSAL,
+            Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
+        INTEREST_REVERSAL =
+          T.let(:INTEREST_REVERSAL, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+        LATE_PAYMENT_REVERSAL =
+          T.let(:LATE_PAYMENT_REVERSAL, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+        BILLING_ERROR_REVERSAL =
+          T.let(:BILLING_ERROR_REVERSAL, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+        PROVISIONAL_CREDIT_REVERSAL =
+          T.let(
+            :PROVISIONAL_CREDIT_REVERSAL,
+            Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
+        RETURNED_PAYMENT =
+          T.let(:RETURNED_PAYMENT, Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol)
+        RETURNED_PAYMENT_REVERSAL =
+          T.let(
+            :RETURNED_PAYMENT_REVERSAL,
+            Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
+
+        sig { override.returns(T::Array[Lithic::Models::ManagementOperationCreateParams::EventType::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/management_operation_list_params.rbi

@@ -0,0 +1,167 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class ManagementOperationListParams < 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_
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :business_account_token
+
+      sig { params(business_account_token: String).void }
+      attr_writer :business_account_token
+
+      # Management operation category to be returned.
+      sig { returns(T.nilable(Lithic::Models::ManagementOperationListParams::Category::OrSymbol)) }
+      attr_reader :category
+
+      sig { params(category: Lithic::Models::ManagementOperationListParams::Category::OrSymbol).void }
+      attr_writer :category
+
+      # 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
+
+      # Globally unique identifier for the financial account. Accepted type dependent on
+      #   the program's use case.
+      sig { returns(T.nilable(String)) }
+      attr_reader :financial_account_token
+
+      sig { params(financial_account_token: String).void }
+      attr_writer :financial_account_token
+
+      # 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
+
+      # Management operation status to be returned.
+      sig { returns(T.nilable(Lithic::Models::ManagementOperationListParams::Status::OrSymbol)) }
+      attr_reader :status
+
+      sig { params(status: Lithic::Models::ManagementOperationListParams::Status::OrSymbol).void }
+      attr_writer :status
+
+      sig do
+        params(
+          begin_: Time,
+          business_account_token: String,
+          category: Lithic::Models::ManagementOperationListParams::Category::OrSymbol,
+          end_: Time,
+          ending_before: String,
+          financial_account_token: String,
+          page_size: Integer,
+          starting_after: String,
+          status: Lithic::Models::ManagementOperationListParams::Status::OrSymbol,
+          request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        begin_: nil,
+        business_account_token: nil,
+        category: nil,
+        end_: nil,
+        ending_before: nil,
+        financial_account_token: nil,
+        page_size: nil,
+        starting_after: nil,
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              begin_: Time,
+              business_account_token: String,
+              category: Lithic::Models::ManagementOperationListParams::Category::OrSymbol,
+              end_: Time,
+              ending_before: String,
+              financial_account_token: String,
+              page_size: Integer,
+              starting_after: String,
+              status: Lithic::Models::ManagementOperationListParams::Status::OrSymbol,
+              request_options: Lithic::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # Management operation category to be returned.
+      module Category
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationListParams::Category) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ManagementOperationListParams::Category::TaggedSymbol) }
+
+        MANAGEMENT_FEE =
+          T.let(:MANAGEMENT_FEE, Lithic::Models::ManagementOperationListParams::Category::TaggedSymbol)
+        MANAGEMENT_DISPUTE =
+          T.let(:MANAGEMENT_DISPUTE, Lithic::Models::ManagementOperationListParams::Category::TaggedSymbol)
+        MANAGEMENT_REWARD =
+          T.let(:MANAGEMENT_REWARD, Lithic::Models::ManagementOperationListParams::Category::TaggedSymbol)
+        MANAGEMENT_ADJUSTMENT =
+          T.let(:MANAGEMENT_ADJUSTMENT, Lithic::Models::ManagementOperationListParams::Category::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::ManagementOperationListParams::Category::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      # Management operation status to be returned.
+      module Status
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::ManagementOperationListParams::Status) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::ManagementOperationListParams::Status::TaggedSymbol) }
+
+        PENDING = T.let(:PENDING, Lithic::Models::ManagementOperationListParams::Status::TaggedSymbol)
+        SETTLED = T.let(:SETTLED, Lithic::Models::ManagementOperationListParams::Status::TaggedSymbol)
+        DECLINED = T.let(:DECLINED, Lithic::Models::ManagementOperationListParams::Status::TaggedSymbol)
+        REVERSED = T.let(:REVERSED, Lithic::Models::ManagementOperationListParams::Status::TaggedSymbol)
+        CANCELED = T.let(:CANCELED, Lithic::Models::ManagementOperationListParams::Status::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::ManagementOperationListParams::Status::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/management_operation_retrieve_params.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class ManagementOperationRetrieveParams < 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