lithic 0.1.0.pre.alpha.22 → 0.1.0.pre.alpha.24

data/rbi/lithic/resources/tokenizations.rbi

@@ -5,14 +5,18 @@ module Lithic
     class Tokenizations
       # Get tokenization
       sig do
-        params(tokenization_token: String, request_options: Lithic::RequestOpts)
-          .returns(Lithic::Models::TokenizationRetrieveResponse)
+        params(
+          tokenization_token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(Lithic::Models::TokenizationRetrieveResponse)
       end
       def retrieve(
         # Tokenization token
         tokenization_token,
         request_options: {}
-      ); end
+      )
+      end
+
       # List card tokenizations
       sig do
         params(
@@ -23,10 +27,10 @@ module Lithic
           ending_before: String,
           page_size: Integer,
           starting_after: String,
-          tokenization_channel: Lithic::Models::TokenizationListParams::TokenizationChannel::OrSymbol,
-          request_options: Lithic::RequestOpts
-        )
-          .returns(Lithic::Internal::CursorPage[Lithic::Models::Tokenization])
+          tokenization_channel:
+            Lithic::TokenizationListParams::TokenizationChannel::OrSymbol,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(Lithic::Internal::CursorPage[Lithic::Tokenization])
       end
       def list(
         # Filters for tokenizations associated with a specific account.
@@ -49,7 +53,9 @@ module Lithic
         # DIGITAL_WALLET tokenizations will be returned.
         tokenization_channel: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       # This endpoint is used to ask the card network to activate a tokenization. A
       # successful response indicates that the request was successfully delivered to the
       # card network. When the card network activates the tokenization, the state will
@@ -58,12 +64,19 @@ module Lithic
       # `PENDING_ACTIVATION`, or `PENDING_2FA`. This will put the tokenization in an
       # active state, and transactions will be allowed. Reach out at
       # [lithic.com/contact](https://lithic.com/contact) for more information.
-      sig { params(tokenization_token: String, request_options: Lithic::RequestOpts).void }
+      sig do
+        params(
+          tokenization_token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).void
+      end
       def activate(
         # Tokenization token
         tokenization_token,
         request_options: {}
-      ); end
+      )
+      end
+
       # This endpoint is used to ask the card network to deactivate a tokenization. A
       # successful response indicates that the request was successfully delivered to the
       # card network. When the card network deactivates the tokenization, the state will
@@ -73,12 +86,19 @@ module Lithic
       # operation. If the target is a digital wallet tokenization, it will be removed
       # from its device. Reach out at [lithic.com/contact](https://lithic.com/contact)
       # for more information.
-      sig { params(tokenization_token: String, request_options: Lithic::RequestOpts).void }
+      sig do
+        params(
+          tokenization_token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).void
+      end
       def deactivate(
         # Tokenization token
         tokenization_token,
         request_options: {}
-      ); end
+      )
+      end
+
       # This endpoint is used to ask the card network to pause a tokenization. A
       # successful response indicates that the request was successfully delivered to the
       # card network. When the card network pauses the tokenization, the state will be
@@ -87,12 +107,19 @@ module Lithic
       # merchants from sending authorizations, and is a temporary status that can be
       # changed. Reach out at [lithic.com/contact](https://lithic.com/contact) for more
       # information.
-      sig { params(tokenization_token: String, request_options: Lithic::RequestOpts).void }
+      sig do
+        params(
+          tokenization_token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).void
+      end
       def pause(
         # Tokenization token
         tokenization_token,
         request_options: {}
-      ); end
+      )
+      end
+
       # This endpoint is used to ask the card network to send another activation code to
       # a cardholder that has already tried tokenizing a card. A successful response
       # indicates that the request was successfully delivered to the card network. The
@@ -106,10 +133,10 @@ module Lithic
       sig do
         params(
           tokenization_token: String,
-          activation_method_type: Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol,
-          request_options: Lithic::RequestOpts
-        )
-          .void
+          activation_method_type:
+            Lithic::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol,
+          request_options: Lithic::RequestOptions::OrHash
+        ).void
       end
       def resend_activation_code(
         # Tokenization token
@@ -119,7 +146,9 @@ module Lithic
         # = "EMAIL_TO_CARDHOLDER_ADDRESS"
         activation_method_type: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       # This endpoint is used to simulate a card's tokenization in the Digital Wallet
       # and merchant tokenization ecosystem.
       sig do
@@ -127,14 +156,15 @@ module Lithic
           cvv: String,
           expiration_date: String,
           pan: String,
-          tokenization_source: Lithic::Models::TokenizationSimulateParams::TokenizationSource::OrSymbol,
+          tokenization_source:
+            Lithic::TokenizationSimulateParams::TokenizationSource::OrSymbol,
           account_score: Integer,
           device_score: Integer,
           entity: String,
-          wallet_recommended_decision: Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::OrSymbol,
-          request_options: Lithic::RequestOpts
-        )
-          .returns(Lithic::Models::TokenizationSimulateResponse)
+          wallet_recommended_decision:
+            Lithic::TokenizationSimulateParams::WalletRecommendedDecision::OrSymbol,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(Lithic::Models::TokenizationSimulateResponse)
       end
       def simulate(
         # The three digit cvv for the card.
@@ -157,7 +187,9 @@ module Lithic
         # The decision that the Digital Wallet's recommend
         wallet_recommended_decision: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       # This endpoint is used to ask the card network to unpause a tokenization. A
       # successful response indicates that the request was successfully delivered to the
       # card network. When the card network unpauses the tokenization, the state will be
@@ -165,12 +197,19 @@ module Lithic
       # used on tokenizations with status `PAUSED`. This will put the tokenization in an
       # active state, and transactions may resume. Reach out at
       # [lithic.com/contact](https://lithic.com/contact) for more information.
-      sig { params(tokenization_token: String, request_options: Lithic::RequestOpts).void }
+      sig do
+        params(
+          tokenization_token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).void
+      end
       def unpause(
         # Tokenization token
         tokenization_token,
         request_options: {}
-      ); end
+      )
+      end
+
       # This endpoint is used update the digital card art for a digital wallet
       # tokenization. A successful response indicates that the card network has updated
       # the tokenization's art, and the tokenization's `digital_cart_art_token` field
@@ -183,9 +222,8 @@ module Lithic
         params(
           tokenization_token: String,
           digital_card_art_token: String,
-          request_options: Lithic::RequestOpts
-        )
-          .returns(Lithic::Models::TokenizationUpdateDigitalCardArtResponse)
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(Lithic::Models::TokenizationUpdateDigitalCardArtResponse)
       end
       def update_digital_card_art(
         # Tokenization token
@@ -196,10 +234,13 @@ module Lithic
         # [Flexible Card Art Guide](https://docs.lithic.com/docs/about-digital-wallets#flexible-card-art).
         digital_card_art_token: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       # @api private
       sig { params(client: Lithic::Client).returns(T.attached_class) }
-      def self.new(client:); end
+      def self.new(client:)
+      end
     end
   end
 end

data/rbi/lithic/resources/transactions/enhanced_commercial_data.rbi

@@ -7,17 +7,24 @@ module Lithic
         # Get all L2/L3 enhanced commercial data associated with a transaction. Not
         # available in sandbox.
         sig do
-          params(transaction_token: String, request_options: Lithic::RequestOpts)
-            .returns(Lithic::Models::Transactions::EnhancedCommercialDataRetrieveResponse)
+          params(
+            transaction_token: String,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(
+            Lithic::Models::Transactions::EnhancedCommercialDataRetrieveResponse
+          )
         end
         def retrieve(
           # The token of the transaction that the enhanced data is associated with.
           transaction_token,
           request_options: {}
-        ); end
+        )
+        end
+
         # @api private
         sig { params(client: Lithic::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/lithic/resources/transactions/events/enhanced_commercial_data.rbi

@@ -8,17 +8,22 @@ module Lithic
           # Get L2/L3 enhanced commercial data associated with a transaction event. Not
           # available in sandbox.
           sig do
-            params(event_token: String, request_options: Lithic::RequestOpts)
-              .returns(Lithic::Models::Transactions::Events::EnhancedData)
+            params(
+              event_token: String,
+              request_options: Lithic::RequestOptions::OrHash
+            ).returns(Lithic::Transactions::Events::EnhancedData)
           end
           def retrieve(
             # The token of the transaction event that the enhanced data is associated with.
             event_token,
             request_options: {}
-          ); end
+          )
+          end
+
           # @api private
           sig { params(client: Lithic::Client).returns(T.attached_class) }
-          def self.new(client:); end
+          def self.new(client:)
+          end
         end
       end
     end

data/rbi/lithic/resources/transactions/events.rbi

@@ -4,12 +4,17 @@ module Lithic
   module Resources
     class Transactions
       class Events
-        sig { returns(Lithic::Resources::Transactions::Events::EnhancedCommercialData) }
+        sig do
+          returns(
+            Lithic::Resources::Transactions::Events::EnhancedCommercialData
+          )
+        end
         attr_reader :enhanced_commercial_data
 
         # @api private
         sig { params(client: Lithic::Client).returns(T.attached_class) }
-        def self.new(client:); end
+        def self.new(client:)
+        end
       end
     end
   end

data/rbi/lithic/resources/transactions.rbi

@@ -12,14 +12,18 @@ module Lithic
       # Get a specific card transaction. All amounts are in the smallest unit of their
       # respective currency (e.g., cents for USD).
       sig do
-        params(transaction_token: String, request_options: Lithic::RequestOpts)
-          .returns(Lithic::Models::Transaction)
+        params(
+          transaction_token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(Lithic::Transaction)
       end
       def retrieve(
         # Globally unique identifier for the transaction.
         transaction_token,
         request_options: {}
-      ); end
+      )
+      end
+
       # List card transactions. All amounts are in the smallest unit of their respective
       # currency (e.g., cents for USD) and inclusive of any acquirer fees.
       sig do
@@ -30,12 +34,11 @@ module Lithic
           end_: Time,
           ending_before: String,
           page_size: Integer,
-          result: Lithic::Models::TransactionListParams::Result::OrSymbol,
+          result: Lithic::TransactionListParams::Result::OrSymbol,
           starting_after: String,
-          status: Lithic::Models::TransactionListParams::Status::OrSymbol,
-          request_options: Lithic::RequestOpts
-        )
-          .returns(Lithic::Internal::CursorPage[Lithic::Models::Transaction])
+          status: Lithic::TransactionListParams::Status::OrSymbol,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(Lithic::Internal::CursorPage[Lithic::Transaction])
       end
       def list(
         # Filters for transactions associated with a specific account.
@@ -62,14 +65,23 @@ module Lithic
         # Filters for transactions using transaction status field.
         status: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       # Expire authorization
-      sig { params(transaction_token: String, request_options: Lithic::RequestOpts).void }
+      sig do
+        params(
+          transaction_token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).void
+      end
       def expire_authorization(
         # The token of the transaction to expire.
         transaction_token,
         request_options: {}
-      ); end
+      )
+      end
+
       # Simulates an authorization request from the card network as if it came from a
       # merchant acquirer. If you are configured for ASA, simulating authorizations
       # requires your ASA client to be set up properly, i.e. be able to respond to the
@@ -89,10 +101,10 @@ module Lithic
           merchant_currency: String,
           partial_approval_capable: T::Boolean,
           pin: String,
-          status: Lithic::Models::TransactionSimulateAuthorizationParams::Status::OrSymbol,
-          request_options: Lithic::RequestOpts
-        )
-          .returns(Lithic::Models::TransactionSimulateAuthorizationResponse)
+          status:
+            Lithic::TransactionSimulateAuthorizationParams::Status::OrSymbol,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(Lithic::Models::TransactionSimulateAuthorizationResponse)
       end
       def simulate_authorization(
         # Amount (in cents) to authorize. For credit authorizations and financial credit
@@ -141,13 +153,20 @@ module Lithic
         #   the transaction.
         status: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       # Simulates an authorization advice from the card network as if it came from a
       # merchant acquirer. An authorization advice changes the pending amount of the
       # transaction.
       sig do
-        params(token: String, amount: Integer, request_options: Lithic::RequestOpts)
-          .returns(Lithic::Models::TransactionSimulateAuthorizationAdviceResponse)
+        params(
+          token: String,
+          amount: Integer,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(
+          Lithic::Models::TransactionSimulateAuthorizationAdviceResponse
+        )
       end
       def simulate_authorization_advice(
         # The transaction token returned from the /v1/simulate/authorize. response.
@@ -156,7 +175,9 @@ module Lithic
         # amount that was originally set by /v1/simulate/authorize.
         amount:,
         request_options: {}
-      ); end
+      )
+      end
+
       # Clears an existing authorization, either debit or credit. After this event, the
       # transaction transitions from `PENDING` to `SETTLED` status.
       #
@@ -164,8 +185,11 @@ module Lithic
       # Transactions that have already cleared, either partially or fully, cannot be
       # cleared again using this endpoint.
       sig do
-        params(token: String, amount: Integer, request_options: Lithic::RequestOpts)
-          .returns(Lithic::Models::TransactionSimulateClearingResponse)
+        params(
+          token: String,
+          amount: Integer,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(Lithic::Models::TransactionSimulateClearingResponse)
       end
       def simulate_clearing(
         # The transaction token returned from the /v1/simulate/authorize response.
@@ -181,7 +205,9 @@ module Lithic
         # cleared again using this endpoint.
         amount: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       # Simulates a credit authorization advice from the card network. This message
       # indicates that the network approved a credit authorization on your behalf.
       sig do
@@ -191,9 +217,10 @@ module Lithic
           pan: String,
           mcc: String,
           merchant_acceptor_id: String,
-          request_options: Lithic::RequestOpts
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(
+          Lithic::Models::TransactionSimulateCreditAuthorizationResponse
         )
-          .returns(Lithic::Models::TransactionSimulateCreditAuthorizationResponse)
       end
       def simulate_credit_authorization(
         # Amount (in cents). Any value entered will be converted into a negative amount in
@@ -211,13 +238,19 @@ module Lithic
         # Unique identifier to identify the payment card acceptor.
         merchant_acceptor_id: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       # Returns, or refunds, an amount back to a card. Returns simulated via this
       # endpoint clear immediately, without prior authorization, and result in a
       # `SETTLED` transaction status.
       sig do
-        params(amount: Integer, descriptor: String, pan: String, request_options: Lithic::RequestOpts)
-          .returns(Lithic::Models::TransactionSimulateReturnResponse)
+        params(
+          amount: Integer,
+          descriptor: String,
+          pan: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(Lithic::Models::TransactionSimulateReturnResponse)
       end
       def simulate_return(
         # Amount (in cents) to authorize.
@@ -227,19 +260,25 @@ module Lithic
         # Sixteen digit card number.
         pan:,
         request_options: {}
-      ); end
+      )
+      end
+
       # Reverses a return, i.e. a credit transaction with a `SETTLED` status. Returns
       # can be financial credit authorizations, or credit authorizations that have
       # cleared.
       sig do
-        params(token: String, request_options: Lithic::RequestOpts)
-          .returns(Lithic::Models::TransactionSimulateReturnReversalResponse)
+        params(
+          token: String,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(Lithic::Models::TransactionSimulateReturnReversalResponse)
       end
       def simulate_return_reversal(
         # The transaction token returned from the /v1/simulate/authorize response.
         token:,
         request_options: {}
-      ); end
+      )
+      end
+
       # Voids a pending authorization. If `amount` is not set, the full amount will be
       # voided. Can be used on partially voided transactions but not partially cleared
       # transactions. _Simulating an authorization expiry on credit authorizations or
@@ -248,10 +287,9 @@ module Lithic
         params(
           token: String,
           amount: Integer,
-          type: Lithic::Models::TransactionSimulateVoidParams::Type::OrSymbol,
-          request_options: Lithic::RequestOpts
-        )
-          .returns(Lithic::Models::TransactionSimulateVoidResponse)
+          type: Lithic::TransactionSimulateVoidParams::Type::OrSymbol,
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(Lithic::Models::TransactionSimulateVoidResponse)
       end
       def simulate_void(
         # The transaction token returned from the /v1/simulate/authorize response.
@@ -266,10 +304,13 @@ module Lithic
         # - `AUTHORIZATION_REVERSAL` indicates authorization was reversed by the merchant.
         type: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       # @api private
       sig { params(client: Lithic::Client).returns(T.attached_class) }
-      def self.new(client:); end
+      def self.new(client:)
+      end
     end
   end
 end

data/rbi/lithic/resources/transfers.rbi

@@ -12,9 +12,8 @@ module Lithic
           to: String,
           token: String,
           memo: String,
-          request_options: Lithic::RequestOpts
-        )
-          .returns(Lithic::Models::Transfer)
+          request_options: Lithic::RequestOptions::OrHash
+        ).returns(Lithic::Transfer)
       end
       def create(
         # Amount to be transferred in the currency’s smallest unit (e.g., cents for USD).
@@ -32,10 +31,13 @@ module Lithic
         # Optional descriptor for the transfer.
         memo: nil,
         request_options: {}
-      ); end
+      )
+      end
+
       # @api private
       sig { params(client: Lithic::Client).returns(T.attached_class) }
-      def self.new(client:); end
+      def self.new(client:)
+      end
     end
   end
 end

data/sig/lithic/client.rbs

@@ -67,7 +67,7 @@ module Lithic
 
     def api_status: (
       ?request_options: Lithic::request_opts
-    ) -> Lithic::Models::APIStatus
+    ) -> Lithic::APIStatus
 
     private def auth_headers: -> ::Hash[String, String]
 

data/sig/lithic/internal/transport/base_client.rbs

@@ -2,6 +2,8 @@ module Lithic
   module Internal
     module Transport
       class BaseClient
+        extend Lithic::Internal::Util::SorbetRuntimeSupport
+
         type request_components =
           {
             method: Symbol,
@@ -20,7 +22,6 @@ module Lithic
             model: Lithic::Internal::Type::Converter::input?,
             options: Lithic::request_opts?
           }
-
         type request_input =
           {
             method: Symbol,
@@ -55,6 +56,20 @@ module Lithic
           stream: Enumerable[String]?
         ) -> void
 
+        attr_reader base_url: URI::Generic
+
+        attr_reader timeout: Float
+
+        attr_reader max_retries: Integer
+
+        attr_reader initial_retry_delay: Float
+
+        attr_reader max_retry_delay: Float
+
+        attr_reader headers: ::Hash[String, String]
+
+        attr_reader idempotency_header: String?
+
         # @api private
         attr_reader requester: Lithic::Internal::Transport::PooledNetRequester
 

data/sig/lithic/internal/transport/pooled_net_requester.rbs

@@ -2,6 +2,8 @@ module Lithic
   module Internal
     module Transport
       class PooledNetRequester
+        extend Lithic::Internal::Util::SorbetRuntimeSupport
+
         type request =
           {
             method: Symbol,

data/sig/lithic/internal/type/base_model.rbs

@@ -3,10 +3,13 @@ module Lithic
     module Type
       class BaseModel
         extend Lithic::Internal::Type::Converter
+        extend Lithic::Internal::Util::SorbetRuntimeSupport
 
         type known_field =
           { mode: (:coerce | :dump)?, required: bool, nilable: bool }
 
+        def self.inherited: (self child) -> void
+
         def self.known_fields: -> ::Hash[Symbol, (Lithic::Internal::Type::BaseModel::known_field
         & { type_fn: (^-> Lithic::Internal::Type::Converter::input) })]
 
@@ -65,23 +68,26 @@ module Lithic
           state: Lithic::Internal::Type::Converter::dump_state
         ) -> (::Hash[top, top] | top)
 
+        def self.recursively_to_h: (
+          Lithic::Internal::Type::BaseModel model,
+          convert: bool
+        ) -> ::Hash[Symbol, top]
+
         def []: (Symbol key) -> top?
 
         def to_h: -> ::Hash[Symbol, top]
 
         alias to_hash to_h
 
-        def deconstruct_keys: (::Array[Symbol]? keys) -> ::Hash[Symbol, top]
+        def deep_to_h: -> ::Hash[Symbol, top]
 
-        def self.walk: (
-          Lithic::Internal::Type::BaseModel model
-        ) -> ::Hash[Symbol, top]
+        def deconstruct_keys: (::Array[Symbol]? keys) -> ::Hash[Symbol, top]
 
         def to_json: (*top a) -> String
 
         def to_yaml: (*top a) -> String
 
-        def initialize: (?::Hash[Symbol, top] | self data) -> void
+        def initialize: (?::Hash[Symbol, top] | instance data) -> void
 
         def self.inspect: (?depth: Integer) -> String
 

data/sig/lithic/internal/type/base_page.rbs

@@ -4,7 +4,7 @@ module Lithic
       module BasePage[Elem]
         def next_page?: -> bool
 
-        def next_page: -> self
+        def next_page: -> instance
 
         def auto_paging_each: { (Elem arg0) -> void } -> void
 

data/sig/lithic/internal/type/converter.rbs

@@ -2,6 +2,8 @@ module Lithic
   module Internal
     module Type
       module Converter
+        extend Lithic::Internal::Util::SorbetRuntimeSupport
+
         type input = Lithic::Internal::Type::Converter | Class
 
         type coerce_state =