delivrie 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 South Circle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,122 @@
-# Temporary Holding Version
+# Delivrie for Node.js
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The official TypeScript SDK for the [Delivrie](https://delivrie.io) email API. It uses only web-standard APIs (`fetch`, Web Crypto), so the same package runs on Node.js 18+, Bun, Deno, Cloudflare Workers and Vercel Edge. No dependencies.
+
+```bash
+npm install delivrie
+```
+
+## Send an email
+
+```ts
+import { Delivrie } from "delivrie";
+
+const delivrie = new Delivrie(process.env.DELIVRIE_API_KEY);
+
+const { data, error } = await delivrie.emails.send({
+  from: "Kora <orders@mail.kora.ng>",
+  to: "ada@example.com",
+  subject: "Your order is on its way",
+  html: "<p>Thanks for your order!</p>",
+});
+
+if (error) console.error(error.name, error.message);
+else console.log("Sent", data.id);
+```
+
+Create an API key at [delivrie.io/api-keys](https://delivrie.io/api-keys). If you leave out the key, the SDK reads `DELIVRIE_API_KEY` from the environment. Never use your key in browser code: call Delivrie from your server or an edge function.
+
+CommonJS works too:
+
+```js
+const Delivrie = require("delivrie");
+const delivrie = new Delivrie("dlv_...");
+```
+
+## Results and errors
+
+Every call resolves to `{ data, error }`, and exactly one of them is `null`. API errors never throw, so you don't need `try`/`catch`:
+
+```ts
+const { error } = await delivrie.domains.get("dom_123");
+if (error?.name === "not_found") { /* ... */ }
+```
+
+`error` has `statusCode`, `name` and `message`, matching the [API's errors](https://delivrie.io/docs/errors). Network problems and timeouts come back with `statusCode: 0` and the name `network_error` or `timeout`.
+
+## Retries and idempotency
+
+Reads and deletes are retried up to twice on server errors and network failures, with backoff. Sends are only retried when you pass an idempotency key, so a retry can never send the same email twice:
+
+```ts
+await delivrie.emails.send(email, { idempotencyKey: `order-${order.id}` });
+```
+
+Change the defaults with `new Delivrie(key, { maxRetries: 0, timeout: 10_000 })`.
+
+## More examples
+
+```ts
+// Attachments: pass a base64 string, a Buffer or a Uint8Array
+await delivrie.emails.send({
+  from: "billing@mail.kora.ng",
+  to: ["ada@example.com"],
+  subject: "Invoice",
+  text: "Your invoice is attached.",
+  attachments: [{ filename: "invoice.pdf", content: await readFile("invoice.pdf") }],
+});
+
+// A published template, scheduled for later
+await delivrie.emails.send({
+  from: "hello@mail.kora.ng",
+  to: "ada@example.com",
+  template: { id: "welcome", variables: { first_name: "Ada" } },
+  scheduledAt: "tomorrow at 9am",
+});
+
+// Up to 100 emails in one request
+await delivrie.emails.batch([{ ... }, { ... }]);
+
+// Domains, contacts, broadcasts
+await delivrie.domains.create({ name: "mail.kora.ng" });
+await delivrie.contacts.create({ email: "ada@example.com", first_name: "Ada" });
+await delivrie.broadcasts.send("bc_123", { scheduled_at: "in 1 hour" });
+
+// Start automations listening for an event
+await delivrie.events.send({ event: "user.signed_up", email: "ada@example.com", data: { plan: "starter" } });
+```
+
+The client covers `emails`, `domains`, `apiKeys`, `webhooks`, `contacts`, `segments`, `topics`, `contactProperties`, `broadcasts`, `templates`, `suppressions`, `events`, `automations`, `inbox`, `metrics`, `logs` and `usage`. For anything else, `delivrie.request(method, path, body)` calls the API directly.
+
+## Verify webhooks
+
+Delivrie signs webhooks with the [Standard Webhooks](https://www.standardwebhooks.com) scheme. Check the signature against the raw body, before parsing it:
+
+```ts
+import { verifyWebhook } from "delivrie";
+
+// Next.js route handler, Hono, Workers, etc.
+export async function POST(req: Request) {
+  try {
+    const event = await verifyWebhook({
+      payload: await req.text(),
+      headers: req.headers,
+      secret: process.env.DELIVRIE_WEBHOOK_SECRET!, // whsec_...
+    });
+    if (event.type === "email.bounced") { /* ... */ }
+    return new Response("ok");
+  } catch {
+    return new Response("invalid signature", { status: 400 });
+  }
+}
+```
+
+With Express, use `express.raw({ type: "application/json" })` on the route and pass `req.body` and `req.headers`.
+
+## Links
+
+- [Docs](https://delivrie.io/docs)
+- [API reference](https://delivrie.io/docs/api)
+- [Changelog](https://delivrie.io/docs/changelog)
+
+MIT licensed.

package/dist/cjs/client.cjs

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Delivrie = exports.VERSION = void 0;
+const webhooks_js_1 = require("./webhooks.cjs");
+exports.VERSION = "0.1.0";
+const DEFAULT_BASE_URL = "https://delivrie.io/api";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const enc = encodeURIComponent;
+function toBase64(bytes) {
+    let s = "";
+    for (let i = 0; i < bytes.length; i += 0x8000)
+        s += String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + 0x8000)));
+    return btoa(s);
+}
+function normalizeEmail(e) {
+    const { replyTo, scheduledAt, attachments, ...rest } = e;
+    const out = { ...rest };
+    if (out.reply_to === undefined && replyTo !== undefined)
+        out.reply_to = replyTo;
+    const when = rest.scheduled_at ?? scheduledAt;
+    if (when !== undefined)
+        out.scheduled_at = when instanceof Date ? when.toISOString() : when;
+    if (attachments)
+        out.attachments = attachments.map((a) => ({ ...a, content: typeof a.content === "string" ? a.content : toBase64(a.content) }));
+    return out;
+}
+/**
+ * The Delivrie client.
+ *
+ * ```ts
+ * import { Delivrie } from "delivrie";
+ * const delivrie = new Delivrie(process.env.DELIVRIE_API_KEY);
+ * const { data, error } = await delivrie.emails.send({ from: "Kora <hi@kora.ng>", to: "ada@example.com", subject: "Hi", html: "<p>Hello</p>" });
+ * ```
+ */
+class Delivrie {
+    constructor(apiKey, options = {}) {
+        // ---------------------------------------------------------------- resources
+        this.emails = {
+            /** Send one email. Returns its id straight away; delivery events arrive through webhooks. */
+            send: (email, opts) => this.request("POST", "/emails", normalizeEmail(email), opts),
+            /** Send up to 100 emails in one request (no attachments or scheduling). */
+            batch: (emails, opts) => this.request("POST", "/emails/batch", emails.map(normalizeEmail), opts),
+            get: (id) => this.request("GET", `/emails/${enc(id)}`),
+            list: (params = {}) => this.request("GET", "/emails", undefined, { query: { ...params } }),
+            /** Received (inbound) emails. */
+            listReceived: (params = {}) => this.request("GET", "/emails/received", undefined, { query: { ...params } }),
+            /** Move a scheduled email. */
+            update: (id, params) => this.request("PATCH", `/emails/${enc(id)}`, { scheduled_at: params.scheduled_at instanceof Date ? params.scheduled_at.toISOString() : params.scheduled_at }),
+            /** Cancel a scheduled email. */
+            cancel: (id) => this.request("POST", `/emails/${enc(id)}/cancel`),
+            forward: (id, params) => this.request("POST", `/emails/${enc(id)}/forward`, params),
+        };
+        this.domains = {
+            create: (params) => this.request("POST", "/domains", params),
+            get: (id) => this.request("GET", `/domains/${enc(id)}`),
+            /** Check DNS now and update the domain's status. */
+            verify: (id) => this.request("POST", `/domains/${enc(id)}/verify`),
+            update: (id, params) => this.request("PATCH", `/domains/${enc(id)}`, params),
+            list: () => this.request("GET", "/domains"),
+            remove: (id) => this.request("DELETE", `/domains/${enc(id)}`),
+        };
+        this.apiKeys = {
+            create: (params) => this.request("POST", "/api-keys", params),
+            list: () => this.request("GET", "/api-keys"),
+            remove: (id) => this.request("DELETE", `/api-keys/${enc(id)}`),
+        };
+        this.webhooks = {
+            create: (params) => this.request("POST", "/webhooks", params),
+            list: () => this.request("GET", "/webhooks"),
+            /** Recent delivery attempts for a webhook. */
+            deliveries: (id) => this.request("GET", `/webhooks/${enc(id)}/events`),
+            /** Send a test event to the endpoint. */
+            test: (id) => this.request("POST", `/webhooks/${enc(id)}/test`),
+            /** Send a past delivery again. */
+            replay: (deliveryId) => this.request("POST", `/webhook-deliveries/${enc(deliveryId)}/replay`),
+            /** Check a webhook request's signature and return the parsed event. Rejects with `WebhookVerificationError` if it isn't from Delivrie. */
+            verify: (opts) => (0, webhooks_js_1.verifyWebhook)(opts),
+        };
+        this.contacts = {
+            create: (params) => this.request("POST", "/contacts", params),
+            /** By id or email address. */
+            get: (idOrEmail) => this.request("GET", `/contacts/${enc(idOrEmail)}`),
+            update: (idOrEmail, params) => this.request("PATCH", `/contacts/${enc(idOrEmail)}`, params),
+            list: (params = {}) => this.request("GET", "/contacts", undefined, { query: { ...params } }),
+            remove: (idOrEmail) => this.request("DELETE", `/contacts/${enc(idOrEmail)}`),
+        };
+        this.segments = {
+            create: (params) => this.request("POST", "/segments", params),
+            list: () => this.request("GET", "/segments"),
+            remove: (id) => this.request("DELETE", `/segments/${enc(id)}`),
+            /** Add contacts by email (they're created if needed). */
+            addContacts: (id, contacts) => this.request("POST", `/segments/${enc(id)}/contacts`, { contacts: contacts.map((c) => (typeof c === "string" ? { email: c } : c)) }),
+        };
+        this.topics = { list: () => this.request("GET", "/topics") };
+        this.contactProperties = { list: () => this.request("GET", "/contact-properties") };
+        this.broadcasts = {
+            create: (params) => this.request("POST", "/broadcasts", params),
+            get: (id) => this.request("GET", `/broadcasts/${enc(id)}`),
+            list: () => this.request("GET", "/broadcasts"),
+            /** Send now, or schedule with `scheduled_at`. */
+            send: (id, params = {}) => this.request("POST", `/broadcasts/${enc(id)}/send`, params.scheduled_at === undefined ? {} : { scheduled_at: params.scheduled_at instanceof Date ? params.scheduled_at.toISOString() : params.scheduled_at }),
+            cancel: (id) => this.request("POST", `/broadcasts/${enc(id)}/cancel`),
+            recipients: (id) => this.request("GET", `/broadcasts/${enc(id)}/recipients`),
+            remove: (id) => this.request("DELETE", `/broadcasts/${enc(id)}`),
+        };
+        this.templates = {
+            create: (params) => this.request("POST", "/templates", params),
+            /** By id or alias. */
+            get: (idOrAlias) => this.request("GET", `/templates/${enc(idOrAlias)}`),
+            list: () => this.request("GET", "/templates"),
+            /** Publish the current draft so sends use it. */
+            publish: (id) => this.request("POST", `/templates/${enc(id)}/publish`),
+        };
+        this.suppressions = {
+            /** Stop sending to one or more addresses. */
+            add: (email) => this.request("POST", "/suppressions", Array.isArray(email) ? { emails: email } : { email }),
+            list: () => this.request("GET", "/suppressions"),
+            remove: (email) => this.request("DELETE", `/suppressions/${enc(email)}`),
+        };
+        this.events = {
+            /** Record an event for a contact; live automations listening for it start. */
+            send: (params) => this.request("POST", "/events", params),
+            list: () => this.request("GET", "/events"),
+        };
+        this.automations = {
+            list: () => this.request("GET", "/automations"),
+            get: (id) => this.request("GET", `/automations/${enc(id)}`),
+            create: (params) => this.request("POST", "/automations", params),
+            runs: (id) => this.request("GET", `/automations/${enc(id)}/runs`),
+            publish: (id) => this.request("POST", `/automations/${enc(id)}/publish`),
+            pause: (id) => this.request("POST", `/automations/${enc(id)}/pause`),
+            resume: (id) => this.request("POST", `/automations/${enc(id)}/resume`),
+        };
+        this.inbox = {
+            threads: {
+                list: (params = {}) => this.request("GET", "/inbox/threads", undefined, { query: params }),
+                get: (id) => this.request("GET", `/inbox/threads/${enc(id)}`),
+                update: (id, params) => this.request("PATCH", `/inbox/threads/${enc(id)}`, params),
+                reply: (id, params) => this.request("POST", `/inbox/threads/${enc(id)}/reply`, params),
+            },
+            labels: { list: () => this.request("GET", "/inbox/labels") },
+        };
+        this.metrics = {
+            get: (params = {}) => this.request("GET", "/metrics", undefined, { query: params }),
+        };
+        this.logs = {
+            list: (params = {}) => this.request("GET", "/logs", undefined, { query: { ...params } }),
+            get: (id) => this.request("GET", `/logs/${enc(id)}`),
+        };
+        this.usage = { get: () => this.request("GET", "/usage") };
+        // process.env on Node, Bun and Deno (with --allow-env); absent on edge runtimes, where you pass the key directly.
+        const env = globalThis.process?.env ?? {};
+        const key = apiKey ?? env.DELIVRIE_API_KEY;
+        if (!key)
+            throw new Error("Missing API key. Pass it to new Delivrie(key) or set DELIVRIE_API_KEY. Create one at https://delivrie.io/api-keys");
+        this.key = key;
+        this.baseUrl = (options.baseUrl ?? env.DELIVRIE_BASE_URL ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+        this.timeout = options.timeout ?? 30000;
+        this.maxRetries = Math.max(0, options.maxRetries ?? 2);
+        const f = options.fetch ?? (typeof fetch !== "undefined" ? fetch : undefined);
+        if (!f)
+            throw new Error("No fetch available. Use Node.js 18 or later, or pass options.fetch.");
+        this.fetchImpl = f;
+        this.extraHeaders = options.headers ?? {};
+    }
+    /** Low-level request for endpoints the SDK doesn't wrap yet. Paths are relative to the API base, e.g. `/emails`. */
+    async request(method, path, body, opts = {}) {
+        let url = this.baseUrl + path;
+        if (opts.query) {
+            const q = Object.entries(opts.query).filter(([, v]) => v !== undefined && v !== null).map(([k, v]) => `${enc(k)}=${enc(String(v))}`).join("&");
+            if (q)
+                url += (url.includes("?") ? "&" : "?") + q;
+        }
+        const headers = {
+            authorization: `Bearer ${this.key}`,
+            accept: "application/json",
+            "user-agent": `delivrie-node/${exports.VERSION}`,
+            ...this.extraHeaders,
+        };
+        if (body !== undefined)
+            headers["content-type"] = "application/json";
+        if (opts.idempotencyKey)
+            headers["idempotency-key"] = opts.idempotencyKey;
+        // GET/DELETE are safe to repeat; POST/PATCH only with an idempotency key, so a retry never sends an email twice.
+        const retryable = method === "GET" || method === "DELETE" || !!opts.idempotencyKey;
+        for (let attempt = 0;; attempt++) {
+            const ctrl = new AbortController();
+            const timer = setTimeout(() => ctrl.abort(new Error("timeout")), this.timeout);
+            const onAbort = () => ctrl.abort(opts.signal?.reason);
+            opts.signal?.addEventListener("abort", onAbort, { once: true });
+            let res;
+            try {
+                res = await this.fetchImpl(url, { method, headers, body: body === undefined ? undefined : JSON.stringify(body), signal: ctrl.signal });
+            }
+            catch (e) {
+                clearTimeout(timer);
+                opts.signal?.removeEventListener("abort", onAbort);
+                if (opts.signal?.aborted)
+                    return { data: null, error: { statusCode: 0, name: "aborted", message: "The request was aborted" } };
+                if (retryable && attempt < this.maxRetries) {
+                    await sleep(backoff(attempt));
+                    continue;
+                }
+                const timedOut = ctrl.signal.aborted;
+                return { data: null, error: { statusCode: 0, name: timedOut ? "timeout" : "network_error", message: timedOut ? `No response within ${this.timeout} ms` : e?.message || "Network error" } };
+            }
+            clearTimeout(timer);
+            opts.signal?.removeEventListener("abort", onAbort);
+            const text = await res.text();
+            let json = null;
+            try {
+                json = text ? JSON.parse(text) : null;
+            }
+            catch {
+                json = null;
+            }
+            if (res.ok)
+                return { data: json, error: null };
+            const err = toError(res.status, json, text);
+            const rateLimited = res.status === 429 && err.name === "rate_limit_exceeded";
+            if ((rateLimited || res.status >= 500) && retryable && attempt < this.maxRetries) {
+                const after = Number(res.headers.get("retry-after"));
+                await sleep(Number.isFinite(after) && after > 0 ? Math.min(after, 30) * 1000 : backoff(attempt));
+                continue;
+            }
+            return { data: null, error: err };
+        }
+    }
+}
+exports.Delivrie = Delivrie;
+function backoff(attempt) {
+    return Math.min(8000, 500 * 2 ** attempt) + Math.floor(Math.random() * 250);
+}
+function toError(status, json, text) {
+    const j = (json && typeof json === "object" ? json : {});
+    return {
+        statusCode: typeof j.statusCode === "number" ? j.statusCode : status,
+        name: typeof j.name === "string" ? j.name : status === 401 ? "invalid_api_key" : status === 404 ? "not_found" : status === 429 ? "rate_limit_exceeded" : "application_error",
+        message: typeof j.message === "string" ? j.message : text.slice(0, 300) || `Request failed with status ${status}`,
+    };
+}

package/dist/cjs/client.d.cts

@@ -0,0 +1,190 @@
+import type { ApiKey, Automation, Broadcast, Contact, CreateApiKeyRequest, CreateApiKeyResponse, CreateBroadcastRequest, CreateContactRequest, CreateDomainRequest, CreateEmailResponse, CreateTemplateRequest, CreateWebhookRequest, CreateWebhookResponse, Domain, Email, EmailSummary, ForwardEmailRequest, InboxThread, List, ListContactsParams, ListEmailsParams, Log, LogSummary, Metrics, Pagination, ReplyToThreadRequest, RequestOptions, Result, Segment, SendEmailRequest, SendEventRequest, Suppression, Template, Topic, UpdateContactRequest, UpdateDomainRequest, Usage, Webhook, WebhookDelivery, Deleted } from "./types.cjs";
+import { type VerifyWebhookOptions } from "./webhooks.cjs";
+export declare const VERSION = "0.1.0";
+export interface DelivrieOptions {
+    /** Defaults to `https://delivrie.io/api`. */
+    baseUrl?: string;
+    /** Per-request timeout in milliseconds. Default 30000. */
+    timeout?: number;
+    /** Retries for rate limits, server errors and network errors. Default 2. Sends are only retried with an idempotency key. */
+    maxRetries?: number;
+    /** A custom fetch, for example in tests or older runtimes. Defaults to the global fetch. */
+    fetch?: typeof fetch;
+    /** Extra headers sent with every request. */
+    headers?: Record<string, string>;
+}
+type Method = "GET" | "POST" | "PATCH" | "DELETE";
+type Query = Record<string, string | number | boolean | undefined | null>;
+/**
+ * The Delivrie client.
+ *
+ * ```ts
+ * import { Delivrie } from "delivrie";
+ * const delivrie = new Delivrie(process.env.DELIVRIE_API_KEY);
+ * const { data, error } = await delivrie.emails.send({ from: "Kora <hi@kora.ng>", to: "ada@example.com", subject: "Hi", html: "<p>Hello</p>" });
+ * ```
+ */
+export declare class Delivrie {
+    readonly baseUrl: string;
+    private readonly key;
+    private readonly timeout;
+    private readonly maxRetries;
+    private readonly fetchImpl;
+    private readonly extraHeaders;
+    constructor(apiKey?: string, options?: DelivrieOptions);
+    /** Low-level request for endpoints the SDK doesn't wrap yet. Paths are relative to the API base, e.g. `/emails`. */
+    request<T>(method: Method, path: string, body?: unknown, opts?: RequestOptions & {
+        query?: Query;
+    }): Promise<Result<T>>;
+    readonly emails: {
+        /** Send one email. Returns its id straight away; delivery events arrive through webhooks. */
+        send: (email: SendEmailRequest, opts?: RequestOptions) => Promise<Result<CreateEmailResponse>>;
+        /** Send up to 100 emails in one request (no attachments or scheduling). */
+        batch: (emails: SendEmailRequest[], opts?: RequestOptions) => Promise<Result<{
+            data: CreateEmailResponse[];
+        }>>;
+        get: (id: string) => Promise<Result<Email>>;
+        list: (params?: ListEmailsParams) => Promise<Result<List<EmailSummary>>>;
+        /** Received (inbound) emails. */
+        listReceived: (params?: Pagination) => Promise<Result<List<EmailSummary>>>;
+        /** Move a scheduled email. */
+        update: (id: string, params: {
+            scheduled_at: string | Date;
+        }) => Promise<Result<{
+            object: "email";
+            id: string;
+        }>>;
+        /** Cancel a scheduled email. */
+        cancel: (id: string) => Promise<Result<{
+            object: "email";
+            id: string;
+        }>>;
+        forward: (id: string, params: ForwardEmailRequest) => Promise<Result<CreateEmailResponse>>;
+    };
+    readonly domains: {
+        create: (params: CreateDomainRequest) => Promise<Result<Domain>>;
+        get: (id: string) => Promise<Result<Domain>>;
+        /** Check DNS now and update the domain's status. */
+        verify: (id: string) => Promise<Result<Domain>>;
+        update: (id: string, params: UpdateDomainRequest) => Promise<Result<Domain>>;
+        list: () => Promise<Result<List<Domain>>>;
+        remove: (id: string) => Promise<Result<Deleted>>;
+    };
+    readonly apiKeys: {
+        create: (params: CreateApiKeyRequest) => Promise<Result<CreateApiKeyResponse>>;
+        list: () => Promise<Result<List<ApiKey>>>;
+        remove: (id: string) => Promise<Result<Deleted>>;
+    };
+    readonly webhooks: {
+        create: (params: CreateWebhookRequest) => Promise<Result<CreateWebhookResponse>>;
+        list: () => Promise<Result<List<Webhook>>>;
+        /** Recent delivery attempts for a webhook. */
+        deliveries: (id: string) => Promise<Result<List<WebhookDelivery>>>;
+        /** Send a test event to the endpoint. */
+        test: (id: string) => Promise<Result<Record<string, unknown>>>;
+        /** Send a past delivery again. */
+        replay: (deliveryId: string) => Promise<Result<Record<string, unknown>>>;
+        /** Check a webhook request's signature and return the parsed event. Rejects with `WebhookVerificationError` if it isn't from Delivrie. */
+        verify: <T = Record<string, unknown>>(opts: VerifyWebhookOptions) => Promise<import("./types.cjs").WebhookEvent<T>>;
+    };
+    readonly contacts: {
+        create: (params: CreateContactRequest) => Promise<Result<{
+            object: "contact";
+            id: string;
+        }>>;
+        /** By id or email address. */
+        get: (idOrEmail: string) => Promise<Result<Contact>>;
+        update: (idOrEmail: string, params: UpdateContactRequest) => Promise<Result<Contact>>;
+        list: (params?: ListContactsParams) => Promise<Result<List<Contact>>>;
+        remove: (idOrEmail: string) => Promise<Result<Deleted>>;
+    };
+    readonly segments: {
+        create: (params: {
+            name: string;
+        }) => Promise<Result<{
+            object: "segment";
+            id: string;
+        }>>;
+        list: () => Promise<Result<List<Segment>>>;
+        remove: (id: string) => Promise<Result<Deleted>>;
+        /** Add contacts by email (they're created if needed). */
+        addContacts: (id: string, contacts: Array<string | CreateContactRequest>) => Promise<Result<Record<string, unknown>>>;
+    };
+    readonly topics: {
+        list: () => Promise<Result<List<Topic>>>;
+    };
+    readonly contactProperties: {
+        list: () => Promise<Result<List<Record<string, unknown>>>>;
+    };
+    readonly broadcasts: {
+        create: (params: CreateBroadcastRequest) => Promise<Result<{
+            object: "broadcast";
+            id: string;
+        }>>;
+        get: (id: string) => Promise<Result<Broadcast>>;
+        list: () => Promise<Result<List<Broadcast>>>;
+        /** Send now, or schedule with `scheduled_at`. */
+        send: (id: string, params?: {
+            scheduled_at?: string | Date;
+        }) => Promise<Result<Broadcast>>;
+        cancel: (id: string) => Promise<Result<Broadcast>>;
+        recipients: (id: string) => Promise<Result<List<Record<string, unknown>>>>;
+        remove: (id: string) => Promise<Result<Deleted>>;
+    };
+    readonly templates: {
+        create: (params: CreateTemplateRequest) => Promise<Result<{
+            object: "template";
+            id: string;
+        }>>;
+        /** By id or alias. */
+        get: (idOrAlias: string) => Promise<Result<Template>>;
+        list: () => Promise<Result<List<Template>>>;
+        /** Publish the current draft so sends use it. */
+        publish: (id: string) => Promise<Result<Template>>;
+    };
+    readonly suppressions: {
+        /** Stop sending to one or more addresses. */
+        add: (email: string | string[]) => Promise<Result<Record<string, unknown>>>;
+        list: () => Promise<Result<List<Suppression>>>;
+        remove: (email: string) => Promise<Result<Deleted>>;
+    };
+    readonly events: {
+        /** Record an event for a contact; live automations listening for it start. */
+        send: (params: SendEventRequest) => Promise<Result<Record<string, unknown>>>;
+        list: () => Promise<Result<List<Record<string, unknown>>>>;
+    };
+    readonly automations: {
+        list: () => Promise<Result<List<Automation>>>;
+        get: (id: string) => Promise<Result<Automation>>;
+        create: (params: Record<string, unknown>) => Promise<Result<Automation>>;
+        runs: (id: string) => Promise<Result<List<Record<string, unknown>>>>;
+        publish: (id: string) => Promise<Result<Automation>>;
+        pause: (id: string) => Promise<Result<Automation>>;
+        resume: (id: string) => Promise<Result<Automation>>;
+    };
+    readonly inbox: {
+        threads: {
+            list: (params?: Pagination & Query) => Promise<Result<List<InboxThread>>>;
+            get: (id: string) => Promise<Result<InboxThread>>;
+            update: (id: string, params: Record<string, unknown>) => Promise<Result<InboxThread>>;
+            reply: (id: string, params: ReplyToThreadRequest) => Promise<Result<CreateEmailResponse>>;
+        };
+        labels: {
+            list: () => Promise<Result<List<Record<string, unknown>>>>;
+        };
+    };
+    readonly metrics: {
+        get: (params?: {
+            days?: number;
+            domain_id?: string;
+        }) => Promise<Result<Metrics>>;
+    };
+    readonly logs: {
+        list: (params?: Pagination) => Promise<Result<List<LogSummary>>>;
+        get: (id: string) => Promise<Result<Log>>;
+    };
+    readonly usage: {
+        get: () => Promise<Result<Usage>>;
+    };
+}
+export {};

package/dist/cjs/index.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.WebhookVerificationError = exports.verifyWebhook = exports.VERSION = exports.Delivrie = void 0;
+var client_js_1 = require("./client.cjs");
+Object.defineProperty(exports, "Delivrie", { enumerable: true, get: function () { return client_js_1.Delivrie; } });
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return client_js_1.VERSION; } });
+var webhooks_js_1 = require("./webhooks.cjs");
+Object.defineProperty(exports, "verifyWebhook", { enumerable: true, get: function () { return webhooks_js_1.verifyWebhook; } });
+Object.defineProperty(exports, "WebhookVerificationError", { enumerable: true, get: function () { return webhooks_js_1.WebhookVerificationError; } });
+var client_js_2 = require("./client.cjs");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return client_js_2.Delivrie; } });
+
+module.exports = Object.assign(exports.Delivrie, exports);

package/dist/cjs/index.d.cts

@@ -0,0 +1,4 @@
+export { Delivrie, VERSION, type DelivrieOptions } from "./client.cjs";
+export { verifyWebhook, WebhookVerificationError, type VerifyWebhookOptions } from "./webhooks.cjs";
+export type * from "./types.cjs";
+export { Delivrie as default } from "./client.cjs";

package/dist/cjs/types.cjs

@@ -0,0 +1,4 @@
+"use strict";
+// Request and response types for the Delivrie API (https://delivrie.io/docs/api).
+// Field names match the API exactly (snake_case), so the API reference and these types read the same.
+Object.defineProperty(exports, "__esModule", { value: true });