@agentisend/sdk-node 0.2.0 → 0.5.0

package/dist/client.js

@@ -1,4 +1,5 @@
 import { AgentiSendError, AgentiSendTransportError, } from './errors.js';
+import { SDK_VERSION } from './version.js';
 export const DEFAULT_BASE_URL = 'https://api.agentisend.com';
 /**
  * Build an idempotency key in the shape that debugs well: `<what>/<which>`,
@@ -78,12 +79,13 @@ export class AgentiSend {
         }
         this.fetchImpl = resolved;
         this.timeoutMs = options.timeoutMs ?? 30_000;
-        this.userAgent = options.userAgent ?? 'agentisend-node';
+        // DX-14: the version travels, so support can tell 0.2.0 from 0.3.0.
+        this.userAgent = options.userAgent ?? `agentisend-node/${SDK_VERSION} node/${process.versions.node}`;
     }
-    async request(raw) {
+    send(raw, accept) {
         const headers = {
             authorization: `Bearer ${this.apiKey}`,
-            accept: 'application/json',
+            accept,
             'user-agent': this.userAgent,
         };
         if (raw.body !== undefined)
@@ -91,14 +93,19 @@ export class AgentiSend {
         if (raw.options?.idempotencyKey) {
             headers['idempotency-key'] = raw.options.idempotencyKey;
         }
-        const response = await this.fetchImpl(`${this.baseUrl}${raw.path}${buildQuery(raw.query)}`, {
+        if (raw.options?.headers) {
+            Object.assign(headers, raw.options.headers);
+        }
+        return this.fetchImpl(`${this.baseUrl}${raw.path}${buildQuery(raw.query)}`, {
             method: raw.method,
             headers,
             ...(raw.body !== undefined ? { body: JSON.stringify(raw.body) } : {}),
             signal: raw.options?.signal ?? AbortSignal.timeout(this.timeoutMs),
         });
+    }
+    async request(raw) {
+        const response = await this.send(raw, 'application/json');
         const text = await response.text();
-        const requestId = response.headers.get('x-request-id') ?? undefined;
         if (response.status === 204 || text.length === 0) {
             if (response.status >= 400) {
                 throw new AgentiSendTransportError(`Request failed with ${response.status} and an empty body`, response.status, '');
@@ -112,19 +119,48 @@ export class AgentiSend {
         catch {
             throw new AgentiSendTransportError(`Response was not JSON (${response.status})`, response.status, text.slice(0, 500));
         }
+        if (response.status >= 400)
+            this.fail(response, parsed, text);
+        return parsed;
+    }
+    /**
+     * A response that is not JSON: an attachment, an .eml, the CSV export. A
+     * refusal still arrives as the JSON error envelope and throws the same
+     * AgentiSendError that request() throws.
+     */
+    async requestBytes(raw) {
+        const response = await this.send(raw, '*/*');
         if (response.status >= 400) {
-            if (!isErrorPayload(parsed)) {
-                throw new AgentiSendTransportError(`Unexpected error shape (${response.status})`, response.status, text.slice(0, 500));
+            const text = await response.text();
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                throw new AgentiSendTransportError(`Request failed with ${response.status}`, response.status, text.slice(0, 500));
             }
-            const retryAfter = response.headers.get('retry-after');
-            const rateLimit = readRateLimit(response);
-            throw new AgentiSendError(parsed.error, response.status, {
-                ...(retryAfter ? { retryAfterSeconds: Number(retryAfter) } : {}),
-                ...(requestId ? { requestId } : {}),
-                ...(rateLimit ? { rateLimit } : {}),
-            });
+            this.fail(response, parsed, text);
         }
-        return parsed;
+        if (response.arrayBuffer)
+            return new Uint8Array(await response.arrayBuffer());
+        return new TextEncoder().encode(await response.text());
+    }
+    /** The same download, decoded as UTF-8: an .eml, raw MIME, a CSV. */
+    async requestText(raw) {
+        return new TextDecoder().decode(await this.requestBytes(raw));
+    }
+    fail(response, parsed, text) {
+        if (!isErrorPayload(parsed)) {
+            throw new AgentiSendTransportError(`Unexpected error shape (${response.status})`, response.status, text.slice(0, 500));
+        }
+        const requestId = response.headers.get('x-request-id') ?? undefined;
+        const retryAfter = response.headers.get('retry-after');
+        const rateLimit = readRateLimit(response);
+        throw new AgentiSendError(parsed.error, response.status, {
+            ...(retryAfter ? { retryAfterSeconds: Number(retryAfter) } : {}),
+            ...(requestId ? { requestId } : {}),
+            ...(rateLimit ? { rateLimit } : {}),
+        });
     }
     emails = {
         send: (payload, options) => this.request({ method: 'POST', path: '/emails', body: payload, ...(options ? { options } : {}) }),
@@ -155,11 +191,20 @@ export class AgentiSend {
             path: `/emails/${id}/cancel`,
             ...(options ? { options } : {}),
         }),
+        /** Delete a sent email and its events for good. A scheduled one must be cancelled first. */
+        remove: (id, options) => this.request({
+            method: 'DELETE',
+            path: `/emails/${id}`,
+            ...(options ? { options } : {}),
+        }),
         /** Move an email to a new time. Works from scheduled AND canceled. */
         reschedule: (id, scheduledAt, options) => this.request({
             method: 'POST',
             path: `/emails/${id}/reschedule`,
-            body: { scheduled_at: scheduledAt },
+            body: {
+                scheduled_at: scheduledAt,
+                ...(options?.timezone !== undefined ? { timezone: options.timezone } : {}),
+            },
             ...(options ? { options } : {}),
         }),
         /**
@@ -170,6 +215,33 @@ export class AgentiSend {
         explain: (id) => this.request({ method: 'GET', path: `/emails/${id}/explain` }),
         /** Run every gate without sending or spending. Free, always. */
         preflight: (payload) => this.request({ method: 'POST', path: '/emails/preflight', body: payload }),
+        /** Deliverability lint without sending: a 0-100 placement score and every finding with its fix. */
+        lint: (payload) => this.request({ method: 'POST', path: '/emails/lint', body: payload }),
+        /** Every event recorded for one message, oldest first. */
+        events: (id, query = {}) => this.request({
+            method: 'GET',
+            path: `/emails/${id}/events`,
+            query: query,
+        }),
+        /** The exact RFC 5322 source of this message, as text. */
+        mime: (id) => this.requestText({ method: 'GET', path: `/emails/${id}/mime` }),
+        /** The same message as a .eml file. */
+        eml: (id) => this.requestText({ method: 'GET', path: `/emails/${id}/eml` }),
+        /** One attachment's bytes, as they were sent. */
+        attachment: (id, attachmentId) => this.requestBytes({ method: 'GET', path: `/emails/${id}/attachments/${attachmentId}` }),
+        /** Cancel scheduled or queued messages by id, or everything scheduled before a time. */
+        bulkCancel: (payload, options) => this.request({
+            method: 'POST',
+            path: '/emails/bulk-cancel',
+            body: payload,
+            ...(options ? { options } : {}),
+        }),
+        /** The message log as CSV, with the same filters as list. */
+        export: (query = {}) => this.requestText({
+            method: 'GET',
+            path: '/emails/export.csv',
+            query: query,
+        }),
         /**
          * Move a scheduled email. The same act as `reschedule`, under the verb a
          * Resend integration already calls (M5.5).
@@ -196,6 +268,16 @@ export class AgentiSend {
             ...(options ? { options } : {}),
         }),
         delete: (id, options) => this.request({ method: 'DELETE', path: `/api-keys/${id}`, ...(options ? { options } : {}) }),
+        /**
+         * Issue a new token for this key. The old one keeps working for
+         * `grace_hours` (0, 1 or 24) so a deploy can pick up the new one.
+         */
+        rotate: (id, payload, options) => this.request({
+            method: 'POST',
+            path: `/api-keys/${id}/rotate`,
+            body: payload,
+            ...(options ? { options } : {}),
+        }),
     };
     domains = {
         create: (payload, options) => this.request({ method: 'POST', path: '/domains', body: payload, ...(options ? { options } : {}) }),
@@ -205,8 +287,10 @@ export class AgentiSend {
             query: query,
         }),
         get: (id) => this.request({ method: 'GET', path: `/domains/${id}` }),
+        /** One-shot DNS sheet: zone file, copy-paste commands, provider. */
+        setup: (id) => this.request({ method: 'GET', path: `/domains/${id}/setup` }),
         verify: (id, options) => this.request({ method: 'POST', path: `/domains/${id}/verify`, ...(options ? { options } : {}) }),
-        /** A8 + P3b: click/open tracking, or a new tracking_subdomain. Never removed. */
+        /** A8 + P3b: click/open tracking, TLS mode, or a new tracking_subdomain. Never removed. */
         update: (id, payload, options) => this.request({
             method: 'PATCH',
             path: `/domains/${id}`,
@@ -214,6 +298,24 @@ export class AgentiSend {
             ...(options ? { options } : {}),
         }),
         delete: (id, options) => this.request({ method: 'DELETE', path: `/domains/${id}`, ...(options ? { options } : {}) }),
+        /**
+         * Long-poll until the domain is verified or failed, or `timeout` seconds
+         * (0-25) pass; 0 is a snapshot. It does not re-check DNS: the server checks
+         * on its own, and `next_poll_seconds` says when to ask again.
+         */
+        wait: (id, query = {}) => this.request({
+            method: 'GET',
+            path: `/domains/${id}/wait`,
+            query: query,
+        }),
+        /** Newest-first timeline: each DNS check, each record found or lost, verified, deleted. */
+        events: (id, query = {}) => this.request({
+            method: 'GET',
+            path: `/domains/${id}/events`,
+            query: query,
+        }),
+        /** Alias of setup: detects the DNS provider and returns the exact records to add. */
+        connect: (id) => this.request({ method: 'GET', path: `/domains/${id}/connect` }),
     };
     webhooks = {
         create: (payload, options) => this.request({ method: 'POST', path: '/webhooks', body: payload, ...(options ? { options } : {}) }),
@@ -244,6 +346,18 @@ export class AgentiSend {
             path: `/webhooks/${id}/dead-letters`,
             query: query,
         }),
+        /** Every delivery to this endpoint, with each attempt and what the receiver answered. */
+        deliveries: (id, query = {}) => this.request({
+            method: 'GET',
+            path: `/webhooks/${id}/deliveries`,
+            query: query,
+        }),
+        /** A new signing secret, returned once. The previous one keeps verifying for 24 hours. */
+        rotateSecret: (id, options) => this.request({
+            method: 'POST',
+            path: `/webhooks/${id}/rotate-secret`,
+            ...(options ? { options } : {}),
+        }),
     };
     limits = {
         list: (query = {}) => this.request({
@@ -270,6 +384,16 @@ export class AgentiSend {
             path: `/limits/keys/${apiKeyId}/resume`,
             ...(options ? { options } : {}),
         }),
+        /**
+         * Stop every key on the account sending, in one call. Undoing it is a
+         * person's decision, made in the console; no key can resume it.
+         */
+        killAll: (reason, options) => this.request({
+            method: 'POST',
+            path: '/limits/kill-all',
+            body: reason !== undefined ? { reason } : {},
+            ...(options ? { options } : {}),
+        }),
     };
     /** M5.5 — the rest of the verb surface a Resend integration calls. */
     /**
@@ -295,6 +419,12 @@ export class AgentiSend {
             query: query,
         }),
         get: (id) => this.request({ method: 'GET', path: `/emails/receiving/${id}` }),
+        /** Delete one received email for good. */
+        remove: (id, options) => this.request({
+            method: 'DELETE',
+            path: `/emails/receiving/${id}`,
+            ...(options ? { options } : {}),
+        }),
         threads: (query = {}) => this.request({
             method: 'GET',
             path: '/emails/receiving/threads',
@@ -307,6 +437,13 @@ export class AgentiSend {
             ...(options ? { options } : {}),
         }),
         attachments: (id) => this.request({ method: 'GET', path: `/emails/receiving/${id}/attachments` }),
+        /** One received attachment's bytes, served as an inert download. */
+        attachment: (id, attachmentId) => this.requestBytes({
+            method: 'GET',
+            path: `/emails/receiving/${id}/attachments/${attachmentId}`,
+        }),
+        /** The message exactly as it arrived, headers and all. */
+        raw: (id) => this.requestText({ method: 'GET', path: `/emails/receiving/${id}/raw` }),
     };
     /**
      * M5.7 — the custom-event registry. Declaring an event's fields turns a
@@ -373,6 +510,65 @@ export class AgentiSend {
             body: payload,
             ...(options ? { options } : {}),
         }),
+        /** Up to 1,000 contacts. Each item succeeds or fails on its own. */
+        batch: (payload, options) => this.request({ method: 'POST', path: '/contacts/batch', body: payload, ...(options ? { options } : {}) }),
+        /** CSV in `csv`. Finishes in this response. `on_conflict` defaults to skip. */
+        importCsv: (payload, options) => this.request({ method: 'POST', path: '/contacts/imports', body: payload, ...(options ? { options } : {}) }),
+        /** Segments whose rules include this contact. The id may be an email. */
+        segments: (id) => this.request({ method: 'GET', path: `/contacts/${id}/segments` }),
+        /** Refused: membership is the segment's rules. Names PATCH /segments/:id. */
+        addSegment: (id, segmentId, options) => this.request({
+            method: 'POST',
+            path: `/contacts/${id}/segments/${segmentId}`,
+            ...(options ? { options } : {}),
+        }),
+        /** Refused: membership is the segment's rules. Names PATCH /segments/:id. */
+        removeSegment: (id, segmentId, options) => this.request({
+            method: 'DELETE',
+            path: `/contacts/${id}/segments/${segmentId}`,
+            ...(options ? { options } : {}),
+        }),
+        /** Lift a marketing unsubscribe after the person opts back in. */
+        resubscribe: (id, payload, options) => this.request({
+            method: 'POST',
+            path: `/contacts/${id}/resubscribe`,
+            body: payload,
+            ...(options ? { options } : {}),
+        }),
+    };
+    /** Property names and types already stored on the account. */
+    contactProperties = {
+        list: () => this.request({ method: 'GET', path: '/contact-properties' }),
+        get: (id) => this.request({ method: 'GET', path: `/contact-properties/${id}` }),
+    };
+    /**
+     * The same contact list, at the paths the official SDK uses when a call
+     * names an audience. This account has one contact list.
+     */
+    audiences = {
+        createContact: (audienceId, payload, options) => this.request({
+            method: 'POST',
+            path: `/audiences/${audienceId}/contacts`,
+            body: payload,
+            ...(options ? { options } : {}),
+        }),
+        listContacts: (audienceId, query = {}) => this.request({
+            method: 'GET',
+            path: `/audiences/${audienceId}/contacts`,
+            query: query,
+        }),
+        getContact: (audienceId, id) => this.request({ method: 'GET', path: `/audiences/${audienceId}/contacts/${id}` }),
+        updateContact: (audienceId, id, payload, options) => this.request({
+            method: 'PATCH',
+            path: `/audiences/${audienceId}/contacts/${id}`,
+            body: payload,
+            ...(options ? { options } : {}),
+        }),
+        deleteContact: (audienceId, id, options) => this.request({
+            method: 'DELETE',
+            path: `/audiences/${audienceId}/contacts/${id}`,
+            ...(options ? { options } : {}),
+        }),
     };
     broadcasts = {
         create: (payload, options) => this.request({ method: 'POST', path: '/broadcasts', body: payload, ...(options ? { options } : {}) }),
@@ -382,8 +578,23 @@ export class AgentiSend {
             query: query,
         }),
         get: (id) => this.request({ method: 'GET', path: `/broadcasts/${id}` }),
+        /** Sent, delivered, opened, clicked, bounced, complained and unsubscribed. A test send is not included. */
+        stats: (id) => this.request({ method: 'GET', path: `/broadcasts/${id}/stats` }),
+        /** The rendered message. Nothing is sent. */
+        preview: (id) => this.request({ method: 'GET', path: `/broadcasts/${id}/preview` }),
         update: (id, payload, options) => this.request({ method: 'PATCH', path: `/broadcasts/${id}`, body: payload, ...(options ? { options } : {}) }),
-        send: (id, options) => this.request({ method: 'POST', path: `/broadcasts/${id}/send`, ...(options ? { options } : {}) }),
+        /**
+         * Send now, or pass `scheduledAt` to schedule it instead (the same time
+         * grammar PATCH /broadcasts/:id accepts). Returns 200 when the broadcast
+         * has finished sending or was scheduled, and 202 while it is still
+         * sending. A 202 has status sending.
+         */
+        send: (id, payload, options) => this.request({
+            method: 'POST',
+            path: `/broadcasts/${id}/send`,
+            ...(payload?.scheduledAt !== undefined ? { body: { scheduled_at: payload.scheduledAt } } : {}),
+            ...(options ? { options } : {}),
+        }),
         /** Archive, not delete: a sent broadcast is history worth keeping (F14). */
         archive: (id, options) => this.request({ method: 'POST', path: `/broadcasts/${id}/archive`, ...(options ? { options } : {}) }),
         messages: (id, query = {}) => this.request({
@@ -391,12 +602,19 @@ export class AgentiSend {
             path: `/broadcasts/${id}/messages`,
             query: query,
         }),
-        /** Cancel a scheduled broadcast: it returns to draft, editable again. */
+        /** Cancel a scheduled broadcast, or stop one that is still sending. Mail already handed off is not pulled back. A scheduled broadcast returns to draft. */
         cancel: (id, options) => this.request({
             method: 'POST',
             path: `/broadcasts/${id}/cancel`,
             ...(options ? { options } : {}),
         }),
+        /** Copy a broadcast into a new draft: the message, segment, reply_to, preview_text and topic_id. No schedule, sends or history. */
+        duplicate: (id, payload = {}, options) => this.request({
+            method: 'POST',
+            path: `/broadcasts/${id}/duplicate`,
+            body: payload,
+            ...(options ? { options } : {}),
+        }),
     };
     templates = {
         create: (payload, options) => this.request({ method: 'POST', path: '/templates', body: payload, ...(options ? { options } : {}) }),
@@ -409,12 +627,40 @@ export class AgentiSend {
         update: (id, payload, options) => this.request({ method: 'PATCH', path: `/templates/${id}`, body: payload, ...(options ? { options } : {}) }),
         /** Snapshot the draft as an immutable version. Nothing already sent changes. */
         publish: (id, options) => this.request({ method: 'POST', path: `/templates/${id}/publish`, ...(options ? { options } : {}) }),
-        render: (id, values = {}, versionNumber) => this.request({
+        /**
+         * `rendered` is the HTML; `text` is the plain-text part a markdown
+         * template yields. `preview: true` shows a missing required variable as
+         * `{{name}}` and lists it in `missing_variables` instead of failing.
+         */
+        render: (id, values = {}, versionNumber, options = {}) => this.request({
             method: 'POST',
             path: `/templates/${id}/render`,
-            body: { values, ...(versionNumber !== undefined ? { version_number: versionNumber } : {}) },
+            body: {
+                values,
+                ...(versionNumber !== undefined ? { version_number: versionNumber } : {}),
+                ...(options.preview !== undefined ? { preview: options.preview } : {}),
+            },
         }),
+        /**
+         * Delete a template and its versions. Sent mail keeps its body and its
+         * template reference. Refused while a broadcast that has not been sent
+         * still uses it.
+         */
+        delete: (id, options) => this.request({ method: 'DELETE', path: `/templates/${id}`, ...(options ? { options } : {}) }),
         versions: (id) => this.request({ method: 'GET', path: `/templates/${id}/versions` }),
+        version: (id, versionNumber) => this.request({ method: 'GET', path: `/templates/${id}/versions/${versionNumber}` }),
+        /** Structured diff between two versions, or between a version and the draft. */
+        diff: (id, from, to) => this.request({ method: 'GET', path: `/templates/${id}/diff`, query: { from, to } }),
+        /**
+         * Start a new draft from an older version. History is never rewritten; the
+         * live version stays until that draft is published.
+         */
+        rollback: (id, toVersion, options) => this.request({
+            method: 'POST',
+            path: `/templates/${id}/rollback`,
+            body: { to_version: toVersion },
+            ...(options ? { options } : {}),
+        }),
         /** Copy a template into a fresh editable draft, history not included. */
         duplicate: (id, payload = {}, options) => this.request({
             method: 'POST',
@@ -430,6 +676,8 @@ export class AgentiSend {
             query: query,
         }),
         add: (payload, options) => this.request({ method: 'POST', path: '/suppressions', body: payload, ...(options ? { options } : {}) }),
+        /** The id or the address. */
+        get: (id, options) => this.request({ method: 'GET', path: `/suppressions/${id}`, ...(options ? { options } : {}) }),
         remove: (id, options) => this.request({ method: 'DELETE', path: `/suppressions/${id}`, ...(options ? { options } : {}) }),
         /** Up to 500 at a time. Each item succeeds or fails on its own. */
         batchAdd: (emails, level, options) => this.request({
@@ -459,6 +707,12 @@ export class AgentiSend {
         get: (id) => this.request({ method: 'GET', path: `/segments/${id}` }),
         update: (id, payload, options) => this.request({ method: 'PATCH', path: `/segments/${id}`, body: payload, ...(options ? { options } : {}) }),
         delete: (id, options) => this.request({ method: 'DELETE', path: `/segments/${id}`, ...(options ? { options } : {}) }),
+        /** The account contact list. An audience id on this path does not select a second list. */
+        contacts: (id, query = {}) => this.request({
+            method: 'GET',
+            path: `/segments/${id}/contacts`,
+            query: query,
+        }),
         members: (id) => this.request({ method: 'GET', path: `/segments/${id}/members` }),
     };
     /**
@@ -543,9 +797,120 @@ export class AgentiSend {
     };
     /** Public per-component health — the same document the status page renders. */
     status = () => this.request({ method: 'GET', path: '/status' });
+    /** Daily uptime per component over the last 90 days, or `days`. A day nobody measured has no samples. */
+    statusHistory = (query = {}) => this.request({ method: 'GET', path: '/status/history', query });
+    /**
+     * Sending-domain DNS check. No API key. Ten checks a minute from one
+     * network. Returns the records to publish; stores nothing.
+     */
+    dnsCheck = (domain) => this.request({ method: 'GET', path: `/tools/dns/${encodeURIComponent(domain)}` });
+    /** Send, delivery and engagement figures with a daily series, over a window. */
+    metrics = (query = {}) => this.request({
+        method: 'GET',
+        path: '/metrics',
+        query: query,
+    });
+    /** This period's usage per key: budget, consumed, remaining, rate window, last used. */
+    usage = () => this.request({ method: 'GET', path: '/usage' });
+    account = {
+        /** Lifecycle status, the reason for it, and when the account was created. */
+        get: () => this.request({ method: 'GET', path: '/account' }),
+        /**
+         * Set the postal address printed in every broadcast footer. `null` clears
+         * it. A broadcast is not sent until the account has one.
+         */
+        update: (payload, options) => this.request({
+            method: 'PATCH',
+            path: '/account',
+            body: payload,
+            ...(options ? { options } : {}),
+        }),
+    };
     trust = {
         /** What the platform currently thinks of this account, in a shape an agent can branch on. */
         standing: () => this.request({ method: 'GET', path: '/trust/standing' }),
+        /** The published enforcement thresholds, as numbers. */
+        thresholds: () => this.request({ method: 'GET', path: '/trust/thresholds' }),
+        /** Appeal the current standing. The reason is recorded verbatim; a person answers by `sla_deadline_at`. */
+        appeal: (reason, options) => this.request({
+            method: 'POST',
+            path: '/trust/appeal',
+            body: { reason },
+            ...(options ? { options } : {}),
+        }),
+        /** The remediation checklist, with what has been ticked. */
+        remediation: () => this.request({ method: 'GET', path: '/trust/remediation' }),
+        /** Tick or untick one checklist item. Returns the whole checklist. */
+        setRemediation: (payload, options) => this.request({
+            method: 'POST',
+            path: '/trust/remediation',
+            body: payload,
+            ...(options ? { options } : {}),
+        }),
+    };
+    /**
+     * Sends held for a person to approve, and what they decided. Approving or
+     * rejecting is done in the console; a key can list, never decide.
+     */
+    agentActions = {
+        list: (query = {}) => this.request({
+            method: 'GET',
+            path: '/agent-actions',
+            query: query,
+        }),
+    };
+    /** Conditions this account should know about: a spent budget, a kill switch, a lost domain. */
+    notifications = {
+        list: (query = {}) => this.request({
+            method: 'GET',
+            path: '/notifications',
+            query: query,
+        }),
+        read: (id, options) => this.request({
+            method: 'POST',
+            path: `/notifications/${id}/read`,
+            ...(options ? { options } : {}),
+        }),
+        readAll: (options) => this.request({ method: 'POST', path: '/notifications/read', ...(options ? { options } : {}) }),
+        preferences: () => this.request({ method: 'GET', path: '/notifications/preferences' }),
+        setPreferences: (preferences, options) => this.request({
+            method: 'PATCH',
+            path: '/notifications/preferences',
+            body: { preferences },
+            ...(options ? { options } : {}),
+        }),
+    };
+    dedicatedIps = {
+        list: (query = {}) => this.request({
+            method: 'GET',
+            path: '/dedicated-ips',
+            query: query,
+        }),
+        /** Provision a dedicated IP. It starts warming on the published curve. */
+        provision: (payload, options) => this.request({
+            method: 'POST',
+            path: '/dedicated-ips',
+            body: payload,
+            ...(options ? { options } : {}),
+        }),
+        release: (id, options) => this.request({ method: 'DELETE', path: `/dedicated-ips/${id}`, ...(options ? { options } : {}) }),
+        /** The published warmup curve: how volume moves, and when. */
+        ramp: () => this.request({ method: 'GET', path: '/dedicated-ips/ramp' }),
+        /** Which route this message would take right now, by the same math the send path uses. */
+        routeDecision: (messageId) => this.request({ method: 'GET', path: `/dedicated-ips/route-decision/${messageId}` }),
+    };
+    deliverability = {
+        /** Every sending domain with its standing over the window, worst first. */
+        domains: (query = {}) => this.request({ method: 'GET', path: '/deliverability/domains', query }),
+        domain: (id) => this.request({ method: 'GET', path: `/deliverability/domains/${id}` }),
+        /** Persist today's rates as a snapshot. Idempotent per domain per day. */
+        snapshot: (id, options) => this.request({
+            method: 'POST',
+            path: `/deliverability/domains/${id}/snapshot`,
+            ...(options ? { options } : {}),
+        }),
+        /** Aggregate authentication reports: aligned and failing volume per day, and every address sending as you. */
+        dmarc: (query = {}) => this.request({ method: 'GET', path: '/deliverability/dmarc', query }),
     };
     billing = {
         /**
@@ -554,6 +919,8 @@ export class AgentiSend {
          * budget comes from Starter; only a signed-in human in the console can buy.
          */
         plan: () => this.request({ method: 'GET', path: '/billing/plan' }),
+        /** Plan, usage against each published limit, and what the next tier changes. Buying stays in the console. */
+        get: () => this.request({ method: 'GET', path: '/billing' }),
     };
 }
 //# sourceMappingURL=client.js.map