telnyx 5.167.0 → 5.169.0

data/rbi/telnyx/resources/ai/typesafe/v1.rbi

@@ -0,0 +1,61 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class AI
+      class Typesafe
+        # Beta API for evaluating shared context with typed questions and structured
+        # answers. Telnyx manages model selection.
+        class V1
+          # **Beta API.** Telnyx controls model selection.
+          #
+          # Evaluate shared context using named choice, noul (yes/no), and score questions.
+          # Returns TypeSafe System One-compatible answer shapes, an opaque compatibility
+          # identifier, and token usage. See the
+          # [decision model guide](https://developers.telnyx.com/docs/inference/decision-models)
+          # for examples and compatibility limits.
+          #
+          # The supported request subset requires instructions for every question, string
+          # descriptions for criteria (or null for choice descriptions), 1–64 questions, and
+          # 2–64 options for choice and score questions. The SDK-supplied model value is
+          # ignored and cannot select a model. Other unknown fields are rejected. The
+          # endpoint is synchronous and does not stream.
+          #
+          # Use the TypeSafe Python SDK with base_url set to
+          # https://api.telnyx.com/v2/ai/typesafe and a Telnyx API key. The SDK appends
+          # /v1/systemone. Compatibility covers this operation and the documented request
+          # subset; it does not include TypeSafe model listing. Scores describe relative
+          # preference, not calibrated correctness.
+          sig do
+            params(
+              questions:
+                T::Hash[
+                  Symbol,
+                  T.any(
+                    Telnyx::AI::Typesafe::V1SystemoneParams::Question::Choice::OrHash,
+                    Telnyx::AI::Typesafe::V1SystemoneParams::Question::Noul::OrHash,
+                    Telnyx::AI::Typesafe::V1SystemoneParams::Question::Score::OrHash
+                  )
+                ],
+              state: Telnyx::AI::Typesafe::V1SystemoneParams::State::Variants,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(Telnyx::Models::AI::Typesafe::V1SystemoneResponse)
+          end
+          def systemone(
+            # Between 1 and 64 named questions. Each key identifies the corresponding answer.
+            questions:,
+            # Shared context evaluated by every question.
+            state:,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Telnyx::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/ai/typesafe.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class AI
+      class Typesafe
+        # Beta API for evaluating shared context with typed questions and structured
+        # answers. Telnyx manages model selection.
+        sig { returns(Telnyx::Resources::AI::Typesafe::V1) }
+        attr_reader :v1
+
+        # @api private
+        sig { params(client: Telnyx::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/ai.rbi

@@ -55,6 +55,9 @@ module Telnyx
       sig { returns(Telnyx::Resources::AI::Knowledge) }
       attr_reader :knowledge
 
+      sig { returns(Telnyx::Resources::AI::Typesafe) }
+      attr_reader :typesafe
+
       # Performs semantic vector search across conversation history records.
       #
       # **How it works:**

data/rbi/telnyx/resources/bot_challenge.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    # Agentic (bot) signup for Telnyx accounts. An AI agent solves a reverse-CAPTCHA
+    # challenge designed to be easy for LLMs and hard for humans, registers an
+    # account, and signs in by consuming a magic link emailed to the account owner.
+    # All endpoints are public and unauthenticated; signup endpoints are additionally
+    # gated by the freemium feature flags and per-country availability.
+    class BotChallenge
+      # Generates a reverse-CAPTCHA challenge used to gate the bot signup flow. A random
+      # active problem is selected from the pool; math problems are returned obfuscated
+      # (case randomization, symbol injection, spacing noise) with an unobfuscated
+      # rounding instruction appended, while string and binary problems are returned
+      # as-is. The response contains a single-use nonce, the problem text, and the
+      # current terms-and-conditions and privacy-policy URLs, which must be echoed back
+      # on the signup request. Challenges expire after a short window (10 minutes by
+      # default) and can only be answered once. This endpoint is public and
+      # unauthenticated.
+      sig do
+        params(
+          llm_model_name: String,
+          llm_parameter_count: String,
+          llm_quantization: String,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::Models::BotChallengeCreateResponse)
+      end
+      def create(
+        # Name of the LLM the client is using.
+        llm_model_name: nil,
+        # Parameter count of the client LLM.
+        llm_parameter_count: nil,
+        # Quantization of the client LLM.
+        llm_quantization: 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/bot_sessions.rbi

@@ -0,0 +1,45 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    # Agentic (bot) signup for Telnyx accounts. An AI agent solves a reverse-CAPTCHA
+    # challenge designed to be easy for LLMs and hard for humans, registers an
+    # account, and signs in by consuming a magic link emailed to the account owner.
+    # All endpoints are public and unauthenticated; signup endpoints are additionally
+    # gated by the freemium feature flags and per-country availability.
+    class BotSessions
+      # Consumes the one-time portal redirect (magic link) token emailed during bot
+      # signup and returns an API session. The token is a UUIDv7 that encodes its
+      # creation time; it expires after a configurable validity window (15 minutes by
+      # default) and is cleared on first use. Although the action creates a session, the
+      # route uses the GET verb because it is opened from an email link. On first use
+      # the account is also initialized. For bot signup (freemium) accounts the response
+      # is a minimal envelope containing only the `api_v2_token`; accounts that are
+      # permitted to use magic links but are not freemium accounts may instead receive
+      # an extended session payload when additional steps (such as two-factor
+      # authentication or identity verification) are required. This endpoint is public;
+      # the magic link token in the query string is the credential.
+      sig do
+        params(
+          email: String,
+          portal_redirect_token: String,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::Models::BotSessionListResponse)
+      end
+      def list(
+        # Email address associated with the magic link token.
+        email:,
+        # Single-use portal redirect (magic link) token, a UUIDv7 sent to the account
+        # owner's email.
+        portal_redirect_token:,
+        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/bot_signup.rbi

@@ -0,0 +1,87 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    # Agentic (bot) signup for Telnyx accounts. An AI agent solves a reverse-CAPTCHA
+    # challenge designed to be easy for LLMs and hard for humans, registers an
+    # account, and signs in by consuming a magic link emailed to the account owner.
+    # All endpoints are public and unauthenticated; signup endpoints are additionally
+    # gated by the freemium feature flags and per-country availability.
+    class BotSignup
+      # Creates a freemium Telnyx account through the agentic signup flow. The request
+      # must carry a valid answer to a previously issued bot challenge
+      # (`bot_challenge_nonce` and `bot_challenge_answer`), accept the terms of service,
+      # and echo the exact terms-and-conditions and privacy-policy URLs returned by the
+      # challenge endpoint. When EU consent enforcement is enabled,
+      # `terms_of_service_eu` and `terms_and_conditions_eu_url` are also required. On
+      # success a one-time sign-in (magic) link is emailed to the address provided; if
+      # the email address belongs to an existing account, a sign-in link is sent instead
+      # of creating a duplicate account. `email` may only be omitted when
+      # placeholder-email registration is enabled server-side. This endpoint is public
+      # and unauthenticated, gated by the freemium feature flags and per-country
+      # availability, and subject to per-IP and per-domain registration limits.
+      sig do
+        params(
+          bot_challenge_answer: String,
+          bot_challenge_nonce: String,
+          privacy_policy_url: String,
+          terms_and_conditions_url: String,
+          terms_of_service:
+            Telnyx::BotSignupCreateParams::TermsOfService::OrBoolean,
+          email: String,
+          terms_and_conditions_eu_url: String,
+          terms_of_service_eu:
+            Telnyx::BotSignupCreateParams::TermsOfServiceEu::OrBoolean,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::SuccessResponse)
+      end
+      def create(
+        # Answer to the issued bot challenge.
+        bot_challenge_answer:,
+        # Nonce from a previously issued bot challenge.
+        bot_challenge_nonce:,
+        # Must exactly match the privacy-policy URL returned by the challenge endpoint.
+        privacy_policy_url:,
+        # Must exactly match the terms-and-conditions URL returned by the challenge
+        # endpoint.
+        terms_and_conditions_url:,
+        # Must be true to accept the terms of service.
+        terms_of_service:,
+        # Email address for the new account. The magic link is sent here. May only be
+        # omitted when placeholder-email registration is enabled server-side.
+        email: nil,
+        # EU terms-and-conditions URL. Required when EU consent enforcement is enabled.
+        terms_and_conditions_eu_url: nil,
+        # EU terms-of-service acceptance. Required when EU consent enforcement is enabled.
+        terms_of_service_eu: nil,
+        request_options: {}
+      )
+      end
+
+      # Resends the one-time sign-in (magic) link for an eligible bot signup account.
+      # Eligibility (account exists, was registered through bot signup, is active, and
+      # has not exceeded the resend limit or rate window) is evaluated server-side; the
+      # response is intentionally uniform and does not reveal whether the account exists
+      # or whether a link was actually sent. This endpoint is public and
+      # unauthenticated, gated by the freemium feature flags and per-country
+      # availability.
+      sig do
+        params(
+          email: String,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::SuccessResponse)
+      end
+      def resend_magic_link(
+        # Email address of the bot signup account to resend the magic link to.
+        email:,
+        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/calls/actions.rbi

@@ -2374,11 +2374,12 @@ module Telnyx
           command_id: nil,
           # Custom headers to be added to the SIP INVITE.
           custom_headers: nil,
-          # The number the inbound call being transferred was originally received on, in
-          # +E164 format. Supplying it lets an unverified non-Telnyx `from` be used as the
-          # caller id, provided that number is still on an active inbound call to this
-          # `diversion` number for your account. The `diversion` number itself must be one
-          # you own or have verified.
+          # The `to` number of an active inbound call, in +E164 format. Telnyx checks
+          # whether there is currently an active inbound call where `to` matches this
+          # `diversion` value and `from` matches the `from` number supplied for this
+          # request. If such a call exists, the `from` number is treated as verified (since
+          # it is already on an active inbound call to you) and can be used as the caller id
+          # for this outbound call.
           diversion: nil,
           # If set to false, early media will not be passed to the originating leg.
           early_media: nil,

data/rbi/telnyx/resources/calls.rbi

@@ -198,11 +198,12 @@ module Telnyx
         # webhook.
         deepfake_detection: nil,
         dialogflow_config: nil,
-        # The number the inbound call being transferred was originally received on, in
-        # +E164 format. Supplying it lets an unverified non-Telnyx `from` be used as the
-        # caller id, provided that number is still on an active inbound call to this
-        # `diversion` number for your account. The `diversion` number itself must be one
-        # you own or have verified.
+        # The `to` number of an active inbound call, in +E164 format. Telnyx checks
+        # whether there is currently an active inbound call where `to` matches this
+        # `diversion` value and `from` matches the `from` number supplied for this
+        # request. If such a call exists, the `from` number is treated as verified (since
+        # it is already on an active inbound call to you) and can be used as the caller id
+        # for this outbound call.
         diversion: nil,
         # Enables Dialogflow for the current call. The default value is false.
         enable_dialogflow: nil,

data/rbi/telnyx/resources/compute/funcs/export.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class Compute
+      class Funcs
+        class Export
+          # Configures the external OTLP endpoint a function's runtime and/or invocation
+          # logs are pushed to as they happen. This operation is a **full replace, not a
+          # patch**: `endpoint`, `headers`, `runtime_export_enabled`, and
+          # `invocation_export_enabled` are all required on every call — omitting any of
+          # them is a 422, not "keep the current value". Headers are encrypted at rest and
+          # never returned in any response.
+          #
+          # The endpoint must be an HTTPS URL. When export is configured, new log records
+          # are converted to OTLP log records and delivered continuously; export never
+          # bypasses platform log storage, and delivery retries with a bounded policy while
+          # the destination is unreachable. Only logs generated after configuration are
+          # exported — there is no historical replay.
+          sig do
+            params(
+              id: String,
+              endpoint: String,
+              headers: T::Hash[Symbol, String],
+              invocation_export_enabled: T::Boolean,
+              runtime_export_enabled: T::Boolean,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(Telnyx::Compute::Funcs::FuncLogExportConfigResponse)
+          end
+          def create(
+            # Function ID
+            id,
+            # HTTPS URL to push logs to
+            endpoint:,
+            # Headers attached to every export push, as key-value pairs (e.g. an auth token
+            # the collector expects). Required even when empty — {} means "no headers".
+            # Encrypted at rest; never returned.
+            headers:,
+            # Export invocation records (one per HTTP request) to this destination
+            invocation_export_enabled:,
+            # Export runtime logs (function stdout/stderr) to this destination
+            runtime_export_enabled:,
+            request_options: {}
+          )
+          end
+
+          # Returns the function's configured log export destination and which log types are
+          # exported. Headers are never returned. Returns 404 (error code 10005) when no
+          # destination is configured for the function.
+          sig do
+            params(
+              id: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(Telnyx::Compute::Funcs::FuncLogExportConfigResponse)
+          end
+          def list(
+            # Function ID
+            id,
+            request_options: {}
+          )
+          end
+
+          # Stops exporting a function's logs and removes its destination configuration.
+          # Idempotent: deleting when nothing is configured succeeds.
+          sig do
+            params(
+              id: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).void
+          end
+          def delete_all(
+            # Function ID
+            id,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Telnyx::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/compute/funcs.rbi

@@ -0,0 +1,114 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class Compute
+      class Funcs
+        sig { returns(Telnyx::Resources::Compute::Funcs::Export) }
+        attr_reader :export
+
+        # Returns logs oldest first. `type=runtime` (default) returns function
+        # stdout/stderr. `type=invocations` returns one platform-generated record per HTTP
+        # request served.
+        sig do
+          params(
+            id: String,
+            end_time: Time,
+            limit: Integer,
+            start_time: Time,
+            type: Telnyx::Compute::FuncRetrieveLogsParams::Type::OrSymbol,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Models::Compute::FuncRetrieveLogsResponse::Variants)
+        end
+        def retrieve_logs(
+          # Function ID
+          id,
+          # Return records at or before this RFC 3339 timestamp.
+          end_time: nil,
+          # Maximum records to return.
+          limit: nil,
+          # Return records at or after this RFC 3339 timestamp.
+          start_time: nil,
+          # Log stream to return.
+          type: nil,
+          request_options: {}
+        )
+        end
+
+        # Returns aggregate request, latency, CPU, memory, and resource-limit metrics for
+        # a function over the requested window.
+        sig do
+          params(
+            id: String,
+            end_time: Time,
+            start_time: Time,
+            filter_edge_site: String,
+            filter_namespace: String,
+            page_number: Integer,
+            page_size: Integer,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(
+            Telnyx::Models::Compute::FuncRetrieveMetricAggregatesResponse
+          )
+        end
+        def retrieve_metric_aggregates(
+          # Function ID
+          id,
+          # Exclusive window end, UTC ISO 8601 with milliseconds
+          end_time:,
+          # Inclusive window start, UTC ISO 8601 with milliseconds
+          start_time:,
+          # Edge site filter
+          filter_edge_site: nil,
+          # Kubernetes namespace filter
+          filter_namespace: nil,
+          page_number: nil,
+          page_size: nil,
+          request_options: {}
+        )
+        end
+
+        # Lists a function's ship history newest first, including per-ship failure stage
+        # and reason when recorded.
+        sig do
+          params(
+            id: String,
+            page_number: Integer,
+            page_size: Integer,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Models::Compute::FuncRetrieveRevisionsResponse)
+        end
+        def retrieve_revisions(
+          # Function ID
+          id,
+          page_number: nil,
+          page_size: nil,
+          request_options: {}
+        )
+        end
+
+        # Returns the latest ship outcome. The stage is `none` on success, `pending` while
+        # building, or a failure stage such as `build`, `platform`, `pre_build`, `deploy`,
+        # or `security_review`. This stage-neutral customer-facing path is an alias over
+        # the same inspection resource as `build_log_inspection`.
+        sig do
+          params(
+            id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Models::Compute::FuncRetrieveShipInspectionResponse)
+        end
+        def retrieve_ship_inspection(
+          # Function ID
+          id,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Telnyx::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/compute.rbi

@@ -0,0 +1,15 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class Compute
+      sig { returns(Telnyx::Resources::Compute::Funcs) }
+      attr_reader :funcs
+
+      # @api private
+      sig { params(client: Telnyx::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/connections.rbi

@@ -78,6 +78,17 @@ module Telnyx
       )
       end
 
+      # Returns the number of connections associated with the authenticated user,
+      # grouped by connection type, together with the connection limits that apply to
+      # the user. Forward-only connections are excluded from the counts.
+      sig do
+        params(request_options: Telnyx::RequestOptions::OrHash).returns(
+          Telnyx::Models::ConnectionRetrieveCountResponse
+        )
+      end
+      def retrieve_count(request_options: {})
+      end
+
       # @api private
       sig { params(client: Telnyx::Client).returns(T.attached_class) }
       def self.new(client:)

data/rbi/telnyx/resources/detail_records.rbi

@@ -21,10 +21,21 @@ module Telnyx
       def list(
         # Filter records on a given record attribute and value. <br/>Example:
         # filter[status]=delivered. <br/>Required: filter[record_type] must be specified.
+        # <br/>The valid filter fields depend on the record_type: filtering by a field
+        # that does not exist for the selected record_type is rejected with a 400 error.
+        # Call-control and sip-trunking records use started_at, finished_at and
+        # answered_at (they have no created_at); messaging records use created_at. To list
+        # the fields available for a record_type, use the /v2/detail_records/options
+        # endpoint.
         filter: nil,
         page_number: nil,
         page_size: nil,
-        # Specifies the sort order for results. <br/>Example: sort=-created_at
+        # Specifies the sort order for results. <br/>Example: sort=-created_at <br/>The
+        # valid sort fields depend on the record_type: sort by a field that does not exist
+        # for the selected record_type is rejected with a 400 error. Call-control and
+        # sip-trunking records use started_at, finished_at and answered_at (they have no
+        # created_at); messaging records use created_at. To list the fields available for
+        # a record_type, use the /v2/detail_records/options endpoint.
         sort: nil,
         request_options: {}
       )

data/rbi/telnyx/resources/email_messages.rbi

@@ -210,7 +210,11 @@ module Telnyx
       )
       end
 
-      # Creates up to 50 email messages in a single request.
+      # Creates up to 1,000 email messages in a single request. Request-wide admission
+      # checks run first and can reject the whole batch before message creation. After
+      # those checks pass, each message is validated and sent independently; item-level
+      # failures do not affect other messages, and the processed batch returns 207
+      # Multi-Status.
       sig do
         params(
           messages: T::Array[Telnyx::EmailMessageBatchParams::Message::OrHash],
@@ -220,7 +224,9 @@ module Telnyx
         ).returns(Telnyx::Models::EmailMessageBatchResponse)
       end
       def batch(
-        # Body param
+        # Body param: Array of email messages to send. Up to 1,000 messages per batch
+        # request. Each message is validated and sent independently; per-message failures
+        # do not affect other messages in the batch.
         messages:,
         # Body param: Applies sandbox mode to all messages in the batch. Overrides any
         # per-message sandbox_mode in the messages array.

data/rbi/telnyx/resources/machine_payments.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    # Machine payment (MPP) account-credit operations. Fund your Telnyx account
+    # programmatically from a machine or agent using the Machine Payment Protocol, an
+    # HTTP-402 flow settled via Stripe or Tempo.
+    class MachinePayments
+      # Creates an account credit using the Machine Payment Protocol (MPP), an HTTP-402
+      # payment flow for machines and agents.
+      #
+      # The flow has two steps. First, send an authenticated request with the
+      # `amount_usd` to credit; the response is `402 Payment Required` with one or more
+      # payment challenges (for example separate Tempo and Stripe challenges) in the
+      # `WWW-Authenticate` header. Second, retry the request with an
+      # `Authorization: Payment ...` credential constructed from the challenge; on
+      # success the response includes the credited transaction and a `Payment-Receipt`
+      # header.
+      #
+      # The credited account is never chosen by the request body: the initial request
+      # credits the account of the authenticated user, and a paid retry credits the
+      # account bound to the verified payment credential. The amount must be within the
+      # configured bounds (by default between 5.00 and 500.00 USD).
+      #
+      # Successful paid retries are idempotent — when Rails reaches its
+      # duplicate-transaction lookup for an already-recorded payment, it returns the
+      # existing transaction with `created: false` instead of crediting the account
+      # again. This deduplication applies to successful fulfillment: re-sending the same
+      # Stripe credential may instead be rejected by the upstream provider as an
+      # idempotent replay and return `402 Payment Required` rather than the existing
+      # transaction.
+      #
+      # > **Warning: the payment credential is bound to a specific Telnyx account ID.**
+      # > A payment is captured before the bound account is validated. If the credential
+      # > names an account that is missing, suspended, blocked, cancelled, dormant, or
+      # > ineligible for the tier, the payment is captured but **no account is
+      # > credited**. If the credential names a different but eligible account, that
+      # > account is credited — the service does not compare it against the payer's
+      # > account. There is **no automatic refund**: if the captured payment does not
+      # > credit the intended account, contact Telnyx support for remediation.
+      sig do
+        params(
+          amount_usd: String,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::Models::MachinePaymentAccountCreditResponse)
+      end
+      def account_credit(
+        # Amount to credit in USD, as a decimal string with up to two fractional digits
+        # (by default between 5.00 and 500.00). The request body is required on the
+        # initial challenge request and remains required on a paid retry, where you
+        # re-send the identical body plus the payment credential — the credential, not the
+        # body, selects the payment, and the retried body is not re-validated.
+        amount_usd:,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Telnyx::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end