@joe-broadhead/messaging 0.0.0-stage → 0.7.1

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

@@ -0,0 +1,375 @@
+/**
+ * Hosted realms: the key directory's signed and hashed objects (spec §15). Every object here is hashed or
+ * signed as JCS, so each is strict: an unknown member is refused rather than carried unsigned.
+ */
+import { z } from "zod";
+/** A map proof (§15.5): a 256-bit bitmap of the non-empty siblings, and those siblings, bottom up. */
+export declare const MapProof: z.ZodObject<{
+    bitmap: z.ZodString;
+    siblings: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type MapProof = z.infer<typeof MapProof>;
+/** What a live person's map leaf commits to (§15.5): their log head, and the hashes of their current keys statements. */
+export declare const MapValue: z.ZodObject<{
+    log: z.ZodObject<{
+        seq: z.ZodNumber;
+        hash: z.ZodString;
+    }, z.core.$strict>;
+    keys: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type MapValue = z.infer<typeof MapValue>;
+/** A device's id: its Ed25519 public key, as a machine's (§3). */
+export declare const DeviceId: z.ZodString;
+export type DeviceId = z.infer<typeof DeviceId>;
+/** What kind of device it is; informational. */
+export declare const DeviceKind: z.ZodEnum<{
+    "jelly-host": "jelly-host";
+    laptop: "laptop";
+    server: "server";
+    other: "other";
+}>;
+export type DeviceKind = z.infer<typeof DeviceKind>;
+/** Why a device was unbound (§15.3). */
+export declare const UnbindReason: z.ZodEnum<{
+    self: "self";
+    removed: "removed";
+    lost: "lost";
+    replaced: "replaced";
+    account_deleted: "account_deleted";
+}>;
+export type UnbindReason = z.infer<typeof UnbindReason>;
+/**
+ * A new device's request to be approved by one of its person's devices (§15.3): shown as
+ * `messaging-link.<base64url(JCS(request))>`. `sig` is the new device's, over JCS(request without sig).
+ */
+export declare const LinkRequest: 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>;
+export type LinkRequest = z.infer<typeof LinkRequest>;
+/** Who vouches for a device-log entry (§15.3). */
+export declare const 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">;
+export type Authority = z.infer<typeof Authority>;
+/**
+ * One entry of a hosted person's device log (§15.3), hash-chained by `prev` and signed by `by` over
+ * JCS(entry without sig) with `DOMAIN.deviceLog`. `bind` names the device's `label` and `kind`; `attest` may
+ * change them; `unbind` gives a `reason` and nothing else.
+ */
+export declare const LogEntry: 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>;
+export type LogEntry = z.infer<typeof LogEntry>;
+/**
+ * A device's self-signed encryption key (§15.4): the directory keeps the latest per device (`seq` strictly
+ * increases). `sig` is the device's, over JCS(statement without sig) with `DOMAIN.deviceKeys`.
+ */
+export declare const KeysStatement: 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>;
+export type KeysStatement = z.infer<typeof KeysStatement>;
+/**
+ * One leaf of the epoch log (§15.6): the map root of epoch `epoch` and of the epoch before it (`E[256]`, the
+ * empty map's root, before epoch 0). The leaf's data is UTF-8(JCS(leaf)).
+ */
+export declare const EpochLeaf: z.ZodObject<{
+    epoch: z.ZodNumber;
+    ts: z.ZodNumber;
+    mapRoot: z.ZodString;
+    prevMapRoot: z.ZodString;
+}, z.core.$strict>;
+export type EpochLeaf = z.infer<typeof EpochLeaf>;
+/** An epoch-log leaf and its RFC 9162 audit path in the tree of the STH it is sent with (§15.6). */
+export declare const EpochProof: 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>;
+export type EpochProof = z.infer<typeof EpochProof>;
+/**
+ * A signed tree head of the epoch log (§15.6): `size` leaves with root `root`, at `ts`. `sig` is the directory's
+ * epoch key's, over JCS(head without sig) with `DOMAIN.epoch`.
+ */
+export declare const 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>;
+export type STH = z.infer<typeof STH>;
+/**
+ * The directory's epoch key moving from `old` to `new` (§15.6): STHs of `fromSize` leaves and more are signed by
+ * `new`. Each key signs JCS(rotation without its two signatures) with `DOMAIN.dirKey`.
+ */
+export declare const KeyRotation: 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>;
+export type KeyRotation = z.infer<typeof KeyRotation>;
+/**
+ * Evidence that log entry `seq` was in the directory by an epoch (§15.7): that epoch's leaf in the view's STH,
+ * and the person's map value there, which commits to a log head at or after `seq`.
+ */
+export declare const EntryEpoch: 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>;
+export type EntryEpoch = z.infer<typeof EntryEpoch>;
+/**
+ * One person's head as the directory serves it at an STH (§7, "Directory frames"; §15.7): the map proof of their value
+ * at the STH's last epoch, and that value's preimage (`value`: their log head and the hashes of their current devices'
+ * keys statements), or none for a person the map does not hold, or `tombstone: true` for an erased one. It holds no
+ * log entry, so no Jelly token and nothing of a profile: what a device about to bind needs, and what anyone may read.
+ */
+export declare const PersonHead: 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>;
+export type PersonHead = z.infer<typeof PersonHead>;
+/**
+ * One person as the directory serves them at an STH (§15.7): their log after the asker's `knownSeq` (all of it
+ * without one), the keys statements of their current devices, the map proof of their value at the STH's last
+ * epoch, and for every entry of `log` with a `jelly` authority, an `EntryEpoch` (its first epoch, from the
+ * directory's records). An erased person is `tombstone: true` with an empty log and no keys.
+ */
+export declare const PersonView: 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>;
+export type PersonView = z.infer<typeof PersonView>;