@joe-broadhead/messaging 0.0.0-stage → 0.7.0

package/dist/types/core/schema/errors.d.ts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+/** The closed set of Messaging error codes. Every emitted code must be documented in docs/spec/messaging-v1.md. */
+export declare const ErrorCode: z.ZodEnum<{
+    expired: "expired";
+    invalid_request: "invalid_request";
+    not_member: "not_member";
+    bad_signature: "bad_signature";
+    unknown_session: "unknown_session";
+    ambiguous_address: "ambiguous_address";
+    no_recipients: "no_recipients";
+    unknown_address: "unknown_address";
+    refused: "refused";
+    declined: "declined";
+    request_required: "request_required";
+    rate_limited: "rate_limited";
+    loop_guard: "loop_guard";
+    too_large: "too_large";
+    secret_refused: "secret_refused";
+    duplicate: "duplicate";
+    relay_unavailable: "relay_unavailable";
+    not_found: "not_found";
+    invalid_state: "invalid_state";
+    forbidden: "forbidden";
+    guarded_turn: "guarded_turn";
+    roster_conflict: "roster_conflict";
+    invite_invalid: "invite_invalid";
+    no_identity: "no_identity";
+    binding_invalid: "binding_invalid";
+    jelly_unavailable: "jelly_unavailable";
+    log_conflict: "log_conflict";
+    device_limit: "device_limit";
+    admission_required: "admission_required";
+    admission_invalid: "admission_invalid";
+    directory_inconsistent: "directory_inconsistent";
+    unknown_device: "unknown_device";
+    directory_unavailable: "directory_unavailable";
+    login_unsupported: "login_unsupported";
+    login_denied: "login_denied";
+    grant_required: "grant_required";
+    grant_invalid: "grant_invalid";
+    ticket_required: "ticket_required";
+    ticket_invalid: "ticket_invalid";
+    daemon_unavailable: "daemon_unavailable";
+    daemon_mismatch: "daemon_mismatch";
+    internal: "internal";
+}>;
+export type ErrorCode = z.infer<typeof ErrorCode>;
+export declare const ErrorBody: z.ZodObject<{
+    code: z.ZodEnum<{
+        expired: "expired";
+        invalid_request: "invalid_request";
+        not_member: "not_member";
+        bad_signature: "bad_signature";
+        unknown_session: "unknown_session";
+        ambiguous_address: "ambiguous_address";
+        no_recipients: "no_recipients";
+        unknown_address: "unknown_address";
+        refused: "refused";
+        declined: "declined";
+        request_required: "request_required";
+        rate_limited: "rate_limited";
+        loop_guard: "loop_guard";
+        too_large: "too_large";
+        secret_refused: "secret_refused";
+        duplicate: "duplicate";
+        relay_unavailable: "relay_unavailable";
+        not_found: "not_found";
+        invalid_state: "invalid_state";
+        forbidden: "forbidden";
+        guarded_turn: "guarded_turn";
+        roster_conflict: "roster_conflict";
+        invite_invalid: "invite_invalid";
+        no_identity: "no_identity";
+        binding_invalid: "binding_invalid";
+        jelly_unavailable: "jelly_unavailable";
+        log_conflict: "log_conflict";
+        device_limit: "device_limit";
+        admission_required: "admission_required";
+        admission_invalid: "admission_invalid";
+        directory_inconsistent: "directory_inconsistent";
+        unknown_device: "unknown_device";
+        directory_unavailable: "directory_unavailable";
+        login_unsupported: "login_unsupported";
+        login_denied: "login_denied";
+        grant_required: "grant_required";
+        grant_invalid: "grant_invalid";
+        ticket_required: "ticket_required";
+        ticket_invalid: "ticket_invalid";
+        daemon_unavailable: "daemon_unavailable";
+        daemon_mismatch: "daemon_mismatch";
+        internal: "internal";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type ErrorBody = z.infer<typeof ErrorBody>;
+/** Error carrying a Messaging code. Messages must never contain bodies, keys or secrets. */
+export declare class MessagingError extends Error {
+    readonly code: ErrorCode;
+    constructor(code: ErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+    toBody(): ErrorBody;
+}
+export declare function isMessagingError(value: unknown): value is MessagingError;

package/dist/types/core/schema/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./common.js";
+export * from "./errors.js";
+export * from "./realm.js";
+export * from "./jelly.js";
+export * from "./directory.js";
+export * as A2A from "./a2a.js";
+export * from "./envelope.js";
+export * from "./delegation.js";
+export * from "./consent.js";
+export * from "./roster.js";
+export * from "./relay.js";
+export * from "./directory-frames.js";
+export * from "./ipc.js";
+export * from "./ipc/device.js";
+export * from "./ipc/consent.js";

package/dist/types/core/schema/ipc/consent.d.ts

@@ -0,0 +1,555 @@
+/**
+ * Consent methods (spec §8.2, "Consent"; §6.9): grants and held requests. Every one is human tier: none is in `AGENT_METHODS`, so the agent
+ * socket refuses them, and agents never set or read a person's grants. Spread into `IPC_METHODS`.
+ */
+import { z } from "zod";
+/** A grant's subject as a person names it: a person, or a channel by its name here. */
+export declare const GrantTarget: z.ZodUnion<readonly [z.ZodObject<{
+    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+}, z.core.$strict>, z.ZodObject<{
+    channel: z.ZodString;
+}, z.core.$strict>]>;
+export type GrantTarget = z.infer<typeof GrantTarget>;
+/** A grant as this device holds it. A channel subject carries the channel's id and, while this person is in it, its name here. */
+export declare const GrantView: z.ZodObject<{
+    id: z.ZodString;
+    ts: z.ZodNumber;
+    by: z.ZodString;
+    resignedAt: z.ZodOptional<z.ZodNumber>;
+    chat: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        muted: "muted";
+        blocked: "blocked";
+    }>>;
+    agentMail: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        blocked: "blocked";
+    }>>;
+    ask: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        request: "request";
+        no: "no";
+    }>>;
+    trustedUntil: z.ZodOptional<z.ZodNumber>;
+    discoverable: z.ZodOptional<z.ZodBoolean>;
+    subject: z.ZodUnion<readonly [z.ZodObject<{
+        person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strip>, z.ZodObject<{
+        channel: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
+export type GrantView = z.infer<typeof GrantView>;
+/** Widening levels that lapsed with their signer, waiting for the person to set them again (spec §6.9, "Signers"). */
+export declare const GrantReview: z.ZodObject<{
+    subject: z.ZodUnion<readonly [z.ZodObject<{
+        person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strip>, z.ZodObject<{
+        channel: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    chat: z.ZodOptional<z.ZodLiteral<"open">>;
+    agentMail: z.ZodOptional<z.ZodLiteral<"open">>;
+    ask: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        request: "request";
+    }>>;
+    trustedUntil: z.ZodOptional<z.ZodNumber>;
+    discoverable: z.ZodOptional<z.ZodLiteral<true>>;
+    at: z.ZodNumber;
+}, z.core.$strip>;
+export type GrantReview = z.infer<typeof GrantReview>;
+/**
+ * `grant.set`'s params: the whole new grant for one subject. A level left out is the relation's default; with no
+ * level it is a clear. `trust: true` trusts for `LIMITS.trustDefaultMs`; `trustedUntil` names the end instead.
+ */
+export declare const GrantSetParams: z.ZodObject<{
+    trust: z.ZodOptional<z.ZodLiteral<true>>;
+    chat: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        muted: "muted";
+        blocked: "blocked";
+    }>>;
+    agentMail: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        blocked: "blocked";
+    }>>;
+    ask: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        request: "request";
+        no: "no";
+    }>>;
+    trustedUntil: z.ZodOptional<z.ZodNumber>;
+    discoverable: z.ZodOptional<z.ZodBoolean>;
+    subject: z.ZodUnion<readonly [z.ZodObject<{
+        person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strict>, z.ZodObject<{
+        channel: z.ZodString;
+    }, z.core.$strict>]>;
+}, z.core.$strict>;
+export type GrantSetParams = z.infer<typeof GrantSetParams>;
+/** A request this device holds for its person to answer (spec §6.9, "Holds"): mail or a task to one of their agents. */
+export declare const AskRequest: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        message: "message";
+        task: "task";
+    }>;
+    from: z.ZodObject<{
+        person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        device: z.ZodString;
+        label: z.ZodString;
+        agent: z.ZodString;
+        address: z.ZodString;
+    }, z.core.$strip>;
+    to: z.ZodString;
+    preview: z.ZodString;
+    at: z.ZodNumber;
+    exp: z.ZodNumber;
+}, z.core.$strip>;
+export type AskRequest = z.infer<typeof AskRequest>;
+/**
+ * A message request this device holds for its person (spec §6.9, "Message requests"): a person of another org asks to
+ * write to them. `name`, `email` and `org` are the realm's verified profile of the sender, never the request's text.
+ */
+export declare const ContactRequestView: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"contact">;
+    from: z.ZodObject<{
+        person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        device: z.ZodString;
+        label: z.ZodString;
+        name: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+        org: z.ZodEnum<{
+            other: "other";
+            none: "none";
+            same: "same";
+        }>;
+    }, z.core.$strip>;
+    text: z.ZodString;
+    at: z.ZodNumber;
+    exp: z.ZodNumber;
+}, z.core.$strip>;
+export type ContactRequestView = z.infer<typeof ContactRequestView>;
+/**
+ * A contact one of this person's agents asks them to make (spec §6.9, "Message requests"): `send {to: "me", request:
+ * {contact}}`. Only the person sends a message request, with `contact.request`; answering this one `decline`
+ * dismisses it.
+ */
+export declare const ContactSuggestion: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"suggestion">;
+    agent: z.ZodString;
+    email: z.ZodString;
+    at: z.ZodNumber;
+}, z.core.$strip>;
+export type ContactSuggestion = z.infer<typeof ContactSuggestion>;
+/** What `request.list` lists: asks to the person's agents, message requests, and contacts their agents suggest. */
+export declare const HeldRequest: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        message: "message";
+        task: "task";
+    }>;
+    from: z.ZodObject<{
+        person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        device: z.ZodString;
+        label: z.ZodString;
+        agent: z.ZodString;
+        address: z.ZodString;
+    }, z.core.$strip>;
+    to: z.ZodString;
+    preview: z.ZodString;
+    at: z.ZodNumber;
+    exp: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"contact">;
+    from: z.ZodObject<{
+        person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        device: z.ZodString;
+        label: z.ZodString;
+        name: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+        org: z.ZodEnum<{
+            other: "other";
+            none: "none";
+            same: "same";
+        }>;
+    }, z.core.$strip>;
+    text: z.ZodString;
+    at: z.ZodNumber;
+    exp: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"suggestion">;
+    agent: z.ZodString;
+    email: z.ZodString;
+    at: z.ZodNumber;
+}, z.core.$strip>]>;
+export type HeldRequest = z.infer<typeof HeldRequest>;
+/**
+ * For an ask: `once` delivers it, guarded; `always` sets the sender's grant to `ask: "open"` (keeping its other
+ * levels), then delivers it, guarded. For a message request: `accept` sets the sender's grant to `chat: "open"`
+ * (keeping its other levels), files the request as their first line and sends them a card. For both: `decline`
+ * refuses it (`declined`); `block` sets the sender's grant to `chat: "blocked"` (keeping its other levels), then
+ * declines it. For a suggestion: `decline` dismisses it.
+ */
+export declare const RequestAnswer: z.ZodEnum<{
+    once: "once";
+    always: "always";
+    accept: "accept";
+    decline: "decline";
+    block: "block";
+}>;
+export type RequestAnswer = z.infer<typeof RequestAnswer>;
+/** A message request's text: 1 to `LIMITS.requestChars` UTF-16 code units. */
+export declare const RequestText: z.ZodString;
+/**
+ * What another person's card says this person may send them, or, with no card, the defaults of the relation
+ * (spec §6.9, "Contact cards"). `at` is when the card was signed.
+ */
+/**
+ * What a person may be sent (spec §6.9, "Contact cards"), and `devicesChangedAt`: when a device of theirs was last
+ * added or removed, while that is under 7 days ago (design §2.8: their devices changed; a rekey or attest is not a change).
+ */
+export declare const PersonReach: z.ZodObject<{
+    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    can: z.ZodObject<{
+        chat: z.ZodBoolean;
+        agentMail: z.ZodBoolean;
+        ask: z.ZodEnum<{
+            open: "open";
+            request: "request";
+            no: "no";
+        }>;
+        trustedUntil: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    source: z.ZodEnum<{
+        default: "default";
+        card: "card";
+    }>;
+    at: z.ZodOptional<z.ZodNumber>;
+    devicesChangedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PersonReach = z.infer<typeof PersonReach>;
+/** `request.answer`'s params, which `request.answer.preview` takes too (spec §8.2, "Previews"). */
+export declare const RequestAnswerParams: z.ZodObject<{
+    id: z.ZodString;
+    answer: z.ZodEnum<{
+        once: "once";
+        always: "always";
+        accept: "accept";
+        decline: "decline";
+        block: "block";
+    }>;
+    all: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+/** `contact.request`'s params; its preview takes them with `text` optional (it reads only `email`). */
+export declare const ContactRequestParams: z.ZodObject<{
+    email: z.ZodString;
+    text: z.ZodString;
+    suggestion: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const CONSENT_METHODS: {
+    /** This person's grants, newest first, and the review list. With `subject`, only that subject's. */
+    readonly "grant.list": {
+        readonly params: z.ZodObject<{
+            subject: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            }, z.core.$strict>, z.ZodObject<{
+                channel: z.ZodString;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            grants: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                ts: z.ZodNumber;
+                by: z.ZodString;
+                resignedAt: z.ZodOptional<z.ZodNumber>;
+                chat: z.ZodOptional<z.ZodEnum<{
+                    open: "open";
+                    muted: "muted";
+                    blocked: "blocked";
+                }>>;
+                agentMail: z.ZodOptional<z.ZodEnum<{
+                    open: "open";
+                    blocked: "blocked";
+                }>>;
+                ask: z.ZodOptional<z.ZodEnum<{
+                    open: "open";
+                    request: "request";
+                    no: "no";
+                }>>;
+                trustedUntil: z.ZodOptional<z.ZodNumber>;
+                discoverable: z.ZodOptional<z.ZodBoolean>;
+                subject: z.ZodUnion<readonly [z.ZodObject<{
+                    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                }, z.core.$strip>, z.ZodObject<{
+                    channel: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>]>;
+            }, z.core.$strip>>;
+            review: z.ZodArray<z.ZodObject<{
+                subject: z.ZodUnion<readonly [z.ZodObject<{
+                    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                }, z.core.$strip>, z.ZodObject<{
+                    channel: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>]>;
+                chat: z.ZodOptional<z.ZodLiteral<"open">>;
+                agentMail: z.ZodOptional<z.ZodLiteral<"open">>;
+                ask: z.ZodOptional<z.ZodEnum<{
+                    open: "open";
+                    request: "request";
+                }>>;
+                trustedUntil: z.ZodOptional<z.ZodNumber>;
+                discoverable: z.ZodOptional<z.ZodLiteral<true>>;
+                at: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    /**
+     * Signs and stores the subject's new grant, sends it to this person's other devices, and drops the subject from
+     * the review list. `not_found` for a person the realm does not know or a channel this person is not in.
+     */
+    readonly "grant.set": {
+        readonly params: z.ZodObject<{
+            trust: z.ZodOptional<z.ZodLiteral<true>>;
+            chat: z.ZodOptional<z.ZodEnum<{
+                open: "open";
+                muted: "muted";
+                blocked: "blocked";
+            }>>;
+            agentMail: z.ZodOptional<z.ZodEnum<{
+                open: "open";
+                blocked: "blocked";
+            }>>;
+            ask: z.ZodOptional<z.ZodEnum<{
+                open: "open";
+                request: "request";
+                no: "no";
+            }>>;
+            trustedUntil: z.ZodOptional<z.ZodNumber>;
+            discoverable: z.ZodOptional<z.ZodBoolean>;
+            subject: z.ZodUnion<readonly [z.ZodObject<{
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            }, z.core.$strict>, z.ZodObject<{
+                channel: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            grant: z.ZodObject<{
+                id: z.ZodString;
+                ts: z.ZodNumber;
+                by: z.ZodString;
+                resignedAt: z.ZodOptional<z.ZodNumber>;
+                chat: z.ZodOptional<z.ZodEnum<{
+                    open: "open";
+                    muted: "muted";
+                    blocked: "blocked";
+                }>>;
+                agentMail: z.ZodOptional<z.ZodEnum<{
+                    open: "open";
+                    blocked: "blocked";
+                }>>;
+                ask: z.ZodOptional<z.ZodEnum<{
+                    open: "open";
+                    request: "request";
+                    no: "no";
+                }>>;
+                trustedUntil: z.ZodOptional<z.ZodNumber>;
+                discoverable: z.ZodOptional<z.ZodBoolean>;
+                subject: z.ZodUnion<readonly [z.ZodObject<{
+                    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                }, z.core.$strip>, z.ZodObject<{
+                    channel: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>]>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    };
+    /** What `grant.set` with these params would mean, in one fixed sentence; changes nothing. */
+    readonly "grant.set.preview": {
+        readonly params: z.ZodObject<{
+            trust: z.ZodOptional<z.ZodLiteral<true>>;
+            chat: z.ZodOptional<z.ZodEnum<{
+                open: "open";
+                muted: "muted";
+                blocked: "blocked";
+            }>>;
+            agentMail: z.ZodOptional<z.ZodEnum<{
+                open: "open";
+                blocked: "blocked";
+            }>>;
+            ask: z.ZodOptional<z.ZodEnum<{
+                open: "open";
+                request: "request";
+                no: "no";
+            }>>;
+            trustedUntil: z.ZodOptional<z.ZodNumber>;
+            discoverable: z.ZodOptional<z.ZodBoolean>;
+            subject: z.ZodUnion<readonly [z.ZodObject<{
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            }, z.core.$strict>, z.ZodObject<{
+                channel: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            sentence: z.ZodString;
+        }, z.core.$strip>;
+    };
+    /** The requests this device holds for its person, oldest first: asks, then message requests, then suggestions. */
+    readonly "request.list": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            requests: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    message: "message";
+                    task: "task";
+                }>;
+                from: z.ZodObject<{
+                    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                    device: z.ZodString;
+                    label: z.ZodString;
+                    agent: z.ZodString;
+                    address: z.ZodString;
+                }, z.core.$strip>;
+                to: z.ZodString;
+                preview: z.ZodString;
+                at: z.ZodNumber;
+                exp: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodLiteral<"contact">;
+                from: z.ZodObject<{
+                    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                    device: z.ZodString;
+                    label: z.ZodString;
+                    name: z.ZodString;
+                    email: z.ZodOptional<z.ZodString>;
+                    org: z.ZodEnum<{
+                        other: "other";
+                        none: "none";
+                        same: "same";
+                    }>;
+                }, z.core.$strip>;
+                text: z.ZodString;
+                at: z.ZodNumber;
+                exp: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodLiteral<"suggestion">;
+                agent: z.ZodString;
+                email: z.ZodString;
+                at: z.ZodNumber;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>;
+    };
+    /**
+     * Answers a held request; with `all`, every request of the same kind held from the same sending person. Returns
+     * the ids answered. `not_found` for an id this device does not hold; `invalid_request` for an answer its kind does
+     * not take.
+     */
+    readonly "request.answer": {
+        readonly params: z.ZodObject<{
+            id: z.ZodString;
+            answer: z.ZodEnum<{
+                once: "once";
+                always: "always";
+                accept: "accept";
+                decline: "decline";
+                block: "block";
+            }>;
+            all: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            answered: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    /**
+     * Read-only: what `request.answer` would do, for its confirmation (spec §6.9, "Holds", "Message requests"). It takes
+     * exactly `request.answer`'s input. It returns whom the person answers (`from`: the realm's verified profile of the
+     * sender, or of the person for their own agent's suggestion; `name` and `email` are untrusted text), the request's
+     * `kind`, the sender's `agent` and the local session it is `to` (an ask), how many requests the answer would settle
+     * (`count`, more than 1 only with `all`), and one fixed `sentence`: what this `answer` does. `not_found` and `invalid_request` as `request.answer` would answer. Changes nothing.
+     */
+    readonly "request.answer.preview": {
+        readonly params: z.ZodObject<{
+            id: z.ZodString;
+            answer: z.ZodEnum<{
+                once: "once";
+                always: "always";
+                accept: "accept";
+                decline: "decline";
+                block: "block";
+            }>;
+            all: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            kind: z.ZodEnum<{
+                message: "message";
+                task: "task";
+                contact: "contact";
+                suggestion: "suggestion";
+            }>;
+            from: z.ZodObject<{
+                name: z.ZodString;
+                email: z.ZodOptional<z.ZodString>;
+                org: z.ZodEnum<{
+                    other: "other";
+                    none: "none";
+                    same: "same";
+                }>;
+            }, z.core.$strip>;
+            agent: z.ZodOptional<z.ZodString>;
+            to: z.ZodOptional<z.ZodString>;
+            count: z.ZodNumber;
+            sentence: z.ZodString;
+        }, z.core.$strip>;
+    };
+    /**
+     * A message request (spec §6.9, "Message requests"), hosted realms only: resolves the exact `email` at the
+     * directory, then sends `text` to every device of that person as a request, and files it as this person's line in
+     * `dm:<person>`. `not_found` when no Messaging user with that email accepts requests (the same for an unknown and an
+     * undiscoverable email); `rate_limited` while a request to them waits, or past `LIMITS.requestsPerDay` persons
+     * today. `suggestion` dismisses the agent's suggestion it answers.
+     */
+    readonly "contact.request": {
+        readonly params: z.ZodObject<{
+            email: z.ZodString;
+            text: z.ZodString;
+            suggestion: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            id: z.ZodString;
+            conversation: z.ZodString;
+            person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        }, z.core.$strip>;
+    };
+    /** Whether `contact.request` would find a person for `email`; counts against the directory's lookup limits. Sends nothing. */
+    readonly "contact.request.preview": {
+        readonly params: z.ZodObject<{
+            email: z.ZodString;
+            text: z.ZodOptional<z.ZodString>;
+            suggestion: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            found: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    /**
+     * Asks `person` for their card (spec §6.9, "Contact cards"): at most once a day per person; `sent: false` when
+     * this device asked them in the last day.
+     */
+    readonly "card.get": {
+        readonly params: z.ZodObject<{
+            person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            sent: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+};