lithic 0.5.0 → 0.7.0

data/rbi/lithic/resources/account_holders.rbi

@@ -3,6 +3,9 @@
 module Lithic
   module Resources
     class AccountHolders
+      sig { returns(Lithic::Resources::AccountHolders::Entities) }
+      attr_reader :entities
+
       # Create an account holder and initiate the appropriate onboarding workflow.
       # Account holders and accounts have a 1:1 relationship. When an account holder is
       # successfully created an associated account is also created. All calls to this
@@ -13,108 +16,17 @@ module Lithic
       # that the calling API key manages.
       sig do
         params(
-          business_entity:
-            Lithic::AccountHolderCreateParams::BusinessEntity::OrHash,
-          tos_timestamp: String,
-          workflow: Lithic::AccountHolderCreateParams::Workflow::OrSymbol,
-          individual: Lithic::AccountHolderCreateParams::Individual::OrHash,
-          address: Lithic::Address::OrHash,
-          email: String,
-          first_name: String,
-          kyc_exemption_type:
-            Lithic::AccountHolderCreateParams::KYCExemptionType::OrSymbol,
-          last_name: String,
-          phone_number: String,
-          beneficial_owner_individuals:
-            T::Array[
-              Lithic::AccountHolderCreateParams::BeneficialOwnerIndividual::OrHash
-            ],
-          control_person:
-            Lithic::AccountHolderCreateParams::ControlPerson::OrHash,
-          nature_of_business: String,
-          beneficial_owner_entities:
-            T::Array[
-              Lithic::AccountHolderCreateParams::BeneficialOwnerEntity::OrHash
-            ],
-          external_id: String,
-          kyb_passed_timestamp: String,
-          naics_code: String,
-          website_url: String,
-          kyc_passed_timestamp: String,
-          business_account_token: String,
+          body:
+            T.any(
+              Lithic::KYB::OrHash,
+              Lithic::AccountHolderCreateParams::Body::KYBDelegated::OrHash,
+              Lithic::KYC::OrHash,
+              Lithic::KYCExempt::OrHash
+            ),
           request_options: Lithic::RequestOptions::OrHash
         ).returns(Lithic::Models::AccountHolderCreateResponse)
       end
-      def create(
-        # Information for business for which the account is being opened.
-        business_entity:,
-        # 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.
-        tos_timestamp:,
-        # Specifies the workflow type. This must be 'KYC_EXEMPT'
-        workflow:,
-        # Information on individual for whom the account is being opened and KYC is being
-        # run.
-        individual:,
-        # KYC Exempt user's current address - PO boxes, UPS drops, and FedEx drops are not
-        # acceptable; APO/FPO are acceptable.
-        address:,
-        # The KYC Exempt user's email
-        email:,
-        # The KYC Exempt user's first name
-        first_name:,
-        # Specifies the type of KYC Exempt user
-        kyc_exemption_type:,
-        # The KYC Exempt user's last name
-        last_name:,
-        # The KYC Exempt user's phone number, entered in E.164 format.
-        phone_number:,
-        # You can submit a list of all direct and indirect individuals with 25% or more
-        # ownership in the company. A maximum of 4 beneficial owners can be submitted. If
-        # no individual owns 25% of the company you do not need to send beneficial owner
-        # information. See
-        # [FinCEN requirements](https://www.fincen.gov/sites/default/files/shared/CDD_Rev6.7_Sept_2017_Certificate.pdf)
-        # (Section I) for more background on individuals that should be included.
-        beneficial_owner_individuals: nil,
-        # An individual with significant responsibility for managing the legal entity
-        # (e.g., a Chief Executive Officer, Chief Financial Officer, Chief Operating
-        # Officer, Managing Member, General Partner, President, Vice President, or
-        # Treasurer). This can be an executive, or someone who will have program-wide
-        # access to the cards that Lithic will provide. In some cases, this individual
-        # could also be a beneficial owner listed above. See
-        # [FinCEN requirements](https://www.fincen.gov/sites/default/files/shared/CDD_Rev6.7_Sept_2017_Certificate.pdf)
-        # (Section II) for more background.
-        control_person: nil,
-        # Short description of the company's line of business (i.e., what does the company
-        # do?).
-        nature_of_business: nil,
-        # Deprecated.
-        beneficial_owner_entities: nil,
-        # A user provided id that can be used to link an account holder with an external
-        # system
-        external_id: nil,
-        # An RFC 3339 timestamp indicating when precomputed KYB was completed on the
-        # business with a pass result.
-        #
-        # This field is required only if workflow type is `KYB_BYO`.
-        kyb_passed_timestamp: nil,
-        # 6-digit North American Industry Classification System (NAICS) code for the
-        # business.
-        naics_code: nil,
-        # Company website URL.
-        website_url: nil,
-        # 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`.
-        kyc_passed_timestamp: nil,
-        # 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.
-        business_account_token: nil,
-        request_options: {}
-      )
+      def create(body:, request_options: {})
       end
 
       # Get an Individual or Business Account Holder and/or their KYC or KYB evaluation
@@ -145,90 +57,20 @@ module Lithic
       sig do
         params(
           account_holder_token: String,
-          beneficial_owner_entities:
-            T::Array[
-              Lithic::AccountHolderUpdateParams::BeneficialOwnerEntity::OrHash
-            ],
-          beneficial_owner_individuals:
-            T::Array[
-              Lithic::AccountHolderUpdateParams::BeneficialOwnerIndividual::OrHash
-            ],
-          business_entity:
-            Lithic::AccountHolderUpdateParams::BusinessEntity::OrHash,
-          control_person:
-            Lithic::AccountHolderUpdateParams::ControlPerson::OrHash,
-          external_id: String,
-          naics_code: String,
-          nature_of_business: String,
-          website_url: String,
-          individual: Lithic::AccountHolderUpdateParams::Individual::OrHash,
-          address: Lithic::AddressUpdate::OrHash,
-          business_account_token: String,
-          email: String,
-          first_name: String,
-          last_name: String,
-          legal_business_name: String,
-          phone_number: String,
+          body:
+            T.any(
+              Lithic::AccountHolderUpdateParams::Body::KYBPatchRequest::OrHash,
+              Lithic::AccountHolderUpdateParams::Body::KYCPatchRequest::OrHash,
+              Lithic::AccountHolderUpdateParams::Body::PatchRequest::OrHash
+            ),
           request_options: Lithic::RequestOptions::OrHash
         ).returns(Lithic::Models::AccountHolderUpdateResponse::Variants)
       end
       def update(
         # Globally unique identifier for the account holder.
         account_holder_token,
-        # Deprecated.
-        beneficial_owner_entities: nil,
-        # You must submit a list of all direct and indirect individuals with 25% or more
-        # ownership in the company. A maximum of 4 beneficial owners can be submitted. If
-        # no individual owns 25% of the company you do not need to send beneficial owner
-        # information. See
-        # [FinCEN requirements](https://www.fincen.gov/sites/default/files/shared/CDD_Rev6.7_Sept_2017_Certificate.pdf)
-        # (Section I) for more background on individuals that should be included.
-        beneficial_owner_individuals: nil,
-        # Information for business for which the account is being opened and KYB is being
-        # run.
-        business_entity: nil,
-        # An individual with significant responsibility for managing the legal entity
-        # (e.g., a Chief Executive Officer, Chief Financial Officer, Chief Operating
-        # Officer, Managing Member, General Partner, President, Vice President, or
-        # Treasurer). This can be an executive, or someone who will have program-wide
-        # access to the cards that Lithic will provide. In some cases, this individual
-        # could also be a beneficial owner listed above. See
-        # [FinCEN requirements](https://www.fincen.gov/sites/default/files/shared/CDD_Rev6.7_Sept_2017_Certificate.pdf)
-        # (Section II) for more background.
-        control_person: nil,
-        # A user provided id that can be used to link an account holder with an external
-        # system
-        external_id: nil,
-        # 6-digit North American Industry Classification System (NAICS) code for the
-        # business.
-        naics_code: nil,
-        # Short description of the company's line of business (i.e., what does the company
-        # do?).
-        nature_of_business: nil,
-        # Company website URL.
-        website_url: nil,
-        # Information on the individual for whom the account is being opened and KYC is
-        # being run.
-        individual: nil,
-        # Allowed for: KYC-Exempt, BYO-KYC, BYO-KYB.
-        address: nil,
-        # Allowed for: KYC-Exempt, BYO-KYC. The token of the business account to which the
-        # account holder is associated.
-        business_account_token: nil,
-        # Allowed for all Account Holders. Account holder's email address. The primary
-        # purpose of this field is for cardholder identification and verification during
-        # the digital wallet tokenization process.
-        email: nil,
-        # Allowed for KYC-Exempt, BYO-KYC. Account holder's first name.
-        first_name: nil,
-        # Allowed for KYC-Exempt, BYO-KYC. Account holder's last name.
-        last_name: nil,
-        # Allowed for BYO-KYB. Legal business name of the account holder.
-        legal_business_name: nil,
-        # Allowed for all Account Holders. Account holder's phone number, entered in E.164
-        # format. The primary purpose of this field is for cardholder identification and
-        # verification during the digital wallet tokenization process.
-        phone_number: nil,
+        # The KYB request payload for updating a business.
+        body:,
         request_options: {}
       )
       end

data/rbi/lithic/resources/auth_rules/v2.rbi

@@ -10,57 +10,16 @@ module Lithic
         # Creates a new V2 Auth rule in draft mode
         sig do
           params(
-            parameters:
+            body:
               T.any(
-                Lithic::AuthRules::ConditionalBlockParameters::OrHash,
-                Lithic::AuthRules::VelocityLimitParams::OrHash,
-                Lithic::AuthRules::MerchantLockParameters::OrHash,
-                Lithic::AuthRules::Conditional3DSActionParameters::OrHash,
-                Lithic::AuthRules::ConditionalAuthorizationActionParameters::OrHash,
-                Lithic::AuthRules::ConditionalACHActionParameters::OrHash,
-                Lithic::AuthRules::ConditionalTokenizationActionParameters::OrHash
+                Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule::OrHash,
+                Lithic::AuthRules::V2CreateParams::Body::CardLevelRule::OrHash,
+                Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule::OrHash
               ),
-            type: Lithic::AuthRules::V2CreateParams::Type::OrSymbol,
-            card_tokens: T::Array[String],
-            program_level: T::Boolean,
-            account_tokens: T::Array[String],
-            business_account_tokens: T::Array[String],
-            event_stream: Lithic::AuthRules::EventStream::OrSymbol,
-            name: T.nilable(String),
-            excluded_card_tokens: T::Array[String],
             request_options: Lithic::RequestOptions::OrHash
           ).returns(Lithic::AuthRules::AuthRule)
         end
-        def create(
-          # Parameters for the Auth Rule
-          parameters:,
-          # The type of Auth Rule. For certain rule types, this determines the event stream
-          # during which it will be evaluated. For rules that can be applied to one of
-          # several event streams, the effective one is defined by the separate
-          # `event_stream` field.
-          #
-          # - `CONDITIONAL_BLOCK`: AUTHORIZATION event stream.
-          # - `VELOCITY_LIMIT`: AUTHORIZATION event stream.
-          # - `MERCHANT_LOCK`: AUTHORIZATION event stream.
-          # - `CONDITIONAL_ACTION`: AUTHORIZATION, THREE_DS_AUTHENTICATION, TOKENIZATION,
-          #   ACH_CREDIT_RECEIPT, or ACH_DEBIT_RECEIPT event stream.
-          type:,
-          # Card tokens to which the Auth Rule applies.
-          card_tokens:,
-          # Whether the Auth Rule applies to all authorizations on the card program.
-          program_level:,
-          # Account tokens to which the Auth Rule applies.
-          account_tokens: nil,
-          # Business Account tokens to which the Auth Rule applies.
-          business_account_tokens: nil,
-          # The event stream during which the rule will be evaluated.
-          event_stream: nil,
-          # Auth Rule Name
-          name: nil,
-          # Card tokens to which the Auth Rule does not apply.
-          excluded_card_tokens: nil,
-          request_options: {}
-        )
+        def create(body:, request_options: {})
         end
 
         # Fetches a V2 Auth rule by its token
@@ -81,38 +40,16 @@ module Lithic
         sig do
           params(
             auth_rule_token: String,
-            account_tokens: T::Array[String],
-            business_account_tokens: T::Array[String],
-            name: T.nilable(String),
-            state: Lithic::AuthRules::V2UpdateParams::State::OrSymbol,
-            card_tokens: T::Array[String],
-            excluded_card_tokens: T::Array[String],
-            program_level: T::Boolean,
+            body:
+              T.any(
+                Lithic::AuthRules::V2UpdateParams::Body::AccountLevelRule::OrHash,
+                Lithic::AuthRules::V2UpdateParams::Body::CardLevelRule::OrHash,
+                Lithic::AuthRules::V2UpdateParams::Body::ProgramLevelRule::OrHash
+              ),
             request_options: Lithic::RequestOptions::OrHash
           ).returns(Lithic::AuthRules::AuthRule)
         end
-        def update(
-          auth_rule_token,
-          # Account tokens to which the Auth Rule applies.
-          account_tokens: nil,
-          # Business Account tokens to which the Auth Rule applies.
-          business_account_tokens: nil,
-          # Auth Rule Name
-          name: nil,
-          # The desired state of the Auth Rule.
-          #
-          # Note that only deactivating an Auth Rule through this endpoint is supported at
-          # this time. If you need to (re-)activate an Auth Rule the /promote endpoint
-          # should be used to promote a draft to the currently active version.
-          state: nil,
-          # Card tokens to which the Auth Rule applies.
-          card_tokens: nil,
-          # Card tokens to which the Auth Rule does not apply.
-          excluded_card_tokens: nil,
-          # Whether the Auth Rule applies to all authorizations on the card program.
-          program_level: nil,
-          request_options: {}
-        )
+        def update(auth_rule_token, body:, request_options: {})
         end
 
         # Lists V2 Auth rules
@@ -208,6 +145,8 @@ module Lithic
         sig do
           params(
             auth_rule_token: String,
+            begin_: Time,
+            end_: Time,
             ending_before: String,
             event_token: String,
             has_actions: T::Boolean,
@@ -223,6 +162,12 @@ module Lithic
         def list_results(
           # Filter by Auth Rule token
           auth_rule_token: nil,
+          # Date string in RFC 3339 format. Only events evaluated after the specified time
+          # will be included. UTC time zone.
+          begin_: nil,
+          # Date string in RFC 3339 format. Only events evaluated before the specified time
+          # will be included. UTC time zone.
+          end_: nil,
           # 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.
           ending_before: nil,

data/rbi/lithic/resources/external_bank_accounts.rbi

@@ -9,67 +9,16 @@ module Lithic
       # Creates an external bank account within a program or Lithic account.
       sig do
         params(
-          account_number: String,
-          country: String,
-          currency: String,
-          financial_account_token: String,
-          owner: String,
-          owner_type: Lithic::OwnerType::OrSymbol,
-          routing_number: String,
-          type: Lithic::ExternalBankAccountCreateParams::Type::OrSymbol,
-          verification_method:
-            Lithic::ExternalBankAccountCreateParams::VerificationMethod::OrSymbol,
-          account_token: String,
-          address: Lithic::ExternalBankAccountAddress::OrHash,
-          company_id: String,
-          dob: Date,
-          doing_business_as: String,
-          name: String,
-          user_defined_id: String,
-          verification_enforcement: T::Boolean,
+          body:
+            T.any(
+              Lithic::ExternalBankAccountCreateParams::Body::ExternallyVerified::OrHash,
+              Lithic::ExternalBankAccountCreateParams::Body::Unverified::OrHash,
+              Lithic::ExternalBankAccountCreateParams::Body::BankVerifiedCreateBankAccountAPIRequest::OrHash
+            ),
           request_options: Lithic::RequestOptions::OrHash
         ).returns(Lithic::Models::ExternalBankAccountCreateResponse)
       end
-      def create(
-        # Account Number
-        account_number:,
-        # The country that the bank account is located in using ISO 3166-1. We will only
-        # accept USA bank accounts e.g., USA
-        country:,
-        # currency of the external account 3-character alphabetic ISO 4217 code
-        currency:,
-        # The financial account token of the operating account to fund the micro deposits
-        financial_account_token:,
-        # Legal Name of the business or individual who owns the external account. This
-        # will appear in statements
-        owner:,
-        # Owner Type
-        owner_type:,
-        # Routing Number
-        routing_number:,
-        # Account Type
-        type:,
-        # Verification Method
-        verification_method:,
-        # Indicates which Lithic account the external account is associated with. For
-        # external accounts that are associated with the program, account_token field
-        # returned will be null
-        account_token: nil,
-        # Address
-        address: nil,
-        # Optional field that helps identify bank accounts in receipts
-        company_id: nil,
-        # Date of Birth of the Individual that owns the external bank account
-        dob: nil,
-        # Doing Business As
-        doing_business_as: nil,
-        # The nickname for this External Bank Account
-        name: nil,
-        # User Defined ID
-        user_defined_id: nil,
-        verification_enforcement: nil,
-        request_options: {}
-      )
+      def create(body:, request_options: {})
       end
 
       # Get the external bank account by token.

data/rbi/lithic/resources/financial_accounts/interest_tier_schedule.rbi

@@ -0,0 +1,156 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class FinancialAccounts
+      class InterestTierSchedule
+        # Create a new interest tier schedule entry for a supported financial account
+        sig do
+          params(
+            financial_account_token: String,
+            credit_product_token: String,
+            effective_date: Date,
+            tier_name: String,
+            tier_rates: T.anything,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(
+            Lithic::FinancialAccounts::FinancialAccountsInterestTierSchedule
+          )
+        end
+        def create(
+          # Globally unique identifier for financial account
+          financial_account_token,
+          # Globally unique identifier for a credit product
+          credit_product_token:,
+          # Date the tier should be effective in YYYY-MM-DD format
+          effective_date:,
+          # Name of a tier contained in the credit product. Mutually exclusive with
+          # tier_rates
+          tier_name: nil,
+          # Custom rates per category. Mutually exclusive with tier_name
+          tier_rates: nil,
+          request_options: {}
+        )
+        end
+
+        # Get a specific interest tier schedule by effective date
+        sig do
+          params(
+            effective_date: Date,
+            financial_account_token: String,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(
+            Lithic::FinancialAccounts::FinancialAccountsInterestTierSchedule
+          )
+        end
+        def retrieve(
+          # Effective date in ISO format (YYYY-MM-DD)
+          effective_date,
+          # Globally unique identifier for financial account
+          financial_account_token:,
+          request_options: {}
+        )
+        end
+
+        # Update an existing interest tier schedule
+        sig do
+          params(
+            effective_date: Date,
+            financial_account_token: String,
+            tier_name: String,
+            tier_rates: T.anything,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(
+            Lithic::FinancialAccounts::FinancialAccountsInterestTierSchedule
+          )
+        end
+        def update(
+          # Path param: Effective date in ISO format (YYYY-MM-DD)
+          effective_date,
+          # Path param: Globally unique identifier for financial account
+          financial_account_token:,
+          # Body param: Name of a tier contained in the credit product. Mutually exclusive
+          # with tier_rates
+          tier_name: nil,
+          # Body param: Custom rates per category. Mutually exclusive with tier_name
+          tier_rates: nil,
+          request_options: {}
+        )
+        end
+
+        # List interest tier schedules for a financial account with optional date
+        # filtering.
+        #
+        # If no date parameters are provided, returns all tier schedules. If date
+        # parameters are provided, uses filtering to return matching schedules (max 100).
+        #
+        # - for_date: Returns exact match (takes precedence over other dates)
+        # - before_date: Returns schedules with effective_date <= before_date
+        # - after_date: Returns schedules with effective_date >= after_date
+        # - Both before_date and after_date: Returns schedules in range
+        sig do
+          params(
+            financial_account_token: String,
+            after_date: Date,
+            before_date: Date,
+            for_date: Date,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(
+            Lithic::Internal::SinglePage[
+              Lithic::FinancialAccounts::FinancialAccountsInterestTierSchedule
+            ]
+          )
+        end
+        def list(
+          # Globally unique identifier for financial account
+          financial_account_token,
+          # Return schedules with effective_date >= after_date (ISO format YYYY-MM-DD)
+          after_date: nil,
+          # Return schedules with effective_date <= before_date (ISO format YYYY-MM-DD)
+          before_date: nil,
+          # Return schedule with effective_date == for_date (ISO format YYYY-MM-DD)
+          for_date: nil,
+          request_options: {}
+        )
+        end
+
+        # Delete an interest tier schedule entry.
+        #
+        # Returns:
+        #
+        # - 400 Bad Request: Invalid effective_date format OR attempting to delete the
+        #   earliest tier schedule entry for a non-PENDING account
+        # - 404 Not Found: Tier schedule entry not found for the given effective_date OR
+        #   ledger account not found
+        #
+        # Note: PENDING accounts can delete the earliest tier schedule entry (account
+        # hasn't opened yet). Active/non-PENDING accounts cannot delete the earliest entry
+        # to prevent orphaning the account.
+        #
+        # If the deleted tier schedule has a past effective_date and the account is
+        # ACTIVE, the loan tape rebuild configuration will be updated to trigger rebuilds
+        # from that date.
+        sig do
+          params(
+            effective_date: Date,
+            financial_account_token: String,
+            request_options: Lithic::RequestOptions::OrHash
+          ).void
+        end
+        def delete(
+          # Effective date in ISO format (YYYY-MM-DD)
+          effective_date,
+          # Globally unique identifier for financial account
+          financial_account_token:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Lithic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/resources/financial_accounts/loan_tape_configuration.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class FinancialAccounts
+      class LoanTapeConfiguration
+        # Get the loan tape configuration for a given financial account.
+        sig do
+          params(
+            financial_account_token: String,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(
+            Lithic::FinancialAccounts::FinancialAccountsLoanTapeConfiguration
+          )
+        end
+        def retrieve(
+          # Globally unique identifier for financial account.
+          financial_account_token,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Lithic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/resources/financial_accounts.rbi

@@ -20,6 +20,16 @@ module Lithic
       sig { returns(Lithic::Resources::FinancialAccounts::LoanTapes) }
       attr_reader :loan_tapes
 
+      sig do
+        returns(Lithic::Resources::FinancialAccounts::LoanTapeConfiguration)
+      end
+      attr_reader :loan_tape_configuration
+
+      sig do
+        returns(Lithic::Resources::FinancialAccounts::InterestTierSchedule)
+      end
+      attr_reader :interest_tier_schedule
+
       # Create a new financial account
       sig do
         params(

data/rbi/lithic/resources/payments.rbi

@@ -14,6 +14,7 @@ module Lithic
             Lithic::PaymentCreateParams::MethodAttributes::OrHash,
           type: Lithic::PaymentCreateParams::Type::OrSymbol,
           token: String,
+          hold: Lithic::PaymentCreateParams::Hold::OrHash,
           memo: String,
           user_defined_id: String,
           request_options: Lithic::RequestOptions::OrHash
@@ -29,6 +30,8 @@ module Lithic
         # Customer-provided token that will serve as an idempotency token. This token will
         # become the transaction token.
         token: nil,
+        # Optional hold to settle when this payment is initiated.
+        hold: nil,
         memo: nil,
         user_defined_id: nil,
         request_options: {}

data/sig/lithic/internal/util.rbs

@@ -106,6 +106,16 @@ module Lithic
       JSON_CONTENT: Regexp
       JSONL_CONTENT: Regexp
 
+      def encode_query_params: (
+        ::Hash[Symbol, top] query
+      ) -> ::Hash[Symbol, top]
+
+      private def write_query_param_element!: (
+        ::Hash[Symbol, top] collection,
+        String key,
+        top element
+      ) -> nil
+
       def self?.write_multipart_content: (
         Enumerator::Yielder y,
         val: top,