telnyx 5.169.0 → 5.171.0

data/rbi/telnyx/resources/llm_token_gateway/token_keys.rbi

@@ -0,0 +1,220 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class LlmTokenGateway
+      # Manage and report AI Gateway usage.
+      class TokenKeys
+        # Create gateway token key within the authenticated Telnyx account. Foreign and
+        # unknown resource IDs return the same 404 response. The token secret is returned
+        # only on the original create response. A replay returns metadata without the
+        # secret. Provisioning is advisory; ready is not a guarantee of inference
+        # availability.
+        sig do
+          params(
+            name: String,
+            token_group_id: String,
+            idempotency_key: String,
+            allowed_models: T.nilable(T::Array[String]),
+            blocked: T::Boolean,
+            budget_duration:
+              T.nilable(Telnyx::LlmTokenGateway::BudgetDuration::OrSymbol),
+            expires_at: T.nilable(Time),
+            max_budget: T.nilable(Float),
+            max_parallel_requests: T.nilable(Integer),
+            required_end_user_id: T::Boolean,
+            rpm_limit: T.nilable(Integer),
+            token_user_id: T.nilable(String),
+            tpm_limit: T.nilable(Integer),
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::LlmTokenGateway::TokenKeyResponse)
+        end
+        def create(
+          # Body param
+          name:,
+          # Body param
+          token_group_id:,
+          # Header param: 24h, scoped by account+method+path. Same key/body returns same
+          # outcome; changed body 409; in-progress 409 with Retry-After. Token-create replay
+          # returns 200 metadata WITHOUT secret.
+          idempotency_key:,
+          # Body param
+          allowed_models: nil,
+          # Body param
+          blocked: nil,
+          # Body param
+          budget_duration: nil,
+          # Body param
+          expires_at: nil,
+          # Body param: USD, decimal precision at most 6 places; parse exactly to integer
+          # micro-USD, never binary float accounting.
+          max_budget: nil,
+          # Body param: Optional maximum concurrent reserved/dispatched cache misses across
+          # replicas. Null means no concurrency cap. Cache hits do not consume slots;
+          # unknown usage retains its budget hold without a slot.
+          max_parallel_requests: nil,
+          # Body param: Require a nonempty caller-asserted end-user ID; not proof of
+          # identity.
+          required_end_user_id: nil,
+          # Body param: Omitted or null defaults to the maximum (6000) (on a blocked key,
+          # null is kept until the key is unblocked); a value below the minimum (1) or above
+          # the maximum is rejected with 400 limit_out_of_range; a malformed value
+          # (negative, wrong type or precision) is 400 invalid_request. Block the key
+          # (blocked: true) to deny it; blocking is always accepted.
+          rpm_limit: nil,
+          # Body param
+          token_user_id: nil,
+          # Body param: Omitted or null defaults to the maximum (10000000) (on a blocked
+          # key, null is kept until the key is unblocked); a value below the minimum (1) or
+          # above the maximum is rejected with 400 limit_out_of_range; a malformed value
+          # (negative, wrong type or precision) is 400 invalid_request. Block the key
+          # (blocked: true) to deny it; blocking is always accepted.
+          tpm_limit: nil,
+          request_options: {}
+        )
+        end
+
+        # Get gateway token key within the authenticated Telnyx account. Foreign and
+        # unknown resource IDs return the same 404 response.
+        sig do
+          params(
+            id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::LlmTokenGateway::TokenKeyResponse)
+        end
+        def retrieve(id, request_options: {})
+        end
+
+        # Update gateway token key within the authenticated Telnyx account. Foreign and
+        # unknown resource IDs return the same 404 response. Omitted fields are preserved.
+        # Null clears max_parallel_requests; null resets budget and rate limits to their
+        # maximum. A stale If-Match returns 412.
+        sig do
+          params(
+            id: String,
+            idempotency_key: String,
+            if_match: String,
+            allowed_models: T.nilable(T::Array[String]),
+            blocked: T::Boolean,
+            budget_duration:
+              T.nilable(Telnyx::LlmTokenGateway::BudgetDuration::OrSymbol),
+            expires_at: T.nilable(Time),
+            max_budget: T.nilable(Float),
+            max_parallel_requests: T.nilable(Integer),
+            name: String,
+            required_end_user_id: T::Boolean,
+            rpm_limit: T.nilable(Integer),
+            tpm_limit: T.nilable(Integer),
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::LlmTokenGateway::TokenKeyResponse)
+        end
+        def update(
+          # Path param
+          id,
+          # Header param: 24h, scoped by account+method+path. Same key/body returns same
+          # outcome; changed body 409; in-progress 409 with Retry-After. Token-create replay
+          # returns 200 metadata WITHOUT secret.
+          idempotency_key:,
+          # Header param: Exact quoted resource-version ETag; an exact intermediary-weakened
+          # echo W/"n" is accepted. Wildcard, combined and malformed validators are
+          # rejected; stale 412; missing 428. HTTP field names are case-insensitive.
+          # Replayed idempotent result is checked first.
+          if_match:,
+          # Body param
+          allowed_models: nil,
+          # Body param
+          blocked: nil,
+          # Body param
+          budget_duration: nil,
+          # Body param
+          expires_at: nil,
+          # Body param: USD, decimal precision at most 6 places; parse exactly to integer
+          # micro-USD, never binary float accounting.
+          max_budget: nil,
+          # Body param: Optional maximum concurrent reserved/dispatched cache misses across
+          # replicas. Null means no concurrency cap. Cache hits do not consume slots;
+          # unknown usage retains its budget hold without a slot.
+          max_parallel_requests: nil,
+          # Body param
+          name: nil,
+          # Body param: Require a nonempty caller-asserted end-user ID; not proof of
+          # identity. Omission preserves the current requirement.
+          required_end_user_id: nil,
+          # Body param: Omitted or null defaults to the maximum (6000) (on a blocked key,
+          # null is kept until the key is unblocked); a value below the minimum (1) or above
+          # the maximum is rejected with 400 limit_out_of_range; a malformed value
+          # (negative, wrong type or precision) is 400 invalid_request. Block the key
+          # (blocked: true) to deny it; blocking is always accepted.
+          rpm_limit: nil,
+          # Body param: Omitted or null defaults to the maximum (10000000) (on a blocked
+          # key, null is kept until the key is unblocked); a value below the minimum (1) or
+          # above the maximum is rejected with 400 limit_out_of_range; a malformed value
+          # (negative, wrong type or precision) is 400 invalid_request. Block the key
+          # (blocked: true) to deny it; blocking is always accepted.
+          tpm_limit: nil,
+          request_options: {}
+        )
+        end
+
+        # List gateway token keys within the authenticated Telnyx account. Foreign and
+        # unknown resource IDs return the same 404 response.
+        sig do
+          params(
+            page_number: Integer,
+            page_size: Integer,
+            page_snapshot: String,
+            token_group_id: String,
+            token_user_id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(
+            Telnyx::Internal::DefaultFlatPagination[
+              Telnyx::LlmTokenGateway::TokenKey
+            ]
+          )
+        end
+        def list(
+          page_number: nil,
+          page_size: nil,
+          # Required after page 1; account/filter-bound 15-minute stable snapshot;
+          # expired/mismatch 409.
+          page_snapshot: nil,
+          token_group_id: nil,
+          token_user_id: nil,
+          request_options: {}
+        )
+        end
+
+        # Revoke this token key. Acknowledged revocation blocks new admissions with the
+        # key; requests already admitted may complete. Historical usage attribution is
+        # retained. Other keys in the group are unchanged.
+        sig do
+          params(
+            id: String,
+            idempotency_key: String,
+            if_match: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).void
+        end
+        def delete(
+          id,
+          # 24h, scoped by account+method+path. Same key/body returns same outcome; changed
+          # body 409; in-progress 409 with Retry-After. Token-create replay returns 200
+          # metadata WITHOUT secret.
+          idempotency_key:,
+          # Exact quoted resource-version ETag; an exact intermediary-weakened echo W/"n" is
+          # accepted. Wildcard, combined and malformed validators are rejected; stale 412;
+          # missing 428. HTTP field names are case-insensitive. Replayed idempotent result
+          # is checked first.
+          if_match:,
+          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/llm_token_gateway/usage.rbi

@@ -0,0 +1,90 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class LlmTokenGateway
+      # Manage and report AI Gateway usage.
+      class Usage
+        # Durable, replayable, content-free usage export for customer pipelines. Requires
+        # the dedicated llm_token_gateway.usage_export.read V2 action; spend.read and
+        # usage.read do not grant it. Records are inference.request (one per immutable
+        # ledger revision; a correction adds a new id with supersedes, keep the highest
+        # revision per request_id) and guardrail.evaluation (one per guardrail event,
+        # including blocked prompts with no inference record; correlate on request_id).
+        # Delivery is at least once in commit order: deduplicate on id. Records appear
+        # after settlement and after every older database transaction has finished
+        # (meta.horizon_lag_seconds); keep polling with next_cursor, which is always
+        # returned and is reusable after has_more is false. After a logical database
+        # restore, restart from start_time and deduplicate on id; a cursor from before it
+        # may return 409 cursor_expired (no Retry-After). Retention promise 30 days. No
+        # prompts, responses, provider credentials, supplier or customer rates. Gateway
+        # reference/enforcement usage, not invoice truth or BYOK provider charges.
+        sig do
+          params(
+            cursor: String,
+            limit: Integer,
+            start_time: Time,
+            types: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(
+            Telnyx::Models::LlmTokenGateway::UsageRetrieveExportResponse
+          )
+        end
+        def retrieve_export(
+          # Opaque next_cursor from a previous page; not combinable with start_time. Bound
+          # to the requested types; the account always comes from the credential.
+          cursor: nil,
+          limit: nil,
+          # First page only: RFC 3339 with offset, at most 30 days ago and not in the
+          # future; default now - 24h.
+          start_time: nil,
+          # Comma-separated subset of inference.request,guardrail.evaluation; default both.
+          types: nil,
+          request_options: {}
+        )
+        end
+
+        # Gateway reference/enforcement usage, not invoice truth or BYOK provider charges.
+        # Requires the dedicated llm_token_gateway.usage.read V2 action for combined spend
+        # and guardrail reporting; existing spend.read and guardrail_events.read grants do
+        # not grant this endpoint. All totals, UTC daily buckets, models and latest 20
+        # guardrail events share one database snapshot. UTC half-open dates, at most 31
+        # days. Zero-filled days; at most 1000 models (503 rather than truncation on
+        # overflow/timeout). Known tokens sum independently known categories across latest
+        # attempt evidence, including corrections; unknown spend is excluded and
+        # unknown_requests/reserved_spend remain explicit. Guardrail counts count events,
+        # not distinct requests. No raw spend events, prompts or secrets. This read-only
+        # report creates no pagination snapshot and accepts no pagination parameters.
+        sig do
+          params(
+            end_date: Date,
+            start_date: Date,
+            token_group_id: String,
+            metadata: T::Hash[Symbol, String],
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(
+            Telnyx::Models::LlmTokenGateway::UsageRetrieveSummaryResponse
+          )
+        end
+        def retrieve_summary(
+          end_date:,
+          start_date:,
+          token_group_id:,
+          # Request tag filters as metadata[<key>]=<value>, at most 5, combined with AND. A
+          # value matches the tag's text form exactly (booleans as true/false, integers in
+          # decimal), so metadata[flag]=true matches both boolean true and the string
+          # "true". Keys are case-sensitive; reserved-prefix keys are rejected. Unindexed:
+          # bounded by the account, the date range and the report timeout.
+          metadata: nil,
+          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/llm_token_gateway.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class LlmTokenGateway
+      # Manage and report AI Gateway usage.
+      sig { returns(Telnyx::Resources::LlmTokenGateway::Usage) }
+      attr_reader :usage
+
+      # Manage and report AI Gateway usage.
+      sig { returns(Telnyx::Resources::LlmTokenGateway::Spend) }
+      attr_reader :spend
+
+      # Manage and report AI Gateway usage.
+      sig { returns(Telnyx::Resources::LlmTokenGateway::TokenGroups) }
+      attr_reader :token_groups
+
+      # Manage and report AI Gateway usage.
+      sig { returns(Telnyx::Resources::LlmTokenGateway::TokenKeys) }
+      attr_reader :token_keys
+
+      # @api private
+      sig { params(client: Telnyx::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/meeting_sessions/actions.rbi

@@ -22,7 +22,13 @@ module Telnyx
         )
         end
 
-        # Sends audio / text-to-speech into a meeting session.
+        # Sends audio / text-to-speech into a meeting session. With a Telnyx AI Assistant
+        # (or avatar) attached, the bot is a webpage-output bot: the speak audio routes
+        # through the assistant's output page rather than the bot mic and plays once the
+        # assistant is connected -- it is not refused. If that page cannot be reached,
+        # delivery fails with the 502 below, which may arrive without an error envelope,
+        # so branch on the status code before parsing a body. The assistant is designed to
+        # own the conversation, so prefer letting it speak or use `send_chat`.
         sig do
           params(
             id: String,

data/rbi/telnyx/resources/meeting_sessions/artifacts.rbi

@@ -5,23 +5,34 @@ module Telnyx
     class MeetingSessions
       # Create and retrieve asynchronous summaries and action-item artifacts.
       class Artifacts
-        # Requests asynchronous generation of one `summary` or `action_items` artifact.
-        # Each type requires its own request. Generation requires transcript content and
-        # configured inference and currently reads at most the first 10,000 segments, so
-        # exceptionally long transcripts may produce incomplete artifacts or fail model
-        # limits.
+        # Requests asynchronous generation of one artifact: `summary`, `action_items`,
+        # `decisions`, `topics`, `open_questions`, or `custom`. Each request produces one
+        # artifact. `custom` is answered from a `prompt` you supply, which is required for
+        # `custom` and rejected on the five named types. Generation requires transcript
+        # content and configured inference and currently reads at most the first 10,000
+        # segments, so exceptionally long transcripts may produce incomplete artifacts or
+        # fail model limits. **Not idempotent, and every call is billed**: each request is
+        # a separate inference run, so a retry or a duplicate POST produces a second
+        # artifact and a second charge. Guard the call rather than relying on the service
+        # to collapse it. The automatic `summarize_on_end` attempt is billed on the same
+        # basis.
         sig do
           params(
             id: String,
-            type: Telnyx::MeetingSessions::ArtifactCreateParams::Type::OrSymbol,
+            body:
+              T.any(
+                Telnyx::MeetingSessions::ArtifactCreateParams::Body::NamedArtifact::OrHash,
+                Telnyx::MeetingSessions::ArtifactCreateParams::Body::CustomArtifact::OrHash
+              ),
             request_options: Telnyx::RequestOptions::OrHash
           ).returns(Telnyx::MeetingSessions::MeetingSessionArtifactResponse)
         end
         def create(
           # Unique identifier for the meeting session.
           id,
-          # Type of artifact to generate from the session.
-          type:,
+          # One of two shapes: a named type on its own, or `custom` with the prompt it
+          # answers.
+          body:,
           request_options: {}
         )
         end

data/rbi/telnyx/resources/meeting_sessions.rbi

@@ -34,6 +34,7 @@ module Telnyx
               Telnyx::MeetingSessionCreateParams::CameraImage::MeetingSessionCameraImageBase64Source::OrHash,
               Telnyx::MeetingSessionCreateParams::CameraImage::MeetingSessionCameraImageURLSource::OrHash
             ),
+          chat_on_enter: String,
           idempotency_key: String,
           join_at: Time,
           metadata: T::Hash[Symbol, T.anything],
@@ -47,10 +48,10 @@ module Telnyx
       def create(
         # The meeting URL the bot should join.
         meeting_url:,
-        # Request options for attaching a voice assistant to the session. Routing fields
-        # (`call_control_connection_id`, `from`, and `loopback_sip_uri`) are used only to
-        # establish the assistant call leg and are omitted from response objects.
-        # `audio_gate` is returned with `id` in the assistant response object.
+        # Attach a Telnyx AI Assistant to the session. Supply the Assistant's ID; the
+        # Meeting service connects it to the meeting directly. The Call Control
+        # connection, caller ID and loopback SIP URI previously required here have been
+        # removed and are now rejected as unknown fields.
         assistant: nil,
         # Request options for attaching a bring-your-own-key avatar to the session.
         avatar: nil,
@@ -67,6 +68,12 @@ module Telnyx
         # recordings. An effective Avatar or Assistant webpage output takes precedence, so
         # this input is ignored and a URL source is not fetched.
         camera_image: nil,
+        # A message the bot posts to the meeting's chat as soon as it becomes active —
+        # typically a recording disclosure. Delivered at most once. Independent of
+        # `speak_on_enter`: both may be set, and the chat message posts first because it
+        # does not wait for text-to-speech or avatar startup. Rejected with 422
+        # `unsupported_capability` on platforms without meeting chat.
+        chat_on_enter: nil,
         # Client-supplied idempotency key to safely retry creation requests without
         # duplicating sessions. Lookup is scoped to the authenticated account and compares
         # the key only; the request payload is not fingerprinted or compared.
@@ -77,7 +84,10 @@ module Telnyx
         # Arbitrary key-value metadata attached to the session. The serialized JSON
         # representation must not exceed 16384 characters at runtime.
         metadata: nil,
-        # Text the bot speaks when it enters the meeting.
+        # Text the bot speaks when it enters the meeting. **Not spoken when an `assistant`
+        # is attached**: the value is accepted and echoed back on the session, but the
+        # assistant owns the voice and the line is never delivered, with no event
+        # reporting the omission. Use `chat_on_enter` to announce an assistant-backed bot.
         speak_on_enter: nil,
         # If true, generate a summary artifact when the session ends.
         summarize_on_end: nil,
@@ -161,14 +171,12 @@ module Telnyx
       )
       end
 
-      # **Not yet available in production** — this route is not currently routed on
-      # api.telnyx.com and returns a generic 404; it is documented ahead of rollout.
-      # Irreversibly requests deletion of provider-hosted aggregate recording media
-      # under the provider contract. The operation retains the Telnyx-local Meeting
-      # session, transcript segments, events, artifacts, and usage records. It is
-      # separate from `DELETE /meeting_sessions/{id}`, which stops or cancels
-      # participation without deleting the persisted session. A missing/foreign session
-      # returns 404; provider deletion failures return 502.
+      # Irreversibly requests deletion of the aggregate recording media for the session.
+      # The operation retains the Telnyx-local Meeting session, transcript segments,
+      # events, artifacts, and usage records. It is separate from
+      # `DELETE /meeting_sessions/{id}`, which stops or cancels participation without
+      # deleting the persisted session. A missing/foreign session returns 404; provider
+      # deletion failures return 502.
       sig do
         params(
           id: String,

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,
@@ -39,7 +40,8 @@ module Telnyx
         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,

data/rbi/telnyx/resources/private_wireless_gateways.rbi

@@ -11,6 +11,8 @@ module Telnyx
         params(
           name: String,
           network_id: String,
+          address_mode:
+            Telnyx::PrivateWirelessGatewayCreateParams::AddressMode::OrSymbol,
           region_code: String,
           request_options: Telnyx::RequestOptions::OrHash
         ).returns(Telnyx::Models::PrivateWirelessGatewayCreateResponse)
@@ -20,6 +22,12 @@ module Telnyx
         name:,
         # The identification of the related network resource.
         network_id:,
+        # Determines how IP addresses are assigned to SIM cards using this gateway. With
+        # static, each SIM card gets a fixed IP address from the gateway's IP range that
+        # is preserved across sessions. With dynamic, an IP address is assigned by the
+        # network at attach time and may change between sessions. If omitted, the gateway
+        # is created with the default address mode, dynamic.
+        address_mode: nil,
         # The code of the region where the private wireless gateway will be assigned. A
         # list of available regions can be found at the regions endpoint
         region_code: nil,
@@ -54,7 +62,7 @@ module Telnyx
           request_options: Telnyx::RequestOptions::OrHash
         ).returns(
           Telnyx::Internal::DefaultFlatPagination[
-            Telnyx::PrivateWirelessGateway
+            Telnyx::WirelessPrivateWirelessGateway
           ]
         )
       end

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