telnyx 5.168.0 → 5.170.0

data/rbi/telnyx/resources/email_messages.rbi

@@ -102,7 +102,9 @@ module Telnyx
         in_reply_to_message_id: nil,
         # Body param
         inline_css: nil,
-        # Body param: Custom metadata. Write-only; not returned in responses.
+        # Body param: Custom metadata key/value pairs. Stored on the message, returned on
+        # message responses, and propagated to Email Detail Records. Usable in
+        # `filter[metadata]` when listing messages.
         metadata: nil,
         # Body param: Reply-to address. If provided as an object with a name, only the
         # email is stored; the name is ignored.
@@ -116,12 +118,37 @@ module Telnyx
         #
         # Only meaningful alongside `in_reply_to_message_id`.
         reply_to_all: nil,
-        # Body param
+        # Body param: Validates and accepts the message without injecting it into the MTA
+        # or outbound Kafka path. Nothing is delivered: sandbox records are non-billable,
+        # consume no daily-send-limit quota, and feed no delivery-reputation signals.
+        #
+        # The reserved sandbox test-recipient domain is `test.telnyx.com`. In sandbox
+        # mode, these addresses produce deterministic recipient-scoped lifecycle events:
+        #
+        # - `delivered@test.telnyx.com`: queued -> sending -> sent -> delivered
+        # - `hard-bounce@test.telnyx.com`: queued -> sending -> sent -> bounced
+        #   (permanent)
+        # - `soft-bounce@test.telnyx.com`: queued -> sending -> sent -> bounced
+        #   (transient)
+        # - `complaint@test.telnyx.com`: queued -> sending -> sent -> complained
+        # - `suppressed@test.telnyx.com`: queued -> suppressed
+        # - `invalid@test.telnyx.com`: queued -> sending -> failed (invalid recipient)
+        # - `dkim-fail@test.telnyx.com`: queued -> sending -> failed (DKIM unavailable)
+        # - `rate-limit@test.telnyx.com`: queued -> sending -> failed (rate limit
+        #   exceeded)
+        #
+        # Matching is case-insensitive for both the local part and the domain and requires
+        # the exact domain `test.telnyx.com` — subdomains and other domains do not match.
+        # Mixed sandbox sends simulate only reserved test recipients; other recipients
+        # retain ordinary sandbox behavior (accepted, no delivery attempted). Hard-bounce
+        # and complaint outcomes also use the normal automatic-suppression pipeline.
+        # Non-sandbox sends to these addresses use the normal delivery path.
         sandbox_mode: nil,
-        # Body param: Future ISO 8601 time to schedule sending. Invalid or past timestamps
-        # are silently ignored and the email is sent immediately. The legacy alias
-        # `send_at` is still accepted for backward compatibility; when both are provided,
-        # `scheduled_at` wins.
+        # Body param: Future ISO 8601 delivery time. Invalid or non-future timestamps are
+        # rejected. Single sends return HTTP 422; in batch sends the invalid item is
+        # reported in the 207 per-item errors while other items continue. `send_at`
+        # remains a deprecated request alias. A non-null `scheduled_at` takes precedence
+        # over `send_at`; when `scheduled_at` is omitted or null, `send_at` is used.
         scheduled_at: nil,
         # Body param: Deprecated alias for `scheduled_at`.
         send_at: nil,
@@ -129,14 +156,18 @@ module Telnyx
         # the template's subject is rendered; if the template has no subject or renders
         # empty, the request returns 400.
         subject: nil,
-        # Body param: Tags for categorization and reporting. Stored on the message and
-        # propagated to Email Detail Records. Not returned in API responses.
+        # Body param: Tags for categorization and filtering. Stored on the message,
+        # returned on message responses, and propagated to Email Detail Records. Usable in
+        # `filter[tags]` when listing messages.
         tags: nil,
         # Body param
         template_id: nil,
         # Body param: Variables for Liquid template rendering. Non-object values may cause
         # a 422 validation error on message creation, but are silently treated as an empty
-        # object for template rendering.
+        # object for template rendering. When the template enables `strict_variables`, a
+        # missing required variable fails the request with 422 (single send) or a per-item
+        # `unprocessable_entity` error (batch) naming the variable; no message is
+        # persisted for the failed item.
         template_variables: nil,
         # Body param: Plain text email body. Returned only by `GET /email_messages/{id}`;
         # omitted from create and list responses.
@@ -163,7 +194,7 @@ module Telnyx
         params(
           id: String,
           request_options: Telnyx::RequestOptions::OrHash
-        ).returns(Telnyx::Models::EmailMessageRetrieveResponse)
+        ).returns(Telnyx::EmailMessageDetailResponse)
       end
       def retrieve(
         # Email message UUID.
@@ -172,11 +203,13 @@ module Telnyx
       )
       end
 
-      # Lists messages sorted newest first by `created_at desc, id desc`. No filters
-      # other than cursor pagination are implemented. The legacy `/v2/emails` GET route
-      # is a backward-compatible alias for this operation.
+      # Lists messages sorted newest first by `created_at desc, id desc`. Tags and
+      # metadata filters compose with cursor pagination. The legacy `/v2/emails` GET
+      # route is a backward-compatible alias for this operation.
       sig do
         params(
+          filter_metadata: String,
+          filter_tags: String,
           page_cursor: String,
           page_size: Integer,
           request_options: Telnyx::RequestOptions::OrHash
@@ -187,6 +220,19 @@ module Telnyx
         )
       end
       def list(
+        # Metadata containment filter, supplied as a JSON object or comma-separated
+        # `key=value` pairs. All supplied key/value pairs must be contained in the message
+        # metadata. An empty value or empty JSON object omits the filter. Malformed
+        # values, valid non-object JSON, pairs without `=`, empty keys, and
+        # non-string/nested query shapes return HTTP 400.
+        filter_metadata: nil,
+        # Comma-separated tags. Each segment is trimmed, and messages having at least one
+        # supplied tag are returned; matching is exact and case-sensitive after trimming.
+        # Because commas delimit values and surrounding whitespace is removed, this filter
+        # cannot represent stored tags containing literal commas or leading/trailing
+        # whitespace. An empty value omits the filter. Empty segments and
+        # non-string/nested query shapes return HTTP 400.
+        filter_tags: nil,
         # Opaque URL-safe Base64 cursor returned by a previous list response.
         page_cursor: nil,
         # Number of results to return. Defaults to 25; maximum is 100. Invalid values are
@@ -210,9 +256,14 @@ module Telnyx
       )
       end
 
-      # Creates up to 1,000 email messages in a single request. Each message is
-      # validated and sent independently; per-message failures do not affect other
-      # messages in the batch. All responses use 207 Multi-Status.
+      # 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. Per-message failures include validation errors; when a template
+      # has `strict_variables` enabled, a missing required variable produces a per-item
+      # `unprocessable_entity` error naming that variable while the other messages
+      # continue.
       sig do
         params(
           messages: T::Array[Telnyx::EmailMessageBatchParams::Message::OrHash],
@@ -226,8 +277,13 @@ module Telnyx
         # 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.
+        # Body param: Applies sandbox mode to all messages in the batch and overrides any
+        # per-message `sandbox_mode` value — each message's effective `sandbox_mode` is
+        # exactly this envelope value. Reserved recipients at `test.telnyx.com` produce
+        # the deterministic event chains documented on CreateEmailRequest.sandbox_mode; no
+        # batch item is injected into the MTA or outbound Kafka path. Sandbox batch items
+        # are non-billable, consume no daily-send-limit quota, and feed no
+        # delivery-reputation signals.
         sandbox_mode: nil,
         # Header param: Optional opaque, unquoted key for safely retrying the same logical
         # request. Keys must contain 1 to 255 letters, numbers, hyphens, or underscores.
@@ -278,6 +334,15 @@ module Telnyx
       # Lists events for a single message sorted oldest first by
       # `occurred_at asc, id asc`. The legacy `/v2/emails/{id}/events` GET route is a
       # backward-compatible alias.
+      #
+      # For compatibility, each event carries the legacy customer-visible `event_type`
+      # (`email.`-prefixed), the additive `canonical_event_type` (`email.`-prefixed),
+      # and the deprecated `type` duplicate — whose value keeps the exact legacy format:
+      # the bare stored event name, never `email.`-prefixed. Gateway rejections render
+      # `email.failed` + canonical `email.gw_reject`; MTA expirations render
+      # `email.bounced` + canonical `email.expired`; every unchanged outcome carries
+      # identical `event_type` and `canonical_event_type` values (and `type` keeps the
+      # stored name).
       sig do
         params(
           email_id: String,
@@ -298,6 +363,27 @@ module Telnyx
       )
       end
 
+      # Moves an existing scheduled email to a new future send time. Only the delivery
+      # time (`scheduled_at`) changes; the message ID, content, recipients, tags, and
+      # metadata remain unchanged. Returns `409 Conflict` if the message is no longer
+      # scheduled or its scheduled-send worker has already started processing it. This
+      # route emits no dedicated `rescheduled` event.
+      sig do
+        params(
+          email_id: String,
+          scheduled_at: Time,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::EmailMessageDetailResponse)
+      end
+      def update_schedule(
+        # Email message UUID.
+        email_id,
+        # New ISO 8601 delivery time. Must be strictly in the future.
+        scheduled_at:,
+        request_options: {}
+      )
+      end
+
       # @api private
       sig { params(client: Telnyx::Client).returns(T.attached_class) }
       def self.new(client:)

data/rbi/telnyx/resources/email_templates.rbi

@@ -8,9 +8,18 @@ module Telnyx
       sig do
         params(
           name: String,
+          autoescape: T::Boolean,
           html_body: T.nilable(String),
+          strict_variables: T::Boolean,
           subject: T.nilable(String),
           text_body: T.nilable(String),
+          variable_schema:
+            T.nilable(
+              T::Hash[
+                Symbol,
+                Telnyx::EmailTemplateCreateParams::VariableSchema::OrHash
+              ]
+            ),
           variables: T::Array[String],
           idempotency_key: String,
           request_options: Telnyx::RequestOptions::OrHash
@@ -19,12 +28,36 @@ module Telnyx
       def create(
         # Body param: Letters, numbers, spaces, hyphens, and underscores only.
         name:,
+        # Body param: Per-template HTML autoescaping setting. Defaults to `false` for
+        # backward compatibility. When `true`, the rendered `html_body` HTML-escapes each
+        # Liquid expression's output at the output boundary (after its filters run, before
+        # concatenation with literal template markup). Input values are never mutated and
+        # `subject`/`text_body` are never autoescaped. The boundary escape is idempotent:
+        # HTML entities already present in the output (e.g. from an explicit `escape`
+        # filter) are preserved, so an explicit `escape`/`escape_once` is never
+        # double-escaped, and markup introduced by any later filter in the chain is still
+        # escaped.
+        autoescape: nil,
         # Body param: Liquid template HTML body.
         html_body: nil,
+        # Body param: Per-template strict variable-validation setting. Defaults to `false`
+        # for backward compatibility. When `true`, a send or render that is missing a
+        # variable marked `required: true` in `variable_schema` fails with 422 naming the
+        # variable. Missing optional variables never fail; their schema `default` (when
+        # set) is applied to the render.
+        strict_variables: nil,
         # Body param: Liquid template subject.
         subject: nil,
         # Body param: Liquid template text body.
         text_body: nil,
+        # Body param: Structured variable requirements. Required variables cannot define
+        # defaults; invalid combinations return 422. This is independent of the legacy
+        # `variables` array. On render with `strict_variables` enabled: `required`
+        # variables must be supplied as non-empty values — absent, `null`, empty string,
+        # empty object `{}`, and empty array `[]` all fail with 422 naming the variable,
+        # while present values such as `false` and `0` pass (they are present, not empty).
+        # Optional variables fall back to their `default` when absent.
+        variable_schema: nil,
         # Body param: Template variables. Auto-extracted from subject/body fields when
         # absent.
         variables: nil,
@@ -61,10 +94,19 @@ module Telnyx
       sig do
         params(
           id: String,
+          autoescape: T::Boolean,
           html_body: T.nilable(String),
           name: String,
+          strict_variables: T::Boolean,
           subject: T.nilable(String),
           text_body: T.nilable(String),
+          variable_schema:
+            T.nilable(
+              T::Hash[
+                Symbol,
+                Telnyx::UpdateEmailTemplateRequest::VariableSchema::OrHash
+              ]
+            ),
           variables: T::Array[String],
           request_options: Telnyx::RequestOptions::OrHash
         ).returns(Telnyx::EmailTemplateResponse)
@@ -72,13 +114,20 @@ module Telnyx
       def update(
         # Email template UUID.
         id,
+        # Per-template HTML autoescaping setting.
+        autoescape: nil,
         # Liquid template HTML body.
         html_body: nil,
         name: nil,
+        # Per-template strict variable-validation setting.
+        strict_variables: nil,
         # Liquid template subject.
         subject: nil,
         # Liquid template text body.
         text_body: nil,
+        # Structured variable requirements. Required variables cannot define defaults;
+        # invalid combinations return 422. Set to `null` to clear the schema.
+        variable_schema: nil,
         variables: nil,
         request_options: {}
       )
@@ -118,6 +167,12 @@ module Telnyx
 
       # Renders a template using the provided Liquid variables. Missing
       # `template_variables` defaults to `{}`.
+      #
+      # When the template has `strict_variables` enabled and a required variable (per
+      # `variable_schema`) is missing, returns 422 naming the variable. When the
+      # template has `autoescape` enabled, the rendered `html_body` expression output is
+      # HTML-escaped at the output boundary; `subject` and `text_body` are not
+      # autoescaped.
       sig do
         params(
           id: String,
@@ -140,10 +195,19 @@ module Telnyx
       sig do
         params(
           id: String,
+          autoescape: T::Boolean,
           html_body: T.nilable(String),
           name: String,
+          strict_variables: T::Boolean,
           subject: T.nilable(String),
           text_body: T.nilable(String),
+          variable_schema:
+            T.nilable(
+              T::Hash[
+                Symbol,
+                Telnyx::UpdateEmailTemplateRequest::VariableSchema::OrHash
+              ]
+            ),
           variables: T::Array[String],
           request_options: Telnyx::RequestOptions::OrHash
         ).returns(Telnyx::EmailTemplateResponse)
@@ -151,13 +215,20 @@ module Telnyx
       def replace(
         # Email template UUID.
         id,
+        # Per-template HTML autoescaping setting.
+        autoescape: nil,
         # Liquid template HTML body.
         html_body: nil,
         name: nil,
+        # Per-template strict variable-validation setting.
+        strict_variables: nil,
         # Liquid template subject.
         subject: nil,
         # Liquid template text body.
         text_body: nil,
+        # Structured variable requirements. Required variables cannot define defaults;
+        # invalid combinations return 422. Set to `null` to clear the schema.
+        variable_schema: nil,
         variables: nil,
         request_options: {}
       )

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

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,8 +171,6 @@ 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

data/rbi/telnyx/resources/noise_suppression_engines.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    # Noise suppression engines that can be selected when configuring noise
+    # suppression on voice connections.
+    class NoiseSuppressionEngines
+      # Returns all noise suppression engines available to the authenticated user.
+      # Engines gated behind a feature flag are included only when the flag is enabled
+      # for the user's account. Results are not paginated; the number of engines is
+      # expected to remain small.
+      sig do
+        params(request_options: Telnyx::RequestOptions::OrHash).returns(
+          Telnyx::Models::NoiseSuppressionEngineListResponse
+        )
+      end
+      def list(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/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/texml/accounts/calls.rbi

@@ -118,15 +118,15 @@ module Telnyx
             params(
               account_sid: String,
               end_time: String,
-              end_time_gt: String,
               end_time_lt: String,
+              end_time_gt: String,
               from: String,
               page: Integer,
               page_size: Integer,
               page_token: String,
               start_time: String,
-              start_time_gt: String,
               start_time_lt: String,
+              start_time_gt: String,
               status:
                 Telnyx::Texml::Accounts::CallRetrieveCallsParams::Status::OrSymbol,
               to: String,
@@ -140,10 +140,10 @@ module Telnyx
             account_sid,
             # Filters calls by their end date. Expected format is YYYY-MM-DD
             end_time: nil,
-            # Filters calls by their end date (after). Expected format is YYYY-MM-DD
-            end_time_gt: nil,
             # Filters calls by their end date (before). Expected format is YYYY-MM-DD
             end_time_lt: nil,
+            # Filters calls by their end date (after). Expected format is YYYY-MM-DD
+            end_time_gt: nil,
             # Filters calls by the from number.
             from: nil,
             # The number of the page to be displayed, zero-indexed, should be used in
@@ -155,10 +155,10 @@ module Telnyx
             page_token: nil,
             # Filters calls by their start date. Expected format is YYYY-MM-DD.
             start_time: nil,
-            # Filters calls by their start date (after). Expected format is YYYY-MM-DD
-            start_time_gt: nil,
             # Filters calls by their start date (before). Expected format is YYYY-MM-DD
             start_time_lt: nil,
+            # Filters calls by their start date (after). Expected format is YYYY-MM-DD
+            start_time_gt: nil,
             # Filters calls by status.
             status: nil,
             # Filters calls by the to number.