@joe-broadhead/messaging 0.0.0-stage → 0.7.0

package/dist/types/core/schema/directory-frames.d.ts

@@ -0,0 +1,1301 @@
+/**
+ * Directory frames (spec §7, "Directory frames"; design §3.2): the frames a hosted relay, one that runs the
+ * key directory, speaks on the same WebSocket as the relay binding. They follow the frame rules of §7: one
+ * JSON object per text frame, discriminated by `t`; requests carry `req`, replies echo it, and a refusal is
+ * the relay binding's `nack {id: req, code, message}` (with `retryAfterMs` for `rate_limited`).
+ *
+ * Connection, hosted:
+ *   relay  → challenge {proto, relay, nonce}                      (unchanged)
+ *   client → [pre-auth, optional] dir.bind {req, entry}           first binding of this device → dir.ok {req, person, seq, sth}
+ *   client → [pre-auth, optional] dir.sth, dir.heads, dir.device  what a device about to bind reads; heads only, no log
+ *   client → [pre-auth, optional] dir.lookup {.., proof}          a device reads its own person's log (its key proven)
+ *   client → hello {realm, person, device, ts, sig}               sig = Ed25519(device, DOMAIN.relayAuth + JCS(hostedRelayAuthPayload))
+ *   relay  → welcome {sth}                                        or close 4001 (`unknown_device`) when the device is not current
+ *
+ * After welcome, besides send / deliver / presence / recv.ack / ping of §7:
+ *   dir.append {req, entry}               → dir.ok {req, seq, sth}
+ *   dir.keys {req, stmt}                  → dir.ok {req, sth}
+ *   dir.sth {req, size?, from?, epoch?}   → dir.sthIs {req, sth, head, consistency?, epoch?, rotation?}
+ *   dir.lookup {req, persons, size?}      → dir.persons {req, sth, head, persons}
+ *   dir.heads {req, persons, size?}       → dir.headsAre {req, sth, head, persons}
+ *   dir.resolve {req, handle | email}     → dir.resolved {req, persons}
+ *   dir.search {req, query, limit}        → dir.resolved {req, persons}
+ *   dir.watch {req, persons}              → dir.ok {req}; then dir.changed {persons, sth} pushes
+ *   presence.watch {req, persons}         → dir.ok {req}
+ *   dir.erase {req, entries, token}       → dir.ok {req}
+ *   wake.arm {req, url, ticket, agents, awaiting} → dir.ok {req}   a Jelly host's device, before it sleeps (§7, "Wake tickets")
+ *   wake.disarm {req}                     → dir.ok {req}
+ *   relay → dir.unbound {entry, sth}      this device's own unbind, just before close 4003
+ *
+ * The directory's own structures (HostedPersonId, LogEntry, KeysStatement, STH, PersonView, ...) are in
+ * `schema/directory.ts` and `schema/common.ts`, with their verifiers in `packages/core/src/directory/` (spec §15).
+ * The frames take a hosted person (`HostedPersonId`) only.
+ */
+import { z } from "zod";
+import { HostedPersonId, RELAY_PROTOCOL } from "./common.js";
+import { RealmId } from "./realm.js";
+import { DeviceId } from "./directory.js";
+/** A hosted handle (design §6.1): the normalised local part of a verified email. */
+export declare const Handle: z.ZodString;
+/** An exact email address, lower-cased (design §6.1): the domain is ASCII, as Jelly ID's verified emails are. */
+export declare const Email: z.ZodString;
+/** An org (design §2.3): `domain:<d>` until Jelly contract v1.2, then the organisation id. Absent for an individual. */
+export declare const OrgId: z.ZodString;
+/** The value a device signs (with `DOMAIN.relayAuth`) in the hosted `hello` frame. */
+export declare function hostedRelayAuthPayload(args: {
+    relay: string;
+    realm: RealmId;
+    person: HostedPersonId;
+    device: DeviceId;
+    nonce: string;
+    ts: number;
+}): {
+    proto: typeof RELAY_PROTOCOL;
+    relay: string;
+    realm: RealmId;
+    person: HostedPersonId;
+    device: DeviceId;
+    nonce: string;
+    ts: number;
+};
+/** The value a device signs (with `DOMAIN.dirRead`) in a `dir.lookup` before `hello`: its key, on this connection. */
+export declare function dirReadPayload(args: {
+    relay: string;
+    realm: RealmId;
+    device: DeviceId;
+    nonce: string;
+}): {
+    proto: typeof RELAY_PROTOCOL;
+    relay: string;
+    realm: RealmId;
+    device: DeviceId;
+    nonce: string;
+};
+/** A device's proof before `hello` (`dirReadPayload`): `sig` by `device` over this connection's challenge. */
+export declare const DirReadProof: z.ZodObject<{
+    device: z.ZodString;
+    sig: z.ZodString;
+}, z.core.$strict>;
+export type DirReadProof = z.infer<typeof DirReadProof>;
+/** Pre-auth: the first binding of this device, a `bind` entry with a `jelly` authority (design §2.2). */
+export declare const DirBindFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.bind">;
+    req: z.ZodString;
+    entry: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        person: z.ZodString;
+        seq: z.ZodNumber;
+        prev: z.ZodNullable<z.ZodString>;
+        ts: z.ZodNumber;
+        op: z.ZodEnum<{
+            bind: "bind";
+            attest: "attest";
+            unbind: "unbind";
+        }>;
+        device: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            "jelly-host": "jelly-host";
+            laptop: "laptop";
+            server: "server";
+            other: "other";
+        }>>;
+        reason: z.ZodOptional<z.ZodEnum<{
+            self: "self";
+            removed: "removed";
+            lost: "lost";
+            replaced: "replaced";
+            account_deleted: "account_deleted";
+        }>>;
+        authority: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"jelly">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"device">;
+            approver: z.ZodString;
+            link: z.ZodObject<{
+                v: z.ZodLiteral<"messaging/1">;
+                realm: z.ZodString;
+                device: z.ZodString;
+                enc: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodEnum<{
+                    "jelly-host": "jelly-host";
+                    laptop: "laptop";
+                    server: "server";
+                    other: "other";
+                }>;
+                nonce: z.ZodString;
+                ts: z.ZodNumber;
+                sig: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"service">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"self">;
+        }, z.core.$strict>], "kind">;
+        by: z.ZodString;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+/** The hosted `hello`: authenticates a device of a person in a directory realm. A roster relay refuses it. */
+export declare const HostedHelloFrame: z.ZodObject<{
+    t: z.ZodLiteral<"hello">;
+    realm: z.ZodString;
+    person: z.ZodString;
+    device: z.ZodString;
+    ts: z.ZodNumber;
+    sig: z.ZodString;
+}, z.core.$strip>;
+/** An `attest`, an `unbind`, or the `bind` of a QR approval (design §2.1, §2.5), appended to the sender's person's log. */
+export declare const DirAppendFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.append">;
+    req: z.ZodString;
+    entry: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        person: z.ZodString;
+        seq: z.ZodNumber;
+        prev: z.ZodNullable<z.ZodString>;
+        ts: z.ZodNumber;
+        op: z.ZodEnum<{
+            bind: "bind";
+            attest: "attest";
+            unbind: "unbind";
+        }>;
+        device: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            "jelly-host": "jelly-host";
+            laptop: "laptop";
+            server: "server";
+            other: "other";
+        }>>;
+        reason: z.ZodOptional<z.ZodEnum<{
+            self: "self";
+            removed: "removed";
+            lost: "lost";
+            replaced: "replaced";
+            account_deleted: "account_deleted";
+        }>>;
+        authority: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"jelly">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"device">;
+            approver: z.ZodString;
+            link: z.ZodObject<{
+                v: z.ZodLiteral<"messaging/1">;
+                realm: z.ZodString;
+                device: z.ZodString;
+                enc: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodEnum<{
+                    "jelly-host": "jelly-host";
+                    laptop: "laptop";
+                    server: "server";
+                    other: "other";
+                }>;
+                nonce: z.ZodString;
+                ts: z.ZodNumber;
+                sig: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"service">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"self">;
+        }, z.core.$strict>], "kind">;
+        by: z.ZodString;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+/** The sending device's own latest encryption-key statement (design §2.6). */
+export declare const DirKeysFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.keys">;
+    req: z.ZodString;
+    stmt: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        person: z.ZodString;
+        device: z.ZodString;
+        enc: z.ZodString;
+        seq: z.ZodNumber;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+/**
+ * The latest STH, or the STH at `size`. `from`: also a consistency proof from that size. `epoch`: also that
+ * epoch-log leaf with its inclusion proof (an entry's first epoch, design §2.2 step 7).
+ */
+export declare const DirSthFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.sth">;
+    req: z.ZodString;
+    size: z.ZodOptional<z.ZodNumber>;
+    from: z.ZodOptional<z.ZodNumber>;
+    epoch: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Persons' views at the directory's latest STH, which is at least `size`. `knownSeq`: send only the log after it.
+ * Before `hello`, only with `proof` (a device's key on this connection), and only for persons whose log names that
+ * device, current or not: a device reads its own person's log; anyone else reads heads (`dir.heads`).
+ */
+export declare const DirLookupFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.lookup">;
+    req: z.ZodString;
+    persons: z.ZodArray<z.ZodObject<{
+        person: z.ZodString;
+        knownSeq: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    size: z.ZodOptional<z.ZodNumber>;
+    proof: z.ZodOptional<z.ZodObject<{
+        device: z.ZodString;
+        sig: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+/** Persons' heads (`PersonHead`) at the STH of `size`, or the latest; before or after `hello`. */
+export declare const DirHeadsFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.heads">;
+    req: z.ZodString;
+    persons: z.ZodArray<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Before `hello` only: the person whose log binds `device` as a current device, as `dir.headsAre` with that one head at
+ * the latest STH, or none. A device approved by link learns its person this way (design §2.5), then reads that
+ * person's log with `dir.lookup` and its proof.
+ */
+export declare const DirDeviceFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.device">;
+    req: z.ZodString;
+    device: z.ZodString;
+}, z.core.$strip>;
+/** By handle (same org only) or by exact email: exactly one of the two. */
+export declare const DirResolveFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.resolve">;
+    req: z.ZodString;
+    handle: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** A same-org prefix search on handle, name and email local part. */
+export declare const DirSearchFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.search">;
+    req: z.ZodString;
+    query: z.ZodString;
+    limit: z.ZodNumber;
+}, z.core.$strip>;
+/** Sets the persons this connection watches for log and key changes; it replaces the previous set, and `[]` clears it. */
+export declare const DirWatchFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.watch">;
+    req: z.ZodString;
+    persons: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/** Sets the persons whose presence this connection watches (design §8.2); it replaces the previous set. */
+export declare const PresenceWatchFrame: z.ZodObject<{
+    t: z.ZodLiteral<"presence.watch">;
+    req: z.ZodString;
+    persons: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/** The person erases their account from Messaging (design §3.7): an `unbind` of every current device, and a fresh `cnf` token for this device. */
+export declare const DirEraseFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.erase">;
+    req: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        person: z.ZodString;
+        seq: z.ZodNumber;
+        prev: z.ZodNullable<z.ZodString>;
+        ts: z.ZodNumber;
+        op: z.ZodEnum<{
+            bind: "bind";
+            attest: "attest";
+            unbind: "unbind";
+        }>;
+        device: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            "jelly-host": "jelly-host";
+            laptop: "laptop";
+            server: "server";
+            other: "other";
+        }>>;
+        reason: z.ZodOptional<z.ZodEnum<{
+            self: "self";
+            removed: "removed";
+            lost: "lost";
+            replaced: "replaced";
+            account_deleted: "account_deleted";
+        }>>;
+        authority: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"jelly">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"device">;
+            approver: z.ZodString;
+            link: z.ZodObject<{
+                v: z.ZodLiteral<"messaging/1">;
+                realm: z.ZodString;
+                device: z.ZodString;
+                enc: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodEnum<{
+                    "jelly-host": "jelly-host";
+                    laptop: "laptop";
+                    server: "server";
+                    other: "other";
+                }>;
+                nonce: z.ZodString;
+                ts: z.ZodNumber;
+                sig: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"service">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"self">;
+        }, z.core.$strict>], "kind">;
+        by: z.ZodString;
+        sig: z.ZodString;
+    }, z.core.$strict>>;
+    token: z.ZodString;
+}, z.core.$strip>;
+/** Most agents a wake ticket's filter names, and most awaited task requests (spec §7, "Wake tickets"). */
+export declare const WAKE_AGENTS = 64;
+export declare const WAKE_AWAITING = 500;
+/** Most bytes of a wake ticket, and its longest life: Jelly's `jelly-wake+jwt` lives at most seven days. */
+export declare const WAKE_TICKET_BYTES = 4096;
+export declare const WAKE_TICKET_MAX_S: number;
+/** A wake URL: `https://<issuer host>/hosts/<hst>/wake` (or `http://` to a loopback issuer, for tests). */
+export declare const WakeUrl: z.ZodString;
+/**
+ * A Jelly host's device arms a wake ticket before the host sleeps (spec §7, "Wake tickets"). `url` is Jelly ID's wake
+ * endpoint for this device's host; `ticket` the host's single-use `jelly-wake+jwt`, which the relay never verifies
+ * (Jelly ID does) and reads only for its `exp`; `agents` the local sessions whose own person's mail may wake the host;
+ * `awaiting` the request envelope ids of the tasks those agents wait on, whose updates (`replyTo`) may wake it. A new
+ * arm replaces the device's previous one.
+ */
+export declare const WakeArmFrame: z.ZodObject<{
+    t: z.ZodLiteral<"wake.arm">;
+    req: z.ZodString;
+    url: z.ZodString;
+    ticket: z.ZodString;
+    agents: z.ZodArray<z.ZodString>;
+    awaiting: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type WakeArmFrame = z.infer<typeof WakeArmFrame>;
+/** The relay forgets this device's wake ticket. */
+export declare const WakeDisarmFrame: z.ZodObject<{
+    t: z.ZodLiteral<"wake.disarm">;
+    req: z.ZodString;
+}, z.core.$strip>;
+/** Every frame of a directory client that the relay binding (§7) does not already define. */
+export declare const DirectoryClientFrame: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    t: z.ZodLiteral<"dir.bind">;
+    req: z.ZodString;
+    entry: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        person: z.ZodString;
+        seq: z.ZodNumber;
+        prev: z.ZodNullable<z.ZodString>;
+        ts: z.ZodNumber;
+        op: z.ZodEnum<{
+            bind: "bind";
+            attest: "attest";
+            unbind: "unbind";
+        }>;
+        device: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            "jelly-host": "jelly-host";
+            laptop: "laptop";
+            server: "server";
+            other: "other";
+        }>>;
+        reason: z.ZodOptional<z.ZodEnum<{
+            self: "self";
+            removed: "removed";
+            lost: "lost";
+            replaced: "replaced";
+            account_deleted: "account_deleted";
+        }>>;
+        authority: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"jelly">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"device">;
+            approver: z.ZodString;
+            link: z.ZodObject<{
+                v: z.ZodLiteral<"messaging/1">;
+                realm: z.ZodString;
+                device: z.ZodString;
+                enc: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodEnum<{
+                    "jelly-host": "jelly-host";
+                    laptop: "laptop";
+                    server: "server";
+                    other: "other";
+                }>;
+                nonce: z.ZodString;
+                ts: z.ZodNumber;
+                sig: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"service">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"self">;
+        }, z.core.$strict>], "kind">;
+        by: z.ZodString;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"hello">;
+    realm: z.ZodString;
+    person: z.ZodString;
+    device: z.ZodString;
+    ts: z.ZodNumber;
+    sig: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.append">;
+    req: z.ZodString;
+    entry: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        person: z.ZodString;
+        seq: z.ZodNumber;
+        prev: z.ZodNullable<z.ZodString>;
+        ts: z.ZodNumber;
+        op: z.ZodEnum<{
+            bind: "bind";
+            attest: "attest";
+            unbind: "unbind";
+        }>;
+        device: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            "jelly-host": "jelly-host";
+            laptop: "laptop";
+            server: "server";
+            other: "other";
+        }>>;
+        reason: z.ZodOptional<z.ZodEnum<{
+            self: "self";
+            removed: "removed";
+            lost: "lost";
+            replaced: "replaced";
+            account_deleted: "account_deleted";
+        }>>;
+        authority: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"jelly">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"device">;
+            approver: z.ZodString;
+            link: z.ZodObject<{
+                v: z.ZodLiteral<"messaging/1">;
+                realm: z.ZodString;
+                device: z.ZodString;
+                enc: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodEnum<{
+                    "jelly-host": "jelly-host";
+                    laptop: "laptop";
+                    server: "server";
+                    other: "other";
+                }>;
+                nonce: z.ZodString;
+                ts: z.ZodNumber;
+                sig: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"service">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"self">;
+        }, z.core.$strict>], "kind">;
+        by: z.ZodString;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.keys">;
+    req: z.ZodString;
+    stmt: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        person: z.ZodString;
+        device: z.ZodString;
+        enc: z.ZodString;
+        seq: z.ZodNumber;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.sth">;
+    req: z.ZodString;
+    size: z.ZodOptional<z.ZodNumber>;
+    from: z.ZodOptional<z.ZodNumber>;
+    epoch: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.lookup">;
+    req: z.ZodString;
+    persons: z.ZodArray<z.ZodObject<{
+        person: z.ZodString;
+        knownSeq: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    size: z.ZodOptional<z.ZodNumber>;
+    proof: z.ZodOptional<z.ZodObject<{
+        device: z.ZodString;
+        sig: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.device">;
+    req: z.ZodString;
+    device: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.heads">;
+    req: z.ZodString;
+    persons: z.ZodArray<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.resolve">;
+    req: z.ZodString;
+    handle: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.search">;
+    req: z.ZodString;
+    query: z.ZodString;
+    limit: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.watch">;
+    req: z.ZodString;
+    persons: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"presence.watch">;
+    req: z.ZodString;
+    persons: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.erase">;
+    req: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        person: z.ZodString;
+        seq: z.ZodNumber;
+        prev: z.ZodNullable<z.ZodString>;
+        ts: z.ZodNumber;
+        op: z.ZodEnum<{
+            bind: "bind";
+            attest: "attest";
+            unbind: "unbind";
+        }>;
+        device: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            "jelly-host": "jelly-host";
+            laptop: "laptop";
+            server: "server";
+            other: "other";
+        }>>;
+        reason: z.ZodOptional<z.ZodEnum<{
+            self: "self";
+            removed: "removed";
+            lost: "lost";
+            replaced: "replaced";
+            account_deleted: "account_deleted";
+        }>>;
+        authority: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"jelly">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"device">;
+            approver: z.ZodString;
+            link: z.ZodObject<{
+                v: z.ZodLiteral<"messaging/1">;
+                realm: z.ZodString;
+                device: z.ZodString;
+                enc: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodEnum<{
+                    "jelly-host": "jelly-host";
+                    laptop: "laptop";
+                    server: "server";
+                    other: "other";
+                }>;
+                nonce: z.ZodString;
+                ts: z.ZodNumber;
+                sig: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"service">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"self">;
+        }, z.core.$strict>], "kind">;
+        by: z.ZodString;
+        sig: z.ZodString;
+    }, z.core.$strict>>;
+    token: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"wake.arm">;
+    req: z.ZodString;
+    url: z.ZodString;
+    ticket: z.ZodString;
+    agents: z.ZodArray<z.ZodString>;
+    awaiting: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"wake.disarm">;
+    req: z.ZodString;
+}, z.core.$strip>], "t">;
+export type DirectoryClientFrame = z.infer<typeof DirectoryClientFrame>;
+/** The answer to a hosted `hello`: the directory's latest STH. */
+export declare const HostedWelcomeFrame: z.ZodObject<{
+    t: z.ZodLiteral<"welcome">;
+    sth: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        size: z.ZodNumber;
+        root: z.ZodString;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+/**
+ * Success. `dir.bind` gets `person`, `seq` and `sth`; `dir.append` gets `seq` and `sth`; `dir.keys` gets `sth`;
+ * `dir.watch`, `presence.watch` and `dir.erase` get none of them.
+ */
+export declare const DirOkFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.ok">;
+    req: z.ZodString;
+    person: z.ZodOptional<z.ZodString>;
+    seq: z.ZodOptional<z.ZodNumber>;
+    sth: z.ZodOptional<z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        size: z.ZodNumber;
+        root: z.ZodString;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+/**
+ * An STH; `head` is its last epoch-log leaf (index `size − 1`, whose `mapRoot` lookups at this STH prove
+ * against) with its inclusion proof. `consistency` answers `from`, `epoch` answers `epoch`, and `rotation`
+ * comes with any STH signed by a new epoch key (design §3.8).
+ */
+export declare const DirSthIsFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.sthIs">;
+    req: z.ZodString;
+    sth: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        size: z.ZodNumber;
+        root: z.ZodString;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+    head: z.ZodObject<{
+        index: z.ZodNumber;
+        leaf: z.ZodObject<{
+            epoch: z.ZodNumber;
+            ts: z.ZodNumber;
+            mapRoot: z.ZodString;
+            prevMapRoot: z.ZodString;
+        }, z.core.$strict>;
+        inclusion: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    consistency: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    epoch: z.ZodOptional<z.ZodObject<{
+        index: z.ZodNumber;
+        leaf: z.ZodObject<{
+            epoch: z.ZodNumber;
+            ts: z.ZodNumber;
+            mapRoot: z.ZodString;
+            prevMapRoot: z.ZodString;
+        }, z.core.$strict>;
+        inclusion: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    rotation: z.ZodOptional<z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        old: z.ZodString;
+        new: z.ZodString;
+        fromSize: z.ZodNumber;
+        sigOld: z.ZodString;
+        sigNew: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+/** One view per person asked, at `sth`. Fewer when the frame would pass `LIMITS.frameBytes`: ask again for the rest. */
+export declare const DirPersonsFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.persons">;
+    req: z.ZodString;
+    sth: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        size: z.ZodNumber;
+        root: z.ZodString;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+    head: z.ZodObject<{
+        index: z.ZodNumber;
+        leaf: z.ZodObject<{
+            epoch: z.ZodNumber;
+            ts: z.ZodNumber;
+            mapRoot: z.ZodString;
+            prevMapRoot: z.ZodString;
+        }, z.core.$strict>;
+        inclusion: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    persons: z.ZodArray<z.ZodObject<{
+        person: z.ZodString;
+        log: z.ZodArray<z.ZodObject<{
+            v: z.ZodLiteral<"messaging/1">;
+            realm: z.ZodString;
+            person: z.ZodString;
+            seq: z.ZodNumber;
+            prev: z.ZodNullable<z.ZodString>;
+            ts: z.ZodNumber;
+            op: z.ZodEnum<{
+                bind: "bind";
+                attest: "attest";
+                unbind: "unbind";
+            }>;
+            device: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                "jelly-host": "jelly-host";
+                laptop: "laptop";
+                server: "server";
+                other: "other";
+            }>>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                self: "self";
+                removed: "removed";
+                lost: "lost";
+                replaced: "replaced";
+                account_deleted: "account_deleted";
+            }>>;
+            authority: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"jelly">;
+                token: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"device">;
+                approver: z.ZodString;
+                link: z.ZodObject<{
+                    v: z.ZodLiteral<"messaging/1">;
+                    realm: z.ZodString;
+                    device: z.ZodString;
+                    enc: z.ZodString;
+                    label: z.ZodString;
+                    kind: z.ZodEnum<{
+                        "jelly-host": "jelly-host";
+                        laptop: "laptop";
+                        server: "server";
+                        other: "other";
+                    }>;
+                    nonce: z.ZodString;
+                    ts: z.ZodNumber;
+                    sig: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"service">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"self">;
+            }, z.core.$strict>], "kind">;
+            by: z.ZodString;
+            sig: z.ZodString;
+        }, z.core.$strict>>;
+        keys: z.ZodArray<z.ZodObject<{
+            v: z.ZodLiteral<"messaging/1">;
+            realm: z.ZodString;
+            person: z.ZodString;
+            device: z.ZodString;
+            enc: z.ZodString;
+            seq: z.ZodNumber;
+            ts: z.ZodNumber;
+            sig: z.ZodString;
+        }, z.core.$strict>>;
+        mapProof: z.ZodObject<{
+            bitmap: z.ZodString;
+            siblings: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        epochs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            seq: z.ZodNumber;
+            epoch: z.ZodObject<{
+                index: z.ZodNumber;
+                leaf: z.ZodObject<{
+                    epoch: z.ZodNumber;
+                    ts: z.ZodNumber;
+                    mapRoot: z.ZodString;
+                    prevMapRoot: z.ZodString;
+                }, z.core.$strict>;
+                inclusion: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            value: z.ZodObject<{
+                log: z.ZodObject<{
+                    seq: z.ZodNumber;
+                    hash: z.ZodString;
+                }, z.core.$strict>;
+                keys: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            mapProof: z.ZodObject<{
+                bitmap: z.ZodString;
+                siblings: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>>;
+        tombstone: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+/** One head per person asked, at `sth`; `head` as in `dir.persons`. */
+export declare const DirHeadsAreFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.headsAre">;
+    req: z.ZodString;
+    sth: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        size: z.ZodNumber;
+        root: z.ZodString;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+    head: z.ZodObject<{
+        index: z.ZodNumber;
+        leaf: z.ZodObject<{
+            epoch: z.ZodNumber;
+            ts: z.ZodNumber;
+            mapRoot: z.ZodString;
+            prevMapRoot: z.ZodString;
+        }, z.core.$strict>;
+        inclusion: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    persons: z.ZodArray<z.ZodObject<{
+        person: z.ZodString;
+        mapProof: z.ZodObject<{
+            bitmap: z.ZodString;
+            siblings: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        value: z.ZodOptional<z.ZodObject<{
+            log: z.ZodObject<{
+                seq: z.ZodNumber;
+                hash: z.ZodString;
+            }, z.core.$strict>;
+            keys: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        tombstone: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+/** A person a handle, an email or a search matched, as the directory reads them from the person's latest verified token. */
+export declare const ResolvedPerson: z.ZodObject<{
+    person: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    org: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ResolvedPerson = z.infer<typeof ResolvedPerson>;
+/** An unknown email and an undiscoverable one get the same empty answer. */
+export declare const DirResolvedFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.resolved">;
+    req: z.ZodString;
+    persons: z.ZodArray<z.ZodObject<{
+        person: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        org: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** A push: the logs or keys of these watched persons changed as of `sth`. */
+export declare const DirChangedFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.changed">;
+    persons: z.ZodArray<z.ZodString>;
+    sth: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        size: z.ZodNumber;
+        root: z.ZodString;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+/** A push to a device just removed: its own signed `unbind` entry, before the relay closes with 4003. */
+export declare const DirUnboundFrame: z.ZodObject<{
+    t: z.ZodLiteral<"dir.unbound">;
+    entry: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        person: z.ZodString;
+        seq: z.ZodNumber;
+        prev: z.ZodNullable<z.ZodString>;
+        ts: z.ZodNumber;
+        op: z.ZodEnum<{
+            bind: "bind";
+            attest: "attest";
+            unbind: "unbind";
+        }>;
+        device: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            "jelly-host": "jelly-host";
+            laptop: "laptop";
+            server: "server";
+            other: "other";
+        }>>;
+        reason: z.ZodOptional<z.ZodEnum<{
+            self: "self";
+            removed: "removed";
+            lost: "lost";
+            replaced: "replaced";
+            account_deleted: "account_deleted";
+        }>>;
+        authority: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"jelly">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"device">;
+            approver: z.ZodString;
+            link: z.ZodObject<{
+                v: z.ZodLiteral<"messaging/1">;
+                realm: z.ZodString;
+                device: z.ZodString;
+                enc: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodEnum<{
+                    "jelly-host": "jelly-host";
+                    laptop: "laptop";
+                    server: "server";
+                    other: "other";
+                }>;
+                nonce: z.ZodString;
+                ts: z.ZodNumber;
+                sig: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"service">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"self">;
+        }, z.core.$strict>], "kind">;
+        by: z.ZodString;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+    sth: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        size: z.ZodNumber;
+        root: z.ZodString;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+/** Every frame a directory relay sends that the relay binding (§7) does not already define. */
+export declare const DirectoryRelayFrame: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    t: z.ZodLiteral<"welcome">;
+    sth: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        size: z.ZodNumber;
+        root: z.ZodString;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.ok">;
+    req: z.ZodString;
+    person: z.ZodOptional<z.ZodString>;
+    seq: z.ZodOptional<z.ZodNumber>;
+    sth: z.ZodOptional<z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        size: z.ZodNumber;
+        root: z.ZodString;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.sthIs">;
+    req: z.ZodString;
+    sth: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        size: z.ZodNumber;
+        root: z.ZodString;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+    head: z.ZodObject<{
+        index: z.ZodNumber;
+        leaf: z.ZodObject<{
+            epoch: z.ZodNumber;
+            ts: z.ZodNumber;
+            mapRoot: z.ZodString;
+            prevMapRoot: z.ZodString;
+        }, z.core.$strict>;
+        inclusion: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    consistency: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    epoch: z.ZodOptional<z.ZodObject<{
+        index: z.ZodNumber;
+        leaf: z.ZodObject<{
+            epoch: z.ZodNumber;
+            ts: z.ZodNumber;
+            mapRoot: z.ZodString;
+            prevMapRoot: z.ZodString;
+        }, z.core.$strict>;
+        inclusion: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    rotation: z.ZodOptional<z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        old: z.ZodString;
+        new: z.ZodString;
+        fromSize: z.ZodNumber;
+        sigOld: z.ZodString;
+        sigNew: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.persons">;
+    req: z.ZodString;
+    sth: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        size: z.ZodNumber;
+        root: z.ZodString;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+    head: z.ZodObject<{
+        index: z.ZodNumber;
+        leaf: z.ZodObject<{
+            epoch: z.ZodNumber;
+            ts: z.ZodNumber;
+            mapRoot: z.ZodString;
+            prevMapRoot: z.ZodString;
+        }, z.core.$strict>;
+        inclusion: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    persons: z.ZodArray<z.ZodObject<{
+        person: z.ZodString;
+        log: z.ZodArray<z.ZodObject<{
+            v: z.ZodLiteral<"messaging/1">;
+            realm: z.ZodString;
+            person: z.ZodString;
+            seq: z.ZodNumber;
+            prev: z.ZodNullable<z.ZodString>;
+            ts: z.ZodNumber;
+            op: z.ZodEnum<{
+                bind: "bind";
+                attest: "attest";
+                unbind: "unbind";
+            }>;
+            device: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                "jelly-host": "jelly-host";
+                laptop: "laptop";
+                server: "server";
+                other: "other";
+            }>>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                self: "self";
+                removed: "removed";
+                lost: "lost";
+                replaced: "replaced";
+                account_deleted: "account_deleted";
+            }>>;
+            authority: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"jelly">;
+                token: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"device">;
+                approver: z.ZodString;
+                link: z.ZodObject<{
+                    v: z.ZodLiteral<"messaging/1">;
+                    realm: z.ZodString;
+                    device: z.ZodString;
+                    enc: z.ZodString;
+                    label: z.ZodString;
+                    kind: z.ZodEnum<{
+                        "jelly-host": "jelly-host";
+                        laptop: "laptop";
+                        server: "server";
+                        other: "other";
+                    }>;
+                    nonce: z.ZodString;
+                    ts: z.ZodNumber;
+                    sig: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"service">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"self">;
+            }, z.core.$strict>], "kind">;
+            by: z.ZodString;
+            sig: z.ZodString;
+        }, z.core.$strict>>;
+        keys: z.ZodArray<z.ZodObject<{
+            v: z.ZodLiteral<"messaging/1">;
+            realm: z.ZodString;
+            person: z.ZodString;
+            device: z.ZodString;
+            enc: z.ZodString;
+            seq: z.ZodNumber;
+            ts: z.ZodNumber;
+            sig: z.ZodString;
+        }, z.core.$strict>>;
+        mapProof: z.ZodObject<{
+            bitmap: z.ZodString;
+            siblings: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        epochs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            seq: z.ZodNumber;
+            epoch: z.ZodObject<{
+                index: z.ZodNumber;
+                leaf: z.ZodObject<{
+                    epoch: z.ZodNumber;
+                    ts: z.ZodNumber;
+                    mapRoot: z.ZodString;
+                    prevMapRoot: z.ZodString;
+                }, z.core.$strict>;
+                inclusion: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            value: z.ZodObject<{
+                log: z.ZodObject<{
+                    seq: z.ZodNumber;
+                    hash: z.ZodString;
+                }, z.core.$strict>;
+                keys: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+            mapProof: z.ZodObject<{
+                bitmap: z.ZodString;
+                siblings: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>>;
+        tombstone: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.headsAre">;
+    req: z.ZodString;
+    sth: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        size: z.ZodNumber;
+        root: z.ZodString;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+    head: z.ZodObject<{
+        index: z.ZodNumber;
+        leaf: z.ZodObject<{
+            epoch: z.ZodNumber;
+            ts: z.ZodNumber;
+            mapRoot: z.ZodString;
+            prevMapRoot: z.ZodString;
+        }, z.core.$strict>;
+        inclusion: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    persons: z.ZodArray<z.ZodObject<{
+        person: z.ZodString;
+        mapProof: z.ZodObject<{
+            bitmap: z.ZodString;
+            siblings: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        value: z.ZodOptional<z.ZodObject<{
+            log: z.ZodObject<{
+                seq: z.ZodNumber;
+                hash: z.ZodString;
+            }, z.core.$strict>;
+            keys: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        tombstone: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.resolved">;
+    req: z.ZodString;
+    persons: z.ZodArray<z.ZodObject<{
+        person: z.ZodString;
+        handle: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+        org: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.changed">;
+    persons: z.ZodArray<z.ZodString>;
+    sth: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        size: z.ZodNumber;
+        root: z.ZodString;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"dir.unbound">;
+    entry: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        person: z.ZodString;
+        seq: z.ZodNumber;
+        prev: z.ZodNullable<z.ZodString>;
+        ts: z.ZodNumber;
+        op: z.ZodEnum<{
+            bind: "bind";
+            attest: "attest";
+            unbind: "unbind";
+        }>;
+        device: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            "jelly-host": "jelly-host";
+            laptop: "laptop";
+            server: "server";
+            other: "other";
+        }>>;
+        reason: z.ZodOptional<z.ZodEnum<{
+            self: "self";
+            removed: "removed";
+            lost: "lost";
+            replaced: "replaced";
+            account_deleted: "account_deleted";
+        }>>;
+        authority: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"jelly">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"device">;
+            approver: z.ZodString;
+            link: z.ZodObject<{
+                v: z.ZodLiteral<"messaging/1">;
+                realm: z.ZodString;
+                device: z.ZodString;
+                enc: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodEnum<{
+                    "jelly-host": "jelly-host";
+                    laptop: "laptop";
+                    server: "server";
+                    other: "other";
+                }>;
+                nonce: z.ZodString;
+                ts: z.ZodNumber;
+                sig: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"service">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"self">;
+        }, z.core.$strict>], "kind">;
+        by: z.ZodString;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+    sth: z.ZodObject<{
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        size: z.ZodNumber;
+        root: z.ZodString;
+        ts: z.ZodNumber;
+        sig: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strip>], "t">;
+export type DirectoryRelayFrame = z.infer<typeof DirectoryRelayFrame>;