@joe-broadhead/messaging 0.0.0-stage → 0.7.0

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

@@ -0,0 +1,272 @@
+import { z } from "zod";
+/** Protocol identifier carried in every envelope and roster entry. A breaking change gets a new value. */
+export declare const PROTOCOL: "messaging/1";
+/** Relay WebSocket sub-protocol identifier. */
+export declare const RELAY_PROTOCOL: "messaging-relay/1";
+/**
+ * Domain-separation prefixes. Every signature covers `prefix + JCS(value)` as UTF-8,
+ * so a signature made for one purpose can never verify for another.
+ */
+export declare const DOMAIN: {
+    readonly envelope: "messaging/1/envelope\n";
+    readonly roster: "messaging/1/roster\n";
+    readonly relayAuth: "messaging/1/relay-auth\n";
+    /** An invite redeem proof, signed with the invite seed over JCS({team, inviteId, member}). */
+    readonly invite: "messaging/1/invite\n";
+    /** A pre-auth `join` proof, signed with the invite seed over JCS({relay, team, inviteId, nonce}). */
+    readonly inviteJoin: "messaging/1/invite-join\n";
+    /** A delegation grant, signed by the delegating machine over JCS(grant without sig). */
+    readonly delegation: "messaging/1/delegation\n";
+    /** A consent grant (spec §6.9), signed by a device of its person over JCS(grant without sig). */
+    readonly grant: "messaging/1/grant\n";
+    /** A contact card (spec §6.9, "Contact cards"), signed by a device of the person it speaks for over JCS(card without sig). */
+    readonly card: "messaging/1/card\n";
+    /** HKDF `info` for sealing envelope bodies. */
+    readonly seal: "messaging/1/seal";
+    /** Hosted realms (spec §15.1): the prefix of the hash that turns a Jelly account into a `PersonId`. */
+    readonly person: "messaging/1/person\n";
+    /** Hosted realms (spec §15.5): an erased person's map value is the SHA-256 of this text. */
+    readonly tombstone: "messaging/1/tombstone";
+    /**
+     * Hosted realms (spec §7, "Directory frames"): a device's proof, before `hello`, that it holds its key on this
+     * connection, signed over JCS(`dirReadPayload`), so it may read its own person's log.
+     */
+    readonly dirRead: "messaging/1/dir-read\n";
+    /** Hosted realms (spec §15.3): a device-log entry, signed by `by` over JCS(entry without sig). */
+    readonly deviceLog: "messaging/1/device-log\n";
+    /** Hosted realms (spec §15.4): a keys statement, signed by its device over JCS(statement without sig). */
+    readonly deviceKeys: "messaging/1/device-keys\n";
+    /** Hosted realms (spec §15.3): a link request, signed by the new device over JCS(request without sig). */
+    readonly deviceLink: "messaging/1/device-link\n";
+    /** Hosted realms (spec §15.6): a signed tree head, signed by the directory's epoch key over JCS(head without sig). */
+    readonly epoch: "messaging/1/epoch\n";
+    /** Hosted realms (spec §15.6): an epoch-key rotation, signed by the old key and by the new over JCS(rotation without sigs). */
+    readonly dirKey: "messaging/1/dir-key\n";
+};
+/** A2A extension and binding URIs owned by Messaging. */
+export declare const URI: {
+    readonly binding: "urn:messaging:binding:relay:v1";
+    readonly provenance: "urn:messaging:ext:provenance:v1";
+    readonly presence: "urn:messaging:ext:presence:v1";
+};
+export declare const Base64Url: z.ZodString;
+/** Any 32-byte value in base64url, e.g. a raw public key. */
+export declare const Key32: z.ZodString;
+/** A machine's identity: its Ed25519 public key (32 bytes, base64url). */
+export declare const MachineId: z.ZodString;
+/** A machine's X25519 public key used to seal envelope bodies addressed to it. */
+export declare const EncKey: z.ZodString;
+/** SHA-256 digest, base64url. */
+export declare const Hash: z.ZodString;
+/** A team id is the hash of its JCS-canonical genesis entry. */
+export declare const TeamId: z.ZodString;
+/** Crockford base32 ULID, 26 chars. */
+export declare const Ulid: z.ZodString;
+export declare const PersonName: z.ZodString;
+/** A hosted realm's person (spec §15.1): `p_` and 26 lower-case base32 characters, derived from a Jelly account. */
+export declare const HostedPersonId: z.ZodString;
+/** A person in either realm: a roster person name, or a hosted `p_…` id. The two forms cannot collide. */
+export declare const PersonId: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+/** A channel's name (spec §6.8). Unique among the channels one machine holds, not across the team. */
+export declare const ChannelName: z.ZodString;
+/** A chat room (spec §6.8): `dm:<person>` for a direct human message, `channel:<name>` for a channel. */
+export declare const RoomRef: z.ZodString;
+export declare const SessionName: z.ZodString;
+export declare const MachineLabel: z.ZodString;
+export declare const TeamName: z.ZodString;
+/** Client kind, e.g. "opencode", "claude-code", "cli". */
+export declare const AgentKind: z.ZodString;
+/**
+ * The agent kind of the human `messaging` command line (spec §8.2, §8.3): never kept or expired on
+ * disconnect, refused as a task executor, and the only sender of group addresses.
+ */
+export declare const CLI_AGENT = "cli";
+/** Milliseconds since the Unix epoch. */
+export declare const Millis: z.ZodNumber;
+/**
+ * Address grammar (parsed by `parseAddress`); `person` is a `PersonId` (a roster person name or a hosted `p_…`):
+ *   person/session            one session (must be unambiguous across the person's machines)
+ *   person/session@label      one session on a named machine
+ * There are no group addresses (spec §3).
+ */
+export declare const Address: z.ZodString;
+/**
+ * A resolved, fully qualified single-session address: `person/session@label`, where `person` is a `PersonId` (a
+ * roster person name, or a hosted `p_…` id). Every daemon-produced address uses it.
+ */
+export declare const SessionAddress: z.ZodString;
+export declare const MemberRole: z.ZodEnum<{
+    admin: "admin";
+    member: "member";
+}>;
+export declare const SessionState: z.ZodEnum<{
+    idle: "idle";
+    busy: "busy";
+}>;
+/** push: the client may wake an idle session for inbound mail. pull: the agent reads its inbox. */
+export declare const DeliveryTier: z.ZodEnum<{
+    push: "push";
+    pull: "pull";
+}>;
+/** Sender-side view of one envelope's progress. Stages only move forward, except to rejected/expired. */
+export declare const DeliveryStage: z.ZodEnum<{
+    accepted: "accepted";
+    relayed: "relayed";
+    delivered: "delivered";
+    held: "held";
+    handed_to_agent: "handed_to_agent";
+    read: "read";
+    replied: "replied";
+    rejected: "rejected";
+    expired: "expired";
+}>;
+export declare const LIMITS: {
+    /** Max bytes for one relay WebSocket frame. */
+    readonly frameBytes: 1048576;
+    /** Max bytes for one IPC NDJSON line. */
+    readonly ipcLineBytes: 2097152;
+    /** Max UTF-8 bytes of a decrypted envelope body (JCS). */
+    readonly plaintextBytes: 262144;
+    /** Max characters in a single text part. */
+    readonly textPartChars: 65536;
+    /** Max parts in one message. */
+    readonly partsPerMessage: 16;
+    /** Default and max envelope TTL, and the max invite lifetime (`expires − ts`). */
+    readonly ttlMs: number;
+    /** Max nesting of arrays and objects in any JSON value Messaging parses, signs or hashes; the outermost container is depth 1. */
+    readonly jsonDepth: 32;
+    /** Accepted clock skew for `ts` in the future. */
+    readonly clockSkewMs: number;
+    /** Inbound envelopes accepted per sending machine per minute (daemon policy). */
+    readonly inboundPerMachinePerMinute: 60;
+    /** Agent-to-agent loop guard per (sender session, recipient session) pair. */
+    readonly loopGuard: {
+        readonly max: 12;
+        readonly windowMs: number;
+    };
+    /** Max sessions advertised in one presence payload. */
+    readonly presenceSessions: 200;
+    /**
+     * Max UTF-8 bytes of a presence body (JCS). It bounds what each member adds to every welcome's replay
+     * and every fan-out, and still holds `presenceSessions` sessions once their optional fields are dropped.
+     */
+    readonly presenceBytes: 65536;
+    /** Max preview characters in an inbox item. */
+    readonly previewChars: 200;
+    /** Max UTF-8 bytes of one relay frame before `hello`; a larger one closes the connection. */
+    readonly preAuthFrameBytes: 32768;
+    /** Max UTF-8 bytes of an envelope header: JCS of the envelope without `body` (relay nacks `too_large`). */
+    readonly headerBytes: 4096;
+    /** Max unexpired envelopes the relay queues from one sender machine to one recipient machine (`rate_limited`). */
+    readonly queuePerSender: 1000;
+    /** Relay budget per machine for every frame after `hello`: a token bucket of this many frames, refilled per minute. */
+    readonly relayFramesPerMinute: 600;
+    /** Relay budget per machine for every frame after `hello`: a token bucket of this many UTF-8 bytes, refilled per minute. */
+    readonly relayBytesPerMinute: number;
+    /** Relay limit on presence frames per machine: a token bucket of `presenceBurst`, refilled one per `presenceIntervalMs`. */
+    readonly presenceIntervalMs: 2000;
+    /** See `presenceIntervalMs`. */
+    readonly presenceBurst: 3;
+    /** Max entries in one `join` or `roster.sync` reply page. */
+    readonly rosterPageEntries: 256;
+    /** Max UTF-8 bytes of one roster entry (JCS). */
+    readonly rosterEntryBytes: 16384;
+    /** Max grants in a delegation chain (spec §6.7): R → X → Y → Z → W. */
+    readonly delegationDepth: 4;
+    /** Max scope labels in one delegation grant. */
+    readonly delegationScopes: 8;
+    /** Max UTF-8 bytes of a whole delegation chain (JCS). */
+    readonly delegationBytes: 8192;
+    /** Max persons in a channel, its creator included (spec §6.8). */
+    readonly channelPersons: 32;
+    /** Max UTF-16 code units of one chat line's text (spec §6.8). */
+    readonly chatChars: 8000;
+    /** Max follow-ups a requester's task record lists (spec §6.3, the newest). */
+    readonly taskFollowUps: 20;
+    /** Max current devices of one hosted person (spec §15.3); also bounds `dir.erase` (§7, "Directory frames"). */
+    readonly devicesPerPerson: 10;
+    /** A directory makes a new epoch at most this often while changes wait (spec §15.10). */
+    readonly epochMinMs: 5000;
+    /** ...and one at least this often without changes, so a fresh STH always exists. */
+    readonly epochHeartbeatMs: number;
+    /** How often a directory reads Jelly ID's account-deletion feed (spec §15.10). */
+    readonly deletionPollMs: number;
+    /** After a gap in that feed of over 90 days, the directory erases persons idle for this many days, once. */
+    readonly dormantDays: 180;
+    /** Distinct persons one person may send message requests to per day, at a directory relay. */
+    readonly requestsPerDay: 20;
+    /** Max UTF-16 code units of a message request's text (spec §6.9, "Message requests"): the whole of what a stranger may say first. */
+    readonly requestChars: 500;
+    /** Envelopes per day from one person to another who never sent to them (an unsolicited pair). */
+    readonly unsolicitedPerPairPerDay: 20;
+    /** Distinct persons one person may send to unsolicited per day. */
+    readonly unsolicitedTargetsPerDay: 50;
+    /** Max persons in one `dir.lookup`. */
+    readonly dirLookupPersons: 64;
+    /** Max persons one `dir.resolve` or `dir.search` answers. */
+    readonly dirSearchResults: 25;
+    /** Max persons one device watches with `dir.watch`, and with `presence.watch`. */
+    readonly watchPersons: 500;
+    /** Max age of a link request when its device is approved, and of an approval after it (spec §15.3). */
+    readonly linkTtlMs: number;
+    /**
+     * A directory realm's freshness bounds (spec §15.9): a person's devices are sealed to only when verified at an STH
+     * fetched at most `dirFreshFirstMs` ago for a first message or right after a change push, and at most `dirFreshMs`
+     * ago otherwise.
+     */
+    readonly dirFreshFirstMs: number;
+    readonly dirFreshMs: number;
+    /** How often, at least, a device verifies its own person's log and keys at the directory (spec §15.9). */
+    readonly selfMonitorMs: number;
+    /** A Jelly-vouched device attests again at its first chance after this long (spec §15.9). */
+    readonly attestAfterMs: number;
+    /** Max UTF-8 bytes of one device-log entry (JCS), a Jelly token included (spec §15.3). */
+    readonly logEntryBytes: 16384;
+    /** Max UTF-8 bytes of one keys statement (JCS) (spec §15.4). */
+    readonly keysStatementBytes: 1024;
+    /** Trust a grant gives when the person names no end (spec §6.9). */
+    readonly trustDefaultMs: number;
+    /** Max `trustedUntil − ts` of a grant (spec §6.9). */
+    readonly trustMaxMs: number;
+    /** Max UTF-8 bytes of one grant (JCS). */
+    readonly grantBytes: 2048;
+    /** Max UTF-8 bytes of one contact card (JCS) (spec §6.9, "Contact cards"). */
+    readonly cardBytes: 2048;
+    /** Max grants one person's device holds (spec §6.9): one per subject. */
+    readonly grantsPerPerson: 5000;
+    /** Max requests a device holds from one sending person for its person to answer (spec §6.9). */
+    readonly heldPerSender: 20;
+    /** Max requests a device holds in all (spec §6.9). */
+    readonly heldTotal: 200;
+    /** Max lines one person's agents send to another person in an hour, summed over the agents (spec §6.9, "Pacing"). */
+    readonly a2hPerHour: 30;
+    /** Max lines one person's agents send to another person in a day, summed over the agents (spec §6.9, "Pacing"). */
+    readonly a2hPerDay: 100;
+};
+/**
+ * True for a relay URL a client may connect to: `wss://`, or `ws://` to a loopback host (`localhost`,
+ * 127.0.0.0/8 or `[::1]`, after WHATWG URL parsing). Anything else, including text that is not a URL, is false.
+ */
+export declare function isAllowedRelayUrl(url: string): boolean;
+/** A relay connect URL that passes `isAllowedRelayUrl`. */
+export declare const RelayUrl: z.ZodString;
+export type MachineId = z.infer<typeof MachineId>;
+export type EncKey = z.infer<typeof EncKey>;
+export type Hash = z.infer<typeof Hash>;
+export type TeamId = z.infer<typeof TeamId>;
+export type Ulid = z.infer<typeof Ulid>;
+export type PersonName = z.infer<typeof PersonName>;
+export type HostedPersonId = z.infer<typeof HostedPersonId>;
+export type PersonId = z.infer<typeof PersonId>;
+export type ChannelName = z.infer<typeof ChannelName>;
+export type RoomRef = z.infer<typeof RoomRef>;
+export type SessionName = z.infer<typeof SessionName>;
+export type MachineLabel = z.infer<typeof MachineLabel>;
+export type Millis = z.infer<typeof Millis>;
+export type Address = z.infer<typeof Address>;
+export type RelayUrl = z.infer<typeof RelayUrl>;
+export type SessionAddress = z.infer<typeof SessionAddress>;
+export type MemberRole = z.infer<typeof MemberRole>;
+export type SessionState = z.infer<typeof SessionState>;
+export type DeliveryTier = z.infer<typeof DeliveryTier>;
+export type DeliveryStage = z.infer<typeof DeliveryStage>;

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

@@ -0,0 +1,140 @@
+/**
+ * Consent (spec §6.9): a person's grants, the policy they hold for one sender person or one channel. One of the
+ * person's devices signs each grant; only the person's own devices hold it, and their daemons enforce it on
+ * receipt. Agents never sign or change a grant: every method that does is human tier (§8.2).
+ */
+import { z } from "zod";
+/** H2H lines from the subject: `muted` delivers with no notification and no unread mark; `blocked` refuses every class from them. */
+export declare const ChatLevel: z.ZodEnum<{
+    open: "open";
+    muted: "muted";
+    blocked: "blocked";
+}>;
+export type ChatLevel = z.infer<typeof ChatLevel>;
+/** Lines from the subject's agents to the person (A2H). */
+export declare const AgentMailLevel: z.ZodEnum<{
+    open: "open";
+    blocked: "blocked";
+}>;
+export type AgentMailLevel = z.infer<typeof AgentMailLevel>;
+/** Mail and tasks from the subject or their agents to the person's agents: `request` holds each one for the person to answer. */
+export declare const AskLevel: z.ZodEnum<{
+    open: "open";
+    request: "request";
+    no: "no";
+}>;
+export type AskLevel = z.infer<typeof AskLevel>;
+/** Whom a grant is about: one person, or every member of one channel (by its id). */
+export declare const GrantSubject: 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 GrantSubject = z.infer<typeof GrantSubject>;
+/**
+ * A grant, signed by `by`, a device of `person`: `sig = Ed25519(by, "messaging/1/grant\n" || JCS(grant without sig))`.
+ * Every level is optional: an absent level is the default for the relation (spec §6.9, "Effective policy"), and a
+ * grant with none is a clear. `trustedUntil` needs `ask: "open"` and is at most `ts + LIMITS.trustMaxMs`. A channel
+ * grant sets only `ask` and `agentMail`. A grant about the person themself sets only `discoverable`.
+ * `resignedAt` marks a grant re-signed by another device of the person (spec §6.9, "Signers"); it keeps `id` and
+ * `ts`.
+ */
+export declare const ConsentGrant: z.ZodObject<{
+    v: z.ZodLiteral<"messaging/1">;
+    realm: z.ZodString;
+    id: z.ZodString;
+    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    by: z.ZodString;
+    ts: z.ZodNumber;
+    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>]>;
+    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>;
+    resignedAt: z.ZodOptional<z.ZodNumber>;
+    sig: z.ZodString;
+}, z.core.$strip>;
+export type ConsentGrant = z.infer<typeof ConsentGrant>;
+/** Most grants one `self` sync envelope carries (spec §6.9, "Sync"): a snapshot goes in as many envelopes as it needs. */
+export declare const GRANTS_PER_SYNC = 100;
+/**
+ * The one data part of a `self` sync envelope (spec §6.9, "Sync"): grants as signed, kept raw so that members a
+ * newer device adds stay covered by their signatures. The receiver verifies each one.
+ */
+export declare const GrantSync: z.ZodObject<{
+    grants: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type GrantSync = z.infer<typeof GrantSync>;
+/** The grant's levels, the part a person sets. */
+export type GrantLevels = Pick<ConsentGrant, "chat" | "agentMail" | "ask" | "trustedUntil" | "discoverable">;
+/** The rules of a grant that its schema alone cannot say. */
+export declare function grantProblem(grant: Omit<ConsentGrant, "sig">): string | undefined;
+/**
+ * What a person's card tells another person they may send (spec §6.9, "Contact cards"): DM lines (`chat`), lines from
+ * their agents (`agentMail`), and asks to the person's agents (`ask`, with `trustedUntil` while they are trusted).
+ */
+export declare const CardCan: 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>;
+export type CardCan = z.infer<typeof CardCan>;
+/**
+ * A contact card: `from`'s word to `to` about what `to` may send them, signed by `by`, a device of `from`:
+ * `sig = Ed25519(by, "messaging/1/card\n" || JCS(card without sig))`. `seq` rises with every card `from` sends `to`;
+ * the receiver keeps the highest. `grantId` names the grant it reflects. A card is advice: `from`'s own daemon
+ * enforces the grants, which may be newer.
+ */
+export declare const ContactCard: z.ZodObject<{
+    v: z.ZodLiteral<"messaging/1">;
+    realm: z.ZodString;
+    from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    by: z.ZodString;
+    seq: z.ZodNumber;
+    ts: z.ZodNumber;
+    grantId: z.ZodOptional<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>;
+    sig: z.ZodString;
+}, z.core.$strip>;
+export type ContactCard = z.infer<typeof ContactCard>;
+/** The rules of a card that its schema alone cannot say. */
+export declare function cardProblem(card: Omit<ContactCard, "sig">): string | undefined;
+/** The one data part of a `card` message (spec §5, "Meaning"): the card as signed, kept raw; the receiver verifies it. */
+export declare const CardData: z.ZodObject<{
+    card: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+/** The one data part of a card request (`what: "get"`). */
+export declare const CardGetData: z.ZodObject<{
+    get: z.ZodLiteral<true>;
+}, z.core.$strict>;

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

@@ -0,0 +1,58 @@
+/**
+ * Delegation chains (spec §6.7). A task request carries the chain of signed
+ * grants from its root requester to the session it addresses, so an executor (and whoever approves
+ * its work) sees who asked whom, for which task.
+ *
+ *   sig         = Ed25519(by, DOMAIN.delegation + JCS(grant without sig))
+ *   grantHash   = SHA-256(UTF-8(JCS(grant))), base64url, over the full grant including sig
+ *   chain       = [root grant, …, grant to this session]; each later grant has parent = grantHash(previous)
+ *
+ * Every hop is a new statement by the machine that delegates; nothing is forwarded as a credential.
+ * A hop can only narrow: scope ⊆ the previous scope (absent = unrestricted), maxDepth ≤ the previous
+ * maxDepth, exp ≤ the previous exp. `verifyChain` in core checks all of it.
+ *
+ * Grants are loose objects: a field a newer signer adds stays in the parsed grant, so the signature
+ * and the hash still cover it.
+ */
+import { z } from "zod";
+/** A scope label. Its meaning is left to clients; the protocol only checks that a hop never widens the set. */
+export declare const DelegationScope: z.ZodString;
+export type DelegationScope = z.infer<typeof DelegationScope>;
+export declare const DelegationGrant: z.ZodObject<{
+    realm: z.ZodString;
+    task: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    by: z.ZodString;
+    ts: z.ZodNumber;
+    exp: z.ZodNumber;
+    maxDepth: z.ZodNumber;
+    scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    parent: z.ZodOptional<z.ZodString>;
+    sig: z.ZodString;
+}, z.core.$loose>;
+export type DelegationGrant = z.infer<typeof DelegationGrant>;
+/** Root first. Carried as `MessagePayload.delegation` on `kind: "task"` only. */
+export declare const DelegationChain: z.ZodArray<z.ZodObject<{
+    realm: z.ZodString;
+    task: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    by: z.ZodString;
+    ts: z.ZodNumber;
+    exp: z.ZodNumber;
+    maxDepth: z.ZodNumber;
+    scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    parent: z.ZodOptional<z.ZodString>;
+    sig: z.ZodString;
+}, z.core.$loose>>;
+export type DelegationChain = z.infer<typeof DelegationChain>;
+/** What a verified chain says, as the daemon shows it on `InboxItem.chain` and `TaskRecord.chain`. */
+export declare const DelegationSummary: z.ZodObject<{
+    addresses: z.ZodArray<z.ZodString>;
+    depth: z.ZodNumber;
+    maxDepth: z.ZodNumber;
+    scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exp: z.ZodNumber;
+}, z.core.$strip>;
+export type DelegationSummary = z.infer<typeof DelegationSummary>;