telnyx 5.169.0 → 5.170.0

data/rbi/telnyx/models/wireless_private_wireless_gateway.rbi

@@ -0,0 +1,211 @@
+# typed: strong
+
+module Telnyx
+  module Models
+    class WirelessPrivateWirelessGateway < Telnyx::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Telnyx::WirelessPrivateWirelessGateway,
+            Telnyx::Internal::AnyHash
+          )
+        end
+
+      # The address mode of the private wireless gateway. With static, each SIM card
+      # gets a fixed IP address from the gateway's IP range that is preserved across
+      # sessions. With dynamic, IP addresses are assigned by the network at attach time
+      # and may change between sessions.
+      sig do
+        returns(
+          T.nilable(
+            Telnyx::WirelessPrivateWirelessGateway::AddressMode::TaggedSymbol
+          )
+        )
+      end
+      attr_reader :address_mode
+
+      sig do
+        params(
+          address_mode:
+            Telnyx::WirelessPrivateWirelessGateway::AddressMode::OrSymbol
+        ).void
+      end
+      attr_writer :address_mode
+
+      # A list of the resources that have been assigned to the Private Wireless Gateway.
+      sig { returns(T.nilable(T::Array[Telnyx::PwgAssignedResourcesSummary])) }
+      attr_reader :assigned_resources
+
+      sig do
+        params(
+          assigned_resources:
+            T::Array[Telnyx::PwgAssignedResourcesSummary::OrHash]
+        ).void
+      end
+      attr_writer :assigned_resources
+
+      # The private wireless gateway name.
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      # The identification of the related network resource.
+      sig { returns(T.nilable(String)) }
+      attr_reader :network_id
+
+      sig { params(network_id: String).void }
+      attr_writer :network_id
+
+      # The name of the region where the Private Wireless Gateway is deployed.
+      sig { returns(T.nilable(String)) }
+      attr_reader :region_code
+
+      sig { params(region_code: String).void }
+      attr_writer :region_code
+
+      # The current status or failure details of the Private Wireless Gateway.
+      sig { returns(T.nilable(Telnyx::PrivateWirelessGatewayStatus)) }
+      attr_reader :status
+
+      sig { params(status: Telnyx::PrivateWirelessGatewayStatus::OrHash).void }
+      attr_writer :status
+
+      # Identifies the resource.
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      # ISO 8601 formatted date-time indicating when the resource was created.
+      sig { returns(T.nilable(String)) }
+      attr_reader :created_at
+
+      sig { params(created_at: String).void }
+      attr_writer :created_at
+
+      # IP block used to assign IPs to the SIM cards in the Private Wireless Gateway.
+      sig { returns(T.nilable(String)) }
+      attr_reader :ip_range
+
+      sig { params(ip_range: String).void }
+      attr_writer :ip_range
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :record_type
+
+      sig { params(record_type: String).void }
+      attr_writer :record_type
+
+      # ISO 8601 formatted date-time indicating when the resource was updated.
+      sig { returns(T.nilable(String)) }
+      attr_reader :updated_at
+
+      sig { params(updated_at: String).void }
+      attr_writer :updated_at
+
+      sig do
+        params(
+          id: String,
+          address_mode:
+            Telnyx::WirelessPrivateWirelessGateway::AddressMode::OrSymbol,
+          assigned_resources:
+            T::Array[Telnyx::PwgAssignedResourcesSummary::OrHash],
+          created_at: String,
+          ip_range: String,
+          name: String,
+          network_id: String,
+          record_type: String,
+          region_code: String,
+          status: Telnyx::PrivateWirelessGatewayStatus::OrHash,
+          updated_at: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Identifies the resource.
+        id: nil,
+        # The address mode of the private wireless gateway. With static, each SIM card
+        # gets a fixed IP address from the gateway's IP range that is preserved across
+        # sessions. With dynamic, IP addresses are assigned by the network at attach time
+        # and may change between sessions.
+        address_mode: nil,
+        # A list of the resources that have been assigned to the Private Wireless Gateway.
+        assigned_resources: nil,
+        # ISO 8601 formatted date-time indicating when the resource was created.
+        created_at: nil,
+        # IP block used to assign IPs to the SIM cards in the Private Wireless Gateway.
+        ip_range: nil,
+        # The private wireless gateway name.
+        name: nil,
+        # The identification of the related network resource.
+        network_id: nil,
+        record_type: nil,
+        # The name of the region where the Private Wireless Gateway is deployed.
+        region_code: nil,
+        # The current status or failure details of the Private Wireless Gateway.
+        status: nil,
+        # ISO 8601 formatted date-time indicating when the resource was updated.
+        updated_at: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            address_mode:
+              Telnyx::WirelessPrivateWirelessGateway::AddressMode::TaggedSymbol,
+            assigned_resources: T::Array[Telnyx::PwgAssignedResourcesSummary],
+            created_at: String,
+            ip_range: String,
+            name: String,
+            network_id: String,
+            record_type: String,
+            region_code: String,
+            status: Telnyx::PrivateWirelessGatewayStatus,
+            updated_at: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The address mode of the private wireless gateway. With static, each SIM card
+      # gets a fixed IP address from the gateway's IP range that is preserved across
+      # sessions. With dynamic, IP addresses are assigned by the network at attach time
+      # and may change between sessions.
+      module AddressMode
+        extend Telnyx::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Telnyx::WirelessPrivateWirelessGateway::AddressMode)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        STATIC =
+          T.let(
+            :static,
+            Telnyx::WirelessPrivateWirelessGateway::AddressMode::TaggedSymbol
+          )
+        DYNAMIC =
+          T.let(
+            :dynamic,
+            Telnyx::WirelessPrivateWirelessGateway::AddressMode::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Telnyx::WirelessPrivateWirelessGateway::AddressMode::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/models.rbi

@@ -751,6 +751,8 @@ module Telnyx
 
   EmailDomainRetrieveParams = Telnyx::Models::EmailDomainRetrieveParams
 
+  EmailDomainRotateDkimParams = Telnyx::Models::EmailDomainRotateDkimParams
+
   EmailDomains = Telnyx::Models::EmailDomains
 
   EmailDomainStatus = Telnyx::Models::EmailDomainStatus
@@ -794,6 +796,8 @@ module Telnyx
   EmailMessageDeleteScheduleParams =
     Telnyx::Models::EmailMessageDeleteScheduleParams
 
+  EmailMessageDetailResponse = Telnyx::Models::EmailMessageDetailResponse
+
   EmailMessageListParams = Telnyx::Models::EmailMessageListParams
 
   EmailMessageRetrieveEventsParams =
@@ -803,6 +807,9 @@ module Telnyx
 
   EmailMessages = Telnyx::Models::EmailMessages
 
+  EmailMessageUpdateScheduleParams =
+    Telnyx::Models::EmailMessageUpdateScheduleParams
+
   EmailTemplate = Telnyx::Models::EmailTemplate
 
   EmailTemplateCreateParams = Telnyx::Models::EmailTemplateCreateParams
@@ -850,6 +857,8 @@ module Telnyx
 
   EmailValidations = Telnyx::Models::EmailValidations
 
+  EmailWebhookRecipient = Telnyx::Models::EmailWebhookRecipient
+
   EncryptedMedia = Telnyx::Models::EncryptedMedia
 
   EnterpriseBrandedCallingParams =
@@ -2490,6 +2499,9 @@ module Telnyx
 
   WirelessError = Telnyx::Models::WirelessError
 
+  WirelessPrivateWirelessGateway =
+    Telnyx::Models::WirelessPrivateWirelessGateway
+
   WirelessRetrieveRegionsParams = Telnyx::Models::WirelessRetrieveRegionsParams
 
   WirelessWirelessBlocklist = Telnyx::Models::WirelessWirelessBlocklist

data/rbi/telnyx/resources/ai/assistants/versions.rbi

@@ -80,7 +80,8 @@ module Telnyx
                 ],
               transcription: Telnyx::AI::TranscriptionSettings::OrHash,
               version_name: String,
-              voice_settings: Telnyx::AI::VoiceSettings::OrHash,
+              voice_settings:
+                Telnyx::AI::InferenceEmbeddingVoiceSettings::OrHash,
               widget_settings: Telnyx::AI::WidgetSettings::OrHash,
               request_options: Telnyx::RequestOptions::OrHash
             ).returns(Telnyx::AI::InferenceEmbedding)

data/rbi/telnyx/resources/ai/assistants.rbi

@@ -84,7 +84,7 @@ module Telnyx
                 )
               ],
             transcription: Telnyx::AI::TranscriptionSettings::OrHash,
-            voice_settings: Telnyx::AI::VoiceSettings::OrHash,
+            voice_settings: Telnyx::AI::InferenceEmbeddingVoiceSettings::OrHash,
             widget_settings: Telnyx::AI::WidgetSettings::OrHash,
             idempotency_key: String,
             request_options: Telnyx::RequestOptions::OrHash
@@ -298,7 +298,7 @@ module Telnyx
               ],
             transcription: Telnyx::AI::TranscriptionSettings::OrHash,
             version_name: String,
-            voice_settings: Telnyx::AI::VoiceSettings::OrHash,
+            voice_settings: Telnyx::AI::InferenceEmbeddingVoiceSettings::OrHash,
             widget_settings: Telnyx::AI::WidgetSettings::OrHash,
             request_options: Telnyx::RequestOptions::OrHash
           ).returns(Telnyx::AI::InferenceEmbedding)

data/rbi/telnyx/resources/ai/memory/namespaces/profiles/memories.rbi

@@ -0,0 +1,94 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class AI
+      class Memory
+        class Namespaces
+          class Profiles
+            # What a namespace and a profile hold.
+            class Memories
+              # One memory by its id, as `recall` and the listing return it, together with what
+              # it came from. A fact names its `source_id`: read it with
+              # `GET .../sources/{source_id}` to see what was stored. A memory derived from
+              # other memories names them in `derived_from` instead; read each of those to reach
+              # its source.
+              sig do
+                params(
+                  memory_id: String,
+                  namespace: String,
+                  profile_id: String,
+                  request_options: Telnyx::RequestOptions::OrHash
+                ).returns(
+                  Telnyx::Models::AI::Memory::Namespaces::Profiles::MemoryRetrieveResponse
+                )
+              end
+              def retrieve(
+                # A memory's id, as `recall` and the listing return it.
+                memory_id,
+                # The namespace. `default` exists for every organization.
+                namespace:,
+                # The profile: your identifier for the user, caller or agent this memory is about.
+                profile_id:,
+                request_options: {}
+              )
+              end
+
+              # Everything stored under one profile, unranked -- ask `recall` for the memories
+              # that answer a question. A profile that holds nothing is an empty page rather
+              # than a 404: profiles exist by being written to. Each memory names the
+              # `source_id` it was extracted from, or null for a memory derived from other
+              # memories -- which can read almost the same as the fact it restates. A
+              # `source_id` narrows the listing to the memories extracted from that source, and
+              # a `session_id` to those extracted from the session, which is the same thing
+              # named another way; pass one or the other. Neither is everything the source led
+              # to: a memory derived from several sources belongs to no single one and appears
+              # only in the unfiltered listing. A memory written while the listing is paged
+              # shifts the pages after it, so an entry can be repeated or missed at a page
+              # boundary.
+              sig do
+                params(
+                  profile_id: String,
+                  namespace: String,
+                  page_number: Integer,
+                  page_size: Integer,
+                  session_id: T.nilable(String),
+                  source_id: T.nilable(String),
+                  request_options: Telnyx::RequestOptions::OrHash
+                ).returns(
+                  Telnyx::Internal::DefaultFlatPagination[
+                    Telnyx::Models::AI::Memory::Namespaces::Profiles::MemoryListResponse
+                  ]
+                )
+              end
+              def list(
+                # Path param
+                profile_id,
+                # Path param
+                namespace:,
+                # Query param: The page to return, counting from 1. Bounded in depth:
+                # (page[number] - 1) \* page[size] may be at most 10000.
+                page_number: nil,
+                # Query param: How many results a page holds.
+                page_size: nil,
+                # Query param: An ingested session, by the `session_id` it was ingested with.
+                # Narrows the request to the source that session was stored as.
+                session_id: nil,
+                # Query param: Narrows the listing to the memories extracted from one source, a
+                # remembered fact as well as a session. Pass this or `session_id`, not both.
+                source_id: nil,
+                request_options: {}
+              )
+              end
+
+              # @api private
+              sig { params(client: Telnyx::Client).returns(T.attached_class) }
+              def self.new(client:)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/ai/memory/namespaces/profiles/sources.rbi

@@ -0,0 +1,117 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class AI
+      class Memory
+        class Namespaces
+          class Profiles
+            # What a profile stored, and what its memories came from.
+            class Sources
+              # One source and its content, as it was stored: an ingested session's payload or a
+              # remembered fact. A source whose ingest is still queued answers 404 until it has
+              # been stored.
+              sig do
+                params(
+                  source_id: String,
+                  namespace: String,
+                  profile_id: String,
+                  request_options: Telnyx::RequestOptions::OrHash
+                ).returns(
+                  Telnyx::Models::AI::Memory::Namespaces::Profiles::SourceRetrieveResponse
+                )
+              end
+              def retrieve(
+                # Identifies one source within its profile: an ingested session, or one remembered
+                # fact. Returned by `ingest` and `remember` when the write is accepted.
+                # Re-ingesting a session keeps its source id.
+                source_id,
+                # The namespace. `default` exists for every organization.
+                namespace:,
+                # The profile: your identifier for the user, caller or agent this memory is about.
+                profile_id:,
+                request_options: {}
+              )
+              end
+
+              # Everything a profile has stored and extracts memories from: each ingested
+              # session, and each remembered fact, which has no session. Content is not listed;
+              # read one source for it. A source whose ingest is still queued is not here yet.
+              # Re-ingesting a session moves it to the front, so a listing paged while sessions
+              # are written can repeat or miss one at a page boundary. A `session_id` narrows
+              # the listing to the source that session was stored as: one source or none, and
+              # none -- an empty page, not a 404 -- for a session never ingested, still queued,
+              # or another profile's.
+              sig do
+                params(
+                  profile_id: String,
+                  namespace: String,
+                  page_number: Integer,
+                  page_size: Integer,
+                  session_id: T.nilable(String),
+                  request_options: Telnyx::RequestOptions::OrHash
+                ).returns(
+                  Telnyx::Internal::DefaultFlatPagination[
+                    Telnyx::AI::Collections::Source
+                  ]
+                )
+              end
+              def list(
+                # Path param
+                profile_id,
+                # Path param
+                namespace:,
+                # Query param: The page to return, counting from 1. Bounded in depth:
+                # (page[number] - 1) \* page[size] may be at most 10000.
+                page_number: nil,
+                # Query param: How many results a page holds.
+                page_size: nil,
+                # Query param: An ingested session, by the `session_id` it was ingested with.
+                # Narrows the request to the source that session was stored as.
+                session_id: nil,
+                request_options: {}
+              )
+              end
+
+              # Deletes one source -- an ingested session or a remembered fact -- together with
+              # the memories derived from it. A memory derived from this source and others is
+              # deleted too, and derived again from what remains in the background. It answers
+              # only once the source is gone. A source that is not there -- never stored,
+              # another profile's, or already deleted -- answers 404, so on a `502` or a `504`
+              # repeat the identical request and read a 404 as done. An ingest of the same
+              # session that is still queued is not cancelled, and stores the session again when
+              # it runs. Nothing here can be undone.
+              sig do
+                params(
+                  source_id: String,
+                  namespace: String,
+                  profile_id: String,
+                  request_options: Telnyx::RequestOptions::OrHash
+                ).returns(
+                  Telnyx::Models::AI::Memory::Namespaces::Profiles::SourceDeleteResponse
+                )
+              end
+              def delete(
+                # Identifies one source within its profile: an ingested session, or one remembered
+                # fact. Returned by `ingest` and `remember` when the write is accepted.
+                # Re-ingesting a session keeps its source id.
+                source_id,
+                # The namespace. `default` exists for every organization.
+                namespace:,
+                # The profile: your identifier for the user, caller or agent this memory is about.
+                profile_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
+  end
+end

data/rbi/telnyx/resources/ai/memory/namespaces/profiles.rbi

@@ -0,0 +1,196 @@
+# typed: strong
+
+module Telnyx
+  module Resources
+    class AI
+      class Memory
+        class Namespaces
+          class Profiles
+            # What a namespace and a profile hold.
+            sig do
+              returns(
+                Telnyx::Resources::AI::Memory::Namespaces::Profiles::Memories
+              )
+            end
+            attr_reader :memories
+
+            # What a profile stored, and what its memories came from.
+            sig do
+              returns(
+                Telnyx::Resources::AI::Memory::Namespaces::Profiles::Sources
+              )
+            end
+            attr_reader :sources
+
+            # Profiles are never created, only written to, so this lists the ones that hold a
+            # memory. A profile whose first ingest is still running is not here yet. Ordered
+            # by memory count, largest first, so a profile written to while the listing is
+            # paged can move between pages and be repeated or missed.
+            sig do
+              params(
+                namespace: String,
+                page_number: Integer,
+                page_size: Integer,
+                request_options: Telnyx::RequestOptions::OrHash
+              ).returns(
+                Telnyx::Internal::DefaultFlatPagination[
+                  Telnyx::Models::AI::Memory::Namespaces::ProfileListResponse
+                ]
+              )
+            end
+            def list(
+              namespace,
+              # The page to return, counting from 1. Bounded in depth: (page[number] - 1) \*
+              # page[size] may be at most 10000.
+              page_number: nil,
+              # How many results a page holds.
+              page_size: nil,
+              request_options: {}
+            )
+            end
+
+            # Delete everything held about one profile. A 2xx means none of its memories are
+            # left, and its summary goes with them. There is no undo.
+            sig do
+              params(
+                profile_id: String,
+                namespace: String,
+                request_options: Telnyx::RequestOptions::OrHash
+              ).returns(
+                Telnyx::Models::AI::Memory::Namespaces::ProfileDeleteResponse
+              )
+            end
+            def delete(
+              # The profile: your identifier for the user, caller or agent this memory is about.
+              profile_id,
+              # The namespace. `default` exists for every organization.
+              namespace:,
+              request_options: {}
+            )
+            end
+
+            # Store a session. Facts are extracted from whatever you send — the body is taken
+            # as any JSON value and stored whole, so a framework's own transcript shape works
+            # unchanged. `messages` of `role`/`content` is the conventional shape, not a
+            # requirement. An empty object or a null body is refused. Carry a `session_id` to
+            # name the session: re-ingesting the same one replaces what it held. Omit it and a
+            # session is opened and returned. Extraction runs asynchronously — poll the
+            # returned operation.
+            sig do
+              params(
+                profile_id: String,
+                namespace: String,
+                body:
+                  Telnyx::AI::Memory::Namespaces::ProfileIngestParams::Body::Variants,
+                session_id: T.nilable(String),
+                request_options: Telnyx::RequestOptions::OrHash
+              ).returns(
+                Telnyx::Models::AI::Memory::Namespaces::ProfileIngestResponse
+              )
+            end
+            def ingest(
+              # Path param
+              profile_id,
+              # Path param
+              namespace:,
+              # Body param: The session's messages, in whatever shape your framework produces.
+              # Any JSON value but null is accepted and stored whole, as long as it holds
+              # something to remember: a body with no content anywhere in it -- `{}`, `[]`,
+              # `""`, `{"messages": []}` -- is a 422.
+              body:,
+              # Query param: Names the session. Re-ingesting the same session replaces what it
+              # held and keeps its `source_id`. Omit it to have one derived from the content and
+              # returned. No whitespace, control characters, or any of / \ # ? %.
+              session_id: nil,
+              request_options: {}
+            )
+            end
+
+            # Ranked memories for a question. Matching runs over the profile's memories and
+            # returns them in rank order with a relevance `score`; the score is null where the
+            # deployment's reranker is a passthrough, in which case order is the only signal.
+            # No model runs in this path — recall returns facts, it does not compose an
+            # answer.
+            sig do
+              params(
+                profile_id: String,
+                namespace: String,
+                query: String,
+                top_k: T.nilable(Integer),
+                request_options: Telnyx::RequestOptions::OrHash
+              ).returns(
+                Telnyx::Models::AI::Memory::Namespaces::ProfileRecallResponse
+              )
+            end
+            def recall(
+              # Path param
+              profile_id,
+              # Path param
+              namespace:,
+              # Body param
+              query:,
+              # Body param
+              top_k: nil,
+              request_options: {}
+            )
+            end
+
+            # For a fact the agent has already distilled: `text` is stored as given, with
+            # nothing extracted from it. Send a transcript to `ingest` instead. Remembering
+            # the same text again writes the same memory rather than a second copy of it, so a
+            # retry is safe. The write runs asynchronously -- poll the returned operation.
+            sig do
+              params(
+                profile_id: String,
+                namespace: String,
+                text: String,
+                request_options: Telnyx::RequestOptions::OrHash
+              ).returns(
+                Telnyx::Models::AI::Memory::Namespaces::ProfileRememberResponse
+              )
+            end
+            def remember(
+              # Path param
+              profile_id,
+              # Path param
+              namespace:,
+              # Body param
+              text:,
+              request_options: {}
+            )
+            end
+
+            # The whole profile as one card, precomputed, with no query. Built for the start
+            # of a session, where there is no question to ask yet.
+            #
+            # A summary is generated in the background. `is_stale` tells you newer memories
+            # have arrived since it was written; that is ordinary and the card is still
+            # usable.
+            sig do
+              params(
+                profile_id: String,
+                namespace: String,
+                request_options: Telnyx::RequestOptions::OrHash
+              ).returns(
+                Telnyx::Models::AI::Memory::Namespaces::ProfileRetrieveSummaryResponse
+              )
+            end
+            def retrieve_summary(
+              # The profile: your identifier for the user, caller or agent this memory is about.
+              profile_id,
+              # The namespace. `default` exists for every organization.
+              namespace:,
+              request_options: {}
+            )
+            end
+
+            # @api private
+            sig { params(client: Telnyx::Client).returns(T.attached_class) }
+            def self.new(client:)
+            end
+          end
+        end
+      end
+    end
+  end
+end