lithic 0.1.0.pre.alpha.22 → 0.1.0.pre.alpha.23

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/type/request_parameters.rbs

@@ -4,7 +4,9 @@ module Lithic
       type request_parameters = { request_options: Lithic::request_opts }
 
       module RequestParameters
-        attr_accessor request_options: Lithic::request_opts
+        attr_reader request_options: Lithic::request_opts
+
+        def request_options=: (Lithic::request_opts) -> Lithic::request_opts
 
         module Converter
           def dump_request: (top params) -> [top, ::Hash[Symbol, top]]

data/sig/lithic/models/account.rbs

@@ -4,12 +4,12 @@ module Lithic
       {
         token: String,
         created: Time?,
-        spend_limit: Lithic::Models::Account::SpendLimit,
-        state: Lithic::Models::Account::state,
-        account_holder: Lithic::Models::Account::AccountHolder,
+        spend_limit: Lithic::Account::SpendLimit,
+        state: Lithic::Account::state,
+        account_holder: Lithic::Account::AccountHolder,
         auth_rule_tokens: ::Array[String],
         cardholder_currency: String,
-        verification_address: Lithic::Models::Account::VerificationAddress
+        verification_address: Lithic::Account::VerificationAddress
       }
 
     class Account < Lithic::Internal::Type::BaseModel
@@ -17,15 +17,15 @@ module Lithic
 
       attr_accessor created: Time?
 
-      attr_accessor spend_limit: Lithic::Models::Account::SpendLimit
+      attr_accessor spend_limit: Lithic::Account::SpendLimit
 
-      attr_accessor state: Lithic::Models::Account::state
+      attr_accessor state: Lithic::Account::state
 
-      attr_reader account_holder: Lithic::Models::Account::AccountHolder?
+      attr_reader account_holder: Lithic::Account::AccountHolder?
 
       def account_holder=: (
-        Lithic::Models::Account::AccountHolder
-      ) -> Lithic::Models::Account::AccountHolder
+        Lithic::Account::AccountHolder
+      ) -> Lithic::Account::AccountHolder
 
       attr_reader auth_rule_tokens: ::Array[String]?
 
@@ -35,25 +35,23 @@ module Lithic
 
       def cardholder_currency=: (String) -> String
 
-      attr_reader verification_address: Lithic::Models::Account::VerificationAddress?
+      attr_reader verification_address: Lithic::Account::VerificationAddress?
 
       def verification_address=: (
-        Lithic::Models::Account::VerificationAddress
-      ) -> Lithic::Models::Account::VerificationAddress
+        Lithic::Account::VerificationAddress
+      ) -> Lithic::Account::VerificationAddress
 
       def initialize: (
         token: String,
         created: Time?,
-        spend_limit: Lithic::Models::Account::SpendLimit,
-        state: Lithic::Models::Account::state,
-        ?account_holder: Lithic::Models::Account::AccountHolder,
+        spend_limit: Lithic::Account::SpendLimit,
+        state: Lithic::Account::state,
+        ?account_holder: Lithic::Account::AccountHolder,
         ?auth_rule_tokens: ::Array[String],
         ?cardholder_currency: String,
-        ?verification_address: Lithic::Models::Account::VerificationAddress
+        ?verification_address: Lithic::Account::VerificationAddress
       ) -> void
 
-      def to_hash: -> Lithic::Models::account
-
       type spend_limit = { daily: Integer, lifetime: Integer, monthly: Integer }
 
       class SpendLimit < Lithic::Internal::Type::BaseModel
@@ -68,8 +66,6 @@ module Lithic
           lifetime: Integer,
           monthly: Integer
         ) -> void
-
-        def to_hash: -> Lithic::Models::Account::spend_limit
       end
 
       type state = :ACTIVE | :PAUSED | :CLOSED
@@ -81,7 +77,7 @@ module Lithic
         PAUSED: :PAUSED
         CLOSED: :CLOSED
 
-        def self?.values: -> ::Array[Lithic::Models::Account::state]
+        def self?.values: -> ::Array[Lithic::Account::state]
       end
 
       type account_holder =
@@ -107,8 +103,6 @@ module Lithic
           email: String,
           phone_number: String
         ) -> void
-
-        def to_hash: -> Lithic::Models::Account::account_holder
       end
 
       type verification_address =
@@ -144,8 +138,6 @@ module Lithic
           state: String,
           ?address2: String
         ) -> void
-
-        def to_hash: -> Lithic::Models::Account::verification_address
       end
     end
   end