telnyx 5.170.0 → 5.173.0

data/rbi/telnyx/resources/network_routes.rbi

@@ -0,0 +1,93 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    # Routes on a Network that send a CIDR to a next hop, such as a tunnel.
+    class NetworkRoutes
+      # Adds a route to a Network. Traffic on the Network to an address in `cidr` goes
+      # via `next_hop`. With a tunnel as the next hop, functions on the Network reach
+      # the CIDR through the tunnel without a redeploy. A Network holds each CIDR once.
+      sig do
+        params(
+          cidr: String,
+          network_id: String,
+          next_hop: Telnyx::NetworkRouteCreateParams::NextHop::OrHash,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::Models::NetworkRouteCreateResponse)
+      end
+      def create(
+        # The IPv4 subnet to route, such as a subnet behind the tunnel. It must be a
+        # canonical CIDR. Default, loopback, link-local, multicast, and shared address
+        # space (`100.64.0.0/10`) ranges are rejected. So are ranges that overlap the
+        # Tailscale Subnet Router ranges, `172.27.254.0/24` and `198.18.0.0/20`, or a
+        # subnet already on the Network.
+        cidr:,
+        # The id of the Network to add the route to.
+        network_id:,
+        # Where the Network sends traffic for `cidr`.
+        next_hop:,
+        request_options: {}
+      )
+      end
+
+      # Retrieves a route and its status.
+      sig do
+        params(
+          id: String,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::Models::NetworkRouteRetrieveResponse)
+      end
+      def retrieve(
+        # The id of the route.
+        id,
+        request_options: {}
+      )
+      end
+
+      # Lists the routes of the account's Networks. A Network's list is its effective
+      # route table: the routes added with `POST /network_routes` (`origin` `static`)
+      # and the routes that its attachments install (`origin` `attachment`). Lookup is
+      # longest prefix within the Network.
+      sig do
+        params(
+          filter: Telnyx::NetworkRouteListParams::Filter::OrHash,
+          page: Telnyx::NetworkRouteListParams::Page::OrHash,
+          sort: Telnyx::NetworkRouteListParams::Sort::OrSymbol,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::Models::NetworkRouteListResponse)
+      end
+      def list(
+        # Consolidated filter parameter (deepObject style). Originally:
+        # filter[network_id], filter[origin], filter[next_hop.type], filter[cidr],
+        # filter[status]
+        filter:,
+        # Consolidated page parameter (deepObject style). Originally: page[after],
+        # page[limit]
+        page: nil,
+        # Sorts the results by a field, ascending, or descending with a leading `-`. The
+        # default is `-created_at`.
+        sort: nil,
+        request_options: {}
+      )
+      end
+
+      # Deletes a route that was added with `POST /network_routes`. Traffic to its CIDR
+      # stops going via the next hop at once. Routes that an attachment installs
+      # (`origin` `attachment`) leave with the attachment and cannot be deleted here.
+      sig do
+        params(id: String, request_options: Telnyx::RequestOptions::OrHash).void
+      end
+      def delete(
+        # The id of the route.
+        id,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Telnyx::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/number_lookup.rbi

@@ -15,7 +15,10 @@ module Telnyx
       def retrieve(
         # The phone number to be looked up
         phone_number,
-        # Specifies the type of number lookup to be performed
+        # Specifies the type of number lookup to be performed. May be supplied more than
+        # once to request several data sources in a single call (for example,
+        # `?type=carrier&type=enhanced-caller-name`). Each requested type populates the
+        # corresponding object in the response.
         type: nil,
         request_options: {}
       )

data/rbi/telnyx/resources/pay_connectors.rbi

@@ -0,0 +1,191 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    # Generic payment connector configuration.
+    class PayConnectors
+      # Create a generic payment connector in the authenticated organization. The name
+      # must be unique in that organization. Authentication supplies ownership; do not
+      # send user_id or organization_id. Config is encrypted at rest; passwords and
+      # tokens are omitted from responses. This operation stores configuration and does
+      # not initiate a payment. See the
+      # [processor contract](/docs/voice/programmable-voice/pay#request-sent-to-the-payment-processor).
+      sig do
+        params(
+          config:
+            T.any(
+              Telnyx::GenericPayConnectorConfig::BasicAuthenticationAlsoTheValidationDefault::OrHash,
+              Telnyx::GenericPayConnectorConfig::BearerAuthentication::OrHash,
+              Telnyx::GenericPayConnectorConfig::NoProcessorAuthentication::OrHash
+            ),
+          name: String,
+          mode: Telnyx::PayConnectorCreateParams::Mode::OrSymbol,
+          type: Telnyx::PayConnectorCreateParams::Type::OrSymbol,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::PayConnectorResponse)
+      end
+      def create(
+        # Configuration for a generic connector. A config update replaces the complete
+        # object, not individual keys. Unknown config keys are discarded. Authentication
+        # credentials must be nonblank strings when required by the selected auth_type.
+        config:,
+        # Unique within the authenticated organization. Used in resource paths and as
+        # connector_name in the Call Control Pay request. Cannot be renamed by update.
+        name:,
+        # Defaults to test on creation. Test restricts collected card numbers but still
+        # contacts the configured processor; use a processor sandbox URL and sandbox
+        # credentials. Live removes the test-card restriction. Neither mode locks API
+        # updates.
+        mode: nil,
+        # Connector type covered by this reference.
+        type: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve a connector by name within the authenticated organization. Password and
+      # token are omitted. A missing name or a connector owned by another organization
+      # returns 404.
+      sig do
+        params(
+          name: String,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::PayConnectorResponse)
+      end
+      def retrieve(
+        # Connector name, not its UUID. URL-encode the name as a path segment.
+        name,
+        request_options: {}
+      )
+      end
+
+      # Update a generic connector by name in the authenticated organization. Both test
+      # and live connectors can be updated through the API. Omitted fields remain
+      # unchanged. Supplying config replaces the entire config; it does not merge keys.
+      # Include endpoint_url and the credentials required for the selected auth_type on
+      # every config replacement. Omitting config preserves existing credentials,
+      # allowing a mode-only update. The path name cannot be renamed. Public updates use
+      # PATCH.
+      sig do
+        params(
+          name: String,
+          config:
+            T.any(
+              Telnyx::GenericPayConnectorConfig::BasicAuthenticationAlsoTheValidationDefault::OrHash,
+              Telnyx::GenericPayConnectorConfig::BearerAuthentication::OrHash,
+              Telnyx::GenericPayConnectorConfig::NoProcessorAuthentication::OrHash
+            ),
+          mode: Telnyx::PayConnectorUpdateParams::Mode::OrSymbol,
+          type: Telnyx::PayConnectorUpdateParams::Type::OrSymbol,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::PayConnectorResponse)
+      end
+      def update(
+        # Connector name, not its UUID. URL-encode the name as a path segment.
+        name,
+        # Configuration for a generic connector. A config update replaces the complete
+        # object, not individual keys. Unknown config keys are discarded. Authentication
+        # credentials must be nonblank strings when required by the selected auth_type.
+        config: nil,
+        # Omit to preserve the existing mode. Use an explicit test or live value.
+        mode: nil,
+        # Generic connector type. Omit to preserve the existing value.
+        type: nil,
+        request_options: {}
+      )
+      end
+
+      # List connectors belonging to the authenticated organization, including
+      # connectors created by other users in that organization. Set filter[type]=generic
+      # to restrict results to the type covered here. Results default to newest
+      # created_at first. Use meta.end_cursor as page[after] for the next page, or
+      # meta.start_cursor as page[before] for the preceding page. Omit both cursors for
+      # the first page; if both are supplied, page[after] takes precedence. Responses
+      # omit passwords and tokens.
+      sig do
+        params(
+          filter_created_at_eq: String,
+          filter_created_at_gt: String,
+          filter_created_at_gte: String,
+          filter_created_at_lt: String,
+          filter_created_at_lte: String,
+          filter_mode: String,
+          filter_name: String,
+          filter_type: String,
+          filter_updated_at_eq: String,
+          filter_updated_at_gt: String,
+          filter_updated_at_gte: String,
+          filter_updated_at_lt: String,
+          filter_updated_at_lte: String,
+          page_after: String,
+          page_before: String,
+          page_size: Integer,
+          sort: String,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(
+          Telnyx::Internal::EmailBracketCursorPagination[Telnyx::PayConnector]
+        )
+      end
+      def list(
+        # Equal to this created_at timestamp.
+        filter_created_at_eq: nil,
+        # After this created_at timestamp.
+        filter_created_at_gt: nil,
+        # At or after this created_at timestamp.
+        filter_created_at_gte: nil,
+        # Before this created_at timestamp.
+        filter_created_at_lt: nil,
+        # At or before this created_at timestamp.
+        filter_created_at_lte: nil,
+        # Exact match on mode.
+        filter_mode: nil,
+        # Exact match on name.
+        filter_name: nil,
+        # Exact match on type.
+        filter_type: nil,
+        # Equal to this updated_at timestamp.
+        filter_updated_at_eq: nil,
+        # After this updated_at timestamp.
+        filter_updated_at_gt: nil,
+        # At or after this updated_at timestamp.
+        filter_updated_at_gte: nil,
+        # Before this updated_at timestamp.
+        filter_updated_at_lt: nil,
+        # At or before this updated_at timestamp.
+        filter_updated_at_lte: nil,
+        # Opaque cursor from meta.end_cursor.
+        page_after: nil,
+        # Opaque cursor from meta.start_cursor.
+        page_before: nil,
+        # Number of records per page.
+        page_size: nil,
+        # Comma-separated created_at or updated_at fields, optionally prefixed with - for
+        # descending order.
+        sort: nil,
+        request_options: {}
+      )
+      end
+
+      # Delete a connector by name in the authenticated organization. Both test and live
+      # connectors can be deleted. Returns no response body on success; a missing name
+      # or a connector in another organization returns 404.
+      sig do
+        params(
+          name: String,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).void
+      end
+      def delete(
+        # Connector name, not its UUID. URL-encode the name as a path segment.
+        name,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Telnyx::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/phone_numbers/csv_downloads.rbi

@@ -13,6 +13,7 @@ module Telnyx
               Telnyx::PhoneNumbers::CsvDownloadCreateParams::CsvFormat::OrSymbol,
             filter:
               Telnyx::PhoneNumbers::CsvDownloadCreateParams::Filter::OrHash,
+            include_managed_accounts: T::Boolean,
             request_options: Telnyx::RequestOptions::OrHash
           ).returns(Telnyx::Models::PhoneNumbers::CsvDownloadCreateResponse)
         end
@@ -26,6 +27,13 @@ module Telnyx
           # filter[voice.usage_payment_method], filter[billing_group_id],
           # filter[emergency_address_id], filter[customer_reference]
           filter: nil,
+          # When true, the CSV includes phone numbers from all managed accounts in addition
+          # to the requesting account's own numbers. Only applies to V2 format; ignored for
+          # V1. The export appends `user_id` and `email` columns identifying the account
+          # that owns each number. When a filter is provided, it applies to the combined set
+          # of numbers. Requires access to managed accounts; requests without that access
+          # are rejected.
+          include_managed_accounts: nil,
           request_options: {}
         )
         end

data/rbi/telnyx/resources/phone_numbers/jobs.rbi

@@ -21,9 +21,10 @@ module Telnyx
         end
 
         # Returns background jobs that operate on phone numbers. Filter by job type,
-        # target phone numbers, or job status, and sort by creation time. Multiple
-        # phone-number or status values use OR semantics within that filter; different
-        # filter categories use AND semantics. Results include pagination metadata.
+        # target phone numbers, job status, or creation-time customer reference, and sort
+        # by creation time. Multiple phone-number or status values use OR semantics within
+        # that filter; different filter categories use AND semantics. Results include
+        # pagination metadata.
         sig do
           params(
             filter: Telnyx::PhoneNumbers::JobListParams::Filter::OrHash,
@@ -33,13 +34,14 @@ module Telnyx
             request_options: Telnyx::RequestOptions::OrHash
           ).returns(
             Telnyx::Internal::DefaultFlatPagination[
-              Telnyx::PhoneNumbers::PhoneNumbersJob
+              Telnyx::PhoneNumbers::NumbersPhoneNumbersJob
             ]
           )
         end
         def list(
           # Consolidated filter parameter (deepObject style). Originally: filter[type],
-          # filter[phone_number], filter[phone_number][], filter[status][]
+          # filter[phone_number], filter[phone_number][], filter[status][],
+          # filter[customer_reference]
           filter: nil,
           page_number: nil,
           page_size: nil,
@@ -102,7 +104,12 @@ module Telnyx
           billing_group_id: nil,
           # Body param: Identifies the connection associated with the phone number.
           connection_id: nil,
-          # Body param: A customer reference string for customer look ups.
+          # Body param: Sets the customer reference on the selected phone numbers and
+          # retains the supplied value on the job. Recover the job without its ID using GET
+          # /phone_numbers/jobs with filter[customer_reference] within 90 days of job
+          # creation. This body field updates the numbers; the separate
+          # filter[customer_reference] query parameter selects numbers by their current
+          # reference.
           customer_reference: nil,
           # Body param: Indicates whether to enable or disable the deletion lock on each
           # phone number. When enabled, this prevents the phone number from being deleted

data/rbi/telnyx/resources/reputation/numbers.rbi

@@ -33,8 +33,12 @@ module Telnyx
         sig do
           params(
             filter_enterprise_id: String,
+            filter_ownership_status:
+              Telnyx::Enterprises::Reputation::ReputationOwnershipStatus::OrSymbol,
             filter_phone_number_contains: String,
             filter_phone_number_eq: String,
+            filter_source:
+              Telnyx::Enterprises::Reputation::ReputationNumberSource::OrSymbol,
             page_number: Integer,
             page_size: Integer,
             request_options: Telnyx::RequestOptions::OrHash
@@ -47,10 +51,16 @@ module Telnyx
         def list(
           # Filter by enterprise ID.
           filter_enterprise_id: nil,
+          # Only numbers with this ownership status. `removed` lists the numbers that were
+          # removed, each with its `removal_reason` and `removed_at`; removed numbers are
+          # not returned otherwise.
+          filter_ownership_status: nil,
           # Partial match on phone number. Must contain at least 5 digits.
           filter_phone_number_contains: nil,
           # Exact phone-number match (E.164).
           filter_phone_number_eq: nil,
+          # Only numbers with this source.
+          filter_source: nil,
           # 1-based page number. Out-of-range values return an empty page with correct meta.
           page_number: nil,
           # Items per page. Maximum 250; values above are clamped to 250.

data/rbi/telnyx/resources/sip_registration_status.rbi

@@ -0,0 +1,52 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    # UAC connection operations
+    class SipRegistrationStatus
+      # Returns the live SIP registration status for a Telnyx endpoint: whether it is
+      # currently registered, when the current registration expires, and the last
+      # response Telnyx received from the registrar.
+      #
+      # The endpoint supports three credential types, selected with the
+      # `credential_type` query parameter. Each type is keyed by a different identifier:
+      #
+      # | `credential_type`           | Keyed by        | Use case                                                                   |
+      # | --------------------------- | --------------- | -------------------------------------------------------------------------- |
+      # | `uac_external_credential`   | `connection_id` | A UAC (SIP attach) connection that registers to an external PBX.           |
+      # | `telephony_credential`      | `username`      | An ephemeral, one-time-use telephony credential.                           |
+      # | `sip_credential_connection` | `username`      | A traditional SIP credential connection that registers directly to Telnyx. |
+      #
+      # The authenticated account is taken from your API key; you can only read the
+      # registration status of connections and credentials your account owns.
+      sig do
+        params(
+          credential_type:
+            Telnyx::SipRegistrationStatusListParams::CredentialType::OrSymbol,
+          connection_id: String,
+          username: String,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::Models::SipRegistrationStatusListResponse)
+      end
+      def list(
+        # The kind of credential to look up. `uac_external_credential` is keyed by
+        # `connection_id`; `telephony_credential` and `sip_credential_connection` are
+        # keyed by `username`.
+        credential_type:,
+        # Identifier of the UAC connection to look up. Required when `credential_type` is
+        # `uac_external_credential`.
+        connection_id: nil,
+        # SIP username to look up. Required when `credential_type` is
+        # `telephony_credential` or `sip_credential_connection`.
+        username: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Telnyx::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/speech_to_text.rbi

@@ -85,9 +85,10 @@ module Telnyx
         transcription_engine:,
         # Silence duration (in milliseconds) that triggers end-of-speech detection. When
         # set, the engine uses this value to determine when a speaker has stopped talking.
-        # Supported by `xAI`, `Deepgram`, `Google`, `Speechmatics`, and `Soniox`. `Soniox`
-        # accepts values between 500 and 3000. Other engines may not support this
-        # parameter.
+        # Supported by `xAI`, `Deepgram`, `Google`, `Speechmatics`
+        # (`speechmatics/standard` only; `speechmatics/linden-1` uses fixed service-side
+        # voice activity detection and ignores it), and `Soniox`. `Soniox` accepts values
+        # between 500 and 3000. Other engines may not support this parameter.
         endpointing: nil,
         # Whether to receive interim transcription results.
         interim_results: nil,
@@ -99,7 +100,12 @@ module Telnyx
         keywords: nil,
         # The language spoken in the audio stream. For `cohere/ar-stt`, this must be `ar`
         # or `en` — unlike other engines, Cohere does not auto-detect the language, and
-        # rejects unsupported values including `auto`; omitting it defaults to `ar`.
+        # rejects unsupported values including `auto`; omitting it defaults to `ar`. For
+        # `speechmatics/linden-1`, omitting it defaults to `en`; `auto`, `auto_beta`,
+        # `multi`, or a language outside its supported list is rejected when the
+        # connection is established. `speechmatics/linden-1` also accepts `en-US`,
+        # `en-GB`, `en-AU`, `cmn-Hans`, and `cmn-Hant`, which select the spelling or
+        # script variant (`en` alone uses the default spelling).
         language: nil,
         # The specific model to use within the selected transcription engine.
         model: nil,
@@ -109,6 +115,7 @@ module Telnyx
         # Audio sample rate in Hz. Required when `input_format` is a raw encoding
         # (`linear16`, `linear32`) — those formats carry no header metadata. Ignored for
         # container formats (`mp3`, `wav`), which self-describe their rate.
+        # `speechmatics/linden-1` accepts only `16000`.
         sample_rate: nil,
         request_options: {}
       )

data/rbi/telnyx/resources/spend_limits.rbi

@@ -0,0 +1,154 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    # Daily and monthly spend limits per product. A limit applies to the organization
+    # of the authenticated user, or to the user's own account when they belong to no
+    # organization; every user of the organization sees and changes the same limits.
+    #
+    # - **Periods.** `daily` covers the current UTC day and `monthly` the current UTC
+    #   calendar month. The two limits are independent: you can set either, both or
+    #   neither.
+    # - **Blocking.** When spend in a period goes above the limit (strictly greater),
+    #   the product is blocked until the period ends: 00:00 UTC the next day for
+    #   `daily`, 00:00 UTC on the 1st of the next month for `monthly`. A block appears
+    #   within about 2 minutes (daily) or 10 minutes (monthly) of the spend being
+    #   recorded.
+    # - **Changes apply immediately.** Creating, updating or deleting a limit checks
+    #   the period's spend in the same request: raising the limit above the spend, or
+    #   removing it, lifts that period's block, and lowering it below the spend blocks
+    #   the product at once. The `evaluation` object in the response says what
+    #   happened.
+    # - **Supported products.** Today only `inference` supports spend limits. A
+    #   blocked account gets HTTP 403 with the error title
+    #   `Inference spend limit reached` (code `10039`) on new billable chat
+    #   completions, Responses, Anthropic Messages and classification requests;
+    #   requests already running finish normally. Take the list of products from the
+    #   list operation.
+    # - **API key limits.** For `inference`, a limit can also apply to one API key,
+    #   named by `credential_id`: the key's identifier as recorded on usage, never its
+    #   secret. When the key's spend goes above its own limit, only that key is
+    #   blocked, with the error title `API key spend limit reached` (code `10039`);
+    #   the account's other keys keep working. The API key limits of a period cannot
+    #   add up to more than the total limit when the total has an amount. Only
+    #   language-model requests authenticated with an API key count toward its limit.
+    # - **Limits set by Telnyx.** Telnyx support can also set a limit on your account.
+    #   It is listed with `origin: operator` and you can update or delete it like your
+    #   own.
+    class SpendLimits
+      # Sets a limit for a product and period that has none. Send exactly one of
+      # `amount` and `unlimited: true`. The period's spend is checked at once: if it is
+      # already above the new limit, the product is blocked immediately
+      # (`evaluation.blocked_now`). Returns 409 when a limit already exists for the
+      # product and period; update it instead. With `credential_id`, the limit applies
+      # to that API key only: it needs an `amount`, and the period's API key limits
+      # cannot add up to more than the total limit when the total has an amount.
+      sig do
+        params(
+          body:
+            T.any(
+              Telnyx::SpendLimitCreateParams::Body::CreateSpendLimitWithAmount::OrHash,
+              Telnyx::SpendLimitCreateParams::Body::CreateSpendLimitUnlimited::OrHash
+            ),
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::SpendLimitResponse)
+      end
+      def create(
+        # Send exactly one of `amount` and `unlimited: true`.
+        body:,
+        request_options: {}
+      )
+      end
+
+      # Replaces the value of the existing limit for the product and period. Send
+      # exactly one of `amount` and `unlimited: true`. The period's spend is checked at
+      # once: raising the limit above the spend lifts the period's block
+      # (`evaluation.released`), and lowering it below the spend blocks the product
+      # (`evaluation.blocked_now`). Returns 404 when no limit is set; create it instead.
+      # With the `credential_id` query parameter, the request changes that API key's
+      # limit; it needs an `amount`, and it can be at most the period's total limit.
+      # Lowering the total limit below the period's highest API key limit is refused.
+      sig do
+        params(
+          product: String,
+          body:
+            T.any(
+              Telnyx::SpendLimitUpdateParams::Body::UpdateSpendLimitWithAmount::OrHash,
+              Telnyx::SpendLimitUpdateParams::Body::UpdateSpendLimitUnlimited::OrHash
+            ),
+          credential_id: String,
+          period: Telnyx::SpendLimitPeriod::OrSymbol,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::SpendLimitResponse)
+      end
+      def update(
+        # Path param: Product the limit applies to, as returned in `product` by the list
+        # operation.
+        product,
+        # Body param: Send exactly one of `amount` and `unlimited: true`.
+        body:,
+        # Query param: Identifier of one API key as recorded on usage, never the key's
+        # secret, percent-encoded: the request is then about that key's limit. Absent
+        # means the total limit; present but blank is refused.
+        credential_id: nil,
+        # Query param: Limit period. Defaults to `daily`; send it explicitly.
+        period: nil,
+        request_options: {}
+      )
+      end
+
+      # Returns one entry per product and period you can set a limit on, with the limit,
+      # the spend so far in the period and whether the product is blocked. An entry
+      # without a limit is still listed (`limit: null`). When the spend cannot be read,
+      # the entry is returned with `spend_usd: null` and `spend_error` set. The list is
+      # not paginated. Each entry also lists the API key limits of its product and
+      # period in `credential_limits`, with each key's spend and block. Each API key
+      # limit can be at most the total limit; together they may add up to more than it.
+      sig do
+        params(request_options: Telnyx::RequestOptions::OrHash).returns(
+          Telnyx::Models::SpendLimitListResponse
+        )
+      end
+      def list(request_options: {})
+      end
+
+      # Removes the limit for the product and period. For `inference`, which has no
+      # default limit, the product becomes unlimited for the period and the period's
+      # block is lifted (`evaluation.released`). The response carries `limit: null` and
+      # the `effective_limit_usd` that applies after the removal. Returns 404 when no
+      # limit is set. With the `credential_id` query parameter, the request removes that
+      # API key's limit for the period and lifts the key's block in that period at once.
+      # A block under the key's limit in the other period stays
+      # (`evaluation.still_blocked_other_period`). Removing the total limit leaves the
+      # API key limits in place.
+      sig do
+        params(
+          product: String,
+          credential_id: String,
+          period: Telnyx::SpendLimitPeriod::OrSymbol,
+          reason: String,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::SpendLimitResponse)
+      end
+      def delete(
+        # Product the limit applies to, as returned in `product` by the list operation.
+        product,
+        # Identifier of one API key as recorded on usage, never the key's secret,
+        # percent-encoded: the request is then about that key's limit. Absent means the
+        # total limit; present but blank is refused.
+        credential_id: nil,
+        # Limit period. Defaults to `daily`; send it explicitly.
+        period: nil,
+        # Why the limit is removed, kept for audit. At most 500 characters.
+        reason: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Telnyx::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end