@appsolutely-io/waypoint 0.0.0-stage → 0.1.1-next.0

package/etc/hooks.api.md

@@ -0,0 +1,2385 @@
+## API Report File for "@appsolutely-io/waypoint"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+// @public (undocumented)
+export interface ActionEntry {
+    // (undocumented)
+    available: boolean;
+    // (undocumented)
+    busy?: boolean;
+    countedLabelKey?: MessageKey;
+    // (undocumented)
+    id: ActionId;
+    labelKey: MessageKey;
+    labelValues?: Record<string, number>;
+    // (undocumented)
+    reasonKey?: MessageKey;
+    // (undocumented)
+    reasonValues?: Record<string, number>;
+    // (undocumented)
+    schedule?: boolean;
+}
+
+// @public (undocumented)
+export type ActionId = "confirm" | "stop" | "decline" | "leave" | "keep" | "status" | "undoSelected" | "continue";
+
+// @public (undocumented)
+export function asProblem(error: unknown, id: string): Problem;
+
+// @public (undocumented)
+export interface AttachmentPort {
+    // (undocumented)
+    remove(id: string): MaybePromise<void>;
+    // (undocumented)
+    upload(data: Uint8Array, context: {
+        conversationId: string;
+        fileName: string;
+        contentType: string;
+    }): MaybePromise<{
+        id: string;
+    }>;
+}
+
+// @public (undocumented)
+export type Block = BlockMarkdown | BlockCard | BlockDetails | BlockList | BlockTable | BlockForm | BlockChoice | BlockButtons | BlockDiff | BlockPlan | BlockRouteLink | BlockNotice | BlockFormFill | ExtensionBlock;
+
+// @public
+export type BlockAnswer = Pick<Reply, "kind"> & Record<string, unknown>;
+
+// @public (undocumented)
+export interface BlockButtons {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        actions: {
+            id: string;
+            label: string;
+        }[];
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'buttons';
+}
+
+// @public (undocumented)
+export interface BlockCard {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        title: string;
+        blocks: Block[];
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'card';
+}
+
+// @public (undocumented)
+export type BlockCatalogue = Readonly<Record<BlockMessageKey, string>>;
+
+// @public (undocumented)
+export interface BlockChoice {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        mode: 'single' | 'multi' | 'text';
+        options: string[];
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'choice';
+}
+
+// @public
+export interface BlockDetails {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    body: {
+        summary: string;
+        blocks: Block[];
+    };
+    fallback: string;
+    id: string;
+    type: 'details';
+}
+
+// @public (undocumented)
+export interface BlockDiff {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        before: unknown;
+        after: unknown;
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'diff';
+}
+
+// @public (undocumented)
+export interface BlockForm {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        fields: {
+            name: string;
+            label: string;
+            required?: boolean;
+            value?: string;
+        }[];
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'form';
+}
+
+// @public (undocumented)
+export interface BlockFormFill {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        requestId: string;
+        values: {
+            [k: string]: FormFillValue;
+        };
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'form.fill';
+}
+
+// @public (undocumented)
+export interface BlockList {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        items: string[];
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'list';
+}
+
+// @public (undocumented)
+export interface BlockMarkdown {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        text: string;
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'markdown';
+}
+
+// @public (undocumented)
+export type BlockMessageKey = "chat.block.required" | "chat.block.requiredMissing" | "chat.block.answerMissing" | "chat.block.empty" | "chat.block.tierLow" | "chat.block.tierSensitive" | "chat.block.undoCompareAndSet" | "chat.block.undoArchiveCreated" | "chat.block.undoInverse" | "chat.block.status" | "chat.block.outcomeDone" | "chat.block.outcomeFailed" | "chat.block.retryable" | "chat.block.notRetryable" | "chat.block.state.proposed" | "chat.block.state.awaiting-confirmation" | "chat.block.state.running" | "chat.block.state.undoing" | "chat.block.state.completed" | "chat.block.state.submitted" | "chat.block.state.undone" | "chat.block.state.needs-attention" | "chat.block.state.cancelled" | "chat.block.run" | "chat.block.runMissing" | "chat.block.favourite" | "chat.block.flowLoading" | "chat.block.flowsLoading" | "chat.block.flowsEmpty" | "chat.block.answered" | "chat.block.answeredWith";
+
+// @public (undocumented)
+export interface BlockNotice {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        text: string;
+        tone?: 'info' | 'warning' | 'error';
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'notice';
+}
+
+// @public (undocumented)
+export interface BlockPlan {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        planId: string;
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'plan';
+}
+
+// @public (undocumented)
+export interface BlockReply {
+    answered: ReadonlySet<string>;
+    isAnswered(block: Pick<Block, "id" | "answered">, messageId?: string): boolean;
+    reply(block: Pick<Block, "id">, answer: BlockAnswer, messageId?: string): Promise<ReplyOutcome | void>;
+}
+
+// @public (undocumented)
+export interface BlockRouteLink {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        label: string;
+        route: string;
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'route-link';
+}
+
+// @public (undocumented)
+export interface BlockTable {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: {
+        columns: string[];
+        rows: unknown[][];
+    };
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'table';
+}
+
+// @public (undocumented)
+export type BuiltinFlowTab = "favourites" | "most-used" | "recent" | "presets";
+
+// @public (undocumented)
+export interface CanonicalRequest {
+    // (undocumented)
+    body: string;
+    // (undocumented)
+    digest: string;
+    // (undocumented)
+    headers: {
+        [k: string]: string;
+    };
+    // (undocumented)
+    method: 'POST' | 'PUT' | 'PATCH' | 'GET';
+    // (undocumented)
+    path: string;
+}
+
+// @public (undocumented)
+export function canTransition(from: PlanState, to: PlanState): boolean;
+
+// @public (undocumented)
+export const CAPABILITIES: readonly ["plans", "flows", "widgets", "step-up", "scheduled", "form-fill", "plan-recovery", "plan-leave", "plan-keep", "reply-stop"];
+
+// @public (undocumented)
+export type Capability = (typeof CAPABILITIES)[number];
+
+// @public
+export type CardAnswer = {
+    kind: 'action';
+    clientReplyId: string;
+    blockId: string;
+    actionId: string;
+} | {
+    kind: 'form';
+    clientReplyId: string;
+    blockId: string;
+    values?: {};
+};
+
+// @public
+export function cardReplyId(conversationId: string, messageId: string, blockId: string, answer: BlockAnswer): string;
+
+// @public (undocumented)
+export interface ClientConfig {
+    // (undocumented)
+    accountId: string;
+    // (undocumented)
+    beforeSend?: (reply: Reply) => MaybePromise<Reply | false | void>;
+    // (undocumented)
+    contributions?: readonly ComposerContribution[];
+    // (undocumented)
+    conversationId: string;
+    // (undocumented)
+    feedback?: FeedbackPort;
+    // (undocumented)
+    flowOperations?: readonly string[];
+    // (undocumented)
+    flowSource?: FlowSource;
+    // (undocumented)
+    formSession?: FormSession;
+    // (undocumented)
+    plans?: RunnerPorts & {
+        resume?(id: string): Promise<PlanRecord>;
+        retryUndo?(id: string): Promise<PlanRecord>;
+    };
+    // (undocumented)
+    platform: PlatformPorts;
+    // (undocumented)
+    reads?: ReadPorts;
+    // (undocumented)
+    storage?: StoragePort;
+    // (undocumented)
+    tabs?: readonly FlowTab[];
+    // (undocumented)
+    transport: TransportPort;
+    // (undocumented)
+    versions?: MessageVersionPort;
+}
+
+// @public (undocumented)
+export interface ClientSnapshot {
+    // (undocumented)
+    announcement: number;
+    // (undocumented)
+    capabilities: readonly Capability[];
+    confirmationRefusal?: {
+        token: string;
+        problemId: string;
+    };
+    // (undocumented)
+    conversation: Conversation | null;
+    // (undocumented)
+    conversationId: string;
+    // (undocumented)
+    conversationUnavailable: boolean;
+    // (undocumented)
+    draft: string;
+    // (undocumented)
+    flows: Partial<Record<string, FlowSummary[]>>;
+    // (undocumented)
+    flowTab: string;
+    // (undocumented)
+    flowTabs: readonly FlowTab[];
+    // (undocumented)
+    hints: readonly string[];
+    // (undocumented)
+    intentAlert: IntentAlert | null;
+    intentNotice: IntentNotice | null;
+    intentOverlays: Readonly<Record<string, IntentOverlay>>;
+    // (undocumented)
+    observerFailures: number;
+    // (undocumented)
+    pending: readonly PendingSend[];
+    // (undocumented)
+    plan: PlanRecord | null;
+    planReadOnly?: boolean;
+    // (undocumented)
+    problem: Problem | null;
+    // (undocumented)
+    protocol: string | null;
+    // (undocumented)
+    replyState: ReplyState;
+    restored: readonly RestoredMessage[];
+    // (undocumented)
+    sending: boolean;
+    // (undocumented)
+    status: string;
+    streamUnavailable: boolean;
+    toolSteps: readonly ToolStep[];
+    withdrawing: readonly string[];
+}
+
+// @public (undocumented)
+export interface ComposerContribution {
+    // (undocumented)
+    evaluate(context: {
+        draft: string;
+        conversationId: string;
+    }): MaybePromise<{
+        hold?: string;
+        hint?: string;
+        payload?: unknown;
+    }>;
+    // (undocumented)
+    id: string;
+}
+
+// @public (undocumented)
+export type ConfirmationCatalogue = Readonly<Record<ConfirmationMessageKey, string>>;
+
+// @public (undocumented)
+export interface ConfirmationItem {
+    // (undocumented)
+    after?: string;
+    // (undocumented)
+    before?: string;
+    // (undocumented)
+    label: string;
+    // (undocumented)
+    note?: string;
+}
+
+// @public (undocumented)
+export type ConfirmationMessageKey = "chat.confirmation.heading" | "chat.confirmation.apply" | "chat.confirmation.schedule" | "chat.confirmation.applyCount" | "chat.confirmation.scheduleCount" | "chat.confirmation.unavailable" | "chat.confirmation.expired" | "chat.confirmation.used" | "chat.confirmation.changed" | "chat.confirmation.mismatch" | "chat.confirmation.irreversible" | "chat.confirmation.before" | "chat.confirmation.after" | "chat.confirmation.refresh" | "chat.confirmation.verifications" | "chat.confirmation.expires" | "chat.confirmation.showAll";
+
+// @public
+export function confirmationOf(plan: PlanRecord | null | undefined, conversationId: string | undefined): ConfirmationRecord | undefined;
+
+// @public
+export interface ConfirmationRecord {
+    // (undocumented)
+    actionLabel?: string;
+    // (undocumented)
+    conversationId: string;
+    // (undocumented)
+    expiresAt: string;
+    // (undocumented)
+    heading: string;
+    // (undocumented)
+    irreversible: boolean;
+    items: ConfirmationItem[];
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    revision: number;
+    // (undocumented)
+    schedule?: ConfirmationSchedule;
+    // (undocumented)
+    token: string;
+    // (undocumented)
+    undo: string;
+    // (undocumented)
+    verificationCount: number;
+}
+
+// @public (undocumented)
+export interface ConfirmationSchedule {
+    // (undocumented)
+    end: string | null;
+    // (undocumented)
+    endText: string;
+    // (undocumented)
+    start: string | null;
+    // (undocumented)
+    startText: string;
+}
+
+// @public (undocumented)
+export type Conversation = {
+    [k: string]: unknown;
+} & {
+    protocol: string;
+    id: string;
+    title: string;
+    messages: Message[];
+    replyOverdueAt?: number | null;
+    replyStatus?: 'expected' | 'unavailable' | 'failed' | 'complete';
+    mode?: 'form-fill';
+    subject?: FormSubject;
+    parentConversationId?: string;
+    field?: string;
+};
+
+// @public (undocumented)
+export class ConversationReadError extends Error {
+    constructor(conversationId: string, status: number, problem?: unknown);
+    // (undocumented)
+    readonly conversationId: string;
+    readonly problem?: Problem;
+    // (undocumented)
+    readonly status: number;
+}
+
+// @public (undocumented)
+export type ConversationReadResult = {
+    kind: "loaded";
+    conversationId: string;
+    conversation: Conversation;
+} | {
+    kind: "missing";
+    conversationId: string;
+    status: 404 | 410;
+} | {
+    kind: "unavailable" | "superseded";
+    conversationId: string;
+};
+
+// @public (undocumented)
+export interface ConversationSource {
+    // (undocumented)
+    create(input: CreateConversation): MaybePromise<Conversation>;
+    // (undocumented)
+    list(subjectKey?: string): MaybePromise<ConversationSummary[]>;
+}
+
+// @public (undocumented)
+export interface ConversationSummary {
+    // (undocumented)
+    field?: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    mode?: "form-fill";
+    // (undocumented)
+    parentConversationId?: string;
+    // (undocumented)
+    subject?: FormSubject;
+    // (undocumented)
+    title: string;
+}
+
+// @public (undocumented)
+export type CreateConversation = {
+    [k: string]: unknown;
+} & {
+    protocol: string;
+    title: string;
+    mode?: 'form-fill';
+    subject?: FormSubject;
+    parentConversationId?: string;
+    field?: string;
+    clientCreationId?: string;
+};
+
+// @public (undocumented)
+export function createMemoryStorage(asynchronous?: boolean): StoragePort;
+
+// @public (undocumented)
+export function createPlanRunner(ports: RunnerPorts): PlanRunner;
+
+// @public (undocumented)
+export function createWaypointClient(config: ClientConfig): WaypointClient;
+
+// @public (undocumented)
+export interface DecisionVersions {
+    // (undocumented)
+    decisionResolution: number;
+    // (undocumented)
+    evidence: number;
+    // (undocumented)
+    winner: number;
+}
+
+// @public (undocumented)
+export const DEFAULT_FLOW_TABS: readonly BuiltinFlowTab[];
+
+// @public (undocumented)
+export const english: {
+    readonly "form.valid": "Valid";
+    readonly "form.invalid": "Invalid";
+    readonly "form.title": "Fill this form";
+    readonly "form.closeHint": "Closing discards this fill; the reply stays in the conversation.";
+    readonly "form.generate": "Generate draft";
+    readonly "form.references": "Reference links";
+    readonly "form.attachment": "Private attachment";
+    readonly "form.regenerate": "Regenerate {field}";
+    readonly "form.replace": "Replace your edit?";
+    readonly "form.marker": "Form";
+    readonly "form.filter": "Filter by topic";
+    readonly "form.all": "All topics";
+    readonly "form.threads": "Sub-threads";
+    readonly "form.return": "Back to form or record";
+    readonly "form.unlinked": "Saved, not linked";
+    readonly "form.toolsLoading": "Draft tools are still loading.";
+    readonly "form.toolsFailed": "Draft tools couldn't load. Retry first.";
+    readonly "form.fixFirst": "Fix the highlighted fields first.";
+    readonly "form.number": "Enter a number.";
+    readonly "form.editInForm": "Edit this value in the form.";
+    readonly "form.imagesNow": "Images can't be attached right now.";
+    readonly "form.imagesHere": "Images can't be attached here.";
+    readonly "chat.title": "Conversation";
+    readonly "chat.empty": "Start a conversation";
+    readonly "chat.message": "Message";
+    readonly "chat.send": "Send";
+    readonly "chat.sending": "Sending";
+    readonly "chat.pendingSending": "Sending…";
+    readonly "chat.pendingFailed": "Not sent";
+    readonly "chat.planUnavailable": "The plan's steps could not be loaded.";
+    readonly "chat.arrival": "New reply";
+    readonly "chat.arrivalExcerpt": "New reply: {excerpt}";
+    readonly "chat.arrivalFailed": "A reply could not be completed.";
+    readonly "chat.arrivalMany": "{count} new replies. Latest: {excerpt}";
+    readonly "chat.arrivalManyPlain": "{count} new replies";
+    readonly "chat.arrivalManyFailed": "{count} new replies; {failed} could not be completed.";
+    readonly "chat.arrivalAllFailed": "{count} replies could not be completed.";
+    readonly "chat.transcript": "Messages";
+    readonly "chat.outlineItem": "{role}, message {position}: {excerpt}";
+    readonly "chat.outlineItemPlain": "{role}, message {position}";
+    readonly "chat.roleUser": "You";
+    readonly "chat.roleAssistant": "Assistant";
+    readonly "chat.messageLoading": "Loading message…";
+    readonly "chat.messageUnavailable": "This message cannot be shown right now.";
+    readonly "chat.changesTo": "changes to";
+    readonly "chat.stepName": "Change {index}";
+    readonly "chat.stepNamed": "{name} {index}";
+    readonly "chat.fieldName": "Value {index}";
+    readonly "chat.scrollRegion": "Scrollable content";
+    readonly "chat.conversationReadFailed": "This conversation could not be loaded.";
+    readonly "chat.conversationsFailed": "Your conversations could not be loaded.";
+    readonly "chat.messagesUnavailable": "Some messages cannot be shown right now.";
+    readonly unsupportedContent: "Some content cannot be shown here. Contact the site administrator.";
+    readonly "chat.failure": "The request could not be completed.";
+    readonly "chat.update": "This chat needs an update.";
+    readonly "chat.conversationUnavailable": "This conversation is unavailable. Reload to continue; this does not stop a server turn.";
+    readonly "chat.reload": "Reload conversation";
+    readonly "chat.retry": "Retry";
+    readonly "chat.withdraw": "Withdraw";
+    readonly "chat.restored": "Withdrawn messages";
+    readonly "chat.restoredEdit": "Edit";
+    readonly "chat.restoredDiscard": "Discard";
+    readonly "chat.dismiss": "Dismiss";
+    readonly "chat.latest": "Back to latest";
+    readonly "chat.latestNew": "{count, plural, one {Back to latest, # new reply} other {Back to latest, # new replies}}";
+    readonly "chat.outline": "Message outline";
+    readonly "chat.rail": "Conversations";
+    readonly "chat.close": "Close";
+    readonly "chat.quota": "Usage";
+    readonly "chat.actions": "Actions";
+    readonly "chat.panels": "Extra panels";
+    readonly "chat.submit": "Submit";
+    readonly "chat.confirm": "Confirm";
+    readonly "chat.cancel": "Cancel";
+    readonly "chat.stop": "Stop";
+    readonly "chat.planChanged": "The plan changed; confirm again.";
+    readonly "chat.stopped": "The plan was stopped. Start a new plan to continue.";
+    readonly "chat.scheduleUnavailable": "Scheduling is unavailable in this chat.";
+    readonly "chat.start": "Start time";
+    readonly "chat.end": "End time";
+    readonly "chat.view": "View change";
+    readonly "chat.irreversible": "Cannot be undone";
+    readonly "chat.stepUp": "{count, plural, one {# verification prompt} other {# verification prompts}}";
+    readonly "chat.stepUpLabel": "Verification code";
+    readonly "chat.plan": "Plan";
+    readonly "chat.favourite": "Favourite";
+    readonly "chat.run": "Run";
+    readonly "chat.flows": "Saved requests";
+    readonly "flow.favourites": "Favourites";
+    readonly "flow.most-used": "Most used";
+    readonly "flow.recent": "Recent";
+    readonly "flow.presets": "Presets";
+    readonly "reply.writing": "Writing";
+    readonly "reply.stopped": "Stopped";
+    readonly "chat.sources": "Sources ({count})";
+    readonly "chat.source": "Source {index}: {title}";
+    readonly "reply.unavailable": "Reply unavailable";
+    readonly "reply.failed": "Reply failed";
+    readonly "reply.overdue": "Reply overdue";
+    readonly "chat.loading": "Loading";
+    readonly "chat.before": "Before";
+    readonly "chat.after": "After";
+    readonly "chat.undo": "Undo";
+    readonly "chat.verify": "Verification required";
+    readonly "chat.startupLoading": "Loading this conversation…";
+};
+
+// @public (undocumented)
+export interface ExecutionAcceptance {
+    // (undocumented)
+    executionId: string;
+    // (undocumented)
+    fence: number;
+    // (undocumented)
+    planId: string;
+}
+
+// @public (undocumented)
+export interface ExtensionBlock {
+    // (undocumented)
+    answer?: CardAnswer;
+    answered?: boolean;
+    // (undocumented)
+    body: unknown;
+    // (undocumented)
+    fallback: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: string;
+}
+
+// @public
+export interface FeedbackInput extends MessageVersionInput {
+    rating: "positive" | "negative";
+}
+
+// @public
+export interface FeedbackPort {
+    send(input: FeedbackInput): MaybePromise<void>;
+}
+
+// @public (undocumented)
+export interface FinalHistory {
+    contradictedAfterSeal?: string[];
+    // (undocumented)
+    keptFact: KeptFact;
+    // (undocumented)
+    relation?: 'keptElsewhere' | 'leaveCompletedByKeep' | 'leaveCoveredByKeep';
+    // (undocumented)
+    requestedTargetApplied?: boolean;
+    // (undocumented)
+    winner: IntentWinner;
+}
+
+// @public (undocumented)
+export type Flow = {
+    [k: string]: unknown;
+} & {
+    format: '1.0';
+    id: string;
+    title: string;
+    kind: 'structured' | 'prompt';
+    parameters: FlowParameter[];
+    steps?: {
+        operation: string;
+        arguments: {};
+    }[];
+    tags: string[];
+    body: string;
+};
+
+// @public (undocumented)
+export interface FlowParameter {
+    // (undocumented)
+    default?: unknown;
+    // (undocumented)
+    label: string;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    required: boolean;
+    // (undocumented)
+    type: 'string' | 'number' | 'boolean';
+}
+
+// @public (undocumented)
+export interface FlowSource {
+    // (undocumented)
+    list(tab: FlowTab): MaybePromise<FlowSummary[]>;
+    // (undocumented)
+    load?(id: string): MaybePromise<Flow>;
+    // (undocumented)
+    run(id: string, values: Record<string, unknown>, document?: Flow): MaybePromise<{
+        conversationId: string;
+        plan?: PlanRecord;
+    }>;
+    // (undocumented)
+    setFavourite(id: string, favourite: boolean): MaybePromise<void>;
+}
+
+// @public (undocumented)
+export interface FlowSummary {
+    // (undocumented)
+    favourite?: boolean;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    lastRunAt?: number;
+    // (undocumented)
+    runCount?: number;
+    // (undocumented)
+    title: string;
+}
+
+// @public (undocumented)
+export type FlowTab = BuiltinFlowTab | {
+    id: string;
+    labelKey: string;
+};
+
+// @public (undocumented)
+export function flowTabId(tab: FlowTab): string;
+
+// @public
+export const FORM_SESSION_UNAVAILABLE: {
+    readonly code: "retryable";
+    readonly id: "form-session-load";
+};
+
+// @public (undocumented)
+export type FormatMessage = (key: MessageKey, values?: MessageValues) => string;
+
+// @public (undocumented)
+export type FormCatalogue = Readonly<Record<FormMessageKey, string>>;
+
+// @public (undocumented)
+export interface FormDraft {
+    // (undocumented)
+    edited: boolean;
+    // (undocumented)
+    label: string;
+    localInvalid?: true;
+    // (undocumented)
+    localText?: string;
+    // (undocumented)
+    replacement?: {
+        value: unknown;
+        validation: FormValidation;
+        revision: number;
+        fill?: string;
+    };
+    // (undocumented)
+    revision: number;
+    // (undocumented)
+    validation?: FormValidation;
+    // (undocumented)
+    value: unknown;
+}
+
+// @public (undocumented)
+export interface FormField {
+    // (undocumented)
+    label: string;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    tier: "low" | "sensitive" | "human-only";
+    // (undocumented)
+    value: unknown;
+}
+
+// @public (undocumented)
+export interface FormFillField {
+    // (undocumented)
+    label: string;
+    // (undocumented)
+    name: string;
+    // (undocumented)
+    tier: 'low';
+    // (undocumented)
+    value: unknown;
+}
+
+// @public (undocumented)
+export interface FormFillRequest {
+    // (undocumented)
+    attachments: string[];
+    // (undocumented)
+    field?: string;
+    // (undocumented)
+    fields: [FormFillField, ...FormFillField[]];
+    // (undocumented)
+    references: string[];
+    // (undocumented)
+    requestId: string;
+    // (undocumented)
+    text: string;
+}
+
+// @public (undocumented)
+export interface FormFillValue {
+    // (undocumented)
+    label?: string;
+    // (undocumented)
+    validation: FormValidation;
+    // (undocumented)
+    value: unknown;
+}
+
+// @public (undocumented)
+export interface FormMaterial {
+    // (undocumented)
+    attachments?: string[];
+    // (undocumented)
+    field?: string;
+    // (undocumented)
+    references?: string[];
+    // (undocumented)
+    text: string;
+}
+
+// @public (undocumented)
+export type FormMessageKey = "form.generating" | "form.ready" | "form.attention" | "form.reverted" | "form.revert" | "form.revertWait" | "form.suggested" | "form.replaceIt" | "form.keepMine" | "form.attach" | "form.remove" | "form.uploading" | "form.attached" | "form.attachFailed" | "form.removeFailed" | "form.onlyImages" | "form.busy" | "form.unusable";
+
+// @public (undocumented)
+export interface FormSession {
+    // (undocumented)
+    begin(material: FormMaterial): FormFillRequest;
+    // (undocumented)
+    cancel(): void;
+    // (undocumented)
+    cancelReplacement(field: string): void;
+    // (undocumented)
+    dispose(): void;
+    // (undocumented)
+    edit(field: string, value: unknown): void;
+    failRequest(requestId: string): void;
+    // (undocumented)
+    getSnapshot(): FormSnapshot;
+    markEdited(field: string, text: string): void;
+    // (undocumented)
+    receive(body: unknown): boolean;
+    // (undocumented)
+    replace(field: string, revision: number): boolean;
+    revert(fill: string): boolean;
+    // (undocumented)
+    subscribe(listener: () => void): () => void;
+}
+
+// @public (undocumented)
+export interface FormSessionConfig {
+    // (undocumented)
+    fields: readonly FormField[];
+    // (undocumented)
+    ids(): string;
+}
+
+// @public (undocumented)
+export interface FormSnapshot {
+    // (undocumented)
+    fields: Readonly<Record<string, FormDraft>>;
+    fills?: readonly {
+        id: string;
+        fields: readonly string[];
+    }[];
+    // (undocumented)
+    pending: boolean;
+}
+
+// @public (undocumented)
+export type FormSubject = {
+    [k: string]: unknown;
+} & {
+    key: string;
+    resource: string;
+    label: string;
+    route: string;
+    state: 'pending' | 'bound' | 'unlinked';
+    record?: string;
+};
+
+// @public (undocumented)
+export interface FormValidation {
+    // (undocumented)
+    guidance?: string;
+    // (undocumented)
+    messages: string[];
+    // (undocumented)
+    status: 'valid' | 'invalid';
+}
+
+// @public (undocumented)
+export type Frame = FrameMessageStart | FrameTextDelta | FrameBlock | FramePlanDraft | FramePlanFinal | FramePlanStep | FrameToolCall | FramePlanningRead | FrameMessageEnd | FrameStale | FrameProblem;
+
+// @public (undocumented)
+export interface FrameBlock {
+    // (undocumented)
+    block: Block;
+    // (undocumented)
+    messageId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'block';
+}
+
+// @public (undocumented)
+export interface FrameMessageEnd {
+    // (undocumented)
+    messageId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    status: 'completed' | 'failed' | 'unavailable' | 'stopped';
+    // (undocumented)
+    type: 'message.end';
+}
+
+// @public (undocumented)
+export interface FrameMessageStart {
+    // (undocumented)
+    messageId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    role: 'user' | 'assistant';
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'message.start';
+}
+
+// @public (undocumented)
+export interface FramePlanDraft {
+    // (undocumented)
+    messageId: string;
+    // (undocumented)
+    plan: ImmediateDraft;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'plan.draft';
+}
+
+// @public (undocumented)
+export interface FramePlanFinal {
+    // (undocumented)
+    messageId: string;
+    // (undocumented)
+    plan: ImmediatePlan | TimedPlan;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'plan.final';
+}
+
+// @public (undocumented)
+export interface FramePlanningRead {
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    stepId: string;
+    // (undocumented)
+    template: ReadTemplate;
+    // (undocumented)
+    type: 'planning-read';
+}
+
+// @public (undocumented)
+export interface FramePlanStep {
+    // (undocumented)
+    outcome: Outcome;
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'plan.step';
+}
+
+// @public (undocumented)
+export interface FrameProblem {
+    // (undocumented)
+    problem: Problem;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'problem';
+}
+
+// @public (undocumented)
+export interface FrameStale {
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    reads: ('conversation' | 'conversations' | 'plans' | 'flows')[];
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'stale';
+}
+
+// @public (undocumented)
+export interface FrameTextDelta {
+    // (undocumented)
+    messageId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    text: string;
+    // (undocumented)
+    type: 'text.delta';
+}
+
+// @public (undocumented)
+export interface FrameToolCall {
+    // (undocumented)
+    call: ToolCall;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    sequence: number;
+    // (undocumented)
+    type: 'tool.call';
+}
+
+// @public (undocumented)
+export interface ImmediateDraft {
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    kind: 'immediate';
+    // (undocumented)
+    stage: 'draft';
+    // (undocumented)
+    steps: (Step & {
+        [k: string]: unknown;
+    })[];
+}
+
+// @public (undocumented)
+export interface ImmediatePlan {
+    // (undocumented)
+    digest: string;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    kind: 'immediate';
+    // (undocumented)
+    stage: 'final';
+    // (undocumented)
+    steps: (Step & {
+        [k: string]: unknown;
+    })[];
+    // (undocumented)
+    stepUpCount: number;
+}
+
+// @public (undocumented)
+export type IntentAlert = {
+    serial: number;
+    action: "checkStatus" | "retry" | "signIn" | "hostGuidance" | "wait";
+} | {
+    serial: number;
+    restoreFocus: true;
+};
+
+// @public (undocumented)
+export type IntentCause = 'user' | 'connection-lost' | 'renewal-refused' | 'step-failed' | 'step-up-failed' | 'identity-lost' | 'attribution-missing' | 'plan-changed' | 'adapter-configuration';
+
+// @public (undocumented)
+export type IntentFailure = "offline" | "sign-in" | "forbidden" | "rate-limited" | "timeout" | "connection-lost";
+
+// @public (undocumented)
+export type IntentKind = 'stop' | 'cancel-initial' | 'cancel-review' | 'leave' | 'keep';
+
+// @public (undocumented)
+export type IntentNotice = Omit<PlanIntentReply, "slotVersion"> & {
+    resolvedSlotVersion: number;
+};
+
+// @public
+export interface IntentOverlay {
+    // (undocumented)
+    delivery: "sending" | "uncertain" | "not-sent";
+    // (undocumented)
+    kind: IntentKind;
+    // (undocumented)
+    lastProblem?: {
+        key: string;
+        cause: IntentFailure;
+    };
+    // (undocumented)
+    ownRun: boolean;
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    producer: "user" | "automatic";
+    // (undocumented)
+    request: IntentRequest;
+    // (undocumented)
+    retryAt?: number;
+}
+
+// @public (undocumented)
+export interface IntentRequest {
+    // (undocumented)
+    acknowledgment?: LeaveAcknowledgment;
+    // (undocumented)
+    capturedRound: number;
+    // (undocumented)
+    cause: IntentCause;
+    // (undocumented)
+    correlation: string;
+    // (undocumented)
+    expectedSlotVersion: number;
+    // (undocumented)
+    kind: IntentKind;
+    // (undocumented)
+    payload?: string;
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    review?: 'forward-only' | 'end-retention';
+    // (undocumented)
+    target: IntentTarget;
+}
+
+// @public (undocumented)
+export interface IntentTarget {
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    type: 'generation' | 'review' | 'execution';
+}
+
+// @public (undocumented)
+export interface IntentWinner {
+    // (undocumented)
+    cause: IntentCause;
+    // (undocumented)
+    kind: WinnerKind;
+}
+
+// @public (undocumented)
+export interface KeepChangesReview {
+    // (undocumented)
+    acknowledgment: LeaveAcknowledgment;
+    // (undocumented)
+    remaining: number;
+    // (undocumented)
+    review: "forward-only" | "end-retention";
+}
+
+// @public (undocumented)
+export type KeepChangesReviewResult = KeepChangesReview | {
+    disabled: KeepDisabledReason;
+};
+
+// @public (undocumented)
+export type KeepDisabledReason = "loading" | "intentUnavailable" | "capabilityMissing" | "keepNoDecision" | "sealed" | "keepBlockedActive" | "keepBlockedUnknown";
+
+// @public (undocumented)
+export interface KeepSheet {
+    // (undocumented)
+    messages: ViewMessage[];
+    // (undocumented)
+    onCancel(): void;
+    // (undocumented)
+    onProceed(): void;
+    // (undocumented)
+    proceed: {
+        available: boolean;
+        reasonKey?: ViewMessage["key"];
+    };
+}
+
+// @public
+export function keepSheet(review: {
+    review: "forward-only" | "end-retention";
+    remaining: number;
+}, view: PlanView): KeepSheetView;
+
+// @public (undocumented)
+export interface KeepSheetView {
+    // (undocumented)
+    messages: ViewMessage[];
+    // (undocumented)
+    proceed: {
+        available: boolean;
+        reasonKey?: MessageKey;
+    };
+}
+
+// @public (undocumented)
+export interface KeptFact {
+    // (undocumented)
+    actorCause: IntentCause;
+    // (undocumented)
+    keepEffect: 'forward-closed' | 'decision-closed' | 'retention-ended' | 'leave-completed';
+    // (undocumented)
+    round: number;
+}
+
+// @public (undocumented)
+export interface LeaveAcknowledgment {
+    // (undocumented)
+    decisionResolutionVersion: number;
+    // (undocumented)
+    evidenceDigest: string;
+    // (undocumented)
+    evidenceVersion: number;
+    // (undocumented)
+    sourceDecisionKey: string;
+    // (undocumented)
+    unknownCount: number;
+    // (undocumented)
+    winnerVersion: number;
+}
+
+// @public
+export function loadFormSession(config: FormSessionConfig): Promise<FormSession>;
+
+// @public (undocumented)
+export interface ManifestEntry {
+    // (undocumented)
+    fields: {
+        [k: string]: 'low' | 'sensitive' | 'human-only';
+    };
+    // (undocumented)
+    filterable: string[];
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    kind: 'read' | 'planning-read' | 'update' | 'create' | 'action' | 'bulk';
+    // (undocumented)
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH';
+    // (undocumented)
+    path: string;
+    // (undocumented)
+    permission: string;
+    // (undocumented)
+    resource: string;
+    // (undocumented)
+    returns: string[];
+    // (undocumented)
+    undo: string;
+    // (undocumented)
+    view: string;
+}
+
+// @public (undocumented)
+export type MaybePromise<T> = T | Promise<T>;
+
+// @public (undocumented)
+export interface Message {
+    // (undocumented)
+    blocks: Block[];
+    // (undocumented)
+    clientMessageId?: string;
+    // (undocumented)
+    content: string;
+    // (undocumented)
+    createdAt: number;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    role: 'user' | 'assistant';
+    sources?: Source[];
+    // (undocumented)
+    status?: 'writing' | 'completed' | 'failed' | 'unavailable' | 'stopped';
+    // (undocumented)
+    versionCount?: number;
+    // (undocumented)
+    versionIndex?: number;
+}
+
+// @public (undocumented)
+export type MessageKey = keyof typeof english | keyof RecoveryCatalogue | keyof ConfirmationCatalogue | keyof BlockCatalogue | keyof ProblemCatalogue | keyof ReplyCatalogue | keyof FormCatalogue;
+
+// @public (undocumented)
+export type MessageValues = Record<string, string | number | boolean>;
+
+// @public (undocumented)
+export interface MessageVersionInput {
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    conversationId: string;
+    // (undocumented)
+    messageId: string;
+}
+
+// @public (undocumented)
+export interface MessageVersionPort {
+    // (undocumented)
+    edit(input: MessageVersionInput & {
+        content: string;
+    }): MaybePromise<void>;
+    // (undocumented)
+    regenerate(input: MessageVersionInput): MaybePromise<void>;
+    // (undocumented)
+    select(input: MessageVersionInput & {
+        index: number;
+    }): MaybePromise<void>;
+}
+
+// @public (undocumented)
+export interface Negotiated {
+    // (undocumented)
+    agreementId?: string;
+    // (undocumented)
+    capabilities: string[];
+    // (undocumented)
+    protocol: string;
+}
+
+// @public (undocumented)
+export interface Negotiation {
+    // (undocumented)
+    offer?: NegotiationOfferWire;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    supported: string[];
+}
+
+// @public
+export interface NegotiationOffer {
+    // (undocumented)
+    capabilities: readonly string[];
+}
+
+// @public (undocumented)
+export interface NegotiationOfferWire {
+    // (undocumented)
+    capabilities: string[];
+}
+
+// @public (undocumented)
+export interface Outcome {
+    // (undocumented)
+    attributed: boolean;
+    reason?: string;
+    retryable?: boolean;
+    // (undocumented)
+    status: number;
+    // (undocumented)
+    stepId: string;
+    // (undocumented)
+    version?: string;
+}
+
+// @public (undocumented)
+export interface PatchFlow {
+    // (undocumented)
+    favourite: boolean;
+    // (undocumented)
+    flowId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    title: string;
+}
+
+// @public (undocumented)
+export interface PendingSend {
+    // (undocumented)
+    content: string;
+    // (undocumented)
+    extensions?: Record<string, unknown>;
+    // (undocumented)
+    failure: Problem | null;
+    // (undocumented)
+    id: string;
+}
+
+// @public (undocumented)
+export type Plan = ImmediateDraft | ImmediatePlan | TimedPlan;
+
+// @public (undocumented)
+export interface PlanCommand {
+    // (undocumented)
+    action: 'stop' | 'heartbeat' | 'resume' | 'retry-undo';
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    protocol: string;
+}
+
+// @public (undocumented)
+export interface PlanIntentReply {
+    // (undocumented)
+    capturedRound: number;
+    // (undocumented)
+    correlation: string;
+    // (undocumented)
+    count?: number;
+    // (undocumented)
+    dispositionApplied?: boolean;
+    // (undocumented)
+    effectiveRound: number;
+    // (undocumented)
+    finalHistory?: FinalHistory;
+    // (undocumented)
+    forwardClosed?: boolean;
+    // (undocumented)
+    keys: string[];
+    // (undocumented)
+    kind: IntentKind;
+    // (undocumented)
+    phase: RecoveryPhase;
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    replacement?: IntentTarget;
+    // (undocumented)
+    requestedTargetApplied?: boolean;
+    // (undocumented)
+    requestKey?: 'requestAlreadyStopped' | 'requestTargetStopped';
+    // (undocumented)
+    resolvedTarget?: string;
+    // (undocumented)
+    result: 'applied' | 'replaced' | 'already-closed' | 'already-stopped' | 'defeated' | 'superseded' | 'needs-review' | 'conflict' | 'unavailable' | 'invalid-target' | 'refused' | 'kept' | 'already-kept' | 'sealed';
+    // (undocumented)
+    safetyApplied?: boolean;
+    // (undocumented)
+    savedDisposition?: {
+        phase: 'left-known' | 'left-unconfirmed';
+        count: number;
+    };
+    // (undocumented)
+    slotVersion: number;
+    // (undocumented)
+    winner?: IntentWinner;
+}
+
+// @public
+export class PlanReadRefused extends Error {
+    constructor();
+}
+
+// @public (undocumented)
+export interface PlanRecord {
+    // (undocumented)
+    confirmation?: ConfirmationRecord;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    outcomes: Outcome[];
+    // (undocumented)
+    plan: Plan;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    reason?: string;
+    // (undocumented)
+    recovery?: RecoveryView;
+    // (undocumented)
+    state: PlanState;
+    // (undocumented)
+    undoPlanId?: string;
+}
+
+// @public (undocumented)
+export interface PlanRunner {
+    // (undocumented)
+    dispose(): void;
+    interrupt?(): void;
+    // (undocumented)
+    run(id: string, confirmedDigest: string, acceptance?: ExecutionAcceptance): Promise<void>;
+    // (undocumented)
+    stop(id?: string): void;
+}
+
+// @public (undocumented)
+export type PlanState = 'proposed' | 'awaiting-confirmation' | 'running' | 'undoing' | 'completed' | 'submitted' | 'undone' | 'needs-attention' | 'cancelled';
+
+// @public (undocumented)
+export interface PlanView {
+    // (undocumented)
+    actions: ActionEntry[];
+    // (undocumented)
+    alert: PlanViewAlert | null;
+    // (undocumented)
+    conversationUnavailable: boolean;
+    // (undocumented)
+    intent: {
+        kind: IntentKind;
+        status: IntentOverlay["delivery"];
+    } | null;
+    // (undocumented)
+    lines: ViewMessage[];
+    // (undocumented)
+    notice: ViewMessage[];
+    // (undocumented)
+    pending: readonly IntentKind[];
+    // (undocumented)
+    planId: string;
+    readOnly?: true;
+    status: PlanViewStatus | null;
+    // (undocumented)
+    steps: StepStatus[];
+}
+
+// @public
+export function planView(input: PlanViewInput): PlanView | null;
+
+// @public (undocumented)
+export interface PlanViewAlert {
+    // (undocumented)
+    action?: "checkStatus" | "retry" | "signIn" | "hostGuidance" | "wait";
+    // (undocumented)
+    message?: ViewMessage;
+    // (undocumented)
+    restoreFocus?: true;
+    // (undocumented)
+    retryAvailable: boolean;
+    // (undocumented)
+    retryReasonKey?: MessageKey;
+    // (undocumented)
+    retryValues?: Record<string, number>;
+    // (undocumented)
+    serial: number;
+}
+
+// @public (undocumented)
+export interface PlanViewInput {
+    // (undocumented)
+    alert: IntentAlert | null;
+    // (undocumented)
+    capabilities: readonly string[];
+    // (undocumented)
+    conversationId: string;
+    // (undocumented)
+    conversationUnavailable: boolean;
+    // (undocumented)
+    keepReview: KeepChangesReviewResult;
+    // (undocumented)
+    notice: IntentNotice | null;
+    // (undocumented)
+    now: number;
+    // (undocumented)
+    overlay: IntentOverlay | undefined;
+    // (undocumented)
+    pending: readonly IntentKind[];
+    // (undocumented)
+    plan: PlanRecord | null;
+    // (undocumented)
+    readOnly?: boolean;
+}
+
+// @public (undocumented)
+export interface PlanViewStatus {
+    // (undocumented)
+    attention: boolean;
+    // (undocumented)
+    dataStatus: string;
+    // (undocumented)
+    label: ViewMessage;
+    // (undocumented)
+    result?: "kept";
+    // (undocumented)
+    tone: Tone;
+    // (undocumented)
+    wireState: PlanState;
+}
+
+// @public (undocumented)
+export interface PlatformPorts {
+    // (undocumented)
+    clock: {
+        now(): number;
+        setTimeout(fn: () => void, ms: number): unknown;
+        clearTimeout(handle: unknown): void;
+    };
+    // (undocumented)
+    ids(): string;
+    // (undocumented)
+    online(): boolean;
+    subscribeOnline?(listener: (online: boolean) => void): () => void;
+    subscribeVisibility?(listener: (visible: boolean) => void): () => void;
+    // (undocumented)
+    visibility(): boolean;
+}
+
+// @public (undocumented)
+export interface Problem {
+    // (undocumented)
+    code: 'update-required' | 'in-doubt' | 'replaced' | 'retryable' | 'refused' | 'closed' | 'full' | 'declined' | 'unavailable' | 'sign-in' | 'rate-limited' | 'step-up-cancelled' | 'mismatch' | 'invalid-read' | 'invalid-plan' | 'needs-attention' | 'stopped' | 'plan-changed' | 'agreement-expired';
+    confirmation?: {
+        reason: 'expired' | 'used' | 'stale' | 'mismatch' | 'missing';
+    };
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    retryAfter?: number;
+}
+
+// @public
+export const problemAction: (problem: Problem) => "retry" | "refresh" | undefined;
+
+// @public (undocumented)
+export type ProblemCatalogue = Readonly<Record<ProblemMessageKey, string>>;
+
+// @public (undocumented)
+export type ProblemMessageKey = "chat.problem.signIn" | "chat.problem.retryable" | "chat.problem.rateLimited" | "chat.problem.refused" | "chat.problem.closed" | "chat.problem.full" | "chat.problem.declined" | "chat.problem.unavailable" | "chat.problem.stepUp" | "chat.problem.invalid" | "chat.problem.mismatch" | "chat.problem.agreement" | "chat.problem.inDoubt" | "chat.problem.replaced" | "chat.problem.needsAttention" | "chat.problem.answered" | "chat.problem.details" | "chat.problem.code" | "chat.problem.reference" | "chat.problem.refresh";
+
+// @public (undocumented)
+export interface ProblemView {
+    action?: "retry" | "refresh";
+    code: Problem["code"];
+    // (undocumented)
+    id: string;
+    key: MessageKey;
+}
+
+// @public
+export function problemView(problem: Problem, options?: {
+    answeredElsewhere?: boolean;
+}): ProblemView;
+
+// @public
+export interface ReaderRequestContext {
+    // (undocumented)
+    agreementId: string;
+}
+
+// @public (undocumented)
+export interface ReadPorts {
+    // (undocumented)
+    manifest: readonly ManifestEntry[];
+    // (undocumented)
+    planning?: {
+        template(planId: string, stepId: string): MaybePromise<ReadTemplate | null>;
+        request(template: ReadTemplate): Promise<{
+            rows: Record<string, unknown>;
+            versions: Record<string, string>;
+        }>;
+    };
+    // (undocumented)
+    request(call: ToolCall): Promise<unknown>;
+}
+
+// @public
+export function readProblem(error: unknown, id: string): Problem;
+
+// @public (undocumented)
+export interface ReadTemplate {
+    // (undocumented)
+    fields: string[];
+    // (undocumented)
+    method: 'GET';
+    // (undocumented)
+    path: string;
+    // (undocumented)
+    rows: string[];
+}
+
+// @public (undocumented)
+export type RecoveryCatalogue = Readonly<Record<RecoveryMessageKey, string>>;
+
+// @public (undocumented)
+export type RecoveryMessageKey = "chat.recovery.heading" | "chat.recovery.updateToControl" | "chat.recovery.stopping" | "chat.recovery.cancelling" | "chat.recovery.leavePending" | "chat.recovery.currentRunning" | "chat.recovery.currentStopped" | "chat.recovery.cancelledNoChanges" | "chat.recovery.leftKnown" | "chat.recovery.leftUnconfirmed" | "chat.recovery.keptKnown" | "chat.recovery.done" | "chat.recovery.notDone" | "chat.recovery.unknown" | "chat.recovery.stopped" | "chat.recovery.capabilityMissing" | "chat.recovery.intentPendingReason" | "chat.recovery.refreshConversation" | "chat.recovery.hostGuidance" | "chat.recovery.checkIntentStatus" | "chat.recovery.checkSavedChoice" | "chat.recovery.checkKeepStatus" | "chat.recovery.keepChanges" | "chat.recovery.leave" | "chat.recovery.confirmKeepForwardOnly" | "chat.recovery.confirmEndRetention" | "chat.recovery.keepReasonActive" | "chat.recovery.keepReasonUnknown" | "chat.recovery.keepReasonUnavailable" | "chat.recovery.keepReasonChanged" | "chat.recovery.keepReasonPreview" | "chat.recovery.keepReasonNoSource" | "chat.recovery.alreadyKept" | "chat.recovery.stopNotSent" | "chat.recovery.stopNotSentElsewhere" | "chat.recovery.stopUnconfirmed" | "chat.recovery.cancelNotSent" | "chat.recovery.cancelUnconfirmed" | "chat.recovery.reviewCancelNotSent" | "chat.recovery.reviewCancelUnconfirmed" | "chat.recovery.leaveNotSent" | "chat.recovery.leaveUnconfirmed" | "chat.recovery.keepNotSent" | "chat.recovery.keepUnconfirmed" | "chat.recovery.requestAlreadyStopped" | "chat.recovery.requestTargetStopped" | "chat.recovery.requestedIntentApplied" | "chat.recovery.requestedIntentNotApplied" | "chat.recovery.intentSuperseded" | "chat.recovery.intentTargetChanged" | "chat.recovery.alreadyClosedByWinner" | "chat.recovery.alreadyStoppedNeedsDecision" | "chat.recovery.cancelStarted" | "chat.recovery.stoppedNoChanges" | "chat.recovery.initialTargetSettled" | "chat.recovery.initialTargetStopped" | "chat.recovery.reviewTargetSettled" | "chat.recovery.reviewTargetStopped" | "chat.recovery.planClosedKept" | "chat.recovery.keptForwardClosed" | "chat.recovery.keptAlready" | "chat.recovery.leaveCompletedByKeep" | "chat.recovery.leaveCoveredByKeep" | "chat.recovery.leaveNeedsReview" | "chat.recovery.leaveSafetyNeedsReview" | "chat.recovery.laterReceiptAfterKeep" | "chat.recovery.undoSelected" | "chat.recovery.continue" | "chat.recovery.statusProposal" | "chat.recovery.statusCompleted" | "chat.recovery.stepsNotKnownYet" | "chat.recovery.stepsUnknown" | "chat.recovery.stepsNotDone" | "chat.recovery.laterReportAfterKeep" | "chat.recovery.reportedDifferently" | "chat.recovery.notAvailableYet" | "chat.recovery.actionLoading" | "chat.recovery.retryAfterSeconds" | "chat.recovery.keepPending" | "chat.recovery.keepRemainingSteps" | "chat.recovery.signInRequired" | "chat.recovery.requestRefused" | "chat.recovery.acknowledgmentAhead" | "chat.recovery.cancelCoveredByLeaveSafety" | "chat.recovery.cancelCoveredByStopNoChanges" | "chat.recovery.cancelDefeatedByStop" | "chat.recovery.choiceReplacedByStop" | "chat.recovery.initialTargetClosed" | "chat.recovery.keepDefeatedByWinner" | "chat.recovery.leaveDefeatedByWinner" | "chat.recovery.leaveNoDecision" | "chat.recovery.leaveSafetyAlreadyStopped" | "chat.recovery.reopenedEvidence" | "chat.recovery.winnerStopUser" | "chat.recovery.winnerStopConnection" | "chat.recovery.winnerStopRenewal" | "chat.recovery.winnerStopStep" | "chat.recovery.winnerStopStepUp" | "chat.recovery.winnerStopIdentity" | "chat.recovery.winnerStopAttribution" | "chat.recovery.winnerStopChanged" | "chat.recovery.winnerStopAdapter" | "chat.recovery.winnerCancel" | "chat.recovery.winnerLeave" | "chat.recovery.winnerKeep" | "chat.recovery.stepStatusChanged" | "chat.recovery.stepNotKnownYet";
+
+// @public (undocumented)
+export type RecoveryPhase = 'proposal' | 'initial-review' | 'forward-active' | 'readback' | 'completed' | 'cancelled' | 'left-known' | 'left-unconfirmed' | 'left-reopened';
+
+// @public (undocumented)
+export interface RecoveryView {
+    contradictedAfterSeal?: string[];
+    // (undocumented)
+    conversationId: string;
+    // (undocumented)
+    decisionKey?: string;
+    // (undocumented)
+    evidenceDigest?: string;
+    // (undocumented)
+    executionId?: string;
+    // (undocumented)
+    generation: string;
+    // (undocumented)
+    phase: RecoveryPhase | (string & {});
+    // (undocumented)
+    profile: 'plan-recovery-v1' | (string & {});
+    // (undocumented)
+    remaining?: number;
+    // (undocumented)
+    reviewId?: string;
+    // (undocumented)
+    revision: number;
+    // (undocumented)
+    round: number;
+    // (undocumented)
+    sealed?: boolean;
+    // (undocumented)
+    slots: {
+        stop: number;
+        'cancel-initial': number;
+        'cancel-review': number;
+        leave: number;
+        keep: number;
+    };
+    // (undocumented)
+    steps?: {
+        stepId: string;
+        truth: 'done' | 'not-done' | 'unknown';
+    }[];
+    // (undocumented)
+    unknownCount?: number;
+    // (undocumented)
+    versions: DecisionVersions;
+    // (undocumented)
+    winner?: IntentWinner;
+}
+
+// @public (undocumented)
+export type Reply = ReplyMessage | ReplyConfirm | ReplyForm | ReplyAction | ReplyToolResult | ReplyPlanValues | ReplyFormFill | ReplyStop;
+
+// @public (undocumented)
+export interface ReplyAction {
+    // (undocumented)
+    actionId: string;
+    // (undocumented)
+    blockId: string;
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    kind: 'action';
+    // (undocumented)
+    protocol: string;
+}
+
+// @public (undocumented)
+export type ReplyCatalogue = Readonly<Record<ReplyMessageKey, string>>;
+
+// @public (undocumented)
+export interface ReplyConfirm {
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    confirmationToken: string;
+    // (undocumented)
+    digest?: string;
+    // (undocumented)
+    kind: 'confirm';
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    protocol: string;
+}
+
+// @public (undocumented)
+export interface ReplyDecline {
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    kind: 'decline';
+    // (undocumented)
+    planId: string;
+}
+
+// @public
+export interface ReplyDelivery {
+    // (undocumented)
+    acceptance?: ExecutionAcceptance;
+    // (undocumented)
+    id: string;
+}
+
+// @public (undocumented)
+export interface ReplyForm {
+    // (undocumented)
+    blockId: string;
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    kind: 'form';
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    values: {};
+}
+
+// @public (undocumented)
+export interface ReplyFormFill {
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    kind: 'form-fill';
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    request: FormFillRequest;
+}
+
+// @public (undocumented)
+export type ReplyInput = Reply extends infer R ? R extends {
+    protocol: string;
+} ? Omit<R, "protocol"> & {
+    protocol?: string;
+} : never : never;
+
+// @public (undocumented)
+export interface ReplyMessage {
+    // (undocumented)
+    clientMessageId: string;
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    content: string;
+    // (undocumented)
+    kind: 'message';
+    // (undocumented)
+    protocol: string;
+}
+
+// @public (undocumented)
+export type ReplyMessageKey = "chat.reply.stop" | "chat.reply.keepWaiting" | "chat.tool.working" | "chat.tool.running" | "chat.tool.done" | "chat.tool.failed" | "chat.tool.show" | "chat.tool.hide" | "chat.message.actions" | "chat.message.copy" | "chat.message.copied" | "chat.message.copyFailed" | "chat.message.regenerate" | "chat.message.edit" | "chat.message.editLabel" | "chat.message.resend" | "chat.message.good" | "chat.message.bad" | "chat.message.previous" | "chat.message.next" | "chat.message.version";
+
+// @public
+export type ReplyOutcome = {
+    accepted: true;
+} | {
+    accepted: false;
+    problem?: Problem;
+};
+
+// @public (undocumented)
+export interface ReplyPlanValues {
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    kind: 'plan.values';
+    // (undocumented)
+    planId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    steps: {
+        stepId: string;
+        rows: {};
+        versions: {
+            [k: string]: string;
+        };
+    }[];
+}
+
+// @public (undocumented)
+export function replyRow(input: {
+    messages: readonly Message[];
+    pending: readonly PendingSend[];
+    now: number;
+    askedAt?: number;
+    overdueAt?: number;
+    heldUntil?: number;
+    unavailable?: boolean;
+    failed?: boolean;
+    streamLost?: boolean;
+    activityAt?: number;
+}): ReplyState;
+
+// @public (undocumented)
+export interface ReplyRowAction {
+    // (undocumented)
+    id: "keepWaiting" | "retry" | "stop";
+    // (undocumented)
+    labelKey: MessageKey;
+}
+
+// @public
+export function replyRowView(state: ReplyState, options?: {
+    canStop?: boolean;
+    canRetry?: boolean;
+}): {
+    key?: MessageKey;
+    actions: ReplyRowAction[];
+};
+
+// @public (undocumented)
+export type ReplyState = "none" | "writing" | "unavailable" | "failed" | "overdue";
+
+// @public
+export interface ReplyStop {
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    kind: 'stop';
+    // (undocumented)
+    messageId: string;
+    // (undocumented)
+    protocol: string;
+    versionIndex?: number;
+}
+
+// @public (undocumented)
+export interface ReplyToolResult {
+    // (undocumented)
+    callId: string;
+    // (undocumented)
+    clientReplyId: string;
+    // (undocumented)
+    kind: 'tool-result';
+    // (undocumented)
+    problem?: Problem;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    result: unknown;
+}
+
+// @public (undocumented)
+export interface RestoredMessage {
+    // (undocumented)
+    content: string;
+    // (undocumented)
+    id: string;
+}
+
+// @public (undocumented)
+export interface RunFlow {
+    // (undocumented)
+    flowId: string;
+    // (undocumented)
+    protocol: string;
+    // (undocumented)
+    values: {};
+}
+
+// @public (undocumented)
+export interface RunnerPorts {
+    // (undocumented)
+    clock?: PlatformPorts["clock"];
+    heartbeat(id: string, acceptance?: ExecutionAcceptance): Promise<void>;
+    // (undocumented)
+    heartbeatMs?: number;
+    intent?(request: IntentRequest): Promise<PlanIntentReply>;
+    interrupted?(id: string, cause: IntentCause): Promise<void>;
+    // (undocumented)
+    onRecord?(record: PlanRecord): void;
+    read(id: string, context?: ReaderRequestContext): Promise<PlanRecord>;
+    // (undocumented)
+    request(request: CanonicalRequest, context: StepContext): Promise<void>;
+    signal?: ScopeSignal;
+    // (undocumented)
+    stepUp?(planId: string, stepId: string): Promise<string | null>;
+    // @deprecated (undocumented)
+    stop?(id: string): Promise<PlanRecord>;
+}
+
+// @public (undocumented)
+export interface ScopeSignal {
+    // (undocumented)
+    readonly aborted: boolean;
+    // (undocumented)
+    addEventListener(type: "abort", listener: () => void, options?: {
+        once?: boolean;
+    }): void;
+    // (undocumented)
+    removeEventListener(type: "abort", listener: () => void): void;
+}
+
+// @public (undocumented)
+export interface Source {
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    title: string;
+    // (undocumented)
+    url: string;
+}
+
+// @public (undocumented)
+export interface Step {
+    // (undocumented)
+    after?: {};
+    // (undocumented)
+    before?: {};
+    // (undocumented)
+    fields: string[];
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    operation: string;
+    // (undocumented)
+    planningRead?: ReadTemplate;
+    // (undocumented)
+    request?: CanonicalRequest;
+    // (undocumented)
+    resource: string;
+    // (undocumented)
+    rows: string[];
+    // (undocumented)
+    stepUp: boolean;
+    // (undocumented)
+    tier: 'low' | 'sensitive';
+    // (undocumented)
+    undo: string;
+    // (undocumented)
+    view: string;
+}
+
+// @public (undocumented)
+export interface StepContext {
+    // (undocumented)
+    headers: Record<string, string>;
+    // (undocumented)
+    planId: string;
+    signal?: ScopeSignal;
+    // (undocumented)
+    stepId: string;
+    // (undocumented)
+    stepUpCode?: string;
+}
+
+// @public (undocumented)
+export interface StepStatus {
+    index: number;
+    // (undocumented)
+    lateReport?: "contradicted";
+    // (undocumented)
+    resource?: string;
+    // (undocumented)
+    stepId: string;
+    // (undocumented)
+    textKey: MessageKey;
+    // (undocumented)
+    truth: "done" | "not-done" | "unknown";
+}
+
+// @public (undocumented)
+export interface StoragePort {
+    compareAndSet?(key: string, expected: string | null, value: string): MaybePromise<boolean>;
+    // (undocumented)
+    get(key: string): MaybePromise<string | null>;
+    // (undocumented)
+    remove(key: string): MaybePromise<void>;
+    // (undocumented)
+    set(key: string, value: string): MaybePromise<void>;
+}
+
+// @public (undocumented)
+export interface TimedPlan {
+    // (undocumented)
+    end: string | null;
+    // (undocumented)
+    id: string;
+    // (undocumented)
+    kind: 'timed';
+    // (undocumented)
+    start: string | null;
+    // (undocumented)
+    values: {
+        [k: string]: {
+            [k: string]: unknown;
+        };
+    };
+}
+
+// @public (undocumented)
+export type Tone = "neutral" | "progress" | "warning" | "success";
+
+// @public (undocumented)
+export interface ToolCall {
+    // (undocumented)
+    id: string;
+    label?: string;
+    // (undocumented)
+    method: string;
+    // (undocumented)
+    operation: string;
+    // (undocumented)
+    path: string;
+    // (undocumented)
+    query?: {
+        [k: string]: string;
+    };
+}
+
+// @public
+export interface ToolStep {
+    // (undocumented)
+    id: string;
+    label?: string;
+    // (undocumented)
+    status: "running" | "done" | "failed";
+}
+
+// @public (undocumented)
+export type TransportEvent = {
+    type: "status";
+    status: "connecting" | "open" | "reconnecting" | "unavailable";
+} | {
+    type: "frame";
+    frame: Frame;
+}
+/** A hint that the conversation changed; it is never applied as content. */
+| {
+    type: "invalidate";
+};
+
+// @public (undocumented)
+export interface TransportPort {
+    negotiate(supported: readonly string[], offer?: NegotiationOffer): Promise<{
+        protocol: string;
+        capabilities: string[];
+        agreementId?: string;
+    }>;
+    // (undocumented)
+    read(conversationId: string, context?: ReaderRequestContext): Promise<Conversation>;
+    // (undocumented)
+    send(reply: Reply & {
+        extensions?: Record<string, unknown>;
+    }, conversationId: string, context?: ReaderRequestContext): Promise<ReplyDelivery>;
+    // (undocumented)
+    subscribe(conversationId: string, listener: (event: TransportEvent) => void, context?: ReaderRequestContext): () => void;
+}
+
+// @public
+export function useBlockReply(client?: WaypointClient): BlockReply;
+
+// @public
+export function usePlanView(client?: WaypointClient): {
+    view: PlanView | null;
+    press: (id: ActionId | "retry") => void;
+    sheet: KeepSheet | null;
+};
+
+// @public (undocumented)
+export function useWaypointSnapshot(client?: WaypointClient): ClientSnapshot;
+
+// @public (undocumented)
+export function versionWalk(message: {
+    versionIndex?: number | null;
+    versionCount?: number | null;
+}): {
+    index: number;
+    count: number;
+    previous: number | null;
+    next: number | null;
+} | null;
+
+// @public (undocumented)
+export interface ViewMessage {
+    // (undocumented)
+    key: MessageKey;
+    // (undocumented)
+    values?: Record<string, number>;
+}
+
+// @public (undocumented)
+export interface WaypointClient {
+    canChangeVersions(): boolean;
+    // (undocumented)
+    canKeepChanges(id?: string): boolean;
+    canPrepareFlow(): boolean;
+    canRetryReply(): boolean;
+    canSendFeedback(): boolean;
+    canStopReply(): boolean;
+    checkIntentStatus(id?: string): Promise<void>;
+    checkKeepStatus(id?: string): Promise<void>;
+    checkSavedChoice(id?: string): Promise<void>;
+    // (undocumented)
+    confirmPlan(): Promise<void>;
+    declinePlan(): Promise<void>;
+    discardRestored(id: string): Promise<void>;
+    // (undocumented)
+    dismiss(id: string): Promise<void>;
+    // (undocumented)
+    dispose(): void;
+    // (undocumented)
+    editMessage(messageId: string, content: string): Promise<void>;
+    editRestored(id: string): Promise<void>;
+    // (undocumented)
+    getSnapshot(): ClientSnapshot;
+    keepChanges(review: KeepChangesReviewResult): Promise<void>;
+    keepChangesReview(id?: string): KeepChangesReviewResult;
+    keepWaiting(): void;
+    leavePlan(id?: string): Promise<void>;
+    // (undocumented)
+    loadFlows(): Promise<void>;
+    // (undocumented)
+    on(listener: (event: WaypointEvent) => void): () => void;
+    prepareFlow(id?: string): Promise<Flow | void>;
+    readPlan(id?: string): Promise<void>;
+    // (undocumented)
+    ready: Promise<void>;
+    // (undocumented)
+    refresh(): Promise<ConversationReadResult>;
+    // (undocumented)
+    regenerate(messageId: string): Promise<void>;
+    // (undocumented)
+    reply(reply: ReplyInput): Promise<boolean>;
+    replyOutcome(reply: ReplyInput): Promise<ReplyOutcome>;
+    // (undocumented)
+    report(problem: Problem): void;
+    // (undocumented)
+    resumePlan(): Promise<void>;
+    // (undocumented)
+    retry(id: string): Promise<void>;
+    // (undocumented)
+    retryIntent(id?: string): Promise<void>;
+    retryReply(): Promise<void>;
+    // (undocumented)
+    retryUndo(): Promise<void>;
+    runFlow(id: string, values: Record<string, unknown>): Promise<string | void>;
+    // (undocumented)
+    runPlan(id: string, confirmedDigest: string): Promise<void>;
+    // (undocumented)
+    selectFlowTab(tab: FlowTab): void;
+    // (undocumented)
+    selectVersion(messageId: string, index: number): Promise<void>;
+    // (undocumented)
+    send(): Promise<void>;
+    sendFeedback(messageId: string, rating: FeedbackInput["rating"]): Promise<boolean>;
+    // (undocumented)
+    setDraft(value: string): Promise<void>;
+    // (undocumented)
+    setFavourite(id: string, favourite: boolean): Promise<void>;
+    // (undocumented)
+    setPlan(plan: PlanRecord): void;
+    // (undocumented)
+    stopPlan(id?: string): void;
+    stopReply(): Promise<void>;
+    // (undocumented)
+    subscribe(listener: () => void): () => void;
+    // (undocumented)
+    switchConversation(id: string): Promise<ConversationReadResult>;
+    // (undocumented)
+    withdraw(id: string): Promise<void>;
+}
+
+// @public (undocumented)
+export type WaypointEvent = {
+    type: "send" | "reply";
+    conversationId: string;
+    replyId: string;
+} | {
+    type: "plan.state";
+    planId: string;
+} | {
+    type: "problem";
+    problemId: string;
+} | {
+    type: "transport.status";
+    conversationId: string;
+};
+
+// @public (undocumented)
+export type WaypointProtocol = Problem | Negotiation | NegotiationOfferWire | Negotiated | CanonicalRequest | ReadTemplate | Step | ImmediateDraft | ImmediatePlan | TimedPlan | Plan | PlanState | Outcome | ConfirmationItem | ConfirmationSchedule | ConfirmationRecord | PlanRecord | RecoveryPhase | IntentKind | WinnerKind | IntentCause | IntentWinner | RecoveryView | IntentTarget | IntentRequest | PlanIntentReply | ExecutionAcceptance | ReplyDecline | CardAnswer | BlockMarkdown | BlockCard | BlockDetails | BlockList | BlockTable | BlockForm | BlockChoice | BlockButtons | BlockDiff | BlockPlan | BlockRouteLink | BlockNotice | ExtensionBlock | Block | Message | Source | Conversation | ReplyMessage | ReplyConfirm | ReplyForm | ReplyAction | ReplyToolResult | ReplyPlanValues | Reply | ReplyStop | ManifestEntry | ToolCall | FrameMessageStart | FrameTextDelta | FrameBlock | FramePlanDraft | FramePlanFinal | FramePlanStep | FrameToolCall | FramePlanningRead | FrameMessageEnd | FrameStale | FrameProblem | Frame | FlowParameter | Flow | CreateConversation | PlanCommand | RunFlow | PatchFlow | FormSubject | FormValidation | FormFillValue | FormFillField | FormFillRequest | BlockFormFill | ReplyFormFill | LeaveAcknowledgment | DecisionVersions | KeptFact | FinalHistory;
+
+// @public (undocumented)
+export type WinnerKind = 'stop' | 'cancel-initial' | 'cancel-review' | 'leave' | 'keep';
+
+// (No @packageDocumentation comment for this package)
+
+```