lithic 0.21.0 → 0.23.0

data/rbi/lithic/models/transaction_simulate_credit_authorization_advice_params.rbi

@@ -28,6 +28,15 @@ module Lithic
       sig { returns(String) }
       attr_accessor :pan
 
+      # 3-character alphabetic ISO 4217 currency code for the cardholder billing amount.
+      # Permitted values are USD, GBP, EUR and CAD, and any other ISO 4217 code returns
+      # a 422. Defaults to USD
+      sig { returns(T.nilable(String)) }
+      attr_reader :billing_currency
+
+      sig { params(billing_currency: String).void }
+      attr_writer :billing_currency
+
       # Merchant category code for the transaction to be simulated. A four-digit number
       # listed in ISO 18245. Supported merchant category codes can be found
       # [here](https://docs.lithic.com/docs/transactions#merchant-category-codes-mccs).
@@ -70,6 +79,7 @@ module Lithic
           amount: Integer,
           descriptor: String,
           pan: String,
+          billing_currency: String,
           mcc: String,
           merchant_acceptor_city: String,
           merchant_acceptor_country: String,
@@ -87,6 +97,10 @@ module Lithic
         descriptor:,
         # Sixteen digit card number.
         pan:,
+        # 3-character alphabetic ISO 4217 currency code for the cardholder billing amount.
+        # Permitted values are USD, GBP, EUR and CAD, and any other ISO 4217 code returns
+        # a 422. Defaults to USD
+        billing_currency: nil,
         # Merchant category code for the transaction to be simulated. A four-digit number
         # listed in ISO 18245. Supported merchant category codes can be found
         # [here](https://docs.lithic.com/docs/transactions#merchant-category-codes-mccs).
@@ -109,6 +123,7 @@ module Lithic
             amount: Integer,
             descriptor: String,
             pan: String,
+            billing_currency: String,
             mcc: String,
             merchant_acceptor_city: String,
             merchant_acceptor_country: String,

data/rbi/lithic/models/transaction_simulate_return_params.rbi

@@ -26,11 +26,31 @@ module Lithic
       sig { returns(String) }
       attr_accessor :pan
 
+      # 3-character alphabetic ISO 4217 currency code for the cardholder billing amount.
+      # Permitted values are USD, GBP, EUR and CAD, and any other ISO 4217 code returns
+      # a 422. Defaults to USD
+      sig { returns(T.nilable(String)) }
+      attr_reader :billing_currency
+
+      sig { params(billing_currency: String).void }
+      attr_writer :billing_currency
+
+      # 3-character alphabetic ISO 4217 currency code for the settlement amount.
+      # Permitted values are USD, GBP, EUR and CAD, and any other ISO 4217 code returns
+      # a 422. Defaults to the value of billing_currency
+      sig { returns(T.nilable(String)) }
+      attr_reader :settlement_currency
+
+      sig { params(settlement_currency: String).void }
+      attr_writer :settlement_currency
+
       sig do
         params(
           amount: Integer,
           descriptor: String,
           pan: String,
+          billing_currency: String,
+          settlement_currency: String,
           request_options: Lithic::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
@@ -41,6 +61,14 @@ module Lithic
         descriptor:,
         # Sixteen digit card number.
         pan:,
+        # 3-character alphabetic ISO 4217 currency code for the cardholder billing amount.
+        # Permitted values are USD, GBP, EUR and CAD, and any other ISO 4217 code returns
+        # a 422. Defaults to USD
+        billing_currency: nil,
+        # 3-character alphabetic ISO 4217 currency code for the settlement amount.
+        # Permitted values are USD, GBP, EUR and CAD, and any other ISO 4217 code returns
+        # a 422. Defaults to the value of billing_currency
+        settlement_currency: nil,
         request_options: {}
       )
       end
@@ -51,6 +79,8 @@ module Lithic
             amount: Integer,
             descriptor: String,
             pan: String,
+            billing_currency: String,
+            settlement_currency: String,
             request_options: Lithic::RequestOptions
           }
         )

data/rbi/lithic/models/transactions/events/enhanced_data.rbi

@@ -174,7 +174,8 @@ module Lithic
                   )
                 end
 
-              # The price of the item purchased in merchant currency.
+              # Deprecated: Use unit_amount instead. The price of the item purchased in merchant
+              # currency.
               sig { returns(T.nilable(String)) }
               attr_accessor :amount
 
@@ -190,24 +191,41 @@ module Lithic
               sig { returns(T.nilable(String)) }
               attr_accessor :quantity
 
+              # The total cost for the line item in merchant currency, covering all units
+              # purchased.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :total_amount
+
+              # The price per individual unit in merchant currency.
+              sig { returns(T.nilable(String)) }
+              attr_accessor :unit_amount
+
               # An L2/L3 enhanced commercial data line item.
               sig do
                 params(
                   amount: T.nilable(String),
                   description: T.nilable(String),
                   product_code: T.nilable(String),
-                  quantity: T.nilable(String)
+                  quantity: T.nilable(String),
+                  total_amount: T.nilable(String),
+                  unit_amount: T.nilable(String)
                 ).returns(T.attached_class)
               end
               def self.new(
-                # The price of the item purchased in merchant currency.
+                # Deprecated: Use unit_amount instead. The price of the item purchased in merchant
+                # currency.
                 amount: nil,
                 # A human-readable description of the item.
                 description: nil,
                 # An identifier for the item purchased.
                 product_code: nil,
                 # The quantity of the item purchased.
-                quantity: nil
+                quantity: nil,
+                # The total cost for the line item in merchant currency, covering all units
+                # purchased.
+                total_amount: nil,
+                # The price per individual unit in merchant currency.
+                unit_amount: nil
               )
               end
 
@@ -217,7 +235,9 @@ module Lithic
                     amount: T.nilable(String),
                     description: T.nilable(String),
                     product_code: T.nilable(String),
-                    quantity: T.nilable(String)
+                    quantity: T.nilable(String),
+                    total_amount: T.nilable(String),
+                    unit_amount: T.nilable(String)
                   }
                 )
               end

data/rbi/lithic/models/transfer_limits_response.rbi

@@ -70,6 +70,10 @@ module Lithic
         sig { returns(Date) }
         attr_accessor :date
 
+        # Financial entity ID the limits are scoped to
+        sig { returns(String) }
+        attr_accessor :financial_entity_id
+
         # Whether the company is a FBO; based on the company ID prefix
         sig { returns(T::Boolean) }
         attr_accessor :is_fbo
@@ -108,6 +112,7 @@ module Lithic
             daily_limit:
               Lithic::TransferLimitsResponse::Data::DailyLimit::OrHash,
             date: Date,
+            financial_entity_id: String,
             is_fbo: T::Boolean,
             monthly_limit:
               Lithic::TransferLimitsResponse::Data::MonthlyLimit::OrHash,
@@ -122,6 +127,8 @@ module Lithic
           daily_limit:,
           # The date for the limit view (ISO format)
           date:,
+          # Financial entity ID the limits are scoped to
+          financial_entity_id:,
           # Whether the company is a FBO; based on the company ID prefix
           is_fbo:,
           # Monthly limits with progress
@@ -137,6 +144,7 @@ module Lithic
               company_id: String,
               daily_limit: Lithic::TransferLimitsResponse::Data::DailyLimit,
               date: Date,
+              financial_entity_id: String,
               is_fbo: T::Boolean,
               monthly_limit: Lithic::TransferLimitsResponse::Data::MonthlyLimit,
               program_limit_per_transaction:

data/rbi/lithic/models.rbi

@@ -438,6 +438,8 @@ module Lithic
   InternalTransactionUpdatedWebhookEvent =
     Lithic::Models::InternalTransactionUpdatedWebhookEvent
 
+  IPRangeRetrieveParams = Lithic::Models::IPRangeRetrieveParams
+
   KYB = Lithic::Models::KYB
 
   KYBBusinessEntity = Lithic::Models::KYBBusinessEntity

data/rbi/lithic/resources/account_holders/entities.rbi

@@ -28,7 +28,8 @@ module Lithic
           # Globally unique identifier for the account holder.
           account_holder_token,
           # Individual's current address - PO boxes, UPS drops, and FedEx drops are not
-          # acceptable; APO/FPO are acceptable. Only USA addresses are currently supported.
+          # acceptable; APO/FPO are acceptable. Only USA addresses are supported for the KYB
+          # and KYC workflows.
           address:,
           # Individual's date of birth, as an RFC 3339 date.
           dob:,

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

@@ -22,14 +22,14 @@ module Lithic
           # `/v2/auth_rules/{auth_rule_token}/backtests/{auth_rule_backtest_token}`
           # endpoint.
           #
-          # Lithic currently supports backtesting for `CONDITIONAL_BLOCK` /
-          # `CONDITIONAL_ACTION` rules. Backtesting for `VELOCITY_LIMIT` rules is generally
-          # not supported. In specific cases (i.e. where Lithic has pre-calculated the
-          # requested velocity metrics for historical transactions), a backtest may be
-          # feasible. However, such cases are uncommon and customers should not anticipate
-          # support for velocity backtests under most configurations. If a historical
-          # transaction does not feature the required inputs to evaluate the rule, then it
-          # will not be included in the final backtest report.
+          # Lithic currently supports backtesting for `CONDITIONAL_ACTION` rules.
+          # Backtesting for `VELOCITY_LIMIT` rules is generally not supported. In specific
+          # cases (i.e. where Lithic has pre-calculated the requested velocity metrics for
+          # historical transactions), a backtest may be feasible. However, such cases are
+          # uncommon and customers should not anticipate support for velocity backtests
+          # under most configurations. If a historical transaction does not feature the
+          # required inputs to evaluate the rule, then it will not be included in the final
+          # backtest report.
           sig do
             params(
               auth_rule_token: String,

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

@@ -12,6 +12,7 @@ module Lithic
           params(
             body:
               T.any(
+                Lithic::AuthRules::V2CreateParams::Body::Rule::OrHash,
                 Lithic::AuthRules::V2CreateParams::Body::AccountLevelRule::OrHash,
                 Lithic::AuthRules::V2CreateParams::Body::CardLevelRule::OrHash,
                 Lithic::AuthRules::V2CreateParams::Body::ProgramLevelRule::OrHash
@@ -19,7 +20,11 @@ module Lithic
             request_options: Lithic::RequestOptions::OrHash
           ).returns(Lithic::AuthRules::AuthRule)
         end
-        def create(body:, request_options: {})
+        def create(
+          # Deprecated: Use `entities` instead. Cannot be combined with `entities`.
+          body:,
+          request_options: {}
+        )
         end
 
         # Fetches a V2 Auth rule by its token
@@ -34,14 +39,15 @@ module Lithic
 
         # Updates a V2 Auth rule's properties
         #
-        # If `account_tokens`, `card_tokens`, `program_level`, `excluded_card_tokens`,
-        # `excluded_account_tokens`, or `excluded_business_account_tokens` is provided,
-        # this will replace existing associations with the provided list of entities.
+        # If `entities` is provided, this will replace the rule's existing entities with
+        # the provided `include` and `exclude` lists. To change entities incrementally,
+        # use `PATCH /v2/auth_rules/{auth_rule_token}/entities` instead.
         sig do
           params(
             auth_rule_token: String,
             body:
               T.any(
+                Lithic::AuthRules::V2UpdateParams::Body::Rule::OrHash,
                 Lithic::AuthRules::V2UpdateParams::Body::AccountLevelRule::OrHash,
                 Lithic::AuthRules::V2UpdateParams::Body::CardLevelRule::OrHash,
                 Lithic::AuthRules::V2UpdateParams::Body::ProgramLevelRule::OrHash
@@ -49,7 +55,13 @@ module Lithic
             request_options: Lithic::RequestOptions::OrHash
           ).returns(Lithic::AuthRules::AuthRule)
         end
-        def update(auth_rule_token, body:, request_options: {})
+        def update(
+          auth_rule_token,
+          # Replaces the rule's existing entities with the provided `include` and `exclude`
+          # lists. A missing list is treated as empty, so `include` must always be provided.
+          body:,
+          request_options: {}
+        )
         end
 
         # Lists V2 Auth rules
@@ -86,7 +98,8 @@ module Lithic
           event_streams: nil,
           # Page size (for pagination).
           page_size: nil,
-          # Only return Auth Rules that are bound to the provided scope.
+          # Only return Auth Rules that are bound to the provided scope. When no token is
+          # provided, `CARD` also returns Auth Rules that include a `CARD_TAG` entity.
           scope: nil,
           # 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.
@@ -115,7 +128,6 @@ module Lithic
             parameters:
               T.nilable(
                 T.any(
-                  Lithic::AuthRules::ConditionalBlockParameters::OrHash,
                   Lithic::AuthRules::VelocityLimitParams::OrHash,
                   Lithic::AuthRules::MerchantLockParameters::OrHash,
                   Lithic::AuthRules::Conditional3DSActionParameters::OrHash,
@@ -218,7 +230,7 @@ module Lithic
         # - VelocityLimit Rules calculates the current Velocity Feature data. This
         #   requires a `card_token` or `account_token` matching what the rule is Scoped
         #   to.
-        # - ConditionalBlock Rules calculates the CARD*TRANSACTION_COUNT*\* attributes on
+        # - ConditionalAction Rules calculates the CARD*TRANSACTION_COUNT*\* attributes on
         #   the rule. This requires a `card_token`
         sig do
           params(
@@ -267,6 +279,29 @@ module Lithic
         )
         end
 
+        # Adds entities to and removes entities from a V2 Auth rule's `include` and
+        # `exclude` lists
+        #
+        # To replace all of the rule's entities at once, provide `entities` to
+        # `PATCH /v2/auth_rules/{auth_rule_token}` instead.
+        sig do
+          params(
+            auth_rule_token: String,
+            add: Lithic::AuthRules::AuthRuleEntities::OrHash,
+            remove: Lithic::AuthRules::AuthRuleEntities::OrHash,
+            request_options: Lithic::RequestOptions::OrHash
+          ).returns(Lithic::AuthRules::AuthRule)
+        end
+        def update_entities(
+          auth_rule_token,
+          # Entities to add to the rule's `include` and `exclude` lists
+          add: nil,
+          # Entities to remove from the rule's `include` and `exclude` lists
+          remove: nil,
+          request_options: {}
+        )
+        end
+
         # @api private
         sig { params(client: Lithic::Client).returns(T.attached_class) }
         def self.new(client:)

data/rbi/lithic/resources/cards/financial_transactions.rbi

@@ -29,13 +29,14 @@ module Lithic
               Lithic::Cards::FinancialTransactionListParams::Category::OrSymbol,
             end_: Time,
             ending_before: String,
+            page_size: Integer,
             result:
               Lithic::Cards::FinancialTransactionListParams::Result::OrSymbol,
             starting_after: String,
             status:
               Lithic::Cards::FinancialTransactionListParams::Status::OrSymbol,
             request_options: Lithic::RequestOptions::OrHash
-          ).returns(Lithic::Internal::SinglePage[Lithic::FinancialTransaction])
+          ).returns(Lithic::Internal::CursorPage[Lithic::FinancialTransaction])
         end
         def list(
           card_token,
@@ -50,6 +51,8 @@ module Lithic
           # 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,
+          # Page size (for pagination).
+          page_size: nil,
           # Financial Transaction result to be returned.
           result: nil,
           # A cursor representing an item's token after which a page of results should

data/rbi/lithic/resources/cards.rbi

@@ -34,6 +34,7 @@ module Lithic
           spend_limit: Integer,
           spend_limit_duration: Lithic::SpendLimitDuration::OrSymbol,
           state: Lithic::CardCreateParams::State::OrSymbol,
+          tags: T::Hash[Symbol, String],
           idempotency_key: String,
           request_options: Lithic::RequestOptions::OrHash
         ).returns(Lithic::Card)
@@ -184,6 +185,10 @@ module Lithic
         # - `PAUSED` - Card will decline authorizations, but can be resumed at a later
         #   time.
         state: nil,
+        # Body param: Key-value pairs to tag the card with. A replacement card does not
+        # inherit tags from the card it replaces. A card can have at most 50 tags, with
+        # keys up to 40 characters and values up to 500 characters
+        tags: nil,
         # Header param: Idempotency key for the request
         idempotency_key: nil,
         request_options: {}
@@ -218,6 +223,7 @@ module Lithic
           spend_limit_duration: Lithic::SpendLimitDuration::OrSymbol,
           state: Lithic::CardUpdateParams::State::OrSymbol,
           substatus: Lithic::CardUpdateParams::Substatus::OrSymbol,
+          tags: T::Hash[Symbol, T.nilable(String)],
           request_options: Lithic::RequestOptions::OrHash
         ).returns(Lithic::Card)
       end
@@ -298,6 +304,11 @@ module Lithic
         # - `OTHER` - The reason for the status does not fall into any of the above
         #   categories. A comment should be provided to specify the reason.
         substatus: nil,
+        # Key-value pairs to merge into the card's tags. Supplied keys are added or
+        # overwritten, a key with a `null` value is removed, and omitted keys remain
+        # unchanged. A card can have at most 50 tags, with keys up to 40 characters and
+        # values up to 500 characters
+        tags: nil,
         request_options: {}
       )
       end

data/rbi/lithic/resources/financial_accounts/credit_configuration.rbi

@@ -18,7 +18,10 @@ module Lithic
         )
         end
 
-        # Update an account's credit configuration
+        # Update an account's credit configuration. A credit product can only be attached
+        # while the financial account is in the `PENDING` state; once a credit product has
+        # been assigned the account transitions to `OPEN` and `credit_product_token` can
+        # no longer be changed
         sig do
           params(
             financial_account_token: String,
@@ -36,7 +39,10 @@ module Lithic
           financial_account_token,
           auto_collection_configuration: nil,
           credit_limit: nil,
-          # Globally unique identifier for the credit product
+          # Globally unique identifier for the credit product. This can only be set while
+          # the financial account is in the `PENDING` state. Because assigning a credit
+          # product transitions the account to `OPEN`, a credit product can be attached only
+          # once; updating it on an account in any other state returns a `403`
           credit_product_token: nil,
           external_bank_account_token: nil,
           # Tier to assign to a financial account

data/rbi/lithic/resources/financial_accounts/financial_transactions.rbi

@@ -30,13 +30,14 @@ module Lithic
               Lithic::FinancialAccounts::FinancialTransactionListParams::Category::OrSymbol,
             end_: Time,
             ending_before: String,
+            page_size: Integer,
             result:
               Lithic::FinancialAccounts::FinancialTransactionListParams::Result::OrSymbol,
             starting_after: String,
             status:
               Lithic::FinancialAccounts::FinancialTransactionListParams::Status::OrSymbol,
             request_options: Lithic::RequestOptions::OrHash
-          ).returns(Lithic::Internal::SinglePage[Lithic::FinancialTransaction])
+          ).returns(Lithic::Internal::CursorPage[Lithic::FinancialTransaction])
         end
         def list(
           # Globally unique identifier for financial account.
@@ -52,6 +53,8 @@ module Lithic
           # 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,
+          # Page size (for pagination).
+          page_size: nil,
           # Financial Transaction result to be returned.
           result: nil,
           # A cursor representing an item's token after which a page of results should

data/rbi/lithic/resources/financial_accounts/installment_plans/statements.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class FinancialAccounts
+      class InstallmentPlans
+        class Statements
+          # Get a specific statement snapshot for a given installment plan.
+          sig do
+            params(
+              statement_token: String,
+              financial_account_token: String,
+              installment_plan_token: String,
+              request_options: Lithic::RequestOptions::OrHash
+            ).returns(
+              Lithic::FinancialAccounts::InstallmentPlans::InstallmentPlanStatement
+            )
+          end
+          def retrieve(
+            # Globally unique identifier for statement.
+            statement_token,
+            # Globally unique identifier for financial account.
+            financial_account_token:,
+            # Globally unique identifier for installment plan.
+            installment_plan_token:,
+            request_options: {}
+          )
+          end
+
+          # List the statement snapshots for a given installment plan.
+          sig do
+            params(
+              installment_plan_token: String,
+              financial_account_token: String,
+              begin_: Date,
+              end_: Date,
+              ending_before: String,
+              page_size: Integer,
+              starting_after: String,
+              state:
+                T.nilable(
+                  Lithic::FinancialAccounts::InstallmentPlans::StatementListParams::State::OrSymbol
+                ),
+              request_options: Lithic::RequestOptions::OrHash
+            ).returns(
+              Lithic::Internal::CursorPage[
+                Lithic::FinancialAccounts::InstallmentPlans::InstallmentPlanStatement
+              ]
+            )
+          end
+          def list(
+            # Path param: Globally unique identifier for installment plan.
+            installment_plan_token,
+            # Path param: Globally unique identifier for financial account.
+            financial_account_token:,
+            # Query param: Date string in RFC 3339 format. Only entries created after the
+            # specified date will be included.
+            begin_: nil,
+            # Query param: Date string in RFC 3339 format. Only entries created before the
+            # specified date will be included.
+            end_: nil,
+            # Query param: 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,
+            # Query param: Page size (for pagination).
+            page_size: nil,
+            # Query param: 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.
+            starting_after: nil,
+            # Query param: Only snapshots in which the plan was in this state will be
+            # included.
+            state: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Lithic::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/resources/financial_accounts/installment_plans.rbi

@@ -4,6 +4,13 @@ module Lithic
   module Resources
     class FinancialAccounts
       class InstallmentPlans
+        sig do
+          returns(
+            Lithic::Resources::FinancialAccounts::InstallmentPlans::Statements
+          )
+        end
+        attr_reader :statements
+
         # Get a specific installment plan for a given financial account.
         sig do
           params(

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

@@ -10,9 +10,9 @@ module Lithic
             financial_account_token: String,
             credit_product_token: String,
             effective_date: Date,
-            penalty_rates: T.anything,
-            tier_name: String,
-            tier_rates: T.anything,
+            penalty_rates: T.nilable(T.anything),
+            tier_name: T.nilable(String),
+            tier_rates: T.nilable(T.anything),
             request_options: Lithic::RequestOptions::OrHash
           ).returns(
             Lithic::FinancialAccounts::FinancialAccountsInterestTierSchedule
@@ -60,9 +60,9 @@ module Lithic
           params(
             effective_date: Date,
             financial_account_token: String,
-            penalty_rates: T.anything,
-            tier_name: String,
-            tier_rates: T.anything,
+            penalty_rates: T.nilable(T.anything),
+            tier_name: T.nilable(String),
+            tier_rates: T.nilable(T.anything),
             request_options: Lithic::RequestOptions::OrHash
           ).returns(
             Lithic::FinancialAccounts::FinancialAccountsInterestTierSchedule

data/rbi/lithic/resources/funding_events.rbi

@@ -20,16 +20,28 @@ module Lithic
       # Get all funding events for program
       sig do
         params(
+          begin_: Time,
+          end_: Time,
           ending_before: String,
+          network_settlement_date: Date,
           page_size: Integer,
           starting_after: String,
           request_options: Lithic::RequestOptions::OrHash
         ).returns(Lithic::Internal::CursorPage[Lithic::FundingEvent])
       end
       def list(
+        # Date string in RFC 3339 format. Only entries created after the specified time
+        # will be included. UTC time zone.
+        begin_: nil,
+        # Date string in RFC 3339 format. Only entries created 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,
+        # Only funding events with a settlement breakout for this network settlement date
+        # will be included.
+        network_settlement_date: nil,
         # Page size (for pagination).
         page_size: nil,
         # A cursor representing an item's token after which a page of results should

data/rbi/lithic/resources/ip_ranges.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class IPRanges
+      # Returns the IP addresses Lithic sends responder requests from (Auth Stream
+      # Access, 3DS decisioning, and tokenization decisioning), so you can allowlist
+      # them in your firewall. Each environment returns its own set of addresses. Lithic
+      # announces new addresses at least 30 days before sending traffic from them. Event
+      # webhooks are not sent from these addresses
+      sig do
+        params(request_options: Lithic::RequestOptions::OrHash).returns(
+          Lithic::Models::IPRangeRetrieveResponse
+        )
+      end
+      def retrieve(request_options: {})
+      end
+
+      # @api private
+      sig { params(client: Lithic::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end