@joe-broadhead/messaging 0.7.1 → 0.8.0

package/dist/types/core/federation/directory-proof.d.ts

@@ -0,0 +1,8 @@
+import type { JellyKey } from "../directory/jelly-token.js";
+import { type ForeignVerifyInput, type ForeignVerifyResult } from "./proof-state.js";
+/** Key resolution is trusted issuer configuration, never keys embedded in a foreign response.
+ * `options.heads` may only shrink the recent-head working window (tests exercise eviction with a
+ * few heads); it never exceeds FOREIGN_BUDGET.heads. */
+export declare function verifyForeignDirectory(input: ForeignVerifyInput, key: (kid: string) => JellyKey | undefined, options?: {
+    heads?: number;
+}): ForeignVerifyResult;

package/dist/types/core/federation/proof-state.d.ts

@@ -0,0 +1,114 @@
+export declare const FOREIGN_LIMITS: {
+    readonly fetchMs: number;
+    readonly headMs: number;
+    readonly futureMs: number;
+};
+/** Internal work budgets, independent of transport limits. `heads` bounds the recent-head
+ * working window only; the caller's durable archive retains observations beyond it. */
+export declare const FOREIGN_BUDGET: {
+    readonly proofBytes: 1048576;
+    readonly stateBytes: 4194304;
+    readonly nodes: 32768;
+    readonly depth: 32;
+    readonly rosterEntries: 1024;
+    readonly rotations: 64;
+    readonly consistency: 64;
+    readonly heads: 1024;
+};
+export declare class ForeignInputError extends Error {
+    constructor();
+}
+/** Bound traversal before canonicalization allocates/sorts the complete value. No accessors run. */
+export declare function checkForeignValue(value: unknown, maxBytes?: number): void;
+export declare function admitForeignProof(proof: unknown, kind: "directory" | "roster"): void;
+export interface ForeignSubject {
+    readonly realm: string;
+    readonly person: string;
+}
+export interface ForeignPin {
+    readonly kind: "directory" | "roster";
+    readonly realm: string;
+    /** DirectoryRealmConfig, or { genesis: the pinned genesis hash }. Never supplied by a proof. */
+    readonly root: unknown;
+}
+export interface ForeignHead {
+    readonly position: number;
+    readonly hash: string;
+    readonly issuedAt: number;
+    readonly expiresAt: number;
+}
+export interface ForeignDevice {
+    readonly signingKey: string;
+    readonly encryptionKey?: string | undefined;
+    readonly keyVersion: number;
+    /** Last non-self replacement, retained even after a subsequent self rotation. */
+    readonly review: string | null;
+}
+export interface VerifiedForeignRealm {
+    readonly realm: string;
+    readonly pinDigest: string;
+    readonly head: ForeignHead;
+    /** Private verifier state. Only previously verified results may supply this. */
+    readonly cursor: unknown;
+}
+export interface VerifiedForeignIdentity {
+    readonly subject: ForeignSubject;
+    readonly head: ForeignHead;
+    readonly devices: readonly ForeignDevice[];
+    readonly removed: readonly string[];
+    readonly erased: boolean;
+    readonly proofDigest: string;
+    readonly cursor: unknown;
+}
+export interface ForeignVerifyInput {
+    readonly pin: ForeignPin;
+    readonly subject: ForeignSubject;
+    readonly proof: unknown;
+    readonly now: number;
+    readonly realm?: VerifiedForeignRealm | undefined;
+    readonly known?: VerifiedForeignIdentity | undefined;
+    /** A locally verified historical observation, looked up in the caller's durable archive. */
+    readonly observedHead?: ForeignHead | undefined;
+}
+export interface ForeignVerifiedState {
+    readonly realm: VerifiedForeignRealm;
+    readonly identity: VerifiedForeignIdentity;
+}
+export type ForeignVerifyResult = ({
+    readonly ok: true;
+} & ForeignVerifiedState) | {
+    readonly ok: false;
+    readonly reason: "stale";
+    readonly verified: ForeignVerifiedState;
+    readonly evidence: {
+        readonly code: string;
+        readonly digest: string;
+    };
+} | {
+    readonly ok: false;
+    readonly reason: "invalid" | "root" | "rollback" | "fork";
+    readonly evidence: {
+        readonly code: string;
+        readonly digest: string;
+        readonly compatible?: true;
+    };
+};
+export declare class ForeignProofError extends Error {
+    readonly reason: Extract<ForeignVerifyResult, {
+        ok: false;
+    }>["reason"];
+    readonly code: string;
+    readonly compatible: boolean;
+    constructor(reason: Extract<ForeignVerifyResult, {
+        ok: false;
+    }>["reason"], code: string, compatible?: boolean);
+}
+export declare function requireProof(condition: boolean, code: string, reason?: ForeignProofError["reason"], compatible?: boolean): asserts condition;
+export declare function proofDigest(value: unknown): string;
+export declare function proofFailure(error: unknown, proof: unknown): ForeignVerifyResult;
+/** Expiry changes key eligibility, never the authenticated history we must retain. */
+export declare function verifiedProof(verified: ForeignVerifiedState, now: number): ForeignVerifyResult;
+export declare function checkContext(input: ForeignVerifyInput, kind: ForeignPin["kind"]): void;
+export declare function checkHeadTime(head: ForeignHead, now: number): void;
+/** Caller clock only. A future local fetch time (including clock rollback) fails closed. */
+export declare function foreignFresh(head: ForeignHead, fetchedAt: number, now: number): boolean;

package/dist/types/core/federation/roster-proof.d.ts

@@ -0,0 +1,7 @@
+import { type ForeignVerifyInput, type ForeignVerifyResult } from "./proof-state.js";
+/** Internal until X3-2/3 supplies the normative contract. */
+export declare const DOMAIN: {
+    readonly rosterCheckpoint: "messaging/1/federation/roster-checkpoint\n";
+};
+/** Full history only; the caller has separately authorized its disclosure. */
+export declare function verifyForeignRoster(input: ForeignVerifyInput): ForeignVerifyResult;

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

@@ -1,8 +1,13 @@
 export * from "./schema/index.js";
+export * from "./conversation-agent-tools.js";
 export { b64u } from "./b64u.js";
 export { VERSION } from "./version.js";
 export { canonicalize } from "./jcs.js";
 export { parseWire } from "./wire.js";
+export * from "./conversation/requests.js";
+export * from "./conversation/request-log.js";
+export * from "./conversation/request-seal.js";
+export * from "./conversation/guest-invitation.js";
 export { sha256 } from "./hash.js";
 export { ulid } from "./ulid.js";
 export { Identity, IdentityFile, generateIdentity, exportIdentity, importIdentity } from "./identity.js";
@@ -32,14 +37,14 @@ export { createGrant, verifyChain, type GrantArgs, type ChainHop, type ChainCont
 export { canTransition, isTerminal, isInterrupted } from "./task.js";
 export { TERMINAL_STATES } from "./schema/a2a.js";
 export { cleanPeerText, createFence, terminalSafe, displayWidth, HOST_TAGS, PEER_FENCE_TAG, PEER_DATA_NOTICE, provenanceOf, type CleanOptions, type Fence, type FenceAttributes, type FenceOptions, type TerminalOptions } from "./peer-text.js";
-export { AgentTool, TOOL_VERBS, TOOL_DESCRIPTIONS, ToolExpect, UNTRUSTED_SENTENCE, TOOL_REMEDIES, STORE_REFUSED_REMEDIES, DONE_STATES, TaskStateName, ToolErrorBody, ToolFiles, a2aTaskState, conversationOf, decodeToolCursor, encodeToolCursor, formatToolAddress, parseToolAddress, taskStateName, toolErrorBody, toolName, type ToolAddress, type ToolAuthor, type ToolChain, type ToolConsent, type ToolCursor, type ToolInput, type ToolOutput, type ToolPart, type ToolTask, type ToolVerb, } from "./agent-tools.js";
-export { Operations, type CallSession, type ChatAccess, type OperationsContext, type OperationsHooks, type SendPlan, type ToolLink, } from "./agent/operations.js";
-export { agentCan, consentOf, conversationOfPeer, followUpRead, isoOf, presentAgent, presentConvEntry, presentInboxItem, presentLine, presentMail, presentSent, presentTask, presentTaskItem, presentTaskView, } from "./agent/present.js";
+export { AgentTool, TOOL_VERBS, TOOL_DESCRIPTIONS, ToolExpect, UNTRUSTED_SENTENCE, TOOL_REMEDIES, STORE_REFUSED_REMEDIES, DONE_STATES, TaskStateName, ToolErrorBody, ToolFiles, a2aTaskState, formatToolAddress, parseToolAddress, taskStateName, toolErrorBody, toolName, type ToolAddress, type ToolAuthor, type ToolChain, type ToolConsent, type ToolInput, type ToolOutput, type ToolPart, type ToolTask, type ToolVerb, } from "./agent-tools.js";
+export { Operations, type CallSession, type ChatAccess, type OperationsContext, type OperationsHooks, type ToolLink, } from "./agent/operations.js";
+export { agentCan, consentOf, followUpRead, isoOf, presentAgent, presentInboxItem, presentTaskEnvelope, presentTask, presentTaskItem, presentTaskView, } from "./agent/present.js";
 export { chainPath, compact, delegated, delegationPrompt, EXPECT_TEXT, isSafeId, messageAttributes, validatedAddress, type SessionAddressParts, type ToolFramer, } from "./agent/text.js";
 export { dmConvId, selfConvId, participantOf, participantPerson, participantAgent } from "./conversation/ids.js";
 export { admitConvEvent, convEntryHash, convEventDigest, convEventHeader, convEventSigned, convGenesisHash, convLinkHash, signConvEvent, verifyConvEvent, } from "./conversation/event.js";
 export { chainStep, ReceiverChains, ReceiverChainsState, SenderChain, SenderChainState } from "./conversation/ratchet.js";
-export { openConvMeta, openConvMsg, openKeyShares, sealConvMeta, sealConvMsg, sealKeyShares, type ShareRecipient, type UnsealedKeys, type UnsealedMsg, } from "./conversation/seal.js";
-export { ConvLog, type ConvApplyOptions, type ConvExpiredEntry, type ConvLiveChecks, type ConvMessage, type ConvParticipant, type ConvSnapshot, type ConvVote, } from "./conversation/log.js";
+export { openConvMeta, openConvMsg, openConvState, openKeyShares, sealConvMeta, sealConvMsg, sealConvState, sealKeyShare, type ShareRecipient, type UnsealedKeys, type UnsealedMsg, type UnsealedOpEvent, type UnsealedStateOp, } from "./conversation/seal.js";
+export { ConvLog, type ConvApplyOptions, type ConvLiveChecks, type ConvMessage, type ConvParticipant, type ConvSnapshot, type ConvVote, } from "./conversation/log.js";
 export { checkVia, currentLinks, linkReader } from "./conversation/link.js";
 export { CONTEXT_DEFAULTS, contextKindOf, matchContextRule, resolveContext, seatReads, type ContextConv, type ContextDecision, } from "./conversation/context.js";

package/dist/types/core/jelly-host.d.ts

@@ -15,7 +15,7 @@ export declare const JELLY_HOST_SKEW_S = 5;
 export type ActionClass = "view" | "chat" | "local";
 /**
  * The class a method grant must name in `cls` for each human- and admin-tier method (spec §8.11): `chat` for
- * `person.send`, `conv.markRead` and `notice.ack`, `view` for the read-only human-tier methods, `local` for every
+ * line mutations and `notice.ack`, `view` for the read-only human-tier methods, `local` for every
  * other. A plugin's `jelly` declaration gives each action and read the same class; a test there checks one against
  * the other.
  */

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

@@ -54,6 +54,12 @@ export declare const DOMAIN: {
     readonly convMsg: "messaging/1/conv-msg";
     /** Conversations (spec §16.5): HKDF `info` for a sender chain's next chain key. */
     readonly convChain: "messaging/1/conv-chain";
+    readonly request: "messaging/1/contact-request\n";
+    readonly requestContent: "messaging/1/contact-request-content\n";
+    readonly requestDigest: "messaging/1/contact-request-digest\n";
+    readonly requestDecision: "messaging/1/contact-request-decision\n";
+    readonly contactAuthorization: "messaging/1/contact-authorization\n";
+    readonly guestInvitation: "messaging/1/guest-invitation\n";
 };
 /** A2A extension and binding URIs owned by Messaging. */
 export declare const URI: {
@@ -81,8 +87,6 @@ export declare const HostedPersonId: z.ZodString;
 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;
@@ -90,7 +94,7 @@ export declare const TeamName: z.ZodString;
 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.
+ * disconnect and refused as a task executor. No sender can use group addresses.
  */
 export declare const CLI_AGENT = "cli";
 /** Milliseconds since the Unix epoch. */
@@ -141,6 +145,8 @@ export declare const LIMITS: {
     readonly plaintextBytes: 262144;
     /** Max characters in a single text part. */
     readonly textPartChars: 65536;
+    /** Existing model-visible per-part cap, shared with fenced conversation events. */
+    readonly toolTextChars: 32768;
     /** Max parts in one message. */
     readonly partsPerMessage: 16;
     /** Default and max envelope TTL, and the max invite lifetime (`expires − ts`). */
@@ -292,12 +298,32 @@ export declare const LIMITS: {
     readonly rekeyScheduleMs: number;
     /** Max chain keys in one sealed key share, and in one `keys` sync of the `self` conversation. */
     readonly keyShares: 512;
-    /** Max recipient devices one `keys` event seals to; a larger share is split over several events. */
-    readonly keySharesPerEvent: 500;
     /** Max agents one event's `wake` hint names. */
     readonly wakeHints: 5;
     /** Max context rules a person holds (spec §16.8). */
     readonly contextRules: 500;
+    /** Relay (spec §7, "Conversation frames"): appends one device makes to one conversation, a burst of this many... */
+    readonly convAppendBurst: 20;
+    /** ...refilled at this many a minute. */
+    readonly convAppendsPerMinute: 60;
+    /** Appends to one conversation from all its devices, a minute (burst and refill). */
+    readonly convAppendsPerConvPerMinute: 600;
+    /** `rekey` ops with a cause the log cannot prove (`device`, `schedule`) per device per conversation, an hour. */
+    readonly convRekeysPerHour: 4;
+    /** Conversations one device takes part in, through its person (create, add and join refuse past it). */
+    readonly convsPerDevice: 5000;
+    /** Conversations one device creates, an hour (burst and refill). */
+    readonly convCreatesPerHour: 60;
+    /** Key-share events in one `conv.share` frame. */
+    readonly convSharesPerFrame: 100;
+    /** Key shares one sender device holds at the relay for one recipient device in one conversation. */
+    readonly convSharesPerPair: 256;
+    /** Key shares one device sends to one conversation, a burst of this many, refilled per minute. */
+    readonly convSharesPerMinute: 10000;
+    /** Entries (and shares) in one `conv.entries` reply. */
+    readonly convFetchEntries: 500;
+    /** Conversations named in one `conv.head`, and heads in one `conv.heads` reply. */
+    readonly convHeads: 500;
 };
 /**
  * True for a relay URL a client may connect to: `wss://`, or `ws://` to a loopback host (`localhost`,
@@ -315,7 +341,6 @@ 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>;

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

@@ -19,16 +19,16 @@ export declare const AgentMailLevel: z.ZodEnum<{
 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";
+    open: "open";
     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). */
+/** Whom a grant is about: one person, or the verified participants of one conversation. */
 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;
+    conv: z.ZodString;
 }, z.core.$strict>]>;
 export type GrantSubject = z.infer<typeof GrantSubject>;
 /**
@@ -49,7 +49,7 @@ export declare const ConsentGrant: z.ZodObject<{
     subject: z.ZodUnion<readonly [z.ZodObject<{
         person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
     }, z.core.$strict>, z.ZodObject<{
-        channel: z.ZodString;
+        conv: z.ZodString;
     }, z.core.$strict>]>;
     chat: z.ZodOptional<z.ZodEnum<{
         open: "open";
@@ -61,8 +61,8 @@ export declare const ConsentGrant: z.ZodObject<{
         blocked: "blocked";
     }>>;
     ask: z.ZodOptional<z.ZodEnum<{
-        open: "open";
         request: "request";
+        open: "open";
         no: "no";
     }>>;
     trustedUntil: z.ZodOptional<z.ZodNumber>;
@@ -93,8 +93,8 @@ export declare const CardCan: z.ZodObject<{
     chat: z.ZodBoolean;
     agentMail: z.ZodBoolean;
     ask: z.ZodEnum<{
-        open: "open";
         request: "request";
+        open: "open";
         no: "no";
     }>;
     trustedUntil: z.ZodOptional<z.ZodNumber>;
@@ -119,8 +119,8 @@ export declare const ContactCard: z.ZodObject<{
         chat: z.ZodBoolean;
         agentMail: z.ZodBoolean;
         ask: z.ZodEnum<{
-            open: "open";
             request: "request";
+            open: "open";
             no: "no";
         }>;
         trustedUntil: z.ZodOptional<z.ZodNumber>;

package/dist/types/core/schema/contact-request.d.ts

@@ -0,0 +1,264 @@
+/** Portable same-realm contact requests (spec §16.11). All proofs are strict and domain-separated. */
+import { z } from "zod";
+export declare const RequestDescriptor: z.ZodObject<{
+    id: z.ZodString;
+    issuedAt: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+    commitment: z.ZodString;
+    by: z.ZodString;
+    sig: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    realm: z.ZodString;
+    cid: z.ZodString;
+    from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+}, z.core.$strict>;
+export type RequestDescriptor = z.infer<typeof RequestDescriptor>;
+export declare const RequestOpening: z.ZodObject<{
+    salt: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>;
+export type RequestOpening = z.infer<typeof RequestOpening>;
+export declare const PortableRequest: z.ZodObject<{
+    descriptor: z.ZodObject<{
+        id: z.ZodString;
+        issuedAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        commitment: z.ZodString;
+        by: z.ZodString;
+        sig: z.ZodString;
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        cid: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strict>;
+    opening: z.ZodObject<{
+        salt: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type PortableRequest = z.infer<typeof PortableRequest>;
+/** A block is conveyed as decline. The first valid terminal answer is sequenced in the recipient mailbox. */
+export declare const RequestDecision: z.ZodObject<{
+    id: z.ZodString;
+    descriptor: z.ZodString;
+    answer: z.ZodEnum<{
+        accept: "accept";
+        decline: "decline";
+    }>;
+    at: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    realm: z.ZodString;
+    cid: z.ZodString;
+    from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+}, z.core.$strict>;
+export type RequestDecision = z.infer<typeof RequestDecision>;
+export declare const RequestActivation: z.ZodObject<{
+    descriptor: z.ZodObject<{
+        id: z.ZodString;
+        issuedAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        commitment: z.ZodString;
+        by: z.ZodString;
+        sig: z.ZodString;
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        cid: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strict>;
+    decision: z.ZodObject<{
+        id: z.ZodString;
+        descriptor: z.ZodString;
+        answer: z.ZodEnum<{
+            accept: "accept";
+            decline: "decline";
+        }>;
+        at: z.ZodNumber;
+        by: z.ZodString;
+        sig: z.ZodString;
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        cid: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type RequestActivation = z.infer<typeof RequestActivation>;
+/** Existing contacts authorize the exact human DM on both sides, under their current local grants. */
+export declare const ContactAuthorization: z.ZodObject<{
+    at: z.ZodNumber;
+    by: z.ZodString;
+    sig: z.ZodString;
+    v: z.ZodLiteral<"messaging/1">;
+    realm: z.ZodString;
+    cid: z.ZodString;
+    from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+}, z.core.$strict>;
+export type ContactAuthorization = z.infer<typeof ContactAuthorization>;
+export declare const ActivationProof: z.ZodUnion<readonly [z.ZodObject<{
+    descriptor: z.ZodObject<{
+        id: z.ZodString;
+        issuedAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        commitment: z.ZodString;
+        by: z.ZodString;
+        sig: z.ZodString;
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        cid: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strict>;
+    decision: z.ZodObject<{
+        id: z.ZodString;
+        descriptor: z.ZodString;
+        answer: z.ZodEnum<{
+            accept: "accept";
+            decline: "decline";
+        }>;
+        at: z.ZodNumber;
+        by: z.ZodString;
+        sig: z.ZodString;
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        cid: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    contacts: z.ZodTuple<[z.ZodObject<{
+        at: z.ZodNumber;
+        by: z.ZodString;
+        sig: z.ZodString;
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        cid: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strict>, z.ZodObject<{
+        at: z.ZodNumber;
+        by: z.ZodString;
+        sig: z.ZodString;
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        cid: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strict>], null>;
+}, z.core.$strict>]>;
+export type ActivationProof = z.infer<typeof ActivationProof>;
+export declare const RequestImport: z.ZodObject<{
+    opening: z.ZodObject<{
+        salt: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>;
+    descriptor: z.ZodObject<{
+        id: z.ZodString;
+        issuedAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        commitment: z.ZodString;
+        by: z.ZodString;
+        sig: z.ZodString;
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        cid: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strict>;
+    decision: z.ZodObject<{
+        id: z.ZodString;
+        descriptor: z.ZodString;
+        answer: z.ZodEnum<{
+            accept: "accept";
+            decline: "decline";
+        }>;
+        at: z.ZodNumber;
+        by: z.ZodString;
+        sig: z.ZodString;
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        cid: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strict>;
+    t: z.ZodLiteral<"request.import">;
+}, z.core.$strict>;
+export type RequestImport = z.infer<typeof RequestImport>;
+/** No opening or request text is sent to the relay. */
+export declare const RequestSettleFrame: z.ZodObject<{
+    descriptor: z.ZodObject<{
+        id: z.ZodString;
+        issuedAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        commitment: z.ZodString;
+        by: z.ZodString;
+        sig: z.ZodString;
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        cid: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strict>;
+    decision: z.ZodObject<{
+        id: z.ZodString;
+        descriptor: z.ZodString;
+        answer: z.ZodEnum<{
+            accept: "accept";
+            decline: "decline";
+        }>;
+        at: z.ZodNumber;
+        by: z.ZodString;
+        sig: z.ZodString;
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        cid: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strict>;
+    t: z.ZodLiteral<"request.settle">;
+    req: z.ZodString;
+}, z.core.$strict>;
+export declare const RequestStateFrame: z.ZodObject<{
+    t: z.ZodLiteral<"request.state">;
+    req: z.ZodString;
+    descriptor: z.ZodObject<{
+        id: z.ZodString;
+        issuedAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        commitment: z.ZodString;
+        by: z.ZodString;
+        sig: z.ZodString;
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        cid: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const RequestSettledFrame: z.ZodObject<{
+    t: z.ZodLiteral<"request.settled">;
+    req: z.ZodString;
+    id: z.ZodString;
+    decision: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        descriptor: z.ZodString;
+        answer: z.ZodEnum<{
+            accept: "accept";
+            decline: "decline";
+        }>;
+        at: z.ZodNumber;
+        by: z.ZodString;
+        sig: z.ZodString;
+        v: z.ZodLiteral<"messaging/1">;
+        realm: z.ZodString;
+        cid: z.ZodString;
+        from: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;