@agentisend/sdk-node 0.2.0 → 0.4.0

package/dist/compat-resend.js

@@ -8,42 +8,128 @@
  *
  * So the surface is a declared table (`RESEND_SDK_SURFACE`), the shim is built
  * from it, and `sdk_compat_covers_every_resend_sdk_method` fails if the two
- * ever disagree. Where AgentiSend is deliberately stricter, the shim WARNS
- * rather than silently changing behaviour — a migration warning is a feature.
+ * ever disagree. `compat_resend_covers_every_resend_sdk_member` goes further
+ * and walks a real `resend` package instance: every member it has, ours has
+ * too — either wired to the matching AgentiSend endpoint, or a `not_supported`
+ * error naming what to use instead, never `undefined`. Where AgentiSend is
+ * deliberately stricter, the shim WARNS rather than silently changing
+ * behaviour — a migration warning is a feature.
  *
- * Mapped against research/10 §A.1 (Resend OpenAPI, 113 operations, fetched
+ * Mapped against resend@6.30.0's own type definitions (RESENDCOMPAT-6,
+ * CLAIMS-11) and research/10 §A.1 (Resend OpenAPI, 113 operations, fetched
  * 2026-09-04) and research/01.
  */
 /* eslint-disable no-console -- the shim's migration warnings are the feature */
 import { AgentiSend } from './client.js';
-import { AgentiSendError } from './errors.js';
+import { AgentiSendError, toResendName } from './errors.js';
+import { verifySvixSignature, SvixSignatureVerificationError } from './webhook-signing.js';
+/** `string | {id, ...rest}` — Resend's own-object-carries-its-id call shape, normalized. */
+function splitIdPayload(first, second) {
+    if (typeof first === 'string')
+        return [first, (second ?? {})];
+    const { id, ...rest } = first;
+    return [id, rest];
+}
 /**
  * Every method the Resend Node SDK exposes that AgentiSend answers, as data.
  *
  * `audiences` is absent on purpose: Resend marks it Deprecated in their own
- * spec, and building a shim for a surface its author is removing would tie a
- * migration to something with no future.
+ * spec (an alias of `segments`), and building a shim for a surface its author
+ * is removing would tie a migration to something with no future.
  */
 export const RESEND_SDK_SURFACE = {
-    emails: ['send', 'get', 'list', 'update', 'cancel', 'metrics'],
-    'emails.batch': ['send'],
+    emails: ['send', 'create', 'get', 'list', 'update', 'cancel', 'metrics'],
+    'emails.batch': ['send', 'create'],
+    'emails.attachments': ['get', 'list'],
+    'emails.receiving': ['get', 'list', 'forward'],
+    'emails.receiving.attachments': ['get', 'list'],
+    batch: ['send', 'create'],
     domains: ['create', 'list', 'get', 'update', 'verify', 'remove'],
     apiKeys: ['create', 'list', 'update', 'remove'],
     contacts: ['create', 'list', 'get', 'update', 'remove'],
+    'contacts.topics': ['list', 'update'],
+    'contacts.segments': ['list', 'add', 'remove'],
+    'contacts.imports': ['create', 'list', 'get'],
     topics: ['create', 'list', 'get', 'update', 'remove'],
     segments: ['create', 'list', 'get', 'update', 'remove'],
-    broadcasts: ['create', 'list', 'get', 'update', 'send', 'remove'],
-    templates: ['create', 'list', 'get', 'update', 'publish', 'render', 'duplicate'],
-    suppressions: ['create', 'list', 'remove'],
+    broadcasts: ['create', 'list', 'get', 'update', 'send', 'remove', 'cancel', 'duplicate'],
+    templates: ['create', 'list', 'get', 'update', 'publish', 'render', 'duplicate', 'remove'],
+    suppressions: ['add', 'list', 'get', 'remove'],
     'suppressions.batch': ['add', 'remove'],
-    automations: ['create', 'list', 'get', 'update', 'enable', 'disable'],
-    webhooks: ['create', 'list', 'get', 'update', 'remove'],
-    events: ['send'],
+    automations: ['create', 'list', 'get', 'update', 'enable', 'disable', 'remove', 'duplicate', 'stop'],
+    'automations.runs': ['get', 'list'],
+    webhooks: ['create', 'list', 'get', 'update', 'remove', 'verify', 'rotateSigningSecret'],
+    'webhooks.events': ['get', 'list', 'replay'],
+    events: ['send', 'create', 'get', 'list', 'update', 'remove'],
+    contactProperties: ['create', 'list', 'get', 'update', 'remove'],
+    logs: ['get', 'list'],
+    usage: ['get'],
+    oauthGrants: ['list', 'revoke'],
 };
+/** A local refusal (never reaches the API), 422 unless stated (RESENDCOMPAT-3). */
+class LocalRefusal extends Error {
+    code;
+    statusCode;
+    constructor(code, message, statusCode = 422) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+    }
+}
+/** `{data:null, error:{name:'not_supported', statusCode:501, message}}`, never `undefined`. */
+function notSupported(message) {
+    return { data: null, error: { message, name: 'not_supported', statusCode: 501, code: 'not_supported' } };
+}
+/**
+ * A callable stand-in for one path under a not-supported resource. Calling it
+ * answers `not_supported`; reading any further property off it (Resend's own
+ * surface nests namespaces arbitrarily deep — `webhooks.events.attempts.list`)
+ * returns another one of these, so a real member at any depth still resolves
+ * to a function rather than `undefined`.
+ */
+function notSupportedNode(path, hint) {
+    const fn = async () => notSupported(`${path} is not available. ${hint}`);
+    return new Proxy(fn, {
+        get(target, prop, receiver) {
+            if (typeof prop === 'symbol' || prop in target)
+                return Reflect.get(target, prop, receiver);
+            return notSupportedNode(`${path}.${String(prop)}`, hint);
+        },
+    });
+}
+/**
+ * A namespace for a Resend resource we do not answer at all (`contactProperties`,
+ * `logs`, `usage`, `oauthGrants`) or only partly (`events`, `contacts.imports`,
+ * `automations`). Any member, at any depth, reaches a `not_supported` stub
+ * instead of `undefined` — `compat_resend_covers_every_resend_sdk_member`
+ * walks the real SDK and checks every member resolves to a function or a
+ * namespace, this way.
+ */
+function notSupportedNamespace(resource, hint) {
+    return new Proxy({}, {
+        get(_target, prop) {
+            if (typeof prop !== 'string')
+                return undefined;
+            return notSupportedNode(`${resource}.${prop}`, hint);
+        },
+    });
+}
+/** As {@link notSupportedNamespace}, but falls back only for members `target` does not itself answer. */
+function withNotSupportedFallback(target, resource, hint) {
+    return new Proxy(target, {
+        get(obj, prop, receiver) {
+            if (prop in obj || typeof prop === 'symbol')
+                return Reflect.get(obj, prop, receiver);
+            return notSupportedNode(`${resource}.${String(prop)}`, hint);
+        },
+    });
+}
 export class Resend {
     client;
     warn;
     emails;
+    /** Resend's top-level `batch` — the same calls as `emails.batch` (RESENDCOMPAT-6/CLAIMS-11). */
+    batch;
     domains;
     apiKeys;
     contacts;
@@ -55,59 +141,80 @@ export class Resend {
     automations;
     webhooks;
     events;
-    constructor(apiKey, baseUrl) {
-        this.client = new AgentiSend(apiKey, baseUrl !== undefined ? { baseUrl } : {});
+    /** Resend's `contactProperties`, `logs`, `usage`, `oauthGrants`: no AgentiSend counterpart today. */
+    contactProperties;
+    logs;
+    usage;
+    oauthGrants;
+    constructor(key = process.env.RESEND_API_KEY ?? process.env.AGENTISEND_API_KEY, options) {
+        const resolved = typeof options === 'string' ? { baseUrl: options } : options ?? {};
+        this.client = new AgentiSend(key, resolved);
         // A migration warning is a feature: it names exactly where AgentiSend is
         // stricter than Resend instead of silently changing behaviour.
         this.warn = (message) => console.warn(`[agentisend/compat-resend] ${message}`);
+        const sendOne = async (payload, options) => asResend(async () => {
+            const resolved = await this.resolveReact(payload);
+            const result = await this.client.emails.send(this.toSendBody(resolved), options);
+            return { id: result.id };
+        });
+        const sendBatch = async (payloads, options) => asResend(async () => {
+            const resolved = await Promise.all(payloads.map((p) => this.resolveReact(p)));
+            const bodies = resolved.map((p) => this.toSendBody(p));
+            const mode = options?.batchValidation ?? 'strict';
+            const requestOptions = {
+                ...(options?.idempotencyKey !== undefined ? { idempotencyKey: options.idempotencyKey } : {}),
+                ...(mode === 'native' ? {} : { headers: { 'x-batch-validation': mode } }),
+            };
+            const result = (await this.client.emails.batch(bodies, requestOptions));
+            return { data: batchResultItems(mode, result) };
+        });
         this.emails = {
-            send: async (payload, options) => asResend(async () => {
-                if (!payload.html && !payload.text) {
-                    throw new Error('Provide html or text.');
-                }
-                const result = await this.client.emails.send(this.toSendBody(payload), options);
-                return { id: result.id };
-            }),
+            send: sendOne,
+            create: sendOne,
             get: async (id) => asResend(async () => row(await this.client.emails.get(id))),
             list: async (query = {}) => asResend(async () => rowsOf(await this.client.emails.list(query))),
-            update: async (id, payload) => {
+            update: async (idOrPayload, payload) => {
+                const [id, body] = splitIdPayload(idOrPayload, payload);
                 // Their `update` only ever moved the schedule; ours is the same act
                 // under a name that says so.
-                return asResend(async () => row(await this.client.emails.reschedule(id, payload.scheduledAt)));
+                return asResend(async () => row(await this.client.emails.reschedule(id, body.scheduledAt)));
             },
             cancel: async (id) => asResend(async () => row(await this.client.emails.cancel(id))),
             metrics: async (query = {}) => asResend(async () => row(await this.client.emails.metrics(query))),
-            batch: {
-                send: async (payloads, options) => asResend(async () => {
-                    const results = await this.client.emails.batch(payloads.map((p) => this.toSendBody(p)), options);
-                    return results.data.map((item) => {
-                        if (item.status === 'accepted' && item.id !== undefined)
-                            return { id: item.id };
-                        return {
-                            id: null,
-                            error: {
-                                message: item.error?.message ?? 'This item was not accepted.',
-                                name: item.error?.code ?? 'validation_error',
-                                statusCode: 422,
-                            },
-                        };
-                    });
-                }),
+            batch: { send: sendBatch, create: sendBatch },
+            attachments: {
+                get: async ({ emailId, id }) => asResend(async () => ({ content: await this.client.emails.attachment(emailId, id) })),
+                list: async ({ emailId }) => asResend(async () => rowsOf(await this.client.emails.attachments(emailId))),
+            },
+            receiving: {
+                get: async (id) => asResend(async () => row(await this.client.receiving.get(id))),
+                list: async (query = {}) => asResend(async () => rowsOf(await this.client.receiving.list(query))),
+                forward: async () => notSupported('emails.receiving.forward is not available. Reply with emails.receiving.reply-shaped POST /emails/receiving/:id/reply through client.request(), or in the console.'),
+                attachments: {
+                    get: async ({ emailId, id }) => asResend(async () => ({ content: await this.client.receiving.attachment(emailId, id) })),
+                    list: async ({ emailId }) => asResend(async () => rowsOf(await this.client.receiving.attachments(emailId))),
+                },
             },
         };
+        this.batch = this.emails.batch;
+        this.emails = withNotSupportedFallback(this.emails, 'emails', 'attachments, receiving and share have no counterpart beyond what is wired above.');
         this.domains = {
             create: async (input) => {
                 if (typeof input.region !== 'string' || input.region.length === 0) {
-                    this.warn('Resend defaulted a domain region silently; AgentiSend requires an explicit region (F13). Pass region explicitly.');
+                    this.warn('Resend defaulted a domain region silently; omitting it here stores this domain as us (Oregon) — pass an explicit region to choose eu.');
                 }
-                return asResend(async () => row(await this.client.domains.create(input)));
+                return asResend(async () => row(await this.client.domains.create(resendDomainCreate(input))));
             },
             list: async () => asResend(async () => rowsOf(await this.client.domains.list())),
             get: async (id) => asResend(async () => row(await this.client.domains.get(id))),
-            update: async (id, payload) => asResend(async () => row(await this.client.domains.update(id, payload))),
+            update: async (idOrPayload, maybe) => {
+                const [id, raw] = splitIdPayload(idOrPayload, maybe);
+                return asResend(async () => row(await this.client.domains.update(id, resendDomainUpdate(raw))));
+            },
             verify: async (id) => asResend(async () => row(await this.client.domains.verify(id))),
             remove: async (id) => asResend(async () => row(await this.client.domains.delete(id))),
         };
+        this.domains = withNotSupportedFallback({ ...this.domains, claims: notSupportedNamespace('domains.claims', 'Domain claims are not available today.') }, 'domains', 'Not available today.');
         this.apiKeys = {
             create: async (input) => asResend(async () => row(await this.client.apiKeys.create({ name: input.name, permission: input.permission }))),
             list: async () => asResend(async () => rowsOf(await this.client.apiKeys.list())),
@@ -115,17 +222,100 @@ export class Resend {
             remove: async (id) => asResend(async () => row(await this.client.apiKeys.delete(id))),
         };
         this.contacts = {
-            create: async (input) => asResend(async () => row(await this.client.contacts.create(input))),
-            list: async (query = {}) => asResend(async () => rowsOf(await this.client.contacts.list(query))),
-            get: async (id) => asResend(async () => row(await this.client.contacts.get(id))),
-            update: async (id, input) => asResend(async () => row(await this.client.contacts.update(id, input))),
-            remove: async (id) => asResend(async () => row(await this.client.contacts.delete(id))),
+            create: async (input) => asResend(async () => row(await this.client.request({
+                method: 'POST',
+                path: input.audienceId ? `/audiences/${input.audienceId}/contacts` : '/contacts',
+                body: contactWireBody(input),
+            }))),
+            list: async (query = {}) => asResend(async () => {
+                const segmentId = query.segmentId ?? query.audienceId;
+                if (segmentId) {
+                    const page = await this.client.request({
+                        method: 'GET',
+                        path: `/segments/${segmentId}/contacts`,
+                        ...(query.email !== undefined ? { query: { email: query.email } } : {}),
+                    });
+                    return rowsOf(page);
+                }
+                return rowsOf(await this.client.contacts.list(query));
+            }),
+            get: async (idOrOptions) => {
+                const ref = contactRef(idOrOptions);
+                if (!ref.ok)
+                    return ref.result;
+                return asResend(async () => row(await this.client.request({ method: 'GET', path: contactPath(ref.audienceId, ref.key) })));
+            },
+            update: async (idOrOptions, input) => {
+                if (typeof idOrOptions === 'string') {
+                    return asResend(async () => row(await this.client.request({
+                        method: 'PATCH',
+                        path: `/contacts/${idOrOptions}`,
+                        body: contactWireBody(input ?? {}),
+                    })));
+                }
+                const ref = contactRef(idOrOptions);
+                if (!ref.ok)
+                    return ref.result;
+                return asResend(async () => row(await this.client.request({
+                    method: 'PATCH',
+                    path: contactPath(ref.audienceId, ref.key),
+                    body: contactWireBody(idOrOptions),
+                })));
+            },
+            remove: async (idOrOptions) => {
+                const ref = contactRef(idOrOptions);
+                if (!ref.ok)
+                    return ref.result;
+                return asResend(async () => row(await this.client.request({ method: 'DELETE', path: contactPath(ref.audienceId, ref.key) })));
+            },
+            topics: {
+                list: async ({ id, email, ...query }) => {
+                    const key = id ?? email;
+                    if (!key)
+                        return notSupportedRefusal('contacts.topics.list needs id or email.');
+                    return asResend(async () => rowsOf(await this.client.request({
+                        method: 'GET',
+                        path: `/contacts/${key}/topics`,
+                        query: query,
+                    })));
+                },
+                update: async ({ id, email, topics }) => {
+                    const key = id ?? email;
+                    if (!key)
+                        return notSupportedRefusal('contacts.topics.update needs id or email.');
+                    return asResend(async () => row(await this.client.request({ method: 'PATCH', path: `/contacts/${key}/topics`, body: topics })));
+                },
+            },
+            segments: {
+                list: async ({ contactId, email }) => {
+                    const key = contactId ?? email;
+                    if (!key)
+                        return notSupportedRefusal('contacts.segments.list needs contactId or email.');
+                    return asResend(async () => rowsOf(await this.client.contacts.segments(key)));
+                },
+                add: async ({ contactId, email, segmentId }) => {
+                    const key = contactId ?? email;
+                    if (!key)
+                        return notSupportedRefusal('contacts.segments.add needs contactId or email.');
+                    return asResend(async () => row(await this.client.contacts.addSegment(key, segmentId)));
+                },
+                remove: async ({ contactId, email, segmentId }) => {
+                    const key = contactId ?? email;
+                    if (!key)
+                        return notSupportedRefusal('contacts.segments.remove needs contactId or email.');
+                    return asResend(async () => row(await this.client.contacts.removeSegment(key, segmentId)));
+                },
+            },
+            imports: notSupportedNamespace('contacts.imports', 'Send a CSV through client.request({method:"POST", path:"/contacts/imports", body:{csv}}) instead.'),
         };
         this.topics = {
             create: async (input) => asResend(async () => row(await this.client.topics.create(input))),
             list: async () => asResend(async () => rowsOf(await this.client.topics.list())),
             get: async (id) => asResend(async () => row(await this.client.topics.get(id))),
-            update: async (id, input) => asResend(async () => row(await this.client.topics.update(id, input))),
+            update: async (idOrPayload, input) => {
+                const [id, payload] = splitIdPayload(idOrPayload, input);
+                return asResend(async () => row(await this.client.topics.update(id, payload)));
+            },
             remove: async (id) => asResend(async () => row(await this.client.topics.delete(id))),
         };
         this.segments = {
@@ -140,12 +330,15 @@ export class Resend {
             list: async () => asResend(async () => rowsOf(await this.client.broadcasts.list())),
             get: async (id) => asResend(async () => row(await this.client.broadcasts.get(id))),
             update: async (id, payload) => asResend(async () => row(await this.client.broadcasts.update(id, payload))),
-            send: async (id) => asResend(async () => row(await this.client.broadcasts.send(id))),
+            send: async (id, payload) => asResend(async () => row(await this.client.broadcasts.send(id, payload))),
+            cancel: async (id) => asResend(async () => row(await this.client.broadcasts.cancel(id))),
             remove: async (id) => {
                 this.warn('Resend deletes a broadcast; AgentiSend archives it, so what was sent stays auditable (F14). This archived it.');
                 return asResend(async () => row(await this.client.broadcasts.archive(id)));
             },
+            duplicate: async () => notSupported('broadcasts.duplicate is not available. Read it with broadcasts.get and broadcasts.create a copy.'),
         };
+        this.broadcasts = withNotSupportedFallback(this.broadcasts, 'broadcasts', 'Per-recipient and per-link engagement rows are not available; read GET /broadcasts/:id/stats through client.request().');
         this.templates = {
             create: async (payload) => asResend(async () => row(await this.client.templates.create(payload))),
             list: async () => asResend(async () => rowsOf(await this.client.templates.list())),
@@ -154,69 +347,297 @@ export class Resend {
             publish: async (id) => asResend(async () => row(await this.client.templates.publish(id))),
             render: async (id, values = {}) => asResend(async () => await this.client.templates.render(id, values)),
             duplicate: async (id, name) => asResend(async () => row(await this.client.templates.duplicate(id, name !== undefined ? { name } : {}))),
+            remove: async (id) => asResend(async () => row(await this.client.templates.delete(id))),
         };
         this.suppressions = {
-            create: async (input) => asResend(async () => row(await this.client.suppressions.add(input))),
+            add: async (input) => {
+                const email = typeof input === 'string' ? input : input.email;
+                const level = typeof input === 'string' ? undefined : input.level;
+                return asResend(async () => row(await this.client.suppressions.add({ email, ...(level ? { level } : {}) })));
+            },
             list: async () => asResend(async () => rowsOf(await this.client.suppressions.list())),
-            remove: async (id) => asResend(async () => row(await this.client.suppressions.remove(id))),
+            get: async (idOrEmail) => asResend(async () => row(await this.client.suppressions.get(idOrEmail))),
+            remove: async (idOrEmail) => asResend(async () => row(await this.client.suppressions.remove(idOrEmail))),
             batch: {
-                add: async (emails) => asResend(async () => rowsOf(await this.client.suppressions.batchAdd(emails))),
-                remove: async (emails) => asResend(async () => rowsOf(await this.client.suppressions.batchRemove(emails))),
+                add: async (input) => {
+                    const emails = Array.isArray(input) ? input : input.emails;
+                    return asResend(async () => rowsOf(await this.client.suppressions.batchAdd(emails)));
+                },
+                remove: async (input) => {
+                    const emails = Array.isArray(input) ? input : (input.emails ?? []);
+                    return asResend(async () => rowsOf(await this.client.suppressions.batchRemove(emails)));
+                },
             },
         };
-        this.automations = {
+        const automations = {
             create: async (payload) => asResend(async () => row(await this.client.automations.create(payload))),
             list: async () => asResend(async () => rowsOf(await this.client.automations.list())),
             get: async (id) => asResend(async () => row(await this.client.automations.get(id))),
             update: async (id, payload) => asResend(async () => row(await this.client.automations.update(id, payload))),
             enable: async (id) => asResend(async () => row(await this.client.automations.enable(id))),
             disable: async (id) => asResend(async () => row(await this.client.automations.disable(id))),
+            runs: {
+                list: async ({ automationId, ...query }) => asResend(async () => rowsOf(await this.client.automations.runs(automationId, query))),
+                get: async ({ automationId, runId }) => asResend(async () => row(await this.client.automations.run(automationId, runId))),
+            },
         };
-        this.webhooks = {
-            create: async (input) => asResend(async () => row(await this.client.webhooks.create({
-                url: input.endpoint,
+        this.automations = withNotSupportedFallback(automations, 'automations', 'There is no remove, duplicate or stop for automations today; disable it instead.');
+        const webhooks = {
+            create: async (input) => asResend(async () => webhookRow(await this.client.webhooks.create({
+                url: (input.endpoint ?? input.url),
                 events: input.events.includes('*') ? ['*'] : input.events,
+                // Always on: the shim is the bridge for a receiver that kept
+                // its Svix verifier and Resend's own envelope, whether or not
+                // the caller asked for either by name (RESENDCOMPAT-7).
+                svix_compat: true,
+                payload_format: 'resend',
             }))),
             list: async () => asResend(async () => rowsOf(await this.client.webhooks.list())),
-            get: async (id) => asResend(async () => row(await this.client.webhooks.get(id))),
-            update: async (id, payload) => asResend(async () => row(await this.client.webhooks.update(id, payload))),
+            get: async (id) => asResend(async () => webhookRow(await this.client.webhooks.get(id))),
+            update: async (id, payload) => asResend(async () => webhookRow(await this.client.webhooks.update(id, payload))),
             remove: async (id) => asResend(async () => row(await this.client.webhooks.delete(id))),
+            rotateSigningSecret: async (id) => asResend(async () => {
+                const rotated = await this.client.webhooks.rotateSecret(id);
+                return { ...rotated, signing_secret: rotated.secret };
+            }),
+            verify: (payload) => verifySvixSignature(payload.webhookSecret, payload.payload, payload.headers),
+            // Delivery-attempt history: not available through the shim today.
+            events: notSupportedNamespace('webhooks.events', 'Read GET /webhooks/:id/deliveries through client.request() instead.'),
         };
-        this.events = {
-            send: async (payload) => asResend(async () => row(await this.client.events.ingest(payload))),
+        this.webhooks = withNotSupportedFallback(webhooks, 'webhooks', 'events (delivery attempt history) is not available; use GET /webhooks/:id/deliveries through client.request().');
+        const events = {
+            send: async (payload) => asResend(async () => {
+                const name = payload.event ?? payload.name;
+                const contactId = payload.contactId ?? payload.contact_id;
+                if (!name)
+                    throw new LocalRefusal('missing_required_field', 'Provide event (or name).');
+                if (payload.email !== undefined && contactId === undefined) {
+                    throw new LocalRefusal('not_supported', 'events.send by email is not available; resolve a contact_id first (contacts.list({email})).');
+                }
+                return row(await this.client.events.ingest({
+                    name,
+                    ...(contactId !== undefined ? { contact_id: contactId } : {}),
+                    data: payload.payload ?? payload.data ?? {},
+                }));
+            }),
         };
+        this.events = withNotSupportedFallback(events, 'events', 'Custom event definitions (create/get/list/update/remove) are not available; events.send registers one on first use.');
+        this.contactProperties = notSupportedNamespace('contactProperties', 'Store extra fields on the contact itself with contacts.update({properties}).');
+        this.logs = notSupportedNamespace('logs', 'Read GET /emails/:id through client.request(), or the console.');
+        this.usage = notSupportedNamespace('usage', 'Read GET /account through client.request(), or the console.');
+        this.oauthGrants = notSupportedNamespace('oauthGrants', 'Manage MCP OAuth grants in the console.');
+    }
+    /** react → html (and text), via a dynamically imported, optional renderer (RESENDCOMPAT-3). */
+    async resolveReact(payload) {
+        if (payload.react === undefined)
+            return payload;
+        // Never a dependency of this package: a caller who wants react installs
+        // it, same as with the real Resend SDK. The specifier is read from a
+        // variable so a bundler / tsc does not try to resolve it eagerly.
+        const specifier = '@react-email/render';
+        let renderer;
+        try {
+            renderer = (await import(specifier));
+        }
+        catch {
+            throw new LocalRefusal('validation_error', 'Install @react-email/render to send react, or pass html.');
+        }
+        const { react, ...rest } = payload;
+        const html = await renderer.render(react);
+        let text;
+        try {
+            text = await renderer.render(react, { plainText: true });
+        }
+        catch {
+            text = undefined;
+        }
+        return { ...rest, html, ...(text !== undefined ? { text } : {}) };
     }
+    /**
+     * Forward every key `sendEmailBodySchema` accepts (RESENDCOMPAT-2, -3). The
+     * API already folds `replyTo`, `scheduledAt`, `topicId` and `template`, so
+     * only `to`/`cc`/`bcc` (to arrays), `tags` (list to map) and attachment
+     * content (Buffer/Uint8Array to base64) need transforming here — everything
+     * else is spread through unchanged, so an unknown key reaches the API's zod
+     * schema and gets a clear 400 instead of silently vanishing.
+     */
     toSendBody(payload) {
+        const { to, cc, bcc, reply_to, replyTo, tags, attachments, topicId, topic_id, react: _react, ...rest } = payload;
+        void _react; // stripped by resolveReact before this runs; never forwarded.
+        const topic = topicId ?? topic_id;
+        const replies = reply_to ?? replyTo;
         return {
-            from: payload.from,
-            to: toArray(payload.to),
-            subject: payload.subject,
-            ...(payload.html !== undefined ? { html: payload.html } : {}),
-            ...(payload.text !== undefined ? { text: payload.text } : {}),
-            ...(payload.cc !== undefined ? { cc: toArray(payload.cc) } : {}),
-            ...(payload.bcc !== undefined ? { bcc: toArray(payload.bcc) } : {}),
-            ...(payload.reply_to !== undefined ? { reply_to: toArray(payload.reply_to) } : {}),
-            ...(payload.headers !== undefined ? { headers: payload.headers } : {}),
-            ...(payload.tags !== undefined
-                ? { tags: Object.fromEntries(payload.tags.map((t) => [t.name, t.value])) }
+            ...rest,
+            to: toArray(to),
+            ...(cc !== undefined ? { cc: toArray(cc) } : {}),
+            ...(bcc !== undefined ? { bcc: toArray(bcc) } : {}),
+            ...(replies !== undefined ? { reply_to: toArray(replies) } : {}),
+            ...(tags !== undefined
+                ? { tags: Array.isArray(tags) ? Object.fromEntries(tags.map((t) => [t.name, t.value])) : tags }
                 : {}),
-            ...(payload.attachments !== undefined ? { attachments: payload.attachments } : {}),
-            ...(payload.scheduledAt !== undefined ? { scheduled_at: payload.scheduledAt } : {}),
+            ...(attachments !== undefined
+                ? { attachments: attachments.map((a) => ({ ...a, content: attachmentContentToWire(a.content) })) }
+                : {}),
+            ...(topic !== undefined && topic !== null ? { topic_id: topic } : {}),
         };
     }
 }
+/** Resend field names on domains.create, written as the fields POST /domains stores. */
+export function resendDomainCreate(input) {
+    const returnPath = input.return_path_subdomain ?? input.custom_return_path ?? input.customReturnPath;
+    const tls = input.tls_mode ?? input.tls;
+    const open = input.open_tracking ?? input.openTracking;
+    const click = input.click_tracking ?? input.clickTracking;
+    const trackingSubdomain = input.tracking_subdomain ?? input.trackingSubdomain;
+    return {
+        name: input.name,
+        ...(input.region !== undefined ? { region: input.region } : {}),
+        ...(returnPath !== undefined ? { return_path_subdomain: returnPath } : {}),
+        ...(tls !== undefined ? { tls_mode: tls } : {}),
+        ...(open !== undefined ? { open_tracking: open } : {}),
+        ...(click !== undefined ? { click_tracking: click } : {}),
+        ...(trackingSubdomain !== undefined ? { tracking_subdomain: trackingSubdomain } : {}),
+    };
+}
+/** Resend field names on domains.update (RESENDCOMPAT-6): camelCase or snake_case, either wins consistently. */
+export function resendDomainUpdate(input) {
+    const click = input.click_tracking ?? input.clickTracking;
+    const open = input.open_tracking ?? input.openTracking;
+    const tls = input.tls_mode ?? input.tls;
+    const trackingSubdomain = input.tracking_subdomain ?? input.trackingSubdomain;
+    return {
+        ...(click !== undefined ? { click_tracking: click } : {}),
+        ...(open !== undefined ? { open_tracking: open } : {}),
+        ...(tls !== undefined ? { tls_mode: tls } : {}),
+        ...(trackingSubdomain !== undefined ? { tracking_subdomain: trackingSubdomain } : {}),
+    };
+}
 function toArray(value) {
     return Array.isArray(value) ? value : [value];
 }
+/** A base64 string, a Node Buffer, or any `Uint8Array` — all become base64 (RESENDCOMPAT-12). */
+function attachmentContentToWire(content) {
+    if (content === undefined || typeof content === 'string')
+        return content;
+    return Buffer.from(content).toString('base64');
+}
+function contactWireBody(input) {
+    const src = input;
+    const first = src.first_name !== undefined ? src.first_name : src.firstName;
+    const last = src.last_name !== undefined ? src.last_name : src.lastName;
+    return {
+        ...(src.email !== undefined ? { email: src.email } : {}),
+        ...(first !== undefined ? { first_name: first } : {}),
+        ...(last !== undefined ? { last_name: last } : {}),
+        ...(src.unsubscribed !== undefined ? { unsubscribed: src.unsubscribed } : {}),
+        ...(src.status !== undefined ? { status: src.status } : {}),
+        ...(src.properties !== undefined ? { properties: src.properties } : {}),
+    };
+}
+function contactPath(audienceId, key) {
+    return audienceId ? `/audiences/${audienceId}/contacts/${key}` : `/contacts/${key}`;
+}
+function contactRef(idOrOptions) {
+    if (typeof idOrOptions === 'string')
+        return { ok: true, key: idOrOptions };
+    const key = idOrOptions.email ?? idOrOptions.id;
+    if (!key) {
+        return {
+            ok: false,
+            result: {
+                data: null,
+                error: {
+                    message: 'Missing `id` or `email` field.',
+                    name: 'missing_required_field',
+                    statusCode: 422,
+                },
+            },
+        };
+    }
+    return {
+        ok: true,
+        key,
+        ...(idOrOptions.audienceId !== undefined ? { audienceId: idOrOptions.audienceId } : {}),
+    };
+}
+function notSupportedRefusal(message) {
+    return { data: null, error: { message, name: 'missing_required_field', statusCode: 422 } };
+}
 function row(value) {
     return value;
 }
+/** `object:'webhook'` beside the existing `secret`/`signing_secret` (RESENDCOMPAT-7). */
+function webhookRow(value) {
+    return { object: 'webhook', ...value };
+}
 function rowsOf(result) {
-    return result.data;
+    return { object: 'list', data: result.data, has_more: result.has_more ?? false };
+}
+/** `native` mode's own `BatchItemResult[]` (`{index,status,id?,error?}`) → Resend's `{id}`/`{id:null,error}`. */
+function nativeBatchItems(items) {
+    return items.map((item) => {
+        if (item.status === 'accepted' && item.id !== undefined)
+            return { id: item.id };
+        return {
+            id: null,
+            error: {
+                message: item.error?.message ?? 'This item was not accepted.',
+                name: toResendName(item.error?.code ?? 'validation_error', item.error?.message ?? ''),
+                statusCode: 422,
+                ...(item.error?.code !== undefined ? { code: item.error.code } : {}),
+            },
+        };
+    });
+}
+/**
+ * `strict`/`permissive` share Resend's own shape: `{id}` for every accepted
+ * item, in order, plus an `errors: [{index, message}]` side list for
+ * `permissive` (strict either has none, or the whole call already threw).
+ * Reconstructed here into one index-aligned array, so a caller's `data[i]`
+ * still lines up with `payloads[i]` the way `native` mode always has.
+ */
+function shapedBatchItems(result) {
+    const errorsByIndex = new Map((result.errors ?? []).map((e) => [e.index, e]));
+    const total = result.data.length + errorsByIndex.size;
+    const accepted = [...result.data];
+    const out = [];
+    for (let i = 0; i < total; i++) {
+        const err = errorsByIndex.get(i);
+        if (err) {
+            out.push({ id: null, error: { message: err.message, name: toResendName('validation_error', err.message), statusCode: 422 } });
+            continue;
+        }
+        const item = accepted.shift();
+        out.push({ id: item ? item.id : null });
+    }
+    return out;
+}
+function batchResultItems(mode, result) {
+    if (mode === 'native') {
+        return nativeBatchItems(result.data);
+    }
+    return shapedBatchItems(result);
 }
 function toResendError(caught) {
     if (caught instanceof AgentiSendError) {
-        return { message: caught.message, name: caught.code, statusCode: caught.status };
+        return {
+            message: caught.message,
+            name: toResendName(caught.code, caught.message),
+            statusCode: caught.status,
+            code: caught.code,
+            fix: caught.fix,
+        };
+    }
+    if (caught instanceof LocalRefusal) {
+        return {
+            message: caught.message,
+            name: toResendName(caught.code, caught.message),
+            statusCode: caught.statusCode,
+            code: caught.code,
+        };
+    }
+    if (caught instanceof SvixSignatureVerificationError) {
+        return { message: caught.message, name: 'validation_error', statusCode: 401 };
     }
     if (caught instanceof Error) {
         return { message: caught.message, name: 'application_error', statusCode: 500 };