@benclmnt/postmock 0.0.1

package/dist/seeds/empty.d.ts

@@ -0,0 +1,4 @@
+import type { Seed } from "../src/control/seed.ts";
+/** A new account with no token and no server. */
+declare const empty: Seed;
+export default empty;

package/dist/seeds/empty.js

@@ -0,0 +1,3 @@
+/** A new account with no token and no server. */
+const empty = () => { };
+export default empty;

package/dist/seeds/lib/conformance.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tokens and addresses every runner configures its suite with. The tokens exist only in postmock,
+ * so a misrouted request gets 401 from real Postmark and sends nothing (docs/09 §4).
+ * Addresses avoid `.test` and `.local`: postmark-python validates them (docs/08 E12).
+ */
+export declare const CONFORMANCE: {
+    readonly serverId: 10;
+    readonly accountToken: "postmock-account-token";
+    readonly serverToken: "postmock-server-token";
+    readonly serverName: "postmock conformance";
+    readonly senderEmail: "sender@example.com";
+    readonly recipientEmail: "recipient@example.com";
+    readonly domain: "example.com";
+    /** A second verified domain: the placeholder `From` domain of an SDK example. */
+    readonly exampleDomain: "your-verified-domain.com";
+};

package/dist/seeds/lib/conformance.js

@@ -0,0 +1,18 @@
+/**
+ * Tokens and addresses every runner configures its suite with. The tokens exist only in postmock,
+ * so a misrouted request gets 401 from real Postmark and sends nothing (docs/09 §4).
+ * Addresses avoid `.test` and `.local`: postmark-python validates them (docs/08 E12).
+ */
+export const CONFORMANCE = {
+    // Not 1: the push tests expect server 1 to be missing from the account
+    // (sdk/postmark.js/test/integration/Templates.test.ts:178-213; sdk/postmark-java/src/test/java/integration/TemplatePushTest.java:22-26).
+    serverId: 10,
+    accountToken: "postmock-account-token",
+    serverToken: "postmock-server-token",
+    serverName: "postmock conformance",
+    senderEmail: "sender@example.com",
+    recipientEmail: "recipient@example.com",
+    domain: "example.com",
+    /** A second verified domain: the placeholder `From` domain of an SDK example. */
+    exampleDomain: "your-verified-domain.com",
+};

package/dist/seeds/lib/history.d.ts

@@ -0,0 +1,27 @@
+import type { Runtime } from "../../src/runtime.ts";
+import type { Bounce, BounceType, InboundMessage, OutboundMessage } from "../../src/state/types.ts";
+/** An outbound message accepted at `ReceivedAt`. */
+export declare function pastSend(runtime: Runtime, fields: Partial<OutboundMessage> & Pick<OutboundMessage, "ServerID" | "ReceivedAt" | "To">): Promise<OutboundMessage>;
+/**
+ * The first To recipient's server bounces the message at `at`, through the recipient state machine
+ * (a hard bounce suppresses the address). `id` comes from the caller's range (docs/11 §5).
+ */
+export declare const pastBounce: (runtime: Runtime, message: OutboundMessage, { id, type, at }: {
+    id: number;
+    type: BounceType;
+    at: Date;
+}) => Promise<Bounce>;
+/**
+ * An SMTP message to a suppressed address: Postmark accepts no message and records an SMTP API
+ * error bounce (docs/07 §1.4). `email` must be suppressed on `stream`.
+ */
+export declare function pastSmtpApiError(runtime: Runtime, fields: {
+    id: number;
+    serverId: number;
+    stream: string;
+    email: string;
+    tag: string | null;
+    at: Date;
+}): Promise<Bounce>;
+/** An inbound message stored as already processed, blocked or failed; no event fires. */
+export declare function pastInbound(runtime: Runtime, fields: Partial<InboundMessage> & Pick<InboundMessage, "ServerID" | "ReceivedAt" | "Status">): InboundMessage;

package/dist/seeds/lib/history.js

@@ -0,0 +1,129 @@
+import { randomUUID } from "node:crypto";
+import { composeMime } from "../../src/mime/compose.js";
+import { inactiveRecipientsError } from "../../src/pipeline/inactive.js";
+import { recordBounceAt } from "../../src/recipients/transitions.js";
+import { smtpApiErrorBounce } from "../../src/smtp/receive.js";
+import { newMessageId } from "../../src/state/ids.js";
+import { findSuppression } from "../../src/state/suppressions.js";
+import { CONFORMANCE } from "./conformance.js";
+// Past traffic for seeds and tests: messages accepted and bounced before "now". Each record fires
+// the event live traffic fires, so message events and stats follow.
+/** MIME source for the dump endpoint, with the headers Postmark adds (refs/api_messages-api.md:276). */
+const rawSource = (m) => composeMime({
+    from: m.From,
+    to: m.To.map((a) => a.Email),
+    cc: [],
+    subject: m.Subject ?? "",
+    text: m.TextBody ?? "",
+    headers: [
+        ...(m.Tag === null ? [] : [{ name: "X-PM-Tag", value: m.Tag }]),
+        { name: "X-PM-Message-Id", value: m.MessageID },
+        { name: "Message-ID", value: `<${randomUUID()}@mtasv.net>` },
+    ],
+    attachments: [],
+}, m.ReceivedAt);
+/** An outbound message accepted at `ReceivedAt`. */
+export async function pastSend(runtime, fields) {
+    const message = {
+        MessageID: newMessageId(),
+        MessageStream: "outbound",
+        From: "sender@example.com",
+        Cc: [],
+        Bcc: [],
+        ReplyTo: null,
+        Subject: "History",
+        HtmlBody: null,
+        TextBody: "History",
+        Tag: null,
+        Headers: [],
+        Attachments: [],
+        Metadata: {},
+        TrackOpens: false,
+        TrackLinks: "None",
+        Status: "Sent",
+        Sandboxed: false,
+        MessageEvents: [],
+        channel: "rest",
+        request: null,
+        rawSource: "",
+        bulkRequestId: null,
+        templateId: null,
+        suppressedRecipients: [],
+        ...fields,
+    };
+    message.rawSource = rawSource(message);
+    runtime.store.state.outbound.set(message.MessageID, message);
+    await runtime.events.emit("sent", { message });
+    return message;
+}
+/**
+ * The first To recipient's server bounces the message at `at`, through the recipient state machine
+ * (a hard bounce suppresses the address). `id` comes from the caller's range (docs/11 §5).
+ */
+export const pastBounce = (runtime, message, { id, type, at }) => recordBounceAt(runtime, {
+    message,
+    email: message.To[0]?.Email,
+    type,
+    details: "smtp;550 5.1.1 The email account that you tried to reach does not exist.",
+    content: `Return-Path: <>\r\nSubject: Undeliverable: ${message.Subject}\r\n\r\nbounce dump\r\n`,
+}, { id: runtime.store.useId("bounce", id), at });
+/**
+ * An SMTP message to a suppressed address: Postmark accepts no message and records an SMTP API
+ * error bounce (docs/07 §1.4). `email` must be suppressed on `stream`.
+ */
+export async function pastSmtpApiError(runtime, fields) {
+    if (findSuppression(runtime.store.state, fields.serverId, fields.stream, fields.email) === undefined) {
+        throw new Error(`${fields.email} is not suppressed on ${fields.stream}`);
+    }
+    const subject = "History";
+    const bounce = smtpApiErrorBounce(runtime.store.useId("bounce", fields.id), fields.at, {
+        serverId: fields.serverId,
+        stream: fields.stream,
+        messageId: newMessageId(),
+        tag: fields.tag,
+        from: CONFORMANCE.senderEmail,
+        subject,
+        metadata: {},
+        source: `From: ${CONFORMANCE.senderEmail}\r\nTo: ${fields.email}\r\nSubject: ${subject}\r\n\r\n${subject}\r\n`,
+    }, fields.email, inactiveRecipientsError([fields.email]));
+    runtime.store.state.bounces.set(bounce.ID, bounce);
+    await runtime.events.emit("smtpApiError", { bounce });
+    return bounce;
+}
+/** An inbound message stored as already processed, blocked or failed; no event fires. */
+export function pastInbound(runtime, fields) {
+    const server = runtime.store.state.servers.get(fields.ServerID);
+    if (server === undefined)
+        throw new Error(`no server ${fields.ServerID}`);
+    const from = { Email: "writer@example.com", Name: "Writer", MailboxHash: "" };
+    const to = { Email: server.InboundAddress, Name: "", MailboxHash: "" };
+    const message = {
+        MessageID: newMessageId(),
+        MessageStream: "inbound",
+        From: from.Email,
+        FromName: from.Name,
+        FromFull: from,
+        To: to.Email,
+        ToFull: [to],
+        Cc: "",
+        CcFull: [],
+        Bcc: "",
+        BccFull: [],
+        OriginalRecipient: to.Email,
+        ReplyTo: "",
+        Subject: "Inbound",
+        MailboxHash: "",
+        Date: fields.ReceivedAt.toUTCString().replace("GMT", "+0000"),
+        TextBody: "Inbound message.",
+        HtmlBody: "",
+        StrippedTextReply: "",
+        Tag: "",
+        Headers: [{ Name: "MIME-Version", Value: "1.0" }],
+        Attachments: [],
+        BlockedReason: fields.Status === "Blocked" ? `Inbound request blocked by domain rule: ${from.Email}` : null,
+        rawEmail: `From: ${from.Email}\r\nTo: ${to.Email}\r\nSubject: Inbound\r\n\r\nInbound message.\r\n`,
+        ...fields,
+    };
+    runtime.store.state.inbound.set(message.MessageID, message);
+    return message;
+}

package/dist/seeds/lib/read-server.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The server that holds the message history the read suites need (`seeds/conformance/40-messages.ts`).
+ * A runner maps the dotnet and php `READ_*` tokens to `token`; the write suites keep using the core
+ * conformance server, whose counts this history leaves alone. IDs from the T4 range (docs/11 §5).
+ */
+export declare const READ_SERVER: {
+    readonly id: 4000;
+    readonly token: "postmock-read-server-token";
+    readonly name: "postmock read history";
+};

package/dist/seeds/lib/read-server.js

@@ -0,0 +1,10 @@
+/**
+ * The server that holds the message history the read suites need (`seeds/conformance/40-messages.ts`).
+ * A runner maps the dotnet and php `READ_*` tokens to `token`; the write suites keep using the core
+ * conformance server, whose counts this history leaves alone. IDs from the T4 range (docs/11 §5).
+ */
+export const READ_SERVER = {
+    id: 4000,
+    token: "postmock-read-server-token",
+    name: "postmock read history",
+};

package/dist/seeds/lib/template-server.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The server whose template list starts with one template (`seeds/conformance/80-templates.ts`).
+ * postmark-cli sends with the first listed template before its own tests create any
+ * (sdk/postmark-cli/test/integration/email.template.test.ts:36-39,62-67). The dotnet suite counts the
+ * templates of the core conformance server, so they stay on their own server. IDs from the T8
+ * range (docs/11 §5).
+ */
+export declare const TEMPLATE_SERVER: {
+    readonly id: 8000;
+    readonly token: "postmock-template-server-token";
+    readonly name: "postmock templates";
+    readonly templateId: 8000;
+};

package/dist/seeds/lib/template-server.js

@@ -0,0 +1,13 @@
+/**
+ * The server whose template list starts with one template (`seeds/conformance/80-templates.ts`).
+ * postmark-cli sends with the first listed template before its own tests create any
+ * (sdk/postmark-cli/test/integration/email.template.test.ts:36-39,62-67). The dotnet suite counts the
+ * templates of the core conformance server, so they stay on their own server. IDs from the T8
+ * range (docs/11 §5).
+ */
+export const TEMPLATE_SERVER = {
+    id: 8000,
+    token: "postmock-template-server-token",
+    name: "postmock templates",
+    templateId: 8000,
+};

package/dist/src/api/account/authentication.d.ts

@@ -0,0 +1,39 @@
+import type { Domain } from "../../state/types.ts";
+/** The SPF, DKIM and Return-Path fields that domains and sender signatures share. */
+export type Authentication = Omit<Domain, "ID" | "Name">;
+export declare function newAuthentication(domain: string, returnPath: string, now: Date): Authentication;
+/**
+ * A key still pending answers 505: the gem live test renews the key of a new domain and a new
+ * signature and expects it (sdk/postmark-gem/spec/integration/account_api_client_spec.rb:39-41, :76-78).
+ */
+export declare function refuseWhileRenewing(auth: Authentication): void;
+/** Starts a new DKIM key. */
+export declare function rotateDkim(auth: Authentication, domain: string, now: Date): void;
+/** Postmark found the pending DKIM key in DNS: it becomes the active key. */
+export declare function confirmDkim(auth: Authentication): void;
+/** A new Return-Path needs its CNAME verified again; `""` clears it. */
+export declare function setReturnPath(auth: Authentication, returnPath: string): void;
+export declare function verifySpf(auth: Authentication): void;
+/** The wire fields after the entity's own leading fields, in doc order (refs/api_domains-api.md:107-124). */
+export declare const authenticationJson: (auth: Authentication) => {
+    SPFVerified: boolean;
+    SPFHost: string;
+    SPFTextValue: string;
+    DKIMVerified: boolean;
+    WeakDKIM: boolean;
+    DKIMHost: string;
+    DKIMTextValue: string;
+    DKIMPendingHost: string;
+    DKIMPendingTextValue: string;
+    DKIMRevokedHost: string;
+    DKIMRevokedTextValue: string;
+    SafeToRemoveRevokedKeyFromDNS: boolean;
+    DKIMUpdateStatus: "Pending" | "Verified";
+    ReturnPathDomain: string;
+    ReturnPathDomainVerified: boolean;
+    ReturnPathDomainCNAMEValue: string;
+};
+export declare const isHostname: (value: string) => boolean;
+export declare const isEmail: (value: string) => boolean;
+/** A Return-Path must be a subdomain of the domain (refs/api_domains-api.md:186). */
+export declare const isSubdomainOf: (child: string, parent: string) => boolean;

package/dist/src/api/account/authentication.js

@@ -0,0 +1,97 @@
+import { randomBytes } from "node:crypto";
+import { apiError } from "../../errors.js";
+// refs/api_domains-api.md:226-246: a new domain has only a pending DKIM key.
+export function newAuthentication(domain, returnPath, now) {
+    return {
+        SPFVerified: false,
+        SPFHost: domain,
+        SPFTextValue: "v=spf1 a mx include:spf.mtasv.net ~all",
+        DKIMVerified: false,
+        WeakDKIM: false,
+        DKIMHost: "",
+        DKIMTextValue: "",
+        ...pendingKey(domain, now),
+        DKIMRevokedHost: "",
+        DKIMRevokedTextValue: "",
+        SafeToRemoveRevokedKeyFromDNS: false,
+        ReturnPathDomain: returnPath,
+        ReturnPathDomainVerified: false,
+        ReturnPathDomainCNAMEValue: "pm.mtasv.net",
+    };
+}
+// Host shape `20131031155228pm._domainkey.<domain>` (refs/api_domains-api.md:235); the key is random.
+const pendingKey = (domain, now) => ({
+    DKIMPendingHost: `${now.toISOString().replace(/\D/g, "").slice(0, 14)}pm._domainkey.${domain}`,
+    DKIMPendingTextValue: `k=rsa; p=${randomBytes(162).toString("base64")}`,
+    DKIMUpdateStatus: "Pending",
+});
+/**
+ * A key still pending answers 505: the gem live test renews the key of a new domain and a new
+ * signature and expects it (sdk/postmark-gem/spec/integration/account_api_client_spec.rb:39-41, :76-78).
+ */
+export function refuseWhileRenewing(auth) {
+    if (auth.DKIMUpdateStatus === "Pending")
+        throw apiError(505);
+}
+/** Starts a new DKIM key. */
+export function rotateDkim(auth, domain, now) {
+    refuseWhileRenewing(auth);
+    Object.assign(auth, pendingKey(domain, now));
+}
+/** Postmark found the pending DKIM key in DNS: it becomes the active key. */
+export function confirmDkim(auth) {
+    if (auth.DKIMUpdateStatus !== "Pending")
+        throw new Error("no pending DKIM key");
+    if (auth.DKIMHost !== "") {
+        auth.DKIMRevokedHost = auth.DKIMHost;
+        auth.DKIMRevokedTextValue = auth.DKIMTextValue;
+        auth.SafeToRemoveRevokedKeyFromDNS = true;
+    }
+    auth.DKIMHost = auth.DKIMPendingHost;
+    auth.DKIMTextValue = auth.DKIMPendingTextValue;
+    auth.DKIMPendingHost = "";
+    auth.DKIMPendingTextValue = "";
+    auth.DKIMVerified = true;
+    auth.DKIMUpdateStatus = "Verified";
+}
+/** A new Return-Path needs its CNAME verified again; `""` clears it. */
+export function setReturnPath(auth, returnPath) {
+    if (returnPath === auth.ReturnPathDomain)
+        return;
+    auth.ReturnPathDomain = returnPath;
+    auth.ReturnPathDomainVerified = false;
+}
+// SPF is no longer required (refs/api_domains-api.md:536). The gem live test expects `SPFVerified`
+// true from a new domain and signature with no DNS (account_api_client_spec.rb:33, :73).
+export function verifySpf(auth) {
+    auth.SPFVerified = true;
+}
+/** The wire fields after the entity's own leading fields, in doc order (refs/api_domains-api.md:107-124). */
+export const authenticationJson = (auth) => ({
+    SPFVerified: auth.SPFVerified,
+    SPFHost: auth.SPFHost,
+    SPFTextValue: auth.SPFTextValue,
+    DKIMVerified: auth.DKIMVerified,
+    WeakDKIM: auth.WeakDKIM,
+    DKIMHost: auth.DKIMHost,
+    DKIMTextValue: auth.DKIMTextValue,
+    DKIMPendingHost: auth.DKIMPendingHost,
+    DKIMPendingTextValue: auth.DKIMPendingTextValue,
+    DKIMRevokedHost: auth.DKIMRevokedHost,
+    DKIMRevokedTextValue: auth.DKIMRevokedTextValue,
+    SafeToRemoveRevokedKeyFromDNS: auth.SafeToRemoveRevokedKeyFromDNS,
+    DKIMUpdateStatus: auth.DKIMUpdateStatus,
+    ReturnPathDomain: auth.ReturnPathDomain,
+    ReturnPathDomainVerified: auth.ReturnPathDomainVerified,
+    ReturnPathDomainCNAMEValue: auth.ReturnPathDomainCNAMEValue,
+});
+// A hostname with at least two labels (INFERRED; `thisisntadomain` is rejected by
+// sdk/postmark-dotnet/src/Postmark.Tests/AdminClientDomainsTests.cs:67-82).
+const HOSTNAME = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z][a-z0-9-]{0,62}$/i;
+export const isHostname = (value) => HOSTNAME.test(value);
+export const isEmail = (value) => {
+    const at = value.lastIndexOf("@");
+    return at > 0 && !/\s/.test(value) && isHostname(value.slice(at + 1));
+};
+/** A Return-Path must be a subdomain of the domain (refs/api_domains-api.md:186). */
+export const isSubdomainOf = (child, parent) => child.toLowerCase().endsWith(`.${parent.toLowerCase()}`) && isHostname(child);

package/dist/src/api/account/domains.d.ts

@@ -0,0 +1,59 @@
+import type { State } from "../../state/store.ts";
+import type { Domain } from "../../state/types.ts";
+/** A new domain; Name and Return-Path are checked by the caller. */
+export declare const newDomain: (id: number, name: string, returnPath: string, now: Date) => Domain;
+/** A domain whose DKIM key Postmark found in DNS, so it authorizes every `From` address on it. */
+export declare function addVerifiedDomain(state: State, id: number, name: string, now: Date): Domain;
+/** 510 for an unknown or non-numeric ID. */
+export declare function findDomain(state: State, id: string): Domain;
+/** Name checks in the order of the ErrorCodes 514, 515, 516, 512 (refs/api_overview.md:172-176). */
+export declare function checkDomainName(state: State, name: string | undefined): string;
+/** ErrorCode 522; the message is INFERRED (a summary row). */
+export declare function checkReturnPath(returnPath: string, domain: string): string;
+export declare const domainJson: (d: Domain) => {
+    SPFVerified: boolean;
+    SPFHost: string;
+    SPFTextValue: string;
+    DKIMVerified: boolean;
+    WeakDKIM: boolean;
+    DKIMHost: string;
+    DKIMTextValue: string;
+    DKIMPendingHost: string;
+    DKIMPendingTextValue: string;
+    DKIMRevokedHost: string;
+    DKIMRevokedTextValue: string;
+    SafeToRemoveRevokedKeyFromDNS: boolean;
+    DKIMUpdateStatus: "Pending" | "Verified";
+    ReturnPathDomain: string;
+    ReturnPathDomainVerified: boolean;
+    ReturnPathDomainCNAMEValue: string;
+    Name: string;
+    ID: number;
+};
+export declare const domainListItemJson: (d: Domain) => {
+    Name: string;
+    SPFVerified: boolean;
+    DKIMVerified: boolean;
+    WeakDKIM: boolean;
+    ReturnPathDomainVerified: boolean;
+    ID: number;
+};
+export declare const domainDkimJson: (d: Domain) => {
+    Name: string;
+    DKIMVerified: boolean;
+    WeakDKIM: boolean;
+    DKIMHost: string;
+    DKIMTextValue: string;
+    DKIMPendingHost: string;
+    DKIMPendingTextValue: string;
+    DKIMRevokedHost: string;
+    DKIMRevokedTextValue: string;
+    SafeToRemoveRevokedKeyFromDNS: boolean;
+    DKIMUpdateStatus: "Pending" | "Verified";
+    ID: number;
+};
+export declare const domainSpfJson: (d: Domain) => {
+    SPFHost: string;
+    SPFVerified: boolean;
+    SPFTextValue: string;
+};

package/dist/src/api/account/domains.js

@@ -0,0 +1,78 @@
+import { apiError } from "../../errors.js";
+import { authenticationJson, confirmDkim, isHostname, isSubdomainOf, newAuthentication, } from "./authentication.js";
+import { pathId } from "./paging.js";
+// Domains API (docs/06 §4.3; refs/api_domains-api.md).
+/** A new domain; Name and Return-Path are checked by the caller. */
+export const newDomain = (id, name, returnPath, now) => ({
+    ID: id,
+    Name: name,
+    ...newAuthentication(name, returnPath, now),
+});
+/** A domain whose DKIM key Postmark found in DNS, so it authorizes every `From` address on it. */
+export function addVerifiedDomain(state, id, name, now) {
+    const domain = newDomain(id, name, "", now);
+    confirmDkim(domain);
+    state.domains.set(domain.ID, domain);
+    return domain;
+}
+/** 510 for an unknown or non-numeric ID. */
+export function findDomain(state, id) {
+    const domain = state.domains.get(pathId(id) ?? -1);
+    if (domain === undefined)
+        throw apiError(510);
+    return domain;
+}
+/** Name checks in the order of the ErrorCodes 514, 515, 516, 512 (refs/api_overview.md:172-176). */
+export function checkDomainName(state, name) {
+    if (name === undefined)
+        throw apiError(514);
+    if (name.length > 255)
+        throw apiError(515);
+    if (!isHostname(name))
+        throw apiError(516);
+    const taken = [...state.domains.values()].some((d) => d.Name.toLowerCase() === name.toLowerCase());
+    if (taken)
+        throw apiError(512);
+    return name;
+}
+/** ErrorCode 522; the message is INFERRED (a summary row). */
+export function checkReturnPath(returnPath, domain) {
+    if (returnPath !== "" && !isSubdomainOf(returnPath, domain)) {
+        throw apiError(522, {
+            message: `The 'ReturnPathDomain' must be a subdomain of '${domain}'.`,
+        });
+    }
+    return returnPath;
+}
+// refs/api_domains-api.md:107-124.
+export const domainJson = (d) => ({ Name: d.Name, ...authenticationJson(d), ID: d.ID });
+// refs/api_domains-api.md:43-48.
+export const domainListItemJson = (d) => ({
+    Name: d.Name,
+    SPFVerified: d.SPFVerified,
+    DKIMVerified: d.DKIMVerified,
+    WeakDKIM: d.WeakDKIM,
+    ReturnPathDomainVerified: d.ReturnPathDomainVerified,
+    ID: d.ID,
+});
+// refs/api_domains-api.md:611-622.
+export const domainDkimJson = (d) => ({
+    Name: d.Name,
+    DKIMVerified: d.DKIMVerified,
+    WeakDKIM: d.WeakDKIM,
+    DKIMHost: d.DKIMHost,
+    DKIMTextValue: d.DKIMTextValue,
+    DKIMPendingHost: d.DKIMPendingHost,
+    DKIMPendingTextValue: d.DKIMPendingTextValue,
+    DKIMRevokedHost: d.DKIMRevokedHost,
+    DKIMRevokedTextValue: d.DKIMRevokedTextValue,
+    SafeToRemoveRevokedKeyFromDNS: d.SafeToRemoveRevokedKeyFromDNS,
+    DKIMUpdateStatus: d.DKIMUpdateStatus,
+    ID: d.ID,
+});
+// refs/api_domains-api.md:564-566.
+export const domainSpfJson = (d) => ({
+    SPFHost: d.SPFHost,
+    SPFVerified: d.SPFVerified,
+    SPFTextValue: d.SPFTextValue,
+});

package/dist/src/api/account/paging.d.ts

@@ -0,0 +1,12 @@
+import { type Query } from "../../http/normalize.ts";
+/**
+ * One page of an account list. Servers answer ErrorCode 600, domains and senders 500.
+ * The messages are INFERRED: both rows are summaries (docs/02 §4.4).
+ */
+export declare function accountPage<T>(query: Query, key: string, items: readonly T[], code: 500 | 600): Record<string, unknown>;
+/** A numeric path ID; anything else matches no entity. */
+export declare const pathId: (value: string) => number | undefined;
+/** Entities in ID order (INFERRED). */
+export declare const byId: <T extends {
+    ID: number;
+}>(items: Iterable<T>) => T[];

package/dist/src/api/account/paging.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { apiError } from "../../errors.js";
+import { queryInt } from "../../http/normalize.js";
+import { paged } from "../../http/respond.js";
+// `count` (at most 500) and `offset` are required on the servers, domains and senders lists
+// (refs/api_servers-api.md:383-384; refs/api_domains-api.md:34-35; refs/api_signatures-api.md:34-35;
+// the 500 cap for servers: ErrorCode 600, docs/02 §4.4).
+const pageQuery = z.object({
+    count: queryInt.pipe(z.number().int().min(0).max(500)),
+    offset: queryInt.pipe(z.number().int().min(0)),
+});
+/**
+ * One page of an account list. Servers answer ErrorCode 600, domains and senders 500.
+ * The messages are INFERRED: both rows are summaries (docs/02 §4.4).
+ */
+export function accountPage(query, key, items, code) {
+    const page = query.pick(pageQuery);
+    if (!page.success) {
+        const field = String(page.error.issues[0]?.path[0]);
+        throw apiError(code, {
+            message: field === "count"
+                ? "Parameter 'count' must be an integer between 0 and 500."
+                : "Parameter 'offset' must be an integer of 0 or more.",
+        });
+    }
+    const { count, offset } = page.data;
+    // "Postmark API returns 0 as total if you request 0 documents" (sdk/postmark-gem/lib/postmark/client.rb:77).
+    if (count === 0)
+        return { TotalCount: 0, [key]: [] };
+    return paged(key, items, count, offset);
+}
+/** A numeric path ID; anything else matches no entity. */
+export const pathId = (value) => /^\d+$/.test(value) ? Number(value) : undefined;
+/** Entities in ID order (INFERRED). */
+export const byId = (items) => [...items].sort((a, b) => a.ID - b.ID);

package/dist/src/api/account/push.d.ts

@@ -0,0 +1,14 @@
+import type { Store } from "../../state/store.ts";
+import type { Template } from "../../state/types.ts";
+interface PushAction {
+    Action: "Create" | "Edit";
+    TemplateId?: number;
+    Alias: string;
+    Name: string;
+    TemplateType: Template["TemplateType"];
+}
+export declare function pushTemplates(store: Store, body: unknown): {
+    TotalCount: number;
+    Templates: PushAction[];
+};
+export {};