telnyx 5.171.0 → 5.174.0

data/lib/telnyx/resources/email/dedicated_ips/actions.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Telnyx
+  module Resources
+    class Email
+      class DedicatedIPs
+        # Purchase and manage dedicated sending IP addresses for your Telnyx email
+        # traffic.
+        class Actions
+          # Manually complete the warm-up ramp (`warming_up` to `active`), bypassing the
+          # schedule. Use only for an IP already warmed elsewhere. Completion sets
+          # `warmup.progress` to `100`, clears `warmup.daily_cap`, and applies the
+          # ramp-complete allowance to the current UTC day: `warmup.today.cap` becomes
+          # `100000000`, `warmup.today.granted` keeps the sends already released today, and
+          # `warmup.today.remaining` becomes `cap` minus `granted`. Once completion applies
+          # this allowance, an exhausted stage allowance does not block the next eligible
+          # first-attempt send. The response reports these values. On an `active` IP,
+          # `warmup.progress` and `warmup.daily_cap` are informational: they can keep
+          # earlier values after a suspension is lifted and do not limit sending.
+          #
+          # @overload complete_warmup(id, request_options: {})
+          #
+          # @param id [String] The dedicated IP identifier (UUID).
+          #
+          # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Telnyx::Models::Email::DedicatedIPShowResponse]
+          #
+          # @see Telnyx::Models::Email::DedicatedIPs::ActionCompleteWarmupParams
+          def complete_warmup(id, params = {})
+            @client.request(
+              method: :post,
+              path: ["email/dedicated_ips/%1$s/actions/complete_warmup", id],
+              model: Telnyx::Email::DedicatedIPShowResponse,
+              options: params[:request_options]
+            )
+          end
+
+          # Pause the warm-up ramp at its current stage. While paused, the IP releases no
+          # first-attempt sends from hold and the ramp does not advance. Only a `warming_up`
+          # IP can be paused; pausing an already paused IP refreshes `paused_at`.
+          #
+          # @overload pause_warmup(id, request_options: {})
+          #
+          # @param id [String] The dedicated IP identifier (UUID).
+          #
+          # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Telnyx::Models::Email::DedicatedIPShowResponse]
+          #
+          # @see Telnyx::Models::Email::DedicatedIPs::ActionPauseWarmupParams
+          def pause_warmup(id, params = {})
+            @client.request(
+              method: :post,
+              path: ["email/dedicated_ips/%1$s/actions/pause_warmup", id],
+              model: Telnyx::Email::DedicatedIPShowResponse,
+              options: params[:request_options]
+            )
+          end
+
+          # Resume a paused warm-up ramp from its held stage. Only a `warming_up` IP can be
+          # resumed; resuming a ramp that is not paused returns the IP unchanged.
+          #
+          # @overload resume_warmup(id, request_options: {})
+          #
+          # @param id [String] The dedicated IP identifier (UUID).
+          #
+          # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Telnyx::Models::Email::DedicatedIPShowResponse]
+          #
+          # @see Telnyx::Models::Email::DedicatedIPs::ActionResumeWarmupParams
+          def resume_warmup(id, params = {})
+            @client.request(
+              method: :post,
+              path: ["email/dedicated_ips/%1$s/actions/resume_warmup", id],
+              model: Telnyx::Email::DedicatedIPShowResponse,
+              options: params[:request_options]
+            )
+          end
+
+          # Start the warm-up ramp (`provisioning` to `warming_up`). The ramp never starts
+          # automatically. Only a `provisioning` IP can be started; a `suspended` IP returns
+          # `409`. Starting does not check DNS: the IP carries mail only while
+          # `dns_confirmed_at` is set and the IP is in a pool that routes mail.
+          #
+          # @overload start_warmup(id, request_options: {})
+          #
+          # @param id [String] The dedicated IP identifier (UUID).
+          #
+          # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Telnyx::Models::Email::DedicatedIPShowResponse]
+          #
+          # @see Telnyx::Models::Email::DedicatedIPs::ActionStartWarmupParams
+          def start_warmup(id, params = {})
+            @client.request(
+              method: :post,
+              path: ["email/dedicated_ips/%1$s/actions/start_warmup", id],
+              model: Telnyx::Email::DedicatedIPShowResponse,
+              options: params[:request_options]
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Telnyx::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/telnyx/resources/email/dedicated_ips.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module Telnyx
+  module Resources
+    class Email
+      # Purchase and manage dedicated sending IP addresses for your Telnyx email
+      # traffic.
+      class DedicatedIPs
+        # Purchase and manage dedicated sending IP addresses for your Telnyx email
+        # traffic.
+        # @return [Telnyx::Resources::Email::DedicatedIPs::Actions]
+        attr_reader :actions
+
+        # Some parameter documentations has been truncated, see
+        # {Telnyx::Models::Email::DedicatedIPCreateParams} for more details.
+        #
+        # Purchase a dedicated sending IP. Requires a verified, enterprise, or legacy
+        # account, and an `Idempotency-Key` header: a request without the header returns
+        # `400` (code `10015`) and allocates nothing. Telnyx allocates the next available
+        # IP from stock. The optional `region` and `ip_version` fields each restrict which
+        # stock IP is allocated; they never change the allocated IP's metadata. An omitted
+        # field applies no restriction for that field, and omitting the body applies
+        # neither restriction. An unsupported selector value returns `422`; a supported
+        # value that matches no available IP returns `429` and records the request on the
+        # waitlist. Billing: $14/month/IP, charged as a monthly recurring charge (MRC)
+        # from purchase. The IP is returned in `provisioning` status with a Telnyx-managed
+        # PTR hostname and carries no mail until you call `start_warmup` and add it to a
+        # pool that routes mail.
+        #
+        # @overload create(idempotency_key:, ip_version: nil, region: nil, request_options: {})
+        #
+        # @param idempotency_key [String] Header param: Required. Opaque, unquoted key for safely retrying the same purcha
+        #
+        # @param ip_version [Symbol, Telnyx::Models::Email::DedicatedIPCreateParams::IPVersion] Body param: Allocate an IP of this address family. Supported value: `ipv4`. Any
+        #
+        # @param region [Symbol, Telnyx::Models::Email::DedicatedIPCreateParams::Region] Body param: Allocate an IP in this region. Supported value: `ewr-nj1`. Any other
+        #
+        # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Telnyx::Models::Email::DedicatedIPShowResponse]
+        #
+        # @see Telnyx::Models::Email::DedicatedIPCreateParams
+        def create(params)
+          parsed, options = Telnyx::Email::DedicatedIPCreateParams.dump_request(params)
+          header_params = {idempotency_key: "idempotency-key"}
+          @client.request(
+            method: :post,
+            path: "email/dedicated_ips",
+            headers: parsed.slice(*header_params.keys).transform_keys(header_params),
+            body: parsed.except(*header_params.keys),
+            model: Telnyx::Email::DedicatedIPShowResponse,
+            options: options
+          )
+        end
+
+        # Retrieve a single dedicated IP by its identifier, including warm-up state,
+        # billing state, and the DNS/PTR provisioning checklist.
+        #
+        # @overload retrieve(id, request_options: {})
+        #
+        # @param id [String] The dedicated IP identifier (UUID).
+        #
+        # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Telnyx::Models::Email::DedicatedIPShowResponse]
+        #
+        # @see Telnyx::Models::Email::DedicatedIPRetrieveParams
+        def retrieve(id, params = {})
+          @client.request(
+            method: :get,
+            path: ["email/dedicated_ips/%1$s", id],
+            model: Telnyx::Email::DedicatedIPShowResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Telnyx::Models::Email::DedicatedIPUpdateParams} for more details.
+        #
+        # Move the IP to another pool, or pause/resume its warm-up ramp. One change
+        # applies per request. `pool_id` takes precedence over warm-up changes. Otherwise,
+        # use `warmup_paused` or `warmup.paused`; a Boolean `warmup_paused` takes
+        # precedence. Moving the last IP out of a pool requires `force: true` and
+        # `drain: true`. The PTR hostname is managed by Telnyx: a request that includes
+        # `ptr_hostname` returns `422` unless `pool_id` or a warm-up field is present, in
+        # which case `ptr_hostname` is ignored.
+        #
+        # @overload update(id, drain: nil, force: nil, pool_id: nil, warmup: nil, warmup_paused: nil, weight: nil, request_options: {})
+        #
+        # @param id [String] The dedicated IP identifier (UUID).
+        #
+        # @param drain [Boolean] Set together with `force: true` to move the last IP out of its current pool. Ack
+        #
+        # @param force [Boolean] Set together with `drain: true` to move the last IP out of its current pool. Use
+        #
+        # @param pool_id [String] Move the IP to this pool, replacing its current membership. Use the IP's current
+        #
+        # @param warmup [Telnyx::Models::Email::DedicatedIPUpdateParams::Warmup] Alias for `warmup_paused`.
+        #
+        # @param warmup_paused [Boolean] Pause (`true`) or resume (`false`) the warm-up ramp; equivalent to the `pause_wa
+        #
+        # @param weight [Integer] Routing weight in the target pool. Used only with `pool_id`.
+        #
+        # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Telnyx::Models::Email::DedicatedIPShowResponse]
+        #
+        # @see Telnyx::Models::Email::DedicatedIPUpdateParams
+        def update(id, params = {})
+          parsed, options = Telnyx::Email::DedicatedIPUpdateParams.dump_request(params)
+          @client.request(
+            method: :patch,
+            path: ["email/dedicated_ips/%1$s", id],
+            body: parsed,
+            model: Telnyx::Email::DedicatedIPShowResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Telnyx::Models::Email::DedicatedIPListParams} for more details.
+        #
+        # List the dedicated sending IPs owned by the account, newest first. Narrow the
+        # list with `filter[status]`, `filter[pool_id]`, and `filter[region]`; supplied
+        # filters combine, so an IP must match every one. An empty value, or a nested or
+        # array value such as `filter[status][]=active`, applies no filter, and other
+        # `filter[...]` keys are ignored. A value that no IP can match (an unknown status,
+        # a `pool_id` that is not a UUID, or a value containing a NUL byte) returns an
+        # empty list, not an error.
+        #
+        # @overload list(filter_pool_id: nil, filter_region: nil, filter_status: nil, request_options: {})
+        #
+        # @param filter_pool_id [String] Return only IPs in this pool (exact match on `pool_id`). A value that is not a U
+        #
+        # @param filter_region [String] Return only IPs in this region (exact, case-sensitive match on `region`). An emp
+        #
+        # @param filter_status [Symbol, Telnyx::Models::Email::DedicatedIPListParams::FilterStatus] Return only IPs in this lifecycle status (exact match). Any other value returns
+        #
+        # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Telnyx::Models::Email::DedicatedIPListResponse]
+        #
+        # @see Telnyx::Models::Email::DedicatedIPListParams
+        def list(params = {})
+          parsed, options = Telnyx::Email::DedicatedIPListParams.dump_request(params)
+          query = Telnyx::Internal::Util.encode_query_params(parsed)
+          @client.request(
+            method: :get,
+            path: "email/dedicated_ips",
+            query: query.transform_keys(
+              filter_pool_id: "filter[pool_id]",
+              filter_region: "filter[region]",
+              filter_status: "filter[status]"
+            ),
+            model: Telnyx::Models::Email::DedicatedIPListResponse,
+            options: options
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Telnyx::Models::Email::DedicatedIPDeleteParams} for more details.
+        #
+        # Release the dedicated IP to Telnyx. The IP stops carrying mail immediately,
+        # leaves its pool, and moves to `released`. Telnyx sets `quarantine_until` to 30
+        # days after release. Release requests that the MRC stop asynchronously. Check
+        # `billing`: `stopping` means the stop is pending, `stopped` means it completed,
+        # and `stop_failed` means the charge remains. If the charge was never created or
+        # its creation has not completed, `billing` keeps showing the creation status
+        # (`not_started`, `pending`, `in_progress`, or `failed`). Any status except
+        # `released` can be released. Releasing the last IP in a pool requires
+        # `force=true` and `drain=true`.
+        #
+        # @overload delete(id, body_drain: nil, body_force: nil, body_reason: nil, request_options: {})
+        #
+        # @param id [String] Path param: The dedicated IP identifier (UUID).
+        #
+        # @param body_drain [Boolean] Body param: Set together with `force: true` to release the last IP in a pool. Ac
+        #
+        # @param body_force [Boolean] Body param: Set together with `drain: true` to release the last IP in a pool. Ei
+        #
+        # @param body_reason [String] Body param: Free-text reason recorded with the release.
+        #
+        # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Telnyx::Models::Email::DedicatedIPShowResponse]
+        #
+        # @see Telnyx::Models::Email::DedicatedIPDeleteParams
+        def delete(id, params = {})
+          query_params = [:query_drain, :query_force, :query_reason]
+          parsed, options = Telnyx::Email::DedicatedIPDeleteParams.dump_request(params)
+          query = Telnyx::Internal::Util.encode_query_params(parsed.slice(*query_params))
+          @client.request(
+            method: :delete,
+            path: ["email/dedicated_ips/%1$s", id],
+            query: query.transform_keys(query_drain: "drain", query_force: "force", query_reason: "reason"),
+            body: parsed.except(*query_params),
+            model: Telnyx::Email::DedicatedIPShowResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Telnyx::Client]
+        def initialize(client:)
+          @client = client
+          @actions = Telnyx::Resources::Email::DedicatedIPs::Actions.new(client: client)
+        end
+      end
+    end
+  end
+end

data/lib/telnyx/resources/email/ip_pools/ips.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Telnyx
+  module Resources
+    class Email
+      class IPPools
+        # Group dedicated IPs into pools for sending.
+        class IPs
+          # Some parameter documentations has been truncated, see
+          # {Telnyx::Models::Email::IPPools::IPCreateParams} for more details.
+          #
+          # Add a dedicated IP to the pool with an optional routing weight. An IP can belong
+          # to one pool; to move an IP that is already in a pool, use
+          # `PATCH /email/dedicated_ips/{id}` with `pool_id`.
+          #
+          # @overload create(id, dedicated_ip_id:, weight: nil, request_options: {})
+          #
+          # @param id [String] The IP pool identifier (UUID).
+          #
+          # @param dedicated_ip_id [String] The dedicated IP to add. It must belong to the account, must not be released, an
+          #
+          # @param weight [Integer] Relative routing weight for this IP in the pool. Positive integer; defaults to 1
+          #
+          # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Telnyx::Models::Email::IPPools::IPCreateResponse]
+          #
+          # @see Telnyx::Models::Email::IPPools::IPCreateParams
+          def create(id, params)
+            parsed, options = Telnyx::Email::IPPools::IPCreateParams.dump_request(params)
+            @client.request(
+              method: :post,
+              path: ["email/ip_pools/%1$s/ips", id],
+              body: parsed,
+              model: Telnyx::Models::Email::IPPools::IPCreateResponse,
+              options: options
+            )
+          end
+
+          # Some parameter documentations has been truncated, see
+          # {Telnyx::Models::Email::IPPools::IPDeleteParams} for more details.
+          #
+          # Remove the dedicated IP from the pool. The IP is kept but carries no mail until
+          # added to a pool again. Removing the last IP requires `force=true` and
+          # `drain=true`.
+          #
+          # @overload delete(ip_id, id:, drain: nil, force: nil, request_options: {})
+          #
+          # @param ip_id [String] Path param: The dedicated IP identifier (UUID).
+          #
+          # @param id [String] Path param: The IP pool identifier (UUID).
+          #
+          # @param drain [Boolean] Query param: Set together with `force=true` to remove the last IP in the pool. A
+          #
+          # @param force [Boolean] Query param: Set together with `drain=true` to remove the last IP in the pool. E
+          #
+          # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [nil]
+          #
+          # @see Telnyx::Models::Email::IPPools::IPDeleteParams
+          def delete(ip_id, params)
+            parsed, options = Telnyx::Email::IPPools::IPDeleteParams.dump_request(params)
+            query = Telnyx::Internal::Util.encode_query_params(parsed)
+            id =
+              parsed.delete(:id) do
+                raise ArgumentError.new("missing required path argument #{_1}")
+              end
+            @client.request(
+              method: :delete,
+              path: ["email/ip_pools/%1$s/ips/%2$s", id, ip_id],
+              query: query,
+              model: NilClass,
+              options: options
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Telnyx::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/telnyx/resources/email/ip_pools.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Telnyx
+  module Resources
+    class Email
+      # Group dedicated IPs into pools for sending.
+      class IPPools
+        # Group dedicated IPs into pools for sending.
+        # @return [Telnyx::Resources::Email::IPPools::IPs]
+        attr_reader :ips
+
+        # Some parameter documentations has been truncated, see
+        # {Telnyx::Models::Email::IPPoolCreateParams} for more details.
+        #
+        # Create an account-scoped pool of dedicated IPs. Set `is_default` or `domain_id`
+        # for the pool to carry mail; a pool with neither carries none.
+        #
+        # @overload create(name:, domain_id: nil, is_default: nil, request_options: {})
+        #
+        # @param name [String] Pool name: 1-64 characters of lowercase letters, digits, `.`, `_`, and `-`, star
+        #
+        # @param domain_id [String] Scope the pool to one of the account's email domains; the pool then carries that
+        #
+        # @param is_default [Boolean] Make this the account's default pool, which carries mail for sending domains wit
+        #
+        # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Telnyx::Models::Email::IPPoolShowResponse]
+        #
+        # @see Telnyx::Models::Email::IPPoolCreateParams
+        def create(params)
+          parsed, options = Telnyx::Email::IPPoolCreateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "email/ip_pools",
+            body: parsed,
+            model: Telnyx::Email::IPPoolShowResponse,
+            options: options
+          )
+        end
+
+        # Retrieve a single IP pool by its identifier, including its dedicated-IP members
+        # with billing state.
+        #
+        # @overload retrieve(id, request_options: {})
+        #
+        # @param id [String] The IP pool identifier (UUID).
+        #
+        # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Telnyx::Models::Email::IPPoolShowResponse]
+        #
+        # @see Telnyx::Models::Email::IPPoolRetrieveParams
+        def retrieve(id, params = {})
+          @client.request(
+            method: :get,
+            path: ["email/ip_pools/%1$s", id],
+            model: Telnyx::Email::IPPoolShowResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Telnyx::Models::Email::IPPoolUpdateParams} for more details.
+        #
+        # Rename the pool, set or clear the default flag, or change its domain scope.
+        # Routing follows the new settings for subsequent mail.
+        #
+        # @overload update(id, domain_id: nil, is_default: nil, name: nil, request_options: {})
+        #
+        # @param id [String] The IP pool identifier (UUID).
+        #
+        # @param domain_id [String, nil] Scope the pool to one of the account's email domains, or `null` to remove the sc
+        #
+        # @param is_default [Boolean] Set or clear the account default flag. An account can have one default pool.
+        #
+        # @param name [String] Pool name: 1-64 characters of lowercase letters, digits, `.`, `_`, and `-`, star
+        #
+        # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Telnyx::Models::Email::IPPoolShowResponse]
+        #
+        # @see Telnyx::Models::Email::IPPoolUpdateParams
+        def update(id, params = {})
+          parsed, options = Telnyx::Email::IPPoolUpdateParams.dump_request(params)
+          @client.request(
+            method: :patch,
+            path: ["email/ip_pools/%1$s", id],
+            body: parsed,
+            model: Telnyx::Email::IPPoolShowResponse,
+            options: options
+          )
+        end
+
+        # List the account's dedicated-IP pools. Member IPs are not included (`ips` is
+        # empty); retrieve a pool to see its members.
+        #
+        # @overload list(request_options: {})
+        #
+        # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Telnyx::Models::Email::IPPoolListResponse]
+        #
+        # @see Telnyx::Models::Email::IPPoolListParams
+        def list(params = {})
+          @client.request(
+            method: :get,
+            path: "email/ip_pools",
+            model: Telnyx::Models::Email::IPPoolListResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Telnyx::Models::Email::IPPoolDeleteParams} for more details.
+        #
+        # Delete the pool. Member IPs are kept but leave the pool, so they carry no mail
+        # until added to another pool. Deleting a pool changes routing for subsequently
+        # resolved messages. It does not reroute messages already assigned to the deleted
+        # pool. Deleting a pool that still has IPs requires `force=true` and `drain=true`.
+        #
+        # @overload delete(id, drain: nil, force: nil, request_options: {})
+        #
+        # @param id [String] The IP pool identifier (UUID).
+        #
+        # @param drain [Boolean] Set together with `force=true` to delete a pool that still has IPs. Acknowledges
+        #
+        # @param force [Boolean] Set together with `drain=true` to delete a pool that still has IPs. Either flag
+        #
+        # @param request_options [Telnyx::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [nil]
+        #
+        # @see Telnyx::Models::Email::IPPoolDeleteParams
+        def delete(id, params = {})
+          parsed, options = Telnyx::Email::IPPoolDeleteParams.dump_request(params)
+          query = Telnyx::Internal::Util.encode_query_params(parsed)
+          @client.request(
+            method: :delete,
+            path: ["email/ip_pools/%1$s", id],
+            query: query,
+            model: NilClass,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Telnyx::Client]
+        def initialize(client:)
+          @client = client
+          @ips = Telnyx::Resources::Email::IPPools::IPs.new(client: client)
+        end
+      end
+    end
+  end
+end

data/lib/telnyx/resources/email.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Telnyx
+  module Resources
+    class Email
+      # Purchase and manage dedicated sending IP addresses for your Telnyx email
+      # traffic.
+      # @return [Telnyx::Resources::Email::DedicatedIPs]
+      attr_reader :dedicated_ips
+
+      # Group dedicated IPs into pools for sending.
+      # @return [Telnyx::Resources::Email::IPPools]
+      attr_reader :ip_pools
+
+      # @api private
+      #
+      # @param client [Telnyx::Client]
+      def initialize(client:)
+        @client = client
+        @dedicated_ips = Telnyx::Resources::Email::DedicatedIPs.new(client: client)
+        @ip_pools = Telnyx::Resources::Email::IPPools.new(client: client)
+      end
+    end
+  end
+end

data/lib/telnyx/resources/email_templates.rb

@@ -23,7 +23,7 @@ module Telnyx
       #
       # @param text_body [String, nil] Body param: Liquid template text body.
       #
-      # @param variable_schema [Hash{Symbol=>Telnyx::Models::EmailTemplateCreateParams::VariableSchema}, nil] Body param: Structured variable requirements. Required variables cannot define d
+      # @param variable_schema [Hash{Symbol=>Telnyx::Models::VariableSchemaEntry}, nil] Body param: Structured variable requirements. Required variables cannot define d
       #
       # @param variables [Array<String>, nil] Body param: Persisted variable names. In `automatic` mode a non-null array is re
       #
@@ -92,7 +92,7 @@ module Telnyx
       #
       # @param text_body [String, nil] Liquid template text body.
       #
-      # @param variable_schema [Hash{Symbol=>Telnyx::Models::UpdateEmailTemplateRequest::VariableSchema}, nil] Structured variable requirements. Required variables cannot define defaults; inv
+      # @param variable_schema [Hash{Symbol=>Telnyx::Models::VariableSchemaEntry}, nil] Structured variable requirements. Required variables cannot define defaults; inv
       #
       # @param variables [Array<String>, nil] Persisted variable names. In `automatic` mode a non-null array is rejected; in `
       #
@@ -237,7 +237,7 @@ module Telnyx
       #
       # @param text_body [String, nil] Liquid template text body.
       #
-      # @param variable_schema [Hash{Symbol=>Telnyx::Models::UpdateEmailTemplateRequest::VariableSchema}, nil] Structured variable requirements. Required variables cannot define defaults; inv
+      # @param variable_schema [Hash{Symbol=>Telnyx::Models::VariableSchemaEntry}, nil] Structured variable requirements. Required variables cannot define defaults; inv
       #
       # @param variables [Array<String>, nil] Persisted variable names. In `automatic` mode a non-null array is rejected; in `
       #

data/lib/telnyx/resources/enterprises/verify_email.rb

@@ -4,7 +4,7 @@ module Telnyx
   module Resources
     class Enterprises
       # Verify ownership of a DIR's authorizer email. A short code is emailed and
-      # confirmed; the email must be verified before references can be submitted.
+      # confirmed.
       class VerifyEmail
         # Email a 6-digit code to the enterprise account's contact email to confirm
         # ownership of that address.

data/lib/telnyx/resources/enterprises.rb

@@ -14,7 +14,7 @@ module Telnyx
       attr_reader :dir
 
       # Verify ownership of a DIR's authorizer email. A short code is emailed and
-      # confirmed; the email must be verified before references can be submitted.
+      # confirmed.
       # @return [Telnyx::Resources::Enterprises::VerifyEmail]
       attr_reader :verify_email