@benclmnt/postmock 0.0.1

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

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { apiError } from "../../errors.js";
+import { absent, intLike, parseBody } from "../../http/normalize.js";
+import { Unsupported } from "../../http/respond.js";
+// PUT /templates/push (docs/06 §3.4; refs/api_templates-api.md:353-430).
+const pushSchema = z.object({
+    SourceServerID: absent(intLike),
+    DestinationServerID: absent(intLike),
+    PerformChanges: z.boolean(),
+});
+// docs/06 §6: 100 templates per server.
+const TEMPLATE_LIMIT = 100;
+/** The fields a push copies; a template whose fields all match needs no change (INFERRED). */
+const CONTENT = ["Name", "Subject", "HtmlBody", "TextBody", "LayoutTemplate"];
+export function pushTemplates(store, body) {
+    const parsed = parseBody(pushSchema, body);
+    if (!parsed.success) {
+        throw new Unsupported(`push body: ${parsed.error.issues[0]?.message}: Postmark's answer is not captured`);
+    }
+    const { SourceServerID, DestinationServerID, PerformChanges } = parsed.data;
+    const { state } = store;
+    const server = (id) => (id === undefined ? undefined : state.servers.get(id));
+    const sourceServer = server(SourceServerID);
+    const destinationServer = server(DestinationServerID);
+    // Wire text from the live tests (sdk/postmark.js/test/integration/Templates.test.ts:178-211).
+    if (sourceServer === undefined && destinationServer === undefined) {
+        throw apiError(601, { message: "The source and destination servers were not found." });
+    }
+    if (destinationServer === undefined) {
+        throw apiError(601, { message: "The destination server was not found." });
+    }
+    if (sourceServer === undefined)
+        throw apiError(601, { message: "The source server was not found." });
+    const active = (serverId) => [...state.templates.values()]
+        .filter((t) => t.ServerID === serverId && t.Active)
+        .sort((a, b) => a.TemplateId - b.TemplateId);
+    // The destination matches by alias (refs/api_templates-api.md:359). Every template has one
+    // (docs/06 §3.2), so 1124 means a source server without templates.
+    const sources = active(sourceServer.ID);
+    if (sources.length === 0) {
+        // The message is INFERRED (a summary row).
+        throw apiError(1124, { message: "No templates with aliases found to push." });
+    }
+    const destination = active(destinationServer.ID);
+    // Aliases compare without case (INFERRED).
+    const byAlias = new Map(destination.map((t) => [t.Alias.toLowerCase(), t]));
+    const changes = sources.flatMap((source) => {
+        const target = byAlias.get(source.Alias.toLowerCase());
+        if (target !== undefined && target.TemplateType !== source.TemplateType)
+            throw apiError(1125);
+        if (target !== undefined && CONTENT.every((key) => target[key] === source[key]))
+            return [];
+        return [{ source, target }];
+    });
+    const creates = changes.filter((c) => c.target === undefined).length;
+    if (destination.length + creates > TEMPLATE_LIMIT)
+        throw apiError(1105);
+    const templates = changes.map(({ source, target }) => {
+        let templateId = target?.TemplateId;
+        if (PerformChanges) {
+            const content = Object.fromEntries(CONTENT.map((key) => [key, source[key]]));
+            if (target !== undefined)
+                Object.assign(target, content);
+            else {
+                templateId = store.nextId("template");
+                state.templates.set(templateId, {
+                    ...source,
+                    TemplateId: templateId,
+                    ServerID: destinationServer.ID,
+                });
+            }
+        }
+        return {
+            Action: target === undefined ? "Create" : "Edit",
+            // postmark.js types TemplateId as optional; a dry-run Create has no destination template yet,
+            // so it omits TemplateId (INFERRED; the doc example is a real push, refs/api_templates-api.md:420-428).
+            ...(templateId !== undefined && { TemplateId: templateId }),
+            Alias: source.Alias,
+            Name: source.Name,
+            TemplateType: source.TemplateType,
+        };
+    });
+    return { TotalCount: templates.length, Templates: templates };
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,288 @@
+import { z } from "zod";
+import { apiError } from "../../errors.js";
+import { absent, parseBody } from "../../http/normalize.js";
+import { Unsupported } from "../../http/respond.js";
+import { defineRoute } from "../../http/routes.js";
+import { createServer } from "../../state/servers.js";
+import { serverJson } from "../server/json.js";
+import { refuseWhileRenewing, rotateDkim, setReturnPath, verifySpf } from "./authentication.js";
+import { checkDomainName, checkReturnPath, domainDkimJson, domainJson, domainListItemJson, domainSpfJson, findDomain, newDomain, } from "./domains.js";
+import { accountPage, byId } from "./paging.js";
+import { pushTemplates } from "./push.js";
+import { checkFromEmail, checkNote, checkReplyTo, checkSenderReturnPath, findSender, newSender, senderJson, senderListItemJson, } from "./senders.js";
+import { definedSettings, deleteServer, editServer, findServer, parseServerInput, } from "./servers.js";
+// The account-token API: servers, domains, sender signatures, template push (docs/06 §3.4, §4.2–4.4).
+// A body that is no JSON object, or a field of the wrong JSON type, has no documented ErrorCode.
+function parseAccountBody(schema, body) {
+    const parsed = parseBody(schema, body ?? {});
+    if (!parsed.success) {
+        throw new Unsupported(`${z.prettifyError(parsed.error)}: Postmark's answer is not captured`);
+    }
+    return parsed.data;
+}
+// Servers (refs/api_servers-api.md).
+defineRoute({
+    method: "GET",
+    path: "/servers",
+    auth: "account",
+    handler: ({ store, query }) => {
+        // "a string search" (refs/api_servers-api.md:385); case-insensitive is INFERRED.
+        const name = query.get("name")?.toLowerCase();
+        const servers = byId(store.state.servers.values()).filter((s) => name === undefined || s.Name.toLowerCase().includes(name));
+        return accountPage(query, "Servers", servers.map(serverJson), 600);
+    },
+});
+defineRoute({
+    method: "GET",
+    path: "/servers/:id",
+    auth: "account",
+    handler: ({ store, params }) => serverJson(findServer(store.state, params.id)),
+});
+defineRoute({
+    method: "POST",
+    path: "/servers",
+    auth: "account",
+    handler: ({ store, clock, body }) => {
+        const input = parseServerInput(store.state, body, null);
+        if (input.Name === undefined)
+            throw apiError(608, { message: "A server name is required." });
+        return serverJson(createServer(store, clock.now(), definedSettings(input)));
+    },
+});
+defineRoute({
+    method: "PUT",
+    path: "/servers/:id",
+    auth: "account",
+    handler: ({ store, params, body }) => {
+        const server = findServer(store.state, params.id);
+        return serverJson(editServer(store.state, server, body));
+    },
+});
+defineRoute({
+    method: "DELETE",
+    path: "/servers/:id",
+    auth: "account",
+    handler: ({ store, params }) => {
+        if (!store.state.account.serverDeletionEnabled)
+            throw apiError(604);
+        const server = findServer(store.state, params.id);
+        deleteServer(store.state, server);
+        // refs/api_servers-api.md:520.
+        return { ErrorCode: 0, Message: `Server ${server.Name} removed.` };
+    },
+});
+// Domains (refs/api_domains-api.md).
+defineRoute({
+    method: "GET",
+    path: "/domains",
+    auth: "account",
+    handler: ({ store, query }) => accountPage(query, "Domains", byId(store.state.domains.values()).map(domainListItemJson), 500),
+});
+defineRoute({
+    method: "GET",
+    path: "/domains/:id",
+    auth: "account",
+    handler: ({ store, params }) => domainJson(findDomain(store.state, params.id)),
+});
+const createDomainSchema = z.object({
+    Name: absent(z.string()),
+    ReturnPathDomain: absent(z.string()),
+});
+defineRoute({
+    method: "POST",
+    path: "/domains",
+    auth: "account",
+    handler: ({ store, clock, body }) => {
+        const input = parseAccountBody(createDomainSchema, body);
+        const name = checkDomainName(store.state, input.Name);
+        const returnPath = checkReturnPath(input.ReturnPathDomain ?? "", name);
+        const domain = newDomain(store.nextId("domain"), name, returnPath, clock.now());
+        store.state.domains.set(domain.ID, domain);
+        return domainJson(domain);
+    },
+});
+// `""` clears the Return-Path, unlike docs/08 R9: dotnet sends `""` for "clear"
+// (sdk/postmark-dotnet/src/Postmark/PostmarkAdminClient.cs:345). `null` keeps it.
+const returnPathEdit = z.string().nullable().optional();
+defineRoute({
+    method: "PUT",
+    path: "/domains/:id",
+    auth: "account",
+    handler: ({ store, params, body }) => {
+        const domain = findDomain(store.state, params.id);
+        const input = parseAccountBody(z.object({ ReturnPathDomain: returnPathEdit }), body);
+        if (typeof input.ReturnPathDomain === "string") {
+            setReturnPath(domain, checkReturnPath(input.ReturnPathDomain, domain.Name));
+        }
+        return domainJson(domain);
+    },
+});
+defineRoute({
+    method: "DELETE",
+    path: "/domains/:id",
+    auth: "account",
+    handler: ({ store, params }) => {
+        const domain = findDomain(store.state, params.id);
+        store.state.domains.delete(domain.ID);
+        // refs/api_domains-api.md:377.
+        return { ErrorCode: 0, Message: `Domain ${domain.Name} removed.` };
+    },
+});
+// Verification reads the state the control API sets (`POST /control/domains/:id/verify`): postmock
+// has no DNS to look at.
+for (const path of ["/domains/:id/verifyDkim", "/domains/:id/verifyReturnPath"]) {
+    defineRoute({
+        method: "PUT",
+        path,
+        auth: "account",
+        handler: ({ store, params }) => domainJson(findDomain(store.state, params.id)),
+    });
+}
+defineRoute({
+    method: "POST",
+    path: "/domains/:id/verifyspf",
+    auth: "account",
+    handler: ({ store, params }) => {
+        const domain = findDomain(store.state, params.id);
+        verifySpf(domain);
+        return domainSpfJson(domain);
+    },
+});
+defineRoute({
+    method: "POST",
+    path: "/domains/:id/rotatedkim",
+    auth: "account",
+    handler: ({ store, clock, params }) => {
+        const domain = findDomain(store.state, params.id);
+        rotateDkim(domain, domain.Name, clock.now());
+        return domainDkimJson(domain);
+    },
+});
+// Sender signatures (refs/api_signatures-api.md).
+defineRoute({
+    method: "GET",
+    path: "/senders",
+    auth: "account",
+    handler: ({ store, query }) => accountPage(query, "SenderSignatures", byId(store.state.senders.values()).map(senderListItemJson), 500),
+});
+defineRoute({
+    method: "GET",
+    path: "/senders/:id",
+    auth: "account",
+    handler: ({ store, params }) => senderJson(findSender(store.state, params.id)),
+});
+const senderSchema = z.object({
+    FromEmail: absent(z.string()),
+    Name: absent(z.string()),
+    ReplyToEmail: absent(z.string()),
+    ReturnPathDomain: returnPathEdit,
+    ConfirmationPersonalNote: absent(z.string()),
+});
+defineRoute({
+    method: "POST",
+    path: "/senders",
+    auth: "account",
+    handler: ({ store, clock, body }) => {
+        if (body === undefined)
+            throw apiError(502);
+        const input = parseAccountBody(senderSchema, body);
+        const email = checkFromEmail(store.state, input.FromEmail);
+        // Name is required (refs/api_signatures-api.md:199); no ErrorCode names it.
+        if (input.Name === undefined) {
+            throw new Unsupported("a signature without Name: Postmark's answer is not captured");
+        }
+        const sender = newSender(store.nextId("sender"), {
+            FromEmail: email,
+            Name: input.Name,
+            ReplyToEmail: input.ReplyToEmail === undefined ? "" : checkReplyTo(input.ReplyToEmail),
+            ReturnPathDomain: checkSenderReturnPath(input.ReturnPathDomain ?? "", email),
+            ConfirmationPersonalNote: checkNote(input.ConfirmationPersonalNote ?? ""),
+        }, clock.now());
+        store.state.senders.set(sender.ID, sender);
+        return senderJson(sender);
+    },
+});
+// Every field is optional on edit: the dotnet live test edits only the Return-Path
+// (sdk/postmark-dotnet/src/Postmark.Tests/AdminClientSenderSignatureTests.cs:141).
+defineRoute({
+    method: "PUT",
+    path: "/senders/:id",
+    auth: "account",
+    handler: ({ store, params, body }) => {
+        const sender = findSender(store.state, params.id);
+        if (body === undefined)
+            throw apiError(502);
+        const input = parseAccountBody(senderSchema.omit({ FromEmail: true }), body);
+        // Check every field before the first change: a rejected edit changes nothing.
+        const replyTo = input.ReplyToEmail === undefined ? undefined : checkReplyTo(input.ReplyToEmail);
+        const returnPath = typeof input.ReturnPathDomain === "string"
+            ? checkSenderReturnPath(input.ReturnPathDomain, sender.EmailAddress)
+            : undefined;
+        const note = input.ConfirmationPersonalNote === undefined
+            ? undefined
+            : checkNote(input.ConfirmationPersonalNote);
+        if (input.Name !== undefined)
+            sender.Name = input.Name;
+        if (replyTo !== undefined)
+            sender.ReplyToEmailAddress = replyTo;
+        if (returnPath !== undefined)
+            setReturnPath(sender, returnPath);
+        if (note !== undefined)
+            sender.ConfirmationPersonalNote = note;
+        return senderJson(sender);
+    },
+});
+defineRoute({
+    method: "DELETE",
+    path: "/senders/:id",
+    auth: "account",
+    handler: ({ store, params }) => {
+        const sender = findSender(store.state, params.id);
+        store.state.senders.delete(sender.ID);
+        // refs/api_signatures-api.md:424.
+        return { ErrorCode: 0, Message: `Signature ${sender.EmailAddress} removed.` };
+    },
+});
+defineRoute({
+    method: "POST",
+    path: "/senders/:id/resend",
+    auth: "account",
+    handler: ({ store, params }) => {
+        const sender = findSender(store.state, params.id);
+        if (sender.Confirmed)
+            throw apiError(506);
+        // refs/api_signatures-api.md:466.
+        return {
+            ErrorCode: 0,
+            Message: `Confirmation email for Sender Signature ${sender.EmailAddress} was re-sent.`,
+        };
+    },
+});
+defineRoute({
+    method: "POST",
+    path: "/senders/:id/verifyspf",
+    auth: "account",
+    handler: ({ store, params }) => {
+        const sender = findSender(store.state, params.id);
+        verifySpf(sender);
+        return senderJson(sender);
+    },
+});
+defineRoute({
+    method: "POST",
+    path: "/senders/:id/requestnewdkim",
+    auth: "account",
+    handler: ({ store, params }) => {
+        const sender = findSender(store.state, params.id);
+        refuseWhileRenewing(sender);
+        // The doc shows only the 505 body; dotnet reads {ErrorCode, Message}, postmark.js a signature.
+        throw new Unsupported("the requestnewdkim success body is not captured");
+    },
+});
+// Template push (refs/api_templates-api.md:353-430). A literal `push` beats T3's `:idOrAlias`.
+defineRoute({
+    method: "PUT",
+    path: "/templates/push",
+    auth: "account",
+    handler: ({ store, body }) => pushTemplates(store, body),
+});

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

@@ -0,0 +1,54 @@
+import type { State } from "../../state/store.ts";
+import type { SenderSignature } from "../../state/types.ts";
+export interface NewSender {
+    FromEmail: string;
+    Name: string;
+    ReplyToEmail: string;
+    ReturnPathDomain: string;
+    ConfirmationPersonalNote: string;
+}
+export declare const emailDomain: (email: string) => string;
+/** An unconfirmed signature with a pending DKIM key (refs/api_signatures-api.md:250-273). */
+export declare const newSender: (id: number, s: NewSender, now: Date) => SenderSignature;
+/**
+ * ErrorCode 501 for an unknown or non-numeric ID. The doc gives 422 or 404; 404 is INFERRED from the
+ * postmark.js cleanup that tolerates a 404 on delete (sdk/postmark.js/test/integration/Signatures.test.ts:37-40).
+ */
+export declare function findSender(state: State, id: string): SenderSignature;
+export declare function checkFromEmail(state: State, email: string | undefined): string;
+export declare function checkReplyTo(email: string): string;
+export declare function checkNote(note: string): string;
+export declare const checkSenderReturnPath: (returnPath: string, email: string) => string;
+export declare const senderJson: (s: SenderSignature) => {
+    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;
+    Domain: string;
+    EmailAddress: string;
+    ReplyToEmailAddress: string;
+    Name: string;
+    Confirmed: boolean;
+    ID: number;
+    ConfirmationPersonalNote: string;
+};
+export declare const senderListItemJson: (s: SenderSignature) => {
+    Domain: string;
+    EmailAddress: string;
+    ReplyToEmailAddress: string;
+    Name: string;
+    Confirmed: boolean;
+    ID: number;
+};

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

@@ -0,0 +1,87 @@
+import { apiError } from "../../errors.js";
+import { authenticationJson, isEmail, newAuthentication } from "./authentication.js";
+import { checkReturnPath } from "./domains.js";
+import { pathId } from "./paging.js";
+export const emailDomain = (email) => email.slice(email.lastIndexOf("@") + 1);
+/** An unconfirmed signature with a pending DKIM key (refs/api_signatures-api.md:250-273). */
+export const newSender = (id, s, now) => ({
+    ID: id,
+    Domain: emailDomain(s.FromEmail),
+    EmailAddress: s.FromEmail,
+    ReplyToEmailAddress: s.ReplyToEmail,
+    Name: s.Name,
+    Confirmed: false,
+    ConfirmationPersonalNote: s.ConfirmationPersonalNote,
+    ...newAuthentication(emailDomain(s.FromEmail), s.ReturnPathDomain, now),
+});
+/**
+ * ErrorCode 501 for an unknown or non-numeric ID. The doc gives 422 or 404; 404 is INFERRED from the
+ * postmark.js cleanup that tolerates a 404 on delete (sdk/postmark.js/test/integration/Signatures.test.ts:37-40).
+ */
+export function findSender(state, id) {
+    const sender = state.senders.get(pathId(id) ?? -1);
+    if (sender === undefined)
+        throw apiError(501, { status: 404, message: "Signature not found." });
+    return sender;
+}
+// Free mail domains cannot hold a signature (ErrorCode 503). The list is INFERRED.
+const PUBLIC_DOMAINS = new Set([
+    "gmail.com",
+    "googlemail.com",
+    "yahoo.com",
+    "hotmail.com",
+    "outlook.com",
+    "live.com",
+    "aol.com",
+    "icloud.com",
+]);
+export function checkFromEmail(state, email) {
+    if (email === undefined)
+        throw apiError(520);
+    if (email.length > 255)
+        throw tooLong("FromEmail");
+    if (!isEmail(email))
+        throw invalidEmail("FromEmail");
+    if (PUBLIC_DOMAINS.has(emailDomain(email).toLowerCase()))
+        throw apiError(503);
+    const taken = [...state.senders.values()].some((s) => s.EmailAddress.toLowerCase() === email.toLowerCase());
+    if (taken)
+        throw apiError(504, { message: "This signature already exists." });
+    return email;
+}
+export function checkReplyTo(email) {
+    if (email.length > 255)
+        throw tooLong("ReplyToEmail");
+    if (!isEmail(email))
+        throw invalidEmail("ReplyToEmail");
+    return email;
+}
+// The note has at most 400 characters (refs/api_signatures-api.md:202).
+export function checkNote(note) {
+    if (note.length > 400)
+        throw tooLong("ConfirmationPersonalNote");
+    return note;
+}
+export const checkSenderReturnPath = (returnPath, email) => checkReturnPath(returnPath, emailDomain(email));
+const tooLong = (field) => apiError(521, { message: `The '${field}' field is too long.` });
+const invalidEmail = (field) => apiError(522, { message: `The '${field}' field is not a valid email address.` });
+// refs/api_signatures-api.md:107-129.
+export const senderJson = (s) => ({
+    Domain: s.Domain,
+    EmailAddress: s.EmailAddress,
+    ReplyToEmailAddress: s.ReplyToEmailAddress,
+    Name: s.Name,
+    Confirmed: s.Confirmed,
+    ...authenticationJson(s),
+    ID: s.ID,
+    ConfirmationPersonalNote: s.ConfirmationPersonalNote,
+});
+// refs/api_signatures-api.md:43-48.
+export const senderListItemJson = (s) => ({
+    Domain: s.Domain,
+    EmailAddress: s.EmailAddress,
+    ReplyToEmailAddress: s.ReplyToEmailAddress,
+    Name: s.Name,
+    Confirmed: s.Confirmed,
+    ID: s.ID,
+});

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

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import type { State } from "../../state/store.ts";
+import { type Server } from "../../state/types.ts";
+declare const settingsSchema: z.ZodObject<{
+    Name: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+    Color: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"blue" | "green" | "grey" | "orange" | "purple" | "red" | "turquoise" | "yellow", string>>>, unknown>;
+    SmtpApiActivated: z.ZodPreprocess<z.ZodOptional<z.ZodBoolean>, unknown>;
+    RawEmailEnabled: z.ZodPreprocess<z.ZodOptional<z.ZodBoolean>, unknown>;
+    DeliveryType: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"Live" | "Sandbox", string>>>, unknown>;
+    InboundHookUrl: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+    BounceHookUrl: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+    OpenHookUrl: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+    DeliveryHookUrl: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+    ClickHookUrl: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+    PostFirstOpenOnly: z.ZodPreprocess<z.ZodOptional<z.ZodBoolean>, unknown>;
+    InboundDomain: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+    InboundSpamThreshold: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>]>, z.ZodNumber>>, unknown>;
+    TrackOpens: z.ZodPreprocess<z.ZodOptional<z.ZodBoolean>, unknown>;
+    TrackLinks: z.ZodPreprocess<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"HtmlAndText" | "HtmlOnly" | "None" | "TextOnly", string>>>, unknown>;
+    IncludeBounceContentInHook: z.ZodPreprocess<z.ZodOptional<z.ZodBoolean>, unknown>;
+    EnableSmtpApiErrorHooks: z.ZodPreprocess<z.ZodOptional<z.ZodBoolean>, unknown>;
+}, z.core.$strip>;
+export type ServerInput = z.output<typeof settingsSchema>;
+/**
+ * The settings of a create or edit body. A body that is no JSON object is
+ * 609. A bad value gets its field's ErrorCode (refs/api_overview.md:101-108); a field of the wrong
+ * JSON type has no documented code, so it answers 501.
+ */
+export declare function parseServerInput(state: State, body: unknown, self: Server | null): ServerInput;
+/**
+ * Applies an edit body to a server: `PUT /servers/{id}` (account token) and `PUT /server` (server
+ * token) take the same fields. DeliveryType is fixed at create (refs/api_servers-api.md:38).
+ */
+export declare function editServer(state: State, server: Server, body: unknown): Server;
+/** The settings a create or edit sets: absent fields keep their value (docs/08 R9). */
+export declare const definedSettings: (input: ServerInput) => Partial<Server>;
+export declare function findServer(state: State, id: string): Server;
+/** Removes a server and everything it owns. */
+export declare function deleteServer(state: State, server: Server): void;
+export {};