@sentdm/sentdm 0.39.0 → 0.41.0

package/resources/webhooks.d.mts

@@ -75,7 +75,9 @@ export declare class Webhooks extends APIResource {
      */
     listEventTypes(params?: WebhookListEventTypesParams | null | undefined, options?: RequestOptions): APIPromise<WebhookListEventTypesResponse>;
     /**
-     * Retrieves a paginated list of delivery events for the specified webhook.
+     * Retrieves a paginated list of delivery events for the specified webhook. If the
+     * webhook is cloned onto your sender profiles, the list includes what those clones
+     * received; read payload.account_id to tell whose event it is.
      *
      * @example
      * ```ts
@@ -248,7 +250,9 @@ export interface ChannelEventPayload {
      * The account whose market this is, named as on every other family. When an
      * organization receives an event for one of its sender profiles this is the
      * profile, so a reseller compares it with its own id and anything different is one
-     * of its profiles.
+     * of its profiles. Matches customer_id on GET /v3/channels and the sender
+     * profile's id. Together with channel, country, and number_type, it identifies the
+     * market.
      */
     account_id?: string;
     /**
@@ -257,18 +261,44 @@ export interface ChannelEventPayload {
      * than a channel that can be provisioned.
      */
     channel?: string;
+    /**
+     * What a market has been given: the identity it registers under, its programme,
+     * and any documents attached.
+     *
+     * What it does not carry is what the market asks for. That is the subject of GET
+     * /v3/compliance/requirements, and it is the same answer for every caller — a
+     * description of what a compliance regime wants, not a record of one customer's
+     * progress through it. It was reported here as well for a while, which put the
+     * same array in six response shapes and left a caller deciding which of two
+     * sources to believe.
+     *
+     * Present on a list read for markets that register (carrying brand and campaign),
+     * but with documents absent — documents are not fetched for a list, because a
+     * catalog lookup and a document read per market would multiply across a page.
+     * Absent documents is distinct from an empty list: absent says they were not
+     * fetched; empty says the market has been given none. The parent object is null
+     * only when the market registers with nobody and compliance was not computed —
+     * nothing to show at all.
+     */
+    compliance?: ChannelEventPayload.Compliance | null;
     /**
      * The kind of sender the market uses, for example TEN_DLC, LOCAL, or ALPHANUMERIC.
      * Omitted when the subject has no sender type of its own.
      */
     number_type?: string | null;
     /**
-     * Why the market reached this state, when a reason was given — a correction
-     * explained, or a campaign lapse. Free text, passed through from the registry or
-     * carrier that wrote it, so treat it as a message to show a human rather than a
-     * value to branch on.
+     * Why the market reached this state, as a sentence to show a person: the specific
+     * explanation when one was given (a correction explained, a campaign lapse),
+     * otherwise what reason_code means for this market. Not a value to branch on.
      */
     reason?: string | null;
+    /**
+     * Why the market is not ACTIVE, as a stable code: an ErrorCodes CHANNEL_xxx value
+     * such as CHANNEL_001 (something you owe) or CHANNEL_002 (a correction was
+     * requested). The same code the channels resource reports for the market. Switch
+     * on this rather than on reason. Omitted while ACTIVE.
+     */
+    reason_code?: string | null;
     /**
      * The sender itself — a number in E.164, or an alphanumeric sender ID.
      *
@@ -302,6 +332,93 @@ export interface ChannelEventPayload {
      */
     updated_at?: string;
 }
+export declare namespace ChannelEventPayload {
+    /**
+     * What a market has been given: the identity it registers under, its programme,
+     * and any documents attached.
+     *
+     * What it does not carry is what the market asks for. That is the subject of GET
+     * /v3/compliance/requirements, and it is the same answer for every caller — a
+     * description of what a compliance regime wants, not a record of one customer's
+     * progress through it. It was reported here as well for a while, which put the
+     * same array in six response shapes and left a caller deciding which of two
+     * sources to believe.
+     *
+     * Present on a list read for markets that register (carrying brand and campaign),
+     * but with documents absent — documents are not fetched for a list, because a
+     * catalog lookup and a document read per market would multiply across a page.
+     * Absent documents is distinct from an empty list: absent says they were not
+     * fetched; empty says the market has been given none. The parent object is null
+     * only when the market registers with nobody and compliance was not computed —
+     * nothing to show at all.
+     */
+    interface Compliance {
+        /**
+         * The identity this market registers under, with inherit saying whose it is.
+         *
+         * Reported here rather than on the profile because it belongs to the registration
+         * this market files, and only one market files one. It was a top-level block for a
+         * while, which put a per-registration value beside a list of markets and left a
+         * caller to work out which market it belonged to.
+         *
+         * Absent for a market that registers with nobody — such a market asks for no
+         * identity, so there is none to report. Absent and null mean different things:
+         * absent says this market does not ask, null would say it asks and nothing was
+         * supplied.
+         *
+         * Untyped, like the request side, because its members are declared by the market's
+         * own schema rather than by a C# class. A typed pair here would be a second
+         * definition of what a market wants, free to drift from the one that validates.
+         */
+        brand?: {
+            [key: string]: unknown;
+        } | null;
+        /**
+         * The programme this market registers, with inherit saying whose it is.
+         *
+         * One, not a list. TcrCampaigns permits several and an account built on the admin
+         * side may hold them, but this surface offers one — which is what lets the
+         * market's PATCH be an upsert rather than a collection with an addressable create
+         * behind it. An account holding several is reported as its first and refused on
+         * write, rather than half-edited.
+         *
+         * Carries no id. Nothing addresses a campaign, and an undeclared key would be
+         * refused if the caller sent this object back — which it is meant to be able to
+         * do.
+         */
+        campaign?: {
+            [key: string]: unknown;
+        } | null;
+        /**
+         * What has been supplied for this market.
+         *
+         * Files, not values — the declared halves above carry the values. A document
+         * cannot be a JSON value, so it is sent as multipart on the channel call and
+         * reported here as a reference.
+         *
+         * Absent on a list read, which fetches identity but does not compute compliance
+         * documents per market. Absent and empty mean different things: absent says the
+         * documents were not fetched; empty says the market has been given none.
+         */
+        documents?: Array<Compliance.Document> | null;
+    }
+    namespace Compliance {
+        /**
+         * A document a market asked for and has been given.
+         */
+        interface Document {
+            /**
+             * Identifier of the upload, for fetching it back through the documents endpoints.
+             */
+            document_id?: string | null;
+            file_name?: string | null;
+            /**
+             * The catalog's name for this document, matching the requirement it satisfies.
+             */
+            key?: string;
+        }
+    }
+}
 /**
  * The envelope Sent POSTs to a subscribed webhook endpoint. Every event shares
  * this shape and varies only in Payload.
@@ -319,17 +436,25 @@ export interface ContactEvent {
      */
     field?: string;
     /**
-     * Body of a contact.opt_in, contact.opt_out or contact.help event. Delivered when
-     * a contact signals a consent change or asks for help.
+     * Body of a contact.opt_in, contact.opt_out, contact.help or
+     * contact.custom_keyword event. Delivered when a contact signals a consent change,
+     * asks for help, or sends one of your own auto-reply keywords.
      *
      * These events state the signal outright, so you do not have to recognise keywords
      * in the text of a message.received event. They also cover cases that produce no
      * inbound message at all, such as a network handling an opt-out on your behalf.
      *
-     * Fields are ordered identity → resulting state → provenance → join key. Nothing
-     * here restates the envelope: which of the three signals occurred is the
-     * envelope's event, and when it was emitted is its timestamp. Retries carry the
-     * same X-Webhook-Event-ID header, which is what to deduplicate on.
+     * Two of the four change consent and two do not: contact.help and
+     * contact.custom_keyword report the state the contact already had. Read opt_out
+     * for the state and the envelope's event for what happened, rather than inferring
+     * one from the other.
+     *
+     * Fields are ordered identity → resulting state → provenance → join keys. The two
+     * parties are from and to. Note that the message family has not moved to those
+     * names yet — message.received still calls the same two parties inbound_number and
+     * outbound_number. Nothing here restates the envelope: which signal occurred is
+     * the envelope's event, and when it was emitted is its timestamp. Retries carry
+     * the same X-Webhook-Event-ID header, which is what to deduplicate on.
      */
     payload?: ContactEventPayload | null;
     /**
@@ -344,23 +469,32 @@ export interface ContactEvent {
     timestamp?: string;
 }
 /**
- * Body of a contact.opt_in, contact.opt_out or contact.help event. Delivered when
- * a contact signals a consent change or asks for help.
+ * Body of a contact.opt_in, contact.opt_out, contact.help or
+ * contact.custom_keyword event. Delivered when a contact signals a consent change,
+ * asks for help, or sends one of your own auto-reply keywords.
  *
  * These events state the signal outright, so you do not have to recognise keywords
  * in the text of a message.received event. They also cover cases that produce no
  * inbound message at all, such as a network handling an opt-out on your behalf.
  *
- * Fields are ordered identity → resulting state → provenance → join key. Nothing
- * here restates the envelope: which of the three signals occurred is the
- * envelope's event, and when it was emitted is its timestamp. Retries carry the
- * same X-Webhook-Event-ID header, which is what to deduplicate on.
+ * Two of the four change consent and two do not: contact.help and
+ * contact.custom_keyword report the state the contact already had. Read opt_out
+ * for the state and the envelope's event for what happened, rather than inferring
+ * one from the other.
+ *
+ * Fields are ordered identity → resulting state → provenance → join keys. The two
+ * parties are from and to. Note that the message family has not moved to those
+ * names yet — message.received still calls the same two parties inbound_number and
+ * outbound_number. Nothing here restates the envelope: which signal occurred is
+ * the envelope's event, and when it was emitted is its timestamp. Retries carry
+ * the same X-Webhook-Event-ID header, which is what to deduplicate on.
  */
 export interface ContactEventPayload {
     /**
      * Whether the contact is opted out after this signal — the state to write to your
-     * own record. Same meaning as opt_out on the contact resource. On contact.help
-     * this reports the contact's existing state, which help does not change.
+     * own record. Same meaning as opt_out on the contact resource. On contact.help and
+     * contact.custom_keyword this reports the contact's existing state, which neither
+     * changes.
      *
      * Two signals from the same contact can arrive out of order, because each one is
      * queued on its own rather than against the contact. Compare the envelope's
@@ -381,16 +515,32 @@ export interface ContactEventPayload {
      * accounts.
      */
     account_id?: string;
+    /**
+     * The RCS agent the signal reached, when it reached one.
+     *
+     * Omitted entirely on channels that have no agent, rather than sent as null — an
+     * SMS or WhatsApp payload does not carry this key at all. On RCS it is the
+     * counterpart to To: a contact reaches an agent rather than a number, so exactly
+     * one of the two is populated and never both. If you run more than one agent, this
+     * is what tells you which of them the contact acted on.
+     */
+    agent_id?: string | null;
     /**
      * The channel the signal arrived on, for example sms or whatsapp.
      */
     channel?: string;
     /**
      * The contact who raised the signal. Always populated, including for contact.help
-     * from a number you have not messaged before — the contact is created if it does
-     * not exist yet, so this identifier is always resolvable against the contacts API.
+     * or contact.custom_keyword from a number you have not messaged before — the
+     * contact is created if it does not exist yet, so this identifier is always
+     * resolvable against the contacts API.
      */
     contact_id?: string;
+    /**
+     * The contact's number, in E.164 format with the leading + — who raised the
+     * signal. The same party message.received publishes as inbound_number.
+     */
+    from?: string;
     /**
      * The inbound message that carried the signal, matching message_id on the
      * corresponding message.received event so the two can be joined.
@@ -403,16 +553,40 @@ export interface ContactEventPayload {
      */
     message_id?: string | null;
     /**
-     * The contact's number in E.164 format. Same value as phone_number on the contact
-     * resource.
+     * The auto-reply template whose keyword the contact matched, joinable against the
+     * templates API.
+     *
+     * This is what identifies which signal arrived on contact.custom_keyword: every
+     * custom template reports the same event name, so the event alone cannot tell your
+     * booking keyword from your opening-hours one. One template holds as many keywords
+     * as you configured, so this is steadier to switch on than text.
+     *
+     * Populated on the compliance sub-types too, where it names the template that
+     * replied. Sent as null when no template was involved — a network-reported opt-out
+     * matches no keyword. The field is always present, so read it and check for null.
      */
-    phone_number?: string;
+    template_id?: string | null;
     /**
      * The text the contact sent, for example STOP or UNSUBSCRIBE. Sent as null when
      * the signal did not arrive as text. The field is always present, so read it and
      * check for null rather than checking whether the key exists.
      */
     text?: string | null;
+    /**
+     * The number of yours that received the signal, in E.164 format with the leading
+     * +. Tells a multi-number account which of its senders the contact acted on, which
+     * nothing else on this payload answers.
+     *
+     * This is your number, not the contact's. That is the opposite of what to means on
+     * POST /v3/messages, where it is the list of recipients you are sending to. Reply
+     * to From, not to this field, or the message goes back to yourself.
+     *
+     * Sent as null when the signal did not arrive at a number of yours — an RCS signal
+     * terminates at an agent rather than a number, and a provider-reported opt-out may
+     * name no receiving number at all. The field is always present, so read it and
+     * check for null rather than checking whether the key exists.
+     */
+    to?: string | null;
 }
 /**
  * Error information
@@ -487,9 +661,22 @@ export interface InboundMessageEventPayload {
      */
     account_id?: string;
     /**
-     * The channel the message arrived on, for example sms or whatsapp.
+     * The channel the message arrived on, for example sms or mms.
      */
     channel?: string;
+    /**
+     * Attachments the contact sent, present only on channels that carry them (mms
+     * today) and omitted entirely otherwise.
+     *
+     * Each url points at the carrier's own copy of the file — sent.dm records where
+     * the attachment is, not the attachment itself. The link is unauthenticated and
+     * expires on the carrier's schedule, which differs between them: assume days, not
+     * months. Download what you need on receipt; re-reading the message through GET
+     * /v3/messages/{id} returns the same stored link, not a fresh one, so once it
+     * lapses the entry remains with whatever the carrier declared about the file but
+     * the file is no longer reachable.
+     */
+    media?: Array<InboundMessageEventPayload.Media> | null;
     /**
      * The inbound message.
      */
@@ -510,6 +697,37 @@ export interface InboundMessageEventPayload {
      */
     updated_at?: string;
 }
+export declare namespace InboundMessageEventPayload {
+    /**
+     * One attachment on an inbound message.
+     */
+    interface Media {
+        /**
+         * SHA-256 of the file as the carrier declared it, when it declares one. Verify
+         * what you download against this — sent.dm never reads the bytes, so it is the
+         * only integrity signal available.
+         */
+        hash_sha256?: string | null;
+        /**
+         * Content type as the carrier reported it, for example image/jpeg.
+         */
+        mime_type?: string | null;
+        /**
+         * Size in bytes as the carrier declared it. Absent when it declared none.
+         */
+        size_bytes?: number | null;
+        /**
+         * Where the carrier hosts the attachment.
+         *
+         * This link expires and is not authenticated. sent.dm relays it rather than
+         * copying the file, so how long it stays fetchable is the carrier's decision and
+         * differs between them — assume days, not months. Anyone holding the URL can fetch
+         * it until it lapses. Copy the file on receipt if you need it to outlive that
+         * window; do not store this URL as a permanent reference.
+         */
+        url?: string | null;
+    }
+}
 /**
  * The envelope Sent POSTs to a subscribed webhook endpoint. Every event shares
  * this shape and varies only in Payload.
@@ -583,6 +801,31 @@ export interface MessageEventPayload {
      * The recipient's number in E.164 format.
      */
     outbound_number?: string;
+    /**
+     * A human-readable sentence for ReasonCode, for example "The recipient is not
+     * registered on this channel". Omitted whenever reason_code is.
+     */
+    reason?: string | null;
+    /**
+     * Why the message reached this status, as a stable platform code such as
+     * DELIVERY_007 or BUSINESS_003. Present on message.failed, message.filtered and
+     * message.blocked; omitted on every status that needs no explanation. Switch on
+     * this rather than on Reason: the code is stable, the wording may be improved. It
+     * is the platform's classification of the outcome and never a carrier or vendor
+     * code.
+     */
+    reason_code?: string | null;
+    /**
+     * message.scheduled only: why the message is held, either because you scheduled it
+     * or because the recipient is inside a protected quiet-hours window. Omitted on
+     * every other event.
+     */
+    schedule_reason?: string | null;
+    /**
+     * message.scheduled only: when the held message will be released for delivery, in
+     * UTC (yyyy-MM-ddTHH:mm:ssZ). Omitted on every other event.
+     */
+    scheduled_at?: string | null;
     /**
      * The template the message was sent from, when it was sent from one.
      */
@@ -822,17 +1065,324 @@ export interface WebhookListEventsResponse {
     error_message?: string | null;
     /**
      * The exact event body that was delivered, or attempted, for this record. One of
-     * the four webhook envelopes: a message status change, an inbound message, a
-     * template status change, or a contact consent signal. Read field and event to
-     * tell which, the same way your endpoint does.
+     * the six webhook envelopes:
+     *
+     * message — an outbound message changed status. message with event:
+     * message.received — someone replied to you. templates — a template was approved,
+     * rejected, paused or similar. channel — one of your markets moved in provisioning
+     * or compliance. contact — a consent signal: opt-in, opt-out or help. link — a
+     * tracked short link was clicked or a hosted file downloaded, or one expired or
+     * was revoked.
+     *
+     * Read field and event to tell which, the same way your endpoint does. The two
+     * message envelopes are the reason that is two fields and not one: they share a
+     * field and differ by event.
+     *
+     * Treat the list as open. It has grown twice — channel and then link — and a
+     * handler that rejects an envelope it does not recognise will break on the next
+     * addition rather than ignore it.
      */
-    event_data?: MessageEvent | InboundMessageEvent | TemplateEvent | ChannelEvent | ContactEvent;
+    event_data?: MessageEvent | InboundMessageEvent | TemplateEvent | ChannelEvent | ContactEvent | WebhookListEventsResponse.SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload | WebhookListEventsResponse.SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload;
     event_type?: string;
     http_status_code?: number | null;
     processing_completed_at?: string | null;
     processing_started_at?: string | null;
     response_body?: string | null;
 }
+export declare namespace WebhookListEventsResponse {
+    /**
+     * The envelope Sent POSTs to a subscribed webhook endpoint. Every event shares
+     * this shape and varies only in Payload.
+     */
+    interface SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload {
+        /**
+         * The specific event within the family, for example message.delivered,
+         * message.received or contact.opt_out. Absent on events that have no subtype, so
+         * treat it as optional.
+         */
+        event?: string | null;
+        /**
+         * The event family, for example message, templates or contact. Route on this
+         * first, then on event for the specific change.
+         */
+        field?: string;
+        /**
+         * Body of a link event: something happened to a tracked link Sent published on the
+         * customer's behalf. A link points either at a URL the customer supplied or at a
+         * file Sent hosts for them; LinkKind says which. Delivered when an eligible
+         * request is served, or when a published link reaches the end of its life.
+         *
+         * A click is a request, not a read receipt. link.clicked means the redirect was
+         * served; link.downloaded means bytes went out. Neither proves a person saw
+         * anything — messaging providers and link scanners fetch URLs on their own, which
+         * is what TrafficClass exists to tell apart. Filter on it before reporting a
+         * click-through rate; treat likely_human as a hint, never as delivery
+         * confirmation.
+         *
+         * RecordId identifies the link; the X-Webhook-Event-ID header identifies the
+         * delivery. One link is hit many times, so those are the two keys a subscriber
+         * needs: group by the first, deduplicate on the second — exactly as on every other
+         * family. The payload carries no event identifier of its own, for the same reason
+         * none of the others do.
+         *
+         * Nothing here identifies the visitor. No IP address and no visitor token crosses
+         * this boundary. Country, Device and Browser are coarse buckets derived at the
+         * edge and are absent whenever the request did not supply enough to derive them.
+         */
+        payload?: SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload.Payload | null;
+        /**
+         * The event-specific body.
+         */
+        request_id?: string | null;
+        /**
+         * When Sent emitted the event, in UTC (yyyy-MM-ddTHH:mm:ssZ). This is the emission
+         * time, not the time the underlying change happened. Use the timestamp inside the
+         * payload for the latter.
+         */
+        timestamp?: string;
+    }
+    namespace SentDmServicesCommonServicesWebhooksContractsWebhookEventOfLinkWebhookPayload {
+        /**
+         * Body of a link event: something happened to a tracked link Sent published on the
+         * customer's behalf. A link points either at a URL the customer supplied or at a
+         * file Sent hosts for them; LinkKind says which. Delivered when an eligible
+         * request is served, or when a published link reaches the end of its life.
+         *
+         * A click is a request, not a read receipt. link.clicked means the redirect was
+         * served; link.downloaded means bytes went out. Neither proves a person saw
+         * anything — messaging providers and link scanners fetch URLs on their own, which
+         * is what TrafficClass exists to tell apart. Filter on it before reporting a
+         * click-through rate; treat likely_human as a hint, never as delivery
+         * confirmation.
+         *
+         * RecordId identifies the link; the X-Webhook-Event-ID header identifies the
+         * delivery. One link is hit many times, so those are the two keys a subscriber
+         * needs: group by the first, deduplicate on the second — exactly as on every other
+         * family. The payload carries no event identifier of its own, for the same reason
+         * none of the others do.
+         *
+         * Nothing here identifies the visitor. No IP address and no visitor token crosses
+         * this boundary. Country, Device and Browser are coarse buckets derived at the
+         * edge and are absent whenever the request did not supply enough to derive them.
+         */
+        interface Payload {
+            /**
+             * The link's public identifier — the eight-character code in the short URL, for
+             * example A78B2BU0. Unique across both kinds, and never reused, so it is the
+             * stable key to group one link's events by.
+             */
+            record_id: string;
+            /**
+             * Where the request appeared to come from, as an ISO 3166-1 alpha-2 code. Named
+             * separately from the country on a channel event, which is a destination market
+             * the customer registered for — this one is a property of a single visitor and is
+             * absent when the edge could not resolve it.
+             */
+            access_country?: string | null;
+            /**
+             * How the request was served, when the edge recorded it. Free text describing the
+             * outcome — show it to a human rather than branching on it.
+             */
+            access_outcome?: string | null;
+            /**
+             * The requesting browser family, for example chrome or safari, or unknown. Derived
+             * from the user agent.
+             */
+            browser?: string | null;
+            /**
+             * How many bytes were served, for a file access. A ranged request reports the
+             * bytes in that range, not the size of the file, so several accesses of one file
+             * can each report a part.
+             */
+            bytes_served?: number | null;
+            /**
+             * The channel the message carrying this link went out on: sms, whatsapp, or rcs.
+             */
+            channel?: string | null;
+            /**
+             * The organization the link belongs to. Always the parent account, never a sender
+             * profile — read SenderProfileId for that.
+             *
+             * This family publishes the owner as an explicit pair rather than the single
+             * account_id the other families use. The pair says which organization and which
+             * profile without the subscriber deriving either, which is the trade: one more key
+             * against not having to know that account_id silently becomes the profile when one
+             * exists.
+             */
+            customer_id?: string;
+            /**
+             * The requesting device class: mobile, tablet, desktop or unknown. Derived from
+             * the user agent.
+             */
+            device?: string | null;
+            /**
+             * What the link points at: url for a destination the customer supplied, file for
+             * media Sent hosts. Always present, and implied by the event — link.clicked is
+             * always url and link.downloaded always file — but published as its own field so a
+             * subscriber can branch on the kind without parsing the event name, the same
+             * separation the channel family keeps between its event and its status.
+             */
+            link_kind?: string;
+            /**
+             * The message the link was published in.
+             *
+             * The event can arrive before the message is readable through GET /v3/messages: a
+             * provider may fetch a link within milliseconds of the send, and nothing here
+             * waits for the message row. Retry the read rather than treating an unknown id as
+             * an error.
+             */
+            message_id?: string | null;
+            /**
+             * When the access or lifecycle change actually happened, in UTC
+             * (yyyy-MM-ddTHH:mm:ssZ). The envelope's timestamp is when Sent emitted the event;
+             * this is when the thing occurred, and the two differ by the ingest delay.
+             */
+            occurred_at?: string;
+            /**
+             * The caller-supplied label tying this link back to a position in the message, for
+             * example body:0 for the first link in the body. Present when the link was created
+             * with one.
+             */
+            reference_key?: string | null;
+            /**
+             * The host of the page that linked here, when the request supplied one. The host
+             * only — never a full referring URL.
+             */
+            referrer_host?: string | null;
+            /**
+             * The HTTP method of the request that was served, for an access event. Omitted on
+             * link.expired and link.revoked, which describe no request.
+             */
+            request_method?: string | null;
+            /**
+             * The sender profile that owns the link, or null when the organization owns it
+             * directly. Always on the wire so a handler reads one shape rather than branching
+             * on whether the key arrived.
+             *
+             * sender_profile_id, not profile_id: the API already publishes
+             * messaging_profile_id and sending_phone_number_profile_id for provider-side
+             * profiles, which are a different thing entirely. The unqualified name would read
+             * as one of those.
+             */
+            sender_profile_id?: string | null;
+            /**
+             * The HTTP status Sent answered the request with: 302 for a link, 200 or 206 for a
+             * file. Omitted on lifecycle events.
+             */
+            status_code?: number | null;
+            /**
+             * A coarse guess at what made the request: likely_human, provider (a messaging
+             * platform prefetching the link), bot, or unknown. Derived from the user agent, so
+             * it is a hint for filtering noise rather than a fact to bill or report on.
+             */
+            traffic_class?: string | null;
+        }
+    }
+    /**
+     * The envelope Sent POSTs to a subscribed webhook endpoint. Every event shares
+     * this shape and varies only in Payload.
+     */
+    interface SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload {
+        /**
+         * The specific event within the family, for example message.delivered,
+         * message.received or contact.opt_out. Absent on events that have no subtype, so
+         * treat it as optional.
+         */
+        event?: string | null;
+        /**
+         * The event family, for example message, templates or contact. Route on this
+         * first, then on event for the specific change.
+         */
+        field?: string;
+        /**
+         * Body of a call.initiated, call.answered, call.completed, call.failed or
+         * call.recording_ready event. Which of them occurred is the envelope's event.
+         *
+         * Shaped like the message, inbound, template and channel payloads: account_id
+         * names the account the event is about, channel names the channel, and updated_at
+         * is when the change happened on the call, in the same yyyy-MM-ddTHH:mm:ssZ form.
+         * duration_seconds and price are added on call.completed, reason on call.failed
+         * and recording_id on call.recording_ready; each is omitted rather than sent as
+         * null when it does not apply.
+         *
+         * Casing is snake_case because these ride the same webhook stream customers
+         * already parse message_id from; the question/answer contract is a separate
+         * surface and stays camelCase. Nothing here is provider-shaped: no provider call
+         * id, no namespaced identity.
+         */
+        payload?: SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload.Payload | null;
+        /**
+         * The event-specific body.
+         */
+        request_id?: string | null;
+        /**
+         * When Sent emitted the event, in UTC (yyyy-MM-ddTHH:mm:ssZ). This is the emission
+         * time, not the time the underlying change happened. Use the timestamp inside the
+         * payload for the latter.
+         */
+        timestamp?: string;
+    }
+    namespace SentDmServicesCommonServicesWebhooksContractsWebhookEventOfCallWebhookPayload {
+        /**
+         * Body of a call.initiated, call.answered, call.completed, call.failed or
+         * call.recording_ready event. Which of them occurred is the envelope's event.
+         *
+         * Shaped like the message, inbound, template and channel payloads: account_id
+         * names the account the event is about, channel names the channel, and updated_at
+         * is when the change happened on the call, in the same yyyy-MM-ddTHH:mm:ssZ form.
+         * duration_seconds and price are added on call.completed, reason on call.failed
+         * and recording_id on call.recording_ready; each is omitted rather than sent as
+         * null when it does not apply.
+         *
+         * Casing is snake_case because these ride the same webhook stream customers
+         * already parse message_id from; the question/answer contract is a separate
+         * surface and stays camelCase. Nothing here is provider-shaped: no provider call
+         * id, no namespaced identity.
+         */
+        interface Payload {
+            /**
+             * Sent's call id, the same one the customer saw on the first question.
+             */
+            call_id: string;
+            /**
+             * The account the call belongs to: the key's own customer, or the sender profile
+             * it acted as.
+             */
+            account_id?: string;
+            /**
+             * Always voice.
+             */
+            channel?: string;
+            /**
+             * How long the call lasted. Only on call.completed.
+             */
+            duration_seconds?: number | null;
+            /**
+             * The customer number that owns the call, in E.164 format.
+             */
+            number?: string;
+            /**
+             * What the call was charged. Only on call.completed, and omitted there until
+             * billing has recorded the charge.
+             */
+            price?: number | null;
+            /**
+             * The machine-readable reason the call did not complete. Only on call.failed, and
+             * omitted when no reason was recorded.
+             */
+            reason?: string | null;
+            /**
+             * The recording that became available, the same id GET /v3/calls/{id}/recordings
+             * lists it under. Only on call.recording_ready, which is sent once per recording.
+             */
+            recording_id?: string | null;
+            /**
+             * When the change happened on the call, as opposed to when the event was emitted.
+             */
+            updated_at?: string;
+        }
+    }
+}
 /**
  * Standard API response envelope for all v3 endpoints
  */
@@ -920,6 +1470,12 @@ export interface WebhookCreateParams {
      * effects Useful for testing integrations without actual execution
      */
     sandbox?: boolean;
+    /**
+     * Body param: Request-only: the events an organization webhook's sender profile
+     * clones receive, one clone per existing and future profile. Responses never
+     * return it.
+     */
+    sender_profile?: WebhookCreateParams.SenderProfile | null;
     /**
      * Body param
      */
@@ -937,6 +1493,18 @@ export interface WebhookCreateParams {
      */
     'x-profile-id'?: string;
 }
+export declare namespace WebhookCreateParams {
+    /**
+     * Request-only: the events an organization webhook's sender profile clones
+     * receive, one clone per existing and future profile. Responses never return it.
+     */
+    interface SenderProfile {
+        event_filters?: {
+            [key: string]: Array<string>;
+        } | null;
+        event_types?: Array<string>;
+    }
+}
 export interface WebhookRetrieveParams {
     /**
      * Profile UUID to scope the request to a child profile. Only organization API keys
@@ -972,6 +1540,12 @@ export interface WebhookUpdateParams {
      * effects Useful for testing integrations without actual execution
      */
     sandbox?: boolean;
+    /**
+     * Body param: Request-only: the events an organization webhook's sender profile
+     * clones receive, one clone per existing and future profile. Responses never
+     * return it.
+     */
+    sender_profile?: WebhookUpdateParams.SenderProfile | null;
     /**
      * Body param
      */
@@ -989,6 +1563,18 @@ export interface WebhookUpdateParams {
      */
     'x-profile-id'?: string;
 }
+export declare namespace WebhookUpdateParams {
+    /**
+     * Request-only: the events an organization webhook's sender profile clones
+     * receive, one clone per existing and future profile. Responses never return it.
+     */
+    interface SenderProfile {
+        event_filters?: {
+            [key: string]: Array<string>;
+        } | null;
+        event_types?: Array<string>;
+    }
+}
 export interface WebhookListParams extends WebhooksPageParams {
     /**
      * Query param