worldvm 0.0.0-stage → 0.1.0

package/dist/_internal/protocol/index.d.ts

@@ -0,0 +1,1234 @@
+import { Schema as S } from "effect";
+export declare const Actor: S.Struct<{
+    readonly id: S.String;
+    readonly kind: S.Literals<readonly ["human", "agent", "service", "connector"]>;
+    readonly groups: S.optionalKey<S.$Array<S.String>>;
+}>;
+export type Actor = typeof Actor.Type;
+export declare const Scalar: S.Union<readonly [S.String, S.Number, S.Boolean]>;
+export declare const Facts: S.$Record<S.String, S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>>;
+export declare const SignatureInput: S.Struct<{
+    readonly consent: S.Boolean;
+    readonly intent: S.Boolean;
+    readonly method: S.String;
+    readonly device: S.String;
+}>;
+export declare const Draft: S.Union<readonly [S.Struct<{
+    readonly kind: S.Literal<"assert">;
+    readonly values: S.$Record<S.String, S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>>;
+    readonly factKind: S.optionalKey<S.String>;
+}>, S.Struct<{
+    readonly kind: S.Literal<"evidence">;
+    readonly operation: S.String;
+    readonly values: S.$Record<S.String, S.Union<readonly [S.String, S.Number, S.Boolean]>>;
+    readonly instance: S.optionalKey<S.String>;
+}>]>;
+export type Draft = typeof Draft.Type;
+export declare const Proposal: S.Struct<{
+    readonly id: S.String;
+    readonly type: S.String;
+    readonly subject: S.String;
+    readonly by: S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literals<readonly ["human", "agent", "service", "connector"]>;
+        readonly groups: S.optionalKey<S.$Array<S.String>>;
+    }>;
+    readonly at: S.String;
+    readonly rationale: S.String;
+    readonly draft: S.Union<readonly [S.Struct<{
+        readonly kind: S.Literal<"assert">;
+        readonly values: S.$Record<S.String, S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>>;
+        readonly factKind: S.optionalKey<S.String>;
+    }>, S.Struct<{
+        readonly kind: S.Literal<"evidence">;
+        readonly operation: S.String;
+        readonly values: S.$Record<S.String, S.Union<readonly [S.String, S.Number, S.Boolean]>>;
+        readonly instance: S.optionalKey<S.String>;
+    }>]>;
+    readonly state: S.Literals<readonly ["pending", "accepted", "rejected"]>;
+    readonly resolution: S.optionalKey<S.Struct<{
+        readonly by: S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literals<readonly ["human", "agent", "service", "connector"]>;
+            readonly groups: S.optionalKey<S.$Array<S.String>>;
+        }>;
+        readonly at: S.String;
+        readonly command: S.String;
+        readonly reason: S.optionalKey<S.String>;
+    }>>;
+}>;
+export type Proposal = typeof Proposal.Type;
+export declare const requests: {
+    readonly status: S.Struct<{
+        at: S.optionalKey<S.String>;
+        type: S.String;
+        subject: S.String;
+    }>;
+    readonly facts: S.Struct<{
+        at: S.optionalKey<S.String>;
+        type: S.String;
+        subject: S.String;
+    }>;
+    readonly work: S.Struct<{
+        at: S.optionalKey<S.String>;
+        type: S.String;
+        subject: S.String;
+    }>;
+    readonly operations: S.Struct<{
+        at: S.optionalKey<S.String>;
+        type: S.String;
+        subject: S.String;
+    }>;
+    readonly explain: S.Struct<{
+        readonly requirement: S.optionalKey<S.String>;
+        readonly at: S.optionalKey<S.String>;
+        readonly type: S.String;
+        readonly subject: S.String;
+    }>;
+    readonly subjects: S.Struct<{
+        readonly type: S.String;
+    }>;
+    readonly assert: S.Struct<{
+        readonly values: S.$Record<S.String, S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>>;
+        readonly kind: S.optionalKey<S.String>;
+        readonly id: S.String;
+        readonly type: S.String;
+        readonly subject: S.String;
+    }>;
+    readonly perform: S.Struct<{
+        readonly operation: S.String;
+        readonly values: S.optionalKey<S.$Record<S.String, S.Union<readonly [S.String, S.Number, S.Boolean]>>>;
+        readonly instance: S.optionalKey<S.String>;
+        readonly reason: S.optionalKey<S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>>;
+        readonly signature: S.optionalKey<S.Struct<{
+            readonly consent: S.Boolean;
+            readonly intent: S.Boolean;
+            readonly method: S.String;
+            readonly device: S.String;
+        }>>;
+        readonly unsigned: S.optionalKey<S.Boolean>;
+        readonly amend: S.optionalKey<S.Struct<{
+            readonly previous: S.String;
+            readonly reason: S.String;
+        }>>;
+        readonly revoke: S.optionalKey<S.String>;
+        readonly id: S.String;
+        readonly type: S.String;
+        readonly subject: S.String;
+    }>;
+    readonly signal: S.Struct<{
+        readonly machine: S.String;
+        readonly state: S.String;
+        readonly instance: S.optionalKey<S.String>;
+        readonly id: S.String;
+        readonly type: S.String;
+        readonly subject: S.String;
+    }>;
+    readonly propose: S.Struct<{
+        readonly draft: S.Union<readonly [S.Struct<{
+            readonly kind: S.Literal<"assert">;
+            readonly values: S.$Record<S.String, S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>>;
+            readonly factKind: S.optionalKey<S.String>;
+        }>, S.Struct<{
+            readonly kind: S.Literal<"evidence">;
+            readonly operation: S.String;
+            readonly values: S.$Record<S.String, S.Union<readonly [S.String, S.Number, S.Boolean]>>;
+            readonly instance: S.optionalKey<S.String>;
+        }>]>;
+        readonly rationale: S.String;
+        readonly id: S.String;
+        readonly type: S.String;
+        readonly subject: S.String;
+    }>;
+    readonly proposals: S.Struct<{
+        readonly type: S.optionalKey<S.String>;
+        readonly subject: S.optionalKey<S.String>;
+        readonly state: S.optionalKey<S.Literals<readonly ["pending", "accepted", "rejected"]>>;
+    }>;
+    readonly "accept-proposal": S.Struct<{
+        readonly proposal: S.String;
+        readonly signature: S.optionalKey<S.Struct<{
+            readonly consent: S.Boolean;
+            readonly intent: S.Boolean;
+            readonly method: S.String;
+            readonly device: S.String;
+        }>>;
+        readonly id: S.String;
+        readonly type: S.String;
+        readonly subject: S.String;
+    }>;
+    readonly "reject-proposal": S.Struct<{
+        readonly proposal: S.String;
+        readonly reason: S.String;
+        readonly id: S.String;
+        readonly type: S.String;
+        readonly subject: S.String;
+    }>;
+    readonly changes: S.$Record<S.String, S.Never>;
+};
+export type Verb = keyof typeof requests;
+export type Request<V extends Verb> = (typeof requests)[V]["Type"];
+export declare const verbs: Verb[];
+export declare const mutations: readonly Verb[];
+export declare const errorCodes: readonly ["invalid-request", "unauthenticated", "human-required", "forbidden", "not-found", "command-duplicate", "proposal-resolved", "write-refused", "internal"];
+export declare const ProtocolError: S.Struct<{
+    readonly code: S.Literals<readonly ["invalid-request", "unauthenticated", "human-required", "forbidden", "not-found", "command-duplicate", "proposal-resolved", "write-refused", "internal"]>;
+    readonly message: S.String;
+    readonly details: S.optionalKey<S.$Array<S.String>>;
+}>;
+export type ProtocolError = typeof ProtocolError.Type;
+export declare const SubjectStatus: S.Struct<{
+    readonly subject: S.String;
+    readonly at: S.String;
+    readonly release: S.String;
+    readonly revision: S.Number;
+    readonly wakeAt: S.Union<readonly [S.String, S.Null]>;
+    readonly wakeReason: S.String;
+    readonly machines: S.$Array<S.Struct<{
+        readonly instance: S.String;
+        readonly machine: S.String;
+        readonly state: S.Union<readonly [S.String, S.Null]>;
+        readonly since: S.Union<readonly [S.String, S.Null]>;
+    }>>;
+    readonly instances: S.$Array<S.Struct<{
+        readonly instance: S.String;
+        readonly component: S.String;
+        readonly digest: S.String;
+        readonly outputs: S.$Record<S.String, S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>>;
+        readonly requirements: S.$Array<S.Struct<{
+            readonly name: S.String;
+            readonly label: S.String;
+            readonly status: S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>;
+            readonly due: S.Union<readonly [S.String, S.Null]>;
+            readonly blocked: S.Union<readonly [S.String, S.Null]>;
+        }>>;
+    }>>;
+}>;
+export declare const Missing: S.Struct<{
+    readonly text: S.String;
+    readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+    readonly requirement: S.optionalKey<S.String>;
+    readonly instance: S.optionalKey<S.String>;
+    readonly evidence: S.optionalKey<S.String>;
+    readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+        readonly requirement: S.String;
+        readonly instance: S.String;
+    }>>>;
+    readonly fact: S.optionalKey<S.String>;
+    readonly machine: S.optionalKey<S.String>;
+    readonly states: S.optionalKey<S.$Array<S.String>>;
+}>;
+export type Missing = typeof Missing.Type;
+export declare const Fact: S.Struct<{
+    readonly fact: S.String;
+    readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+    readonly by: S.String;
+    readonly at: S.String;
+    readonly command: S.Union<readonly [S.String, S.Null]>;
+}>;
+export type Fact = typeof Fact.Type;
+export declare const WorkItem: S.Struct<{
+    readonly id: S.String;
+    readonly instance: S.String;
+    readonly operation: S.String;
+    readonly label: S.String;
+    readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+    readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+    readonly advances: S.$Array<S.String>;
+    readonly assignee: S.Struct<{
+        readonly id: S.Union<readonly [S.String, S.Null]>;
+        readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+    }>;
+    readonly missing: S.$Array<S.Struct<{
+        readonly text: S.String;
+        readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+        readonly requirement: S.optionalKey<S.String>;
+        readonly instance: S.optionalKey<S.String>;
+        readonly evidence: S.optionalKey<S.String>;
+        readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+            readonly requirement: S.String;
+            readonly instance: S.String;
+        }>>>;
+        readonly fact: S.optionalKey<S.String>;
+        readonly machine: S.optionalKey<S.String>;
+        readonly states: S.optionalKey<S.$Array<S.String>>;
+    }>>;
+    readonly fields: S.$Array<S.Struct<{
+        readonly field: S.String;
+        readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+        readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+    }>>;
+    readonly proposal: S.optionalKey<S.String>;
+}>;
+export declare const Change: S.Struct<{
+    readonly subject: S.String;
+    readonly revision: S.Number;
+    readonly at: S.String;
+    readonly transitions: S.$Array<S.Struct<{
+        readonly instance: S.String;
+        readonly kind: S.Literals<readonly ["requirement", "output"]>;
+        readonly name: S.String;
+        readonly from: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+        readonly to: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+    }>>;
+    readonly opened: S.$Array<S.Struct<{
+        readonly id: S.String;
+        readonly instance: S.String;
+        readonly operation: S.String;
+        readonly label: S.String;
+        readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+        readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+        readonly advances: S.$Array<S.String>;
+        readonly assignee: S.Struct<{
+            readonly id: S.Union<readonly [S.String, S.Null]>;
+            readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+        }>;
+        readonly missing: S.$Array<S.Struct<{
+            readonly text: S.String;
+            readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+            readonly requirement: S.optionalKey<S.String>;
+            readonly instance: S.optionalKey<S.String>;
+            readonly evidence: S.optionalKey<S.String>;
+            readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                readonly requirement: S.String;
+                readonly instance: S.String;
+            }>>>;
+            readonly fact: S.optionalKey<S.String>;
+            readonly machine: S.optionalKey<S.String>;
+            readonly states: S.optionalKey<S.$Array<S.String>>;
+        }>>;
+        readonly fields: S.$Array<S.Struct<{
+            readonly field: S.String;
+            readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+            readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+        }>>;
+        readonly proposal: S.optionalKey<S.String>;
+    }>>;
+    readonly closed: S.$Array<S.Struct<{
+        readonly id: S.String;
+        readonly instance: S.String;
+        readonly operation: S.String;
+        readonly label: S.String;
+        readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+        readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+        readonly advances: S.$Array<S.String>;
+        readonly assignee: S.Struct<{
+            readonly id: S.Union<readonly [S.String, S.Null]>;
+            readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+        }>;
+        readonly missing: S.$Array<S.Struct<{
+            readonly text: S.String;
+            readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+            readonly requirement: S.optionalKey<S.String>;
+            readonly instance: S.optionalKey<S.String>;
+            readonly evidence: S.optionalKey<S.String>;
+            readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                readonly requirement: S.String;
+                readonly instance: S.String;
+            }>>>;
+            readonly fact: S.optionalKey<S.String>;
+            readonly machine: S.optionalKey<S.String>;
+            readonly states: S.optionalKey<S.$Array<S.String>>;
+        }>>;
+        readonly fields: S.$Array<S.Struct<{
+            readonly field: S.String;
+            readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+            readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+        }>>;
+        readonly proposal: S.optionalKey<S.String>;
+    }>>;
+}>;
+export declare const Outcome: S.Struct<{
+    readonly accepted: S.Boolean;
+    readonly codes: S.$Array<S.String>;
+    readonly status: S.Struct<{
+        readonly subject: S.String;
+        readonly at: S.String;
+        readonly release: S.String;
+        readonly revision: S.Number;
+        readonly wakeAt: S.Union<readonly [S.String, S.Null]>;
+        readonly wakeReason: S.String;
+        readonly machines: S.$Array<S.Struct<{
+            readonly instance: S.String;
+            readonly machine: S.String;
+            readonly state: S.Union<readonly [S.String, S.Null]>;
+            readonly since: S.Union<readonly [S.String, S.Null]>;
+        }>>;
+        readonly instances: S.$Array<S.Struct<{
+            readonly instance: S.String;
+            readonly component: S.String;
+            readonly digest: S.String;
+            readonly outputs: S.$Record<S.String, S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>>;
+            readonly requirements: S.$Array<S.Struct<{
+                readonly name: S.String;
+                readonly label: S.String;
+                readonly status: S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>;
+                readonly due: S.Union<readonly [S.String, S.Null]>;
+                readonly blocked: S.Union<readonly [S.String, S.Null]>;
+            }>>;
+        }>>;
+    }>;
+    readonly change: S.Struct<{
+        readonly subject: S.String;
+        readonly revision: S.Number;
+        readonly at: S.String;
+        readonly transitions: S.$Array<S.Struct<{
+            readonly instance: S.String;
+            readonly kind: S.Literals<readonly ["requirement", "output"]>;
+            readonly name: S.String;
+            readonly from: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+            readonly to: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+        }>>;
+        readonly opened: S.$Array<S.Struct<{
+            readonly id: S.String;
+            readonly instance: S.String;
+            readonly operation: S.String;
+            readonly label: S.String;
+            readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+            readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+            readonly advances: S.$Array<S.String>;
+            readonly assignee: S.Struct<{
+                readonly id: S.Union<readonly [S.String, S.Null]>;
+                readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+            }>;
+            readonly missing: S.$Array<S.Struct<{
+                readonly text: S.String;
+                readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+                readonly requirement: S.optionalKey<S.String>;
+                readonly instance: S.optionalKey<S.String>;
+                readonly evidence: S.optionalKey<S.String>;
+                readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                    readonly requirement: S.String;
+                    readonly instance: S.String;
+                }>>>;
+                readonly fact: S.optionalKey<S.String>;
+                readonly machine: S.optionalKey<S.String>;
+                readonly states: S.optionalKey<S.$Array<S.String>>;
+            }>>;
+            readonly fields: S.$Array<S.Struct<{
+                readonly field: S.String;
+                readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+                readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+            }>>;
+            readonly proposal: S.optionalKey<S.String>;
+        }>>;
+        readonly closed: S.$Array<S.Struct<{
+            readonly id: S.String;
+            readonly instance: S.String;
+            readonly operation: S.String;
+            readonly label: S.String;
+            readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+            readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+            readonly advances: S.$Array<S.String>;
+            readonly assignee: S.Struct<{
+                readonly id: S.Union<readonly [S.String, S.Null]>;
+                readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+            }>;
+            readonly missing: S.$Array<S.Struct<{
+                readonly text: S.String;
+                readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+                readonly requirement: S.optionalKey<S.String>;
+                readonly instance: S.optionalKey<S.String>;
+                readonly evidence: S.optionalKey<S.String>;
+                readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                    readonly requirement: S.String;
+                    readonly instance: S.String;
+                }>>>;
+                readonly fact: S.optionalKey<S.String>;
+                readonly machine: S.optionalKey<S.String>;
+                readonly states: S.optionalKey<S.$Array<S.String>>;
+            }>>;
+            readonly fields: S.$Array<S.Struct<{
+                readonly field: S.String;
+                readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+                readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+            }>>;
+            readonly proposal: S.optionalKey<S.String>;
+        }>>;
+    }>;
+}>;
+export type Json = null | boolean | number | string | readonly Json[] | {
+    readonly [key: string]: Json;
+};
+export declare const responses: {
+    readonly status: S.Struct<{
+        readonly subject: S.String;
+        readonly at: S.String;
+        readonly release: S.String;
+        readonly revision: S.Number;
+        readonly wakeAt: S.Union<readonly [S.String, S.Null]>;
+        readonly wakeReason: S.String;
+        readonly machines: S.$Array<S.Struct<{
+            readonly instance: S.String;
+            readonly machine: S.String;
+            readonly state: S.Union<readonly [S.String, S.Null]>;
+            readonly since: S.Union<readonly [S.String, S.Null]>;
+        }>>;
+        readonly instances: S.$Array<S.Struct<{
+            readonly instance: S.String;
+            readonly component: S.String;
+            readonly digest: S.String;
+            readonly outputs: S.$Record<S.String, S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>>;
+            readonly requirements: S.$Array<S.Struct<{
+                readonly name: S.String;
+                readonly label: S.String;
+                readonly status: S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>;
+                readonly due: S.Union<readonly [S.String, S.Null]>;
+                readonly blocked: S.Union<readonly [S.String, S.Null]>;
+            }>>;
+        }>>;
+    }>;
+    readonly facts: S.$Array<S.Struct<{
+        readonly fact: S.String;
+        readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+        readonly by: S.String;
+        readonly at: S.String;
+        readonly command: S.Union<readonly [S.String, S.Null]>;
+    }>>;
+    readonly work: S.$Array<S.Struct<{
+        readonly id: S.String;
+        readonly instance: S.String;
+        readonly operation: S.String;
+        readonly label: S.String;
+        readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+        readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+        readonly advances: S.$Array<S.String>;
+        readonly assignee: S.Struct<{
+            readonly id: S.Union<readonly [S.String, S.Null]>;
+            readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+        }>;
+        readonly missing: S.$Array<S.Struct<{
+            readonly text: S.String;
+            readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+            readonly requirement: S.optionalKey<S.String>;
+            readonly instance: S.optionalKey<S.String>;
+            readonly evidence: S.optionalKey<S.String>;
+            readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                readonly requirement: S.String;
+                readonly instance: S.String;
+            }>>>;
+            readonly fact: S.optionalKey<S.String>;
+            readonly machine: S.optionalKey<S.String>;
+            readonly states: S.optionalKey<S.$Array<S.String>>;
+        }>>;
+        readonly fields: S.$Array<S.Struct<{
+            readonly field: S.String;
+            readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+            readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+        }>>;
+        readonly proposal: S.optionalKey<S.String>;
+    }>>;
+    readonly operations: S.$Array<S.Struct<{
+        readonly instance: S.String;
+        readonly name: S.String;
+        readonly kind: S.Literals<readonly ["action", "decision"]>;
+        readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held", "complete", "not-applicable", "decision"]>;
+    }>>;
+    readonly explain: S.$Array<S.Codec<Json, Json, never, never>>;
+    readonly subjects: S.$Array<S.String>;
+    readonly assert: S.Struct<{
+        readonly accepted: S.Boolean;
+        readonly codes: S.$Array<S.String>;
+        readonly status: S.Struct<{
+            readonly subject: S.String;
+            readonly at: S.String;
+            readonly release: S.String;
+            readonly revision: S.Number;
+            readonly wakeAt: S.Union<readonly [S.String, S.Null]>;
+            readonly wakeReason: S.String;
+            readonly machines: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly machine: S.String;
+                readonly state: S.Union<readonly [S.String, S.Null]>;
+                readonly since: S.Union<readonly [S.String, S.Null]>;
+            }>>;
+            readonly instances: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly component: S.String;
+                readonly digest: S.String;
+                readonly outputs: S.$Record<S.String, S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>>;
+                readonly requirements: S.$Array<S.Struct<{
+                    readonly name: S.String;
+                    readonly label: S.String;
+                    readonly status: S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>;
+                    readonly due: S.Union<readonly [S.String, S.Null]>;
+                    readonly blocked: S.Union<readonly [S.String, S.Null]>;
+                }>>;
+            }>>;
+        }>;
+        readonly change: S.Struct<{
+            readonly subject: S.String;
+            readonly revision: S.Number;
+            readonly at: S.String;
+            readonly transitions: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly kind: S.Literals<readonly ["requirement", "output"]>;
+                readonly name: S.String;
+                readonly from: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+                readonly to: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+            }>>;
+            readonly opened: S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly instance: S.String;
+                readonly operation: S.String;
+                readonly label: S.String;
+                readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+                readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+                readonly advances: S.$Array<S.String>;
+                readonly assignee: S.Struct<{
+                    readonly id: S.Union<readonly [S.String, S.Null]>;
+                    readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+                }>;
+                readonly missing: S.$Array<S.Struct<{
+                    readonly text: S.String;
+                    readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+                    readonly requirement: S.optionalKey<S.String>;
+                    readonly instance: S.optionalKey<S.String>;
+                    readonly evidence: S.optionalKey<S.String>;
+                    readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                        readonly requirement: S.String;
+                        readonly instance: S.String;
+                    }>>>;
+                    readonly fact: S.optionalKey<S.String>;
+                    readonly machine: S.optionalKey<S.String>;
+                    readonly states: S.optionalKey<S.$Array<S.String>>;
+                }>>;
+                readonly fields: S.$Array<S.Struct<{
+                    readonly field: S.String;
+                    readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+                    readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+                }>>;
+                readonly proposal: S.optionalKey<S.String>;
+            }>>;
+            readonly closed: S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly instance: S.String;
+                readonly operation: S.String;
+                readonly label: S.String;
+                readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+                readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+                readonly advances: S.$Array<S.String>;
+                readonly assignee: S.Struct<{
+                    readonly id: S.Union<readonly [S.String, S.Null]>;
+                    readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+                }>;
+                readonly missing: S.$Array<S.Struct<{
+                    readonly text: S.String;
+                    readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+                    readonly requirement: S.optionalKey<S.String>;
+                    readonly instance: S.optionalKey<S.String>;
+                    readonly evidence: S.optionalKey<S.String>;
+                    readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                        readonly requirement: S.String;
+                        readonly instance: S.String;
+                    }>>>;
+                    readonly fact: S.optionalKey<S.String>;
+                    readonly machine: S.optionalKey<S.String>;
+                    readonly states: S.optionalKey<S.$Array<S.String>>;
+                }>>;
+                readonly fields: S.$Array<S.Struct<{
+                    readonly field: S.String;
+                    readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+                    readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+                }>>;
+                readonly proposal: S.optionalKey<S.String>;
+            }>>;
+        }>;
+    }>;
+    readonly perform: S.Struct<{
+        readonly accepted: S.Boolean;
+        readonly codes: S.$Array<S.String>;
+        readonly status: S.Struct<{
+            readonly subject: S.String;
+            readonly at: S.String;
+            readonly release: S.String;
+            readonly revision: S.Number;
+            readonly wakeAt: S.Union<readonly [S.String, S.Null]>;
+            readonly wakeReason: S.String;
+            readonly machines: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly machine: S.String;
+                readonly state: S.Union<readonly [S.String, S.Null]>;
+                readonly since: S.Union<readonly [S.String, S.Null]>;
+            }>>;
+            readonly instances: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly component: S.String;
+                readonly digest: S.String;
+                readonly outputs: S.$Record<S.String, S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>>;
+                readonly requirements: S.$Array<S.Struct<{
+                    readonly name: S.String;
+                    readonly label: S.String;
+                    readonly status: S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>;
+                    readonly due: S.Union<readonly [S.String, S.Null]>;
+                    readonly blocked: S.Union<readonly [S.String, S.Null]>;
+                }>>;
+            }>>;
+        }>;
+        readonly change: S.Struct<{
+            readonly subject: S.String;
+            readonly revision: S.Number;
+            readonly at: S.String;
+            readonly transitions: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly kind: S.Literals<readonly ["requirement", "output"]>;
+                readonly name: S.String;
+                readonly from: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+                readonly to: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+            }>>;
+            readonly opened: S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly instance: S.String;
+                readonly operation: S.String;
+                readonly label: S.String;
+                readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+                readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+                readonly advances: S.$Array<S.String>;
+                readonly assignee: S.Struct<{
+                    readonly id: S.Union<readonly [S.String, S.Null]>;
+                    readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+                }>;
+                readonly missing: S.$Array<S.Struct<{
+                    readonly text: S.String;
+                    readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+                    readonly requirement: S.optionalKey<S.String>;
+                    readonly instance: S.optionalKey<S.String>;
+                    readonly evidence: S.optionalKey<S.String>;
+                    readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                        readonly requirement: S.String;
+                        readonly instance: S.String;
+                    }>>>;
+                    readonly fact: S.optionalKey<S.String>;
+                    readonly machine: S.optionalKey<S.String>;
+                    readonly states: S.optionalKey<S.$Array<S.String>>;
+                }>>;
+                readonly fields: S.$Array<S.Struct<{
+                    readonly field: S.String;
+                    readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+                    readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+                }>>;
+                readonly proposal: S.optionalKey<S.String>;
+            }>>;
+            readonly closed: S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly instance: S.String;
+                readonly operation: S.String;
+                readonly label: S.String;
+                readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+                readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+                readonly advances: S.$Array<S.String>;
+                readonly assignee: S.Struct<{
+                    readonly id: S.Union<readonly [S.String, S.Null]>;
+                    readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+                }>;
+                readonly missing: S.$Array<S.Struct<{
+                    readonly text: S.String;
+                    readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+                    readonly requirement: S.optionalKey<S.String>;
+                    readonly instance: S.optionalKey<S.String>;
+                    readonly evidence: S.optionalKey<S.String>;
+                    readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                        readonly requirement: S.String;
+                        readonly instance: S.String;
+                    }>>>;
+                    readonly fact: S.optionalKey<S.String>;
+                    readonly machine: S.optionalKey<S.String>;
+                    readonly states: S.optionalKey<S.$Array<S.String>>;
+                }>>;
+                readonly fields: S.$Array<S.Struct<{
+                    readonly field: S.String;
+                    readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+                    readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+                }>>;
+                readonly proposal: S.optionalKey<S.String>;
+            }>>;
+        }>;
+    }>;
+    readonly signal: S.Struct<{
+        readonly accepted: S.Boolean;
+        readonly codes: S.$Array<S.String>;
+        readonly status: S.Struct<{
+            readonly subject: S.String;
+            readonly at: S.String;
+            readonly release: S.String;
+            readonly revision: S.Number;
+            readonly wakeAt: S.Union<readonly [S.String, S.Null]>;
+            readonly wakeReason: S.String;
+            readonly machines: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly machine: S.String;
+                readonly state: S.Union<readonly [S.String, S.Null]>;
+                readonly since: S.Union<readonly [S.String, S.Null]>;
+            }>>;
+            readonly instances: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly component: S.String;
+                readonly digest: S.String;
+                readonly outputs: S.$Record<S.String, S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>>;
+                readonly requirements: S.$Array<S.Struct<{
+                    readonly name: S.String;
+                    readonly label: S.String;
+                    readonly status: S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>;
+                    readonly due: S.Union<readonly [S.String, S.Null]>;
+                    readonly blocked: S.Union<readonly [S.String, S.Null]>;
+                }>>;
+            }>>;
+        }>;
+        readonly change: S.Struct<{
+            readonly subject: S.String;
+            readonly revision: S.Number;
+            readonly at: S.String;
+            readonly transitions: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly kind: S.Literals<readonly ["requirement", "output"]>;
+                readonly name: S.String;
+                readonly from: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+                readonly to: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+            }>>;
+            readonly opened: S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly instance: S.String;
+                readonly operation: S.String;
+                readonly label: S.String;
+                readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+                readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+                readonly advances: S.$Array<S.String>;
+                readonly assignee: S.Struct<{
+                    readonly id: S.Union<readonly [S.String, S.Null]>;
+                    readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+                }>;
+                readonly missing: S.$Array<S.Struct<{
+                    readonly text: S.String;
+                    readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+                    readonly requirement: S.optionalKey<S.String>;
+                    readonly instance: S.optionalKey<S.String>;
+                    readonly evidence: S.optionalKey<S.String>;
+                    readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                        readonly requirement: S.String;
+                        readonly instance: S.String;
+                    }>>>;
+                    readonly fact: S.optionalKey<S.String>;
+                    readonly machine: S.optionalKey<S.String>;
+                    readonly states: S.optionalKey<S.$Array<S.String>>;
+                }>>;
+                readonly fields: S.$Array<S.Struct<{
+                    readonly field: S.String;
+                    readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+                    readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+                }>>;
+                readonly proposal: S.optionalKey<S.String>;
+            }>>;
+            readonly closed: S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly instance: S.String;
+                readonly operation: S.String;
+                readonly label: S.String;
+                readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+                readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+                readonly advances: S.$Array<S.String>;
+                readonly assignee: S.Struct<{
+                    readonly id: S.Union<readonly [S.String, S.Null]>;
+                    readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+                }>;
+                readonly missing: S.$Array<S.Struct<{
+                    readonly text: S.String;
+                    readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+                    readonly requirement: S.optionalKey<S.String>;
+                    readonly instance: S.optionalKey<S.String>;
+                    readonly evidence: S.optionalKey<S.String>;
+                    readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                        readonly requirement: S.String;
+                        readonly instance: S.String;
+                    }>>>;
+                    readonly fact: S.optionalKey<S.String>;
+                    readonly machine: S.optionalKey<S.String>;
+                    readonly states: S.optionalKey<S.$Array<S.String>>;
+                }>>;
+                readonly fields: S.$Array<S.Struct<{
+                    readonly field: S.String;
+                    readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+                    readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+                }>>;
+                readonly proposal: S.optionalKey<S.String>;
+            }>>;
+        }>;
+    }>;
+    readonly propose: S.Struct<{
+        readonly accepted: S.Boolean;
+        readonly codes: S.$Array<S.String>;
+        readonly status: S.Struct<{
+            readonly subject: S.String;
+            readonly at: S.String;
+            readonly release: S.String;
+            readonly revision: S.Number;
+            readonly wakeAt: S.Union<readonly [S.String, S.Null]>;
+            readonly wakeReason: S.String;
+            readonly machines: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly machine: S.String;
+                readonly state: S.Union<readonly [S.String, S.Null]>;
+                readonly since: S.Union<readonly [S.String, S.Null]>;
+            }>>;
+            readonly instances: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly component: S.String;
+                readonly digest: S.String;
+                readonly outputs: S.$Record<S.String, S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>>;
+                readonly requirements: S.$Array<S.Struct<{
+                    readonly name: S.String;
+                    readonly label: S.String;
+                    readonly status: S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>;
+                    readonly due: S.Union<readonly [S.String, S.Null]>;
+                    readonly blocked: S.Union<readonly [S.String, S.Null]>;
+                }>>;
+            }>>;
+        }>;
+        readonly change: S.Struct<{
+            readonly subject: S.String;
+            readonly revision: S.Number;
+            readonly at: S.String;
+            readonly transitions: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly kind: S.Literals<readonly ["requirement", "output"]>;
+                readonly name: S.String;
+                readonly from: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+                readonly to: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+            }>>;
+            readonly opened: S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly instance: S.String;
+                readonly operation: S.String;
+                readonly label: S.String;
+                readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+                readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+                readonly advances: S.$Array<S.String>;
+                readonly assignee: S.Struct<{
+                    readonly id: S.Union<readonly [S.String, S.Null]>;
+                    readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+                }>;
+                readonly missing: S.$Array<S.Struct<{
+                    readonly text: S.String;
+                    readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+                    readonly requirement: S.optionalKey<S.String>;
+                    readonly instance: S.optionalKey<S.String>;
+                    readonly evidence: S.optionalKey<S.String>;
+                    readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                        readonly requirement: S.String;
+                        readonly instance: S.String;
+                    }>>>;
+                    readonly fact: S.optionalKey<S.String>;
+                    readonly machine: S.optionalKey<S.String>;
+                    readonly states: S.optionalKey<S.$Array<S.String>>;
+                }>>;
+                readonly fields: S.$Array<S.Struct<{
+                    readonly field: S.String;
+                    readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+                    readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+                }>>;
+                readonly proposal: S.optionalKey<S.String>;
+            }>>;
+            readonly closed: S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly instance: S.String;
+                readonly operation: S.String;
+                readonly label: S.String;
+                readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+                readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+                readonly advances: S.$Array<S.String>;
+                readonly assignee: S.Struct<{
+                    readonly id: S.Union<readonly [S.String, S.Null]>;
+                    readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+                }>;
+                readonly missing: S.$Array<S.Struct<{
+                    readonly text: S.String;
+                    readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+                    readonly requirement: S.optionalKey<S.String>;
+                    readonly instance: S.optionalKey<S.String>;
+                    readonly evidence: S.optionalKey<S.String>;
+                    readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                        readonly requirement: S.String;
+                        readonly instance: S.String;
+                    }>>>;
+                    readonly fact: S.optionalKey<S.String>;
+                    readonly machine: S.optionalKey<S.String>;
+                    readonly states: S.optionalKey<S.$Array<S.String>>;
+                }>>;
+                readonly fields: S.$Array<S.Struct<{
+                    readonly field: S.String;
+                    readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+                    readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+                }>>;
+                readonly proposal: S.optionalKey<S.String>;
+            }>>;
+        }>;
+    }>;
+    readonly proposals: S.$Array<S.Struct<{
+        readonly id: S.String;
+        readonly type: S.String;
+        readonly subject: S.String;
+        readonly by: S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literals<readonly ["human", "agent", "service", "connector"]>;
+            readonly groups: S.optionalKey<S.$Array<S.String>>;
+        }>;
+        readonly at: S.String;
+        readonly rationale: S.String;
+        readonly draft: S.Union<readonly [S.Struct<{
+            readonly kind: S.Literal<"assert">;
+            readonly values: S.$Record<S.String, S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>>;
+            readonly factKind: S.optionalKey<S.String>;
+        }>, S.Struct<{
+            readonly kind: S.Literal<"evidence">;
+            readonly operation: S.String;
+            readonly values: S.$Record<S.String, S.Union<readonly [S.String, S.Number, S.Boolean]>>;
+            readonly instance: S.optionalKey<S.String>;
+        }>]>;
+        readonly state: S.Literals<readonly ["pending", "accepted", "rejected"]>;
+        readonly resolution: S.optionalKey<S.Struct<{
+            readonly by: S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literals<readonly ["human", "agent", "service", "connector"]>;
+                readonly groups: S.optionalKey<S.$Array<S.String>>;
+            }>;
+            readonly at: S.String;
+            readonly command: S.String;
+            readonly reason: S.optionalKey<S.String>;
+        }>>;
+    }>>;
+    readonly "accept-proposal": S.Struct<{
+        readonly accepted: S.Boolean;
+        readonly codes: S.$Array<S.String>;
+        readonly status: S.Struct<{
+            readonly subject: S.String;
+            readonly at: S.String;
+            readonly release: S.String;
+            readonly revision: S.Number;
+            readonly wakeAt: S.Union<readonly [S.String, S.Null]>;
+            readonly wakeReason: S.String;
+            readonly machines: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly machine: S.String;
+                readonly state: S.Union<readonly [S.String, S.Null]>;
+                readonly since: S.Union<readonly [S.String, S.Null]>;
+            }>>;
+            readonly instances: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly component: S.String;
+                readonly digest: S.String;
+                readonly outputs: S.$Record<S.String, S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>>;
+                readonly requirements: S.$Array<S.Struct<{
+                    readonly name: S.String;
+                    readonly label: S.String;
+                    readonly status: S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>;
+                    readonly due: S.Union<readonly [S.String, S.Null]>;
+                    readonly blocked: S.Union<readonly [S.String, S.Null]>;
+                }>>;
+            }>>;
+        }>;
+        readonly change: S.Struct<{
+            readonly subject: S.String;
+            readonly revision: S.Number;
+            readonly at: S.String;
+            readonly transitions: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly kind: S.Literals<readonly ["requirement", "output"]>;
+                readonly name: S.String;
+                readonly from: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+                readonly to: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+            }>>;
+            readonly opened: S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly instance: S.String;
+                readonly operation: S.String;
+                readonly label: S.String;
+                readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+                readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+                readonly advances: S.$Array<S.String>;
+                readonly assignee: S.Struct<{
+                    readonly id: S.Union<readonly [S.String, S.Null]>;
+                    readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+                }>;
+                readonly missing: S.$Array<S.Struct<{
+                    readonly text: S.String;
+                    readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+                    readonly requirement: S.optionalKey<S.String>;
+                    readonly instance: S.optionalKey<S.String>;
+                    readonly evidence: S.optionalKey<S.String>;
+                    readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                        readonly requirement: S.String;
+                        readonly instance: S.String;
+                    }>>>;
+                    readonly fact: S.optionalKey<S.String>;
+                    readonly machine: S.optionalKey<S.String>;
+                    readonly states: S.optionalKey<S.$Array<S.String>>;
+                }>>;
+                readonly fields: S.$Array<S.Struct<{
+                    readonly field: S.String;
+                    readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+                    readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+                }>>;
+                readonly proposal: S.optionalKey<S.String>;
+            }>>;
+            readonly closed: S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly instance: S.String;
+                readonly operation: S.String;
+                readonly label: S.String;
+                readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+                readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+                readonly advances: S.$Array<S.String>;
+                readonly assignee: S.Struct<{
+                    readonly id: S.Union<readonly [S.String, S.Null]>;
+                    readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+                }>;
+                readonly missing: S.$Array<S.Struct<{
+                    readonly text: S.String;
+                    readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+                    readonly requirement: S.optionalKey<S.String>;
+                    readonly instance: S.optionalKey<S.String>;
+                    readonly evidence: S.optionalKey<S.String>;
+                    readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                        readonly requirement: S.String;
+                        readonly instance: S.String;
+                    }>>>;
+                    readonly fact: S.optionalKey<S.String>;
+                    readonly machine: S.optionalKey<S.String>;
+                    readonly states: S.optionalKey<S.$Array<S.String>>;
+                }>>;
+                readonly fields: S.$Array<S.Struct<{
+                    readonly field: S.String;
+                    readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+                    readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+                }>>;
+                readonly proposal: S.optionalKey<S.String>;
+            }>>;
+        }>;
+    }>;
+    readonly "reject-proposal": S.Struct<{
+        readonly accepted: S.Boolean;
+        readonly codes: S.$Array<S.String>;
+        readonly status: S.Struct<{
+            readonly subject: S.String;
+            readonly at: S.String;
+            readonly release: S.String;
+            readonly revision: S.Number;
+            readonly wakeAt: S.Union<readonly [S.String, S.Null]>;
+            readonly wakeReason: S.String;
+            readonly machines: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly machine: S.String;
+                readonly state: S.Union<readonly [S.String, S.Null]>;
+                readonly since: S.Union<readonly [S.String, S.Null]>;
+            }>>;
+            readonly instances: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly component: S.String;
+                readonly digest: S.String;
+                readonly outputs: S.$Record<S.String, S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>>;
+                readonly requirements: S.$Array<S.Struct<{
+                    readonly name: S.String;
+                    readonly label: S.String;
+                    readonly status: S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>;
+                    readonly due: S.Union<readonly [S.String, S.Null]>;
+                    readonly blocked: S.Union<readonly [S.String, S.Null]>;
+                }>>;
+            }>>;
+        }>;
+        readonly change: S.Struct<{
+            readonly subject: S.String;
+            readonly revision: S.Number;
+            readonly at: S.String;
+            readonly transitions: S.$Array<S.Struct<{
+                readonly instance: S.String;
+                readonly kind: S.Literals<readonly ["requirement", "output"]>;
+                readonly name: S.String;
+                readonly from: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+                readonly to: S.Union<readonly [S.Literals<readonly ["Unknown", "Open", "Satisfied", "NotApplicable", "Overdue", "Waived"]>, S.Null]>;
+            }>>;
+            readonly opened: S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly instance: S.String;
+                readonly operation: S.String;
+                readonly label: S.String;
+                readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+                readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+                readonly advances: S.$Array<S.String>;
+                readonly assignee: S.Struct<{
+                    readonly id: S.Union<readonly [S.String, S.Null]>;
+                    readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+                }>;
+                readonly missing: S.$Array<S.Struct<{
+                    readonly text: S.String;
+                    readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+                    readonly requirement: S.optionalKey<S.String>;
+                    readonly instance: S.optionalKey<S.String>;
+                    readonly evidence: S.optionalKey<S.String>;
+                    readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                        readonly requirement: S.String;
+                        readonly instance: S.String;
+                    }>>>;
+                    readonly fact: S.optionalKey<S.String>;
+                    readonly machine: S.optionalKey<S.String>;
+                    readonly states: S.optionalKey<S.$Array<S.String>>;
+                }>>;
+                readonly fields: S.$Array<S.Struct<{
+                    readonly field: S.String;
+                    readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+                    readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+                }>>;
+                readonly proposal: S.optionalKey<S.String>;
+            }>>;
+            readonly closed: S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly instance: S.String;
+                readonly operation: S.String;
+                readonly label: S.String;
+                readonly kind: S.Literals<readonly ["interaction", "connector", "decision", "proposal"]>;
+                readonly state: S.Literals<readonly ["eligible", "waiting", "dispatched", "held"]>;
+                readonly advances: S.$Array<S.String>;
+                readonly assignee: S.Struct<{
+                    readonly id: S.Union<readonly [S.String, S.Null]>;
+                    readonly kind: S.Literals<readonly ["entity", "group", "connector"]>;
+                }>;
+                readonly missing: S.$Array<S.Struct<{
+                    readonly text: S.String;
+                    readonly kind: S.Literals<readonly ["requirement", "evidence", "fact", "machine", "other"]>;
+                    readonly requirement: S.optionalKey<S.String>;
+                    readonly instance: S.optionalKey<S.String>;
+                    readonly evidence: S.optionalKey<S.String>;
+                    readonly producedBy: S.optionalKey<S.$Array<S.Struct<{
+                        readonly requirement: S.String;
+                        readonly instance: S.String;
+                    }>>>;
+                    readonly fact: S.optionalKey<S.String>;
+                    readonly machine: S.optionalKey<S.String>;
+                    readonly states: S.optionalKey<S.$Array<S.String>>;
+                }>>;
+                readonly fields: S.$Array<S.Struct<{
+                    readonly field: S.String;
+                    readonly mode: S.Literals<readonly ["ask", "confirm", "read-only"]>;
+                    readonly value: S.Union<readonly [S.Union<readonly [S.String, S.Number, S.Boolean]>, S.Null]>;
+                }>>;
+                readonly proposal: S.optionalKey<S.String>;
+            }>>;
+        }>;
+    }>;
+    readonly changes: S.Struct<{
+        readonly revision: S.Number;
+        readonly nextWake: S.Union<readonly [S.String, S.Null]>;
+    }>;
+};
+export type Response<V extends Verb> = (typeof responses)[V]["Type"];
+export type Result<V extends Verb> = {
+    readonly ok: true;
+    readonly value: Response<V>;
+} | {
+    readonly ok: false;
+    readonly error: ProtocolError;
+};
+export declare const requestJsonSchema: (verb: Verb) => import("effect/JsonSchema").JsonSchema;
+export declare const responseJsonSchema: (verb: Verb) => import("effect/JsonSchema").Document<"draft-2020-12">;
+export declare const decodeRequest: <V extends Verb>(verb: V, value: unknown) => Request<V>;
+export declare const decodeActor: (value: unknown) => Actor;
+export declare const decodeResponse: <V extends Verb>(verb: V, value: unknown) => Response<V>;
+export declare const resultJsonSchema: (verb: Verb) => import("effect/JsonSchema").Document<"draft-2020-12">;