telnyx 5.170.0 → 5.173.0

data/rbi/telnyx/resources/dir/references.rbi

@@ -6,24 +6,35 @@ module Telnyx
       # Submit and manage the two business references and one financial reference that
       # vouch for a DIR. References are contacted to confirm the business identity
       # during vetting.
+      #
+      # References (two business references and one financial reference) are needed only
+      # if the documents uploaded with the DIR don't already prove the business is
+      # legitimate and financially stable. Any one of these is enough proof: audited or
+      # certified financial statements (uploaded as `other`, with a description), a
+      # commercial credit report (uploaded as `business_credit_report`), or references.
+      # Telnyx reviewers decide during vetting whether your documents are enough.
       class References
         # Submit the two business references and one financial reference for a DIR.
         #
-        # The DIR's authorizer email must be verified first (see the email-verification
-        # endpoint). Until it is, this returns `409` and no references are stored.
+        # References (two business references and one financial reference) are needed only
+        # if the documents uploaded with the DIR don't already prove the business is
+        # legitimate and financially stable. Any one of these is enough proof: audited or
+        # certified financial statements (uploaded as `other`, with a description), a
+        # commercial credit report (uploaded as `business_credit_report`), or references.
+        # Telnyx reviewers decide during vetting whether your documents are enough.
+        #
+        # References can't be changed while the DIR is `verified`. Update the DIR first,
+        # which returns it to draft.
         #
         # The request body carries exactly two business references plus one financial
         # reference. The first submission stores them and returns `201`. Resubmitting
         # returns `200`: identical values are simply confirmed and nothing is written,
         # while changed values replace those references.
         #
-        # Replacing a reference is allowed only while the DIR itself is still editable,
-        # the same window in which a single reference may be updated; once the DIR has
-        # been submitted for vetting this returns `400`. A replaced reference's pending
-        # verification call is cancelled and its dial-in code stops working, and the
-        # replacement contact is emailed fresh scheduling details. References whose
-        # details did not change keep their existing call, code, and the notice already
-        # sent to them.
+        # A replaced reference's pending verification call is cancelled and its dial-in
+        # code stops working, and the replacement contact is emailed fresh scheduling
+        # details. References whose details did not change keep their existing call, code,
+        # and the notice already sent to them.
         #
         # The response always echoes the stored references in the same shape as the GET.
         #
@@ -96,19 +107,22 @@ module Telnyx
           dir_id:,
           # Path param: Reference type to address.
           ref_type:,
-          # Body param: Reference contact email address.
+          # Body param: The reference's email address. We email them scheduling and dial-in
+          # instructions before we call, so use an address they check.
           email: nil,
-          # Body param: Full name of the reference contact.
+          # Body param: The full name of the person we should contact as your reference.
           full_name: nil,
-          # Body param: Job title of the reference contact.
+          # Body param: The reference contact's job title, for example CFO or Owner.
           job_title: nil,
-          # Body param: Organization the reference contact belongs to.
+          # Body param: The name of the organization the reference contact works for.
           organization: nil,
-          # Body param: Reference phone number in E.164 format.
+          # Body param: The reference's phone number in E.164 format, for example
+          # +14155550123. We call this number during their local business hours.
           phone_e164: nil,
           # Body param: How the reference contact is related to the registering business.
           relationship_to_registrant: nil,
-          # Body param: IANA timezone id for the reference.
+          # Body param: The reference's IANA time zone, for example America/New_York. We
+          # only call during their local 8am to 9pm hours, which is why we need it.
           timezone: nil,
           request_options: {}
         )

data/rbi/telnyx/resources/dir/verify_email.rbi

@@ -4,14 +4,26 @@ module Telnyx
   module Resources
     class 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.
       class VerifyEmail
         # Email a 6-digit code to the DIR's authorizer email to confirm ownership of that
-        # address.
+        # address. The code goes to the authorizer, not to the caller. If the authorizer
+        # is someone else (for example a client's executive), that person has to share the
+        # code with whoever is completing setup.
         #
-        # The code expires in 15 minutes. Requesting a new code invalidates any previous
-        # one. Resends are rate limited (a short cooldown plus a daily cap). Submit the
-        # code to `POST /dir/{dir_id}/verify_email/confirm`.
+        # How long the code lasts: 15 minutes by default. 8 hours when the DIR has a call
+        # center (BPO) linked through `bpo_authorizations` whose authorization is pending
+        # review or approved (a rejected authorization does not count). Link the call
+        # center before you send the code: a code sent before the link keeps the 15-minute
+        # window, and a code sent after the link lasts 8 hours. The email states the
+        # window, and `expires_at` in the response always shows the exact expiry.
+        #
+        # To resend, call this endpoint again. Each send issues a fresh code and
+        # invalidates the previous one. Sends are limited to one every 60 seconds and 10
+        # per DIR per UTC day. A throttled send returns `429` with `retry_after_secs` and
+        # `sends_remaining_today` in the error `meta`.
+        #
+        # Submit the code to `POST /dir/{dir_id}/verify_email/confirm`.
         sig do
           params(
             dir_id: String,

data/rbi/telnyx/resources/dir.rbi

@@ -21,11 +21,18 @@ module Telnyx
       # Submit and manage the two business references and one financial reference that
       # vouch for a DIR. References are contacted to confirm the business identity
       # during vetting.
+      #
+      # References (two business references and one financial reference) are needed only
+      # if the documents uploaded with the DIR don't already prove the business is
+      # legitimate and financially stable. Any one of these is enough proof: audited or
+      # certified financial statements (uploaded as `other`, with a description), a
+      # commercial credit report (uploaded as `business_credit_report`), or references.
+      # Telnyx reviewers decide during vetting whether your documents are enough.
       sig { returns(Telnyx::Resources::Dir::References) }
       attr_reader :references
 
       # 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.
       sig { returns(Telnyx::Resources::Dir::VerifyEmail) }
       attr_reader :verify_email
 
@@ -47,17 +54,21 @@ module Telnyx
       # Edit a DIR. DIRs in `draft`, `rejected`, `unsuccessful`, or `suspended` can be
       # edited freely: PATCH is a pure edit, `status` is never changed, and you re-vet
       # by calling `POST /v2/dir/{dir_id}/submit` explicitly. A `verified` DIR can also
-      # be edited in place: a PATCH that changes any value returns the DIR to `draft`
-      # and branded delivery stops until you re-submit and the DIR is approved again,
-      # while a PATCH that changes nothing (an empty body or values identical to the
-      # current ones) leaves the DIR `verified`, so idempotent retries are safe. DIRs in
-      # any other status (`submitted`, `in_review`, `expired`, `infringement_claimed`,
+      # be edited in place: a PATCH that changes any value returns the DIR to `draft`;
+      # the currently approved identity keeps displaying, and the edited content goes
+      # live only after you re-submit and the DIR is approved again. A PATCH that
+      # changes nothing (an empty body or values identical to the current ones) leaves
+      # the DIR `verified`, so idempotent retries are safe. Changing only
+      # `bpo_authorizations` or `webhook_url` is the exception: the DIR stays
+      # `verified`. Each BPO authorization is reviewed on its own instead. DIRs in any
+      # other status (`submitted`, `in_review`, `expired`, `infringement_claimed`,
       # `permanently_rejected`) cannot be edited.
       sig do
         params(
           dir_id: String,
           authorizer_email: String,
           authorizer_name: String,
+          bpo_authorizations: T::Array[Telnyx::BpoAuthorizationInput::OrHash],
           call_reasons: T::Array[String],
           certify_brand_is_accurate: T::Boolean,
           certify_ip_ownership: T::Boolean,
@@ -66,6 +77,7 @@ module Telnyx
           documents: T::Array[Telnyx::Document::OrHash],
           logo_url: String,
           reselling: T::Boolean,
+          webhook_url: T.nilable(String),
           request_options: Telnyx::RequestOptions::OrHash
         ).returns(Telnyx::DirWrapped)
       end
@@ -78,6 +90,13 @@ module Telnyx
         # Name of the person at your enterprise authorizing this DIR. Must be a real
         # individual.
         authorizer_name: nil,
+        # Optional. Replace this DIR's authorized BPO (Business Process Outsourcer)
+        # accounts with these, each with its signed Letter of Authorization. The supplied
+        # list replaces the current one: a BPO left out has its authorization removed, and
+        # a new BPO (or a changed Letter of Authorization) is created `pending` admin
+        # review. Send an empty list to clear all authorizations; omit the field to leave
+        # them unchanged. Editing this list does not re-vet the DIR. Maximum 10.
+        bpo_authorizations: nil,
         # 1–10 reasons your business calls customers. Validate phrasing against
         # `POST /call_reasons/validate`.
         call_reasons: nil,
@@ -102,6 +121,10 @@ module Telnyx
         # Set to true if your organization places calls on behalf of other enterprises
         # (BPO/reseller). Updating this triggers re-vetting on next submit.
         reselling: nil,
+        # Optional `https://` URL that receives webhook notifications when this DIR's
+        # compliance review completes. Send `null` to clear. Changing only this field on a
+        # `verified` DIR does not re-vet it. Maximum 2048 characters.
+        webhook_url: nil,
         request_options: {}
       )
       end
@@ -153,14 +176,18 @@ module Telnyx
       )
       end
 
-      # Delete a DIR. Failure modes: `400` if a child phone number is in a non-deletable
-      # status, `409` if the DIR has an unresolved infringement claim, `404` if the DIR
-      # is not yours.
+      # Request deletion of a DIR. This does not remove the DIR on this call: it records
+      # the request, moves the DIR to `delete_requested`, and Telnyx completes the
+      # removal (de-registration and cleanup) shortly after. A verified DIR keeps
+      # serving its branded identity, and keeps billing, until the removal is executed.
+      # Failure modes: `400` if a child phone number is still attached or the DIR is
+      # `in_review` (wait for the review to finish), `409` if the DIR has an unresolved
+      # infringement claim, `404` if the DIR is not yours.
       sig do
         params(
           dir_id: String,
           request_options: Telnyx::RequestOptions::OrHash
-        ).void
+        ).returns(Telnyx::Models::DirDeleteResponse)
       end
       def delete(
         # The DIR id. Lowercase UUID.
@@ -169,6 +196,40 @@ module Telnyx
       )
       end
 
+      # The Letter of Authorization in which a Brand Owner authorizes an approved BPO
+      # (Business Process Outsourcer) to place branded calls that display this DIR on
+      # the owner's behalf. Both parties are read from the caller's account: the Brand
+      # Owner is the enterprise that owns the DIR, and the BPO is `bpo_enterprise_id`.
+      # No business identity is accepted in the body.
+      #
+      # When `signature` is omitted the PDF is returned unsigned so the Brand Owner can
+      # sign it externally and the BPO can upload it via the Documents API. When
+      # `signature` is present the PDF embeds the supplied image, printed name, and
+      # signed-at date.
+      #
+      # Returns `application/pdf`.
+      sig do
+        params(
+          dir_id: String,
+          bpo_enterprise_id: String,
+          signature: Telnyx::SignaturePayload::OrHash,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(StringIO)
+      end
+      def bpo_loa(
+        # The DIR id.
+        dir_id,
+        # The approved BPO enterprise the Brand Owner is authorizing. Must be a BPO
+        # account on the caller's organization that has already been approved.
+        bpo_enterprise_id:,
+        # Optional. When provided the rendered PDF embeds the signature image, printed
+        # name, and signed-at date. When absent the PDF is returned unsigned so the Brand
+        # Owner can sign externally and the BPO can upload it via the Documents API.
+        signature: nil,
+        request_options: {}
+      )
+      end
+
       # Reference list of `document_type` values accepted by
       # `DirCreateRequest.documents[].document_type` and the infringement-contest
       # endpoint. Each entry has a stable `short_name` (used in API calls) and a
@@ -223,7 +284,7 @@ module Telnyx
           dir_id: String,
           phone_numbers: T::Array[String],
           agent: Telnyx::Enterprises::Reputation::AgentInput::OrHash,
-          signature: Telnyx::DirNewLoaParams::Signature::OrHash,
+          signature: Telnyx::SignaturePayload::OrHash,
           request_options: Telnyx::RequestOptions::OrHash
         ).returns(StringIO)
       end
@@ -233,8 +294,9 @@ module Telnyx
         # Telephone numbers to authorize on the DIR, in `+E164` format (`+` followed by
         # 10-15 digits). Max 15 per request.
         phone_numbers:,
-        # Third-party reseller / partner managing the enterprise's phone numbers. Omit
-        # when the enterprise works directly with Telnyx.
+        # Third-party reseller / partner managing the enterprise's phone numbers on its
+        # behalf, such as a call center (BPO) acting for a client. Omit when the
+        # enterprise manages its own numbers.
         agent: nil,
         # Optional. When provided the rendered PDF embeds the signature image, printed
         # name, and signed-at date. When absent the PDF is returned unsigned so the
@@ -244,6 +306,37 @@ module Telnyx
       )
       end
 
+      # List the BPO (Business Process Outsourcer) accounts a Brand Owner has authorized
+      # on this DIR, together with the review state of each authorization.
+      #
+      # Authorizations are supplied as the `bpo_authorizations` array when creating or
+      # updating a DIR, and each one is reviewed on its own. Only an `approved`
+      # authorization adds that BPO to this DIR's authorized callers in the branded
+      # calling registry; `pending` and `rejected` authorizations do not. Each entry
+      # includes the `loa_document_id` you submitted: because `bpo_authorizations`
+      # replaces the whole list on every DIR update, send each entry you want to keep
+      # back with its `loa_document_id` unchanged, and it keeps its review state. A
+      # rejected entry carries a `rejection_reason`. Returns an empty list when the DIR
+      # has authorized no BPOs.
+      sig do
+        params(
+          dir_id: String,
+          page_number: Integer,
+          page_size: Integer,
+          request_options: Telnyx::RequestOptions::OrHash
+        ).returns(Telnyx::Models::DirRetrieveBpoAuthorizationsResponse)
+      end
+      def retrieve_bpo_authorizations(
+        # The DIR id. Lowercase UUID.
+        dir_id,
+        # 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.
+        page_size: nil,
+        request_options: {}
+      )
+      end
+
       # Submit a DIR for vetting. Sends the DIR back through the vetting cycle from any
       # non-terminal status. When re-submitting from `suspended` or `expired`, the DIR's
       # previous Branded Calling registration is torn down transactionally and its phone
@@ -251,8 +344,7 @@ module Telnyx
       # existing registration stays live throughout the new vetting cycle.
       #
       # Returns `400` from `submitted`/`in_review`/`permanently_rejected`. Returns `400`
-      # if the DIR's business and financial references have not been submitted. Returns
-      # `409` if the DIR has an unresolved infringement claim.
+      # if the DIR has an unresolved infringement claim.
       sig do
         params(
           dir_id: String,
@@ -298,13 +390,16 @@ module Telnyx
         certify_brand_is_accurate:,
         # Must be `true`.
         certify_ip_ownership:,
-        # Must be `true`.
+        # Check to certify that the brand no longer infringes anyone else's trademark or
+        # intellectual property.
         certify_no_infringement:,
         # Must be `true`.
         certify_no_shaft_content:,
         # Explanation of how the infringement concern was addressed.
         infringement_resolution_notes:,
         call_reasons: nil,
+        # The business name shown to call recipients, 1 to 35 characters, no emoji, not
+        # blank.
         display_name: nil,
         # Append-only supporting documents to attach while resolving the claim (e.g.
         # authorization or licensing proof).

data/rbi/telnyx/resources/email/dedicated_ips/actions.rbi

@@ -0,0 +1,89 @@
+# typed: strong
+
+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.
+          sig do
+            params(
+              id: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(Telnyx::Email::DedicatedIPShowResponse)
+          end
+          def complete_warmup(
+            # The dedicated IP identifier (UUID).
+            id,
+            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`.
+          sig do
+            params(
+              id: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(Telnyx::Email::DedicatedIPShowResponse)
+          end
+          def pause_warmup(
+            # The dedicated IP identifier (UUID).
+            id,
+            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.
+          sig do
+            params(
+              id: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(Telnyx::Email::DedicatedIPShowResponse)
+          end
+          def resume_warmup(
+            # The dedicated IP identifier (UUID).
+            id,
+            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.
+          sig do
+            params(
+              id: String,
+              request_options: Telnyx::RequestOptions::OrHash
+            ).returns(Telnyx::Email::DedicatedIPShowResponse)
+          end
+          def start_warmup(
+            # The dedicated IP identifier (UUID).
+            id,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Telnyx::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/telnyx/resources/email/dedicated_ips.rbi

@@ -0,0 +1,187 @@
+# typed: strong
+
+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.
+        sig { returns(Telnyx::Resources::Email::DedicatedIPs::Actions) }
+        attr_reader :actions
+
+        # 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.
+        sig do
+          params(
+            idempotency_key: String,
+            ip_version:
+              Telnyx::Email::DedicatedIPCreateParams::IPVersion::OrSymbol,
+            region: Telnyx::Email::DedicatedIPCreateParams::Region::OrSymbol,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Email::DedicatedIPShowResponse)
+        end
+        def create(
+          # Header param: Required. Opaque, unquoted key for safely retrying the same
+          # purchase. Keys must contain 1 to 255 letters, numbers, hyphens, or underscores.
+          # Generate a unique UUID v4 for each purchase and reuse it only when retrying that
+          # purchase with the same request. A missing header, or an invalid one —including
+          # duplicate, empty, malformed, or overlong values—returns 400 with error
+          # code 10015. A request already in progress with the same key returns 409; reusing
+          # the key with a different request returns 422. Only successful responses are
+          # replayed, for up to 24 hours. Do not include sensitive data in the key.
+          idempotency_key:,
+          # Body param: Allocate an IP of this address family. Supported value: `ipv4`. Any
+          # other value, including `ipv6` or `null`, returns `422`.
+          ip_version: nil,
+          # Body param: Allocate an IP in this region. Supported value: `ewr-nj1`. Any other
+          # value, including an empty string or `null`, returns `422`.
+          region: nil,
+          request_options: {}
+        )
+        end
+
+        # Retrieve a single dedicated IP by its identifier, including warm-up state,
+        # billing state, and the DNS/PTR provisioning checklist.
+        sig do
+          params(
+            id: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Email::DedicatedIPShowResponse)
+        end
+        def retrieve(
+          # The dedicated IP identifier (UUID).
+          id,
+          request_options: {}
+        )
+        end
+
+        # 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.
+        sig do
+          params(
+            id: String,
+            drain: T::Boolean,
+            force: T::Boolean,
+            pool_id: String,
+            warmup: Telnyx::Email::DedicatedIPUpdateParams::Warmup::OrHash,
+            warmup_paused: T::Boolean,
+            weight: Integer,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Email::DedicatedIPShowResponse)
+        end
+        def update(
+          # The dedicated IP identifier (UUID).
+          id,
+          # Set together with `force: true` to move the last IP out of its current pool.
+          # Acknowledges that mail routed to the emptied pool is held. Used only with
+          # `pool_id`.
+          drain: nil,
+          # Set together with `drain: true` to move the last IP out of its current pool.
+          # Used only with `pool_id`.
+          force: nil,
+          # Move the IP to this pool, replacing its current membership. Use the IP's current
+          # pool to change only its weight. To take an IP out of a pool, use
+          # `DELETE /email/ip_pools/{id}/ips/{ip_id}`.
+          pool_id: nil,
+          # Alias for `warmup_paused`.
+          warmup: nil,
+          # Pause (`true`) or resume (`false`) the warm-up ramp; equivalent to the
+          # `pause_warmup` and `resume_warmup` actions. A Boolean value takes precedence
+          # over `warmup.paused`. When a pause field is present and `pool_id` is absent,
+          # supplying neither pause field as a Boolean invokes resume.
+          warmup_paused: nil,
+          # Routing weight in the target pool. Used only with `pool_id`.
+          weight: nil,
+          request_options: {}
+        )
+        end
+
+        # 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.
+        sig do
+          params(
+            filter_pool_id: String,
+            filter_region: String,
+            filter_status:
+              Telnyx::Email::DedicatedIPListParams::FilterStatus::OrSymbol,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Models::Email::DedicatedIPListResponse)
+        end
+        def list(
+          # Return only IPs in this pool (exact match on `pool_id`). A value that is not a
+          # UUID returns an empty list. An empty value applies no filter.
+          filter_pool_id: nil,
+          # Return only IPs in this region (exact, case-sensitive match on `region`). An
+          # empty value applies no filter.
+          filter_region: nil,
+          # Return only IPs in this lifecycle status (exact match). Any other value returns
+          # an empty list. An empty value applies no filter.
+          filter_status: nil,
+          request_options: {}
+        )
+        end
+
+        # 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`.
+        sig do
+          params(
+            id: String,
+            body_drain: T::Boolean,
+            body_force: T::Boolean,
+            body_reason: String,
+            request_options: Telnyx::RequestOptions::OrHash
+          ).returns(Telnyx::Email::DedicatedIPShowResponse)
+        end
+        def delete(
+          # Path param: The dedicated IP identifier (UUID).
+          id,
+          # Body param: Set together with `force: true` to release the last IP in a pool.
+          # Acknowledges that mail routed to the emptied pool is held until the pool has a
+          # sendable IP again.
+          body_drain: nil,
+          # Body param: Set together with `drain: true` to release the last IP in a pool.
+          # Either flag alone has no effect.
+          body_force: nil,
+          # Body param: Free-text reason recorded with the release.
+          body_reason: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Telnyx::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end