@anchrd/intel-contract 0.12.0 → 0.14.0

package/dist/contract/contract.d.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 export declare const IntelId: z.ZodString;
 export declare const IsoDateTime: z.ZodISODateTime;
+export declare const IdempotencyKey: z.ZodString;
 export declare const UI_LANGUAGES: readonly ["en", "de", "es"];
 export type UiLanguage = (typeof UI_LANGUAGES)[number];
 export declare const ProblemDetails: z.ZodObject<{
@@ -16,3379 +17,9 @@ export declare const SessionUser: z.ZodObject<{
     id: z.ZodString;
     email: z.ZodEmail;
     name: z.ZodNullable<z.ZodString>;
+    isAdmin: z.ZodBoolean;
 }, z.core.$strict>;
 export type SessionUser = z.infer<typeof SessionUser>;
-export declare const IntelCapabilities: z.ZodObject<{
-    agentRuntime: z.ZodBoolean;
-}, z.core.$strict>;
-export type IntelCapabilities = z.infer<typeof IntelCapabilities>;
-export declare const NodeKind: z.ZodEnum<{
-    folder: "folder";
-    document: "document";
-    attachment: "attachment";
-    table: "table";
-    agent: "agent";
-    board: "board";
-}>;
-export type NodeKind = z.infer<typeof NodeKind>;
-export declare const ResourceVerb: z.ZodEnum<{
-    read: "read";
-    write: "write";
-    execute: "execute";
-    share: "share";
-}>;
-export type ResourceVerb = z.infer<typeof ResourceVerb>;
-export declare const SharePrincipal: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"user">;
-    id: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    type: z.ZodLiteral<"email">;
-    email: z.ZodEmail;
-}, z.core.$strict>, z.ZodObject<{
-    type: z.ZodLiteral<"organization">;
-}, z.core.$strict>], "type">;
-export type SharePrincipal = z.infer<typeof SharePrincipal>;
-export declare const Node: z.ZodObject<{
-    id: z.ZodString;
-    parentId: z.ZodNullable<z.ZodString>;
-    kind: z.ZodEnum<{
-        folder: "folder";
-        document: "document";
-        attachment: "attachment";
-        table: "table";
-        agent: "agent";
-        board: "board";
-    }>;
-    title: z.ZodString;
-    description: z.ZodNullable<z.ZodString>;
-    ownerId: z.ZodString;
-    currentVersionId: z.ZodNullable<z.ZodString>;
-    createdAt: z.ZodISODateTime;
-    updatedAt: z.ZodISODateTime;
-    archivedAt: z.ZodNullable<z.ZodISODateTime>;
-}, z.core.$strict>;
-export type Node = z.infer<typeof Node>;
-export declare const NodeVersionSegment: z.ZodEnum<{
-    append: "append";
-    snapshot: "snapshot";
-}>;
-export type NodeVersionSegment = z.infer<typeof NodeVersionSegment>;
-export declare const NodeVersion: z.ZodObject<{
-    id: z.ZodString;
-    nodeId: z.ZodString;
-    sequence: z.ZodNumber;
-    contentKey: z.ZodString;
-    mediaType: z.ZodString;
-    contentHash: z.ZodString;
-    size: z.ZodNumber;
-    segment: z.ZodNullable<z.ZodEnum<{
-        append: "append";
-        snapshot: "snapshot";
-    }>>;
-    createdBy: z.ZodString;
-    createdAt: z.ZodISODateTime;
-}, z.core.$strict>;
-export type NodeVersion = z.infer<typeof NodeVersion>;
-export declare const ListNodesInput: z.ZodObject<{
-    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    includeArchived: z.ZodDefault<z.ZodBoolean>;
-    archivedOnly: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export type ListNodesInput = z.infer<typeof ListNodesInput>;
-export declare const GetNodeInput: z.ZodObject<{
-    nodeId: z.ZodString;
-}, z.core.$strict>;
-export type GetNodeInput = z.infer<typeof GetNodeInput>;
-export declare const GetNodeVersionInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    versionId: z.ZodString;
-}, z.core.$strict>;
-export type GetNodeVersionInput = z.infer<typeof GetNodeVersionInput>;
-export declare const ListGrantsInput: z.ZodObject<{
+export declare const LinkConfiguration: z.ZodObject<{
     resourceId: z.ZodString;
 }, z.core.$strict>;
-export type ListGrantsInput = z.infer<typeof ListGrantsInput>;
-export declare const CreateNodeInput: z.ZodObject<{
-    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    kind: z.ZodEnum<{
-        folder: "folder";
-        document: "document";
-        attachment: "attachment";
-        table: "table";
-        agent: "agent";
-        board: "board";
-    }>;
-    title: z.ZodString;
-    description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type CreateNodeInput = z.infer<typeof CreateNodeInput>;
-export declare const SaveNodeVersionInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    baseVersionId: z.ZodNullable<z.ZodString>;
-    content: z.ZodString;
-    mediaType: z.ZodDefault<z.ZodString>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type SaveNodeVersionInput = z.infer<typeof SaveNodeVersionInput>;
-export declare const SaveAttachmentInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    baseVersionId: z.ZodNullable<z.ZodString>;
-    contentBase64: z.ZodString;
-    mediaType: z.ZodString;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type SaveAttachmentInput = z.infer<typeof SaveAttachmentInput>;
-export declare const UpdateNodeInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    baseUpdatedAt: z.ZodISODateTime;
-    title: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type UpdateNodeInput = z.infer<typeof UpdateNodeInput>;
-export declare const ArchiveNodeInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    baseUpdatedAt: z.ZodISODateTime;
-    archived: z.ZodBoolean;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type ArchiveNodeInput = z.infer<typeof ArchiveNodeInput>;
-export declare const NodeList: z.ZodObject<{
-    items: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>>;
-    withChildren: z.ZodDefault<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-export type NodeList = z.infer<typeof NodeList>;
-export declare const NodeVersionList: z.ZodObject<{
-    items: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        nodeId: z.ZodString;
-        sequence: z.ZodNumber;
-        contentKey: z.ZodString;
-        mediaType: z.ZodString;
-        contentHash: z.ZodString;
-        size: z.ZodNumber;
-        segment: z.ZodNullable<z.ZodEnum<{
-            append: "append";
-            snapshot: "snapshot";
-        }>>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type NodeVersionList = z.infer<typeof NodeVersionList>;
-export declare const NodeDocument: z.ZodObject<{
-    node: z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    version: z.ZodNullable<z.ZodObject<{
-        id: z.ZodString;
-        nodeId: z.ZodString;
-        sequence: z.ZodNumber;
-        contentKey: z.ZodString;
-        mediaType: z.ZodString;
-        contentHash: z.ZodString;
-        size: z.ZodNumber;
-        segment: z.ZodNullable<z.ZodEnum<{
-            append: "append";
-            snapshot: "snapshot";
-        }>>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
-    content: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
-export type NodeDocument = z.infer<typeof NodeDocument>;
-export declare const NodeAttachment: z.ZodObject<{
-    node: z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    version: z.ZodObject<{
-        id: z.ZodString;
-        nodeId: z.ZodString;
-        sequence: z.ZodNumber;
-        contentKey: z.ZodString;
-        mediaType: z.ZodString;
-        contentHash: z.ZodString;
-        size: z.ZodNumber;
-        segment: z.ZodNullable<z.ZodEnum<{
-            append: "append";
-            snapshot: "snapshot";
-        }>>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>;
-    resourceUri: z.ZodString;
-}, z.core.$strict>;
-export type NodeAttachment = z.infer<typeof NodeAttachment>;
-export declare const TableMediaType = "text/csv";
-export declare const TableColumn: z.ZodString;
-export declare const TableCell: z.ZodString;
-export declare const TableRow: z.ZodArray<z.ZodString>;
-export declare const DefineTableInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    columns: z.ZodArray<z.ZodString>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type DefineTableInput = z.infer<typeof DefineTableInput>;
-export declare const AppendTableRowsInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    rows: z.ZodArray<z.ZodArray<z.ZodString>>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type AppendTableRowsInput = z.infer<typeof AppendTableRowsInput>;
-export declare const GetTableInput: z.ZodObject<{
-    nodeId: z.ZodString;
-}, z.core.$strict>;
-export type GetTableInput = z.infer<typeof GetTableInput>;
-export declare const NodeTable: z.ZodObject<{
-    node: z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    columns: z.ZodArray<z.ZodString>;
-    rows: z.ZodArray<z.ZodArray<z.ZodString>>;
-    versionId: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
-export type NodeTable = z.infer<typeof NodeTable>;
-export declare const AppendTableRowsResult: z.ZodObject<{
-    node: z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    version: z.ZodObject<{
-        id: z.ZodString;
-        nodeId: z.ZodString;
-        sequence: z.ZodNumber;
-        contentKey: z.ZodString;
-        mediaType: z.ZodString;
-        contentHash: z.ZodString;
-        size: z.ZodNumber;
-        segment: z.ZodNullable<z.ZodEnum<{
-            append: "append";
-            snapshot: "snapshot";
-        }>>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>;
-    appended: z.ZodNumber;
-}, z.core.$strict>;
-export type AppendTableRowsResult = z.infer<typeof AppendTableRowsResult>;
-export declare const TableRowPosition: z.ZodNumber;
-export declare const UpdateTableRowsInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    baseVersionId: z.ZodString;
-    updates: z.ZodArray<z.ZodObject<{
-        position: z.ZodNumber;
-        row: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type UpdateTableRowsInput = z.infer<typeof UpdateTableRowsInput>;
-export declare const UpdateTableRowsResult: z.ZodObject<{
-    node: z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    version: z.ZodObject<{
-        id: z.ZodString;
-        nodeId: z.ZodString;
-        sequence: z.ZodNumber;
-        contentKey: z.ZodString;
-        mediaType: z.ZodString;
-        contentHash: z.ZodString;
-        size: z.ZodNumber;
-        segment: z.ZodNullable<z.ZodEnum<{
-            append: "append";
-            snapshot: "snapshot";
-        }>>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>;
-    updated: z.ZodNumber;
-}, z.core.$strict>;
-export type UpdateTableRowsResult = z.infer<typeof UpdateTableRowsResult>;
-export declare const DeleteTableRowsInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    baseVersionId: z.ZodString;
-    positions: z.ZodArray<z.ZodNumber>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type DeleteTableRowsInput = z.infer<typeof DeleteTableRowsInput>;
-export declare const DeleteTableRowsResult: z.ZodObject<{
-    node: z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    version: z.ZodObject<{
-        id: z.ZodString;
-        nodeId: z.ZodString;
-        sequence: z.ZodNumber;
-        contentKey: z.ZodString;
-        mediaType: z.ZodString;
-        contentHash: z.ZodString;
-        size: z.ZodNumber;
-        segment: z.ZodNullable<z.ZodEnum<{
-            append: "append";
-            snapshot: "snapshot";
-        }>>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>;
-    deleted: z.ZodNumber;
-}, z.core.$strict>;
-export type DeleteTableRowsResult = z.infer<typeof DeleteTableRowsResult>;
-export declare const RedefineTableColumn: z.ZodObject<{
-    name: z.ZodString;
-    source: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-}, z.core.$strict>;
-export type RedefineTableColumn = z.infer<typeof RedefineTableColumn>;
-export declare const RedefineTableInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    baseVersionId: z.ZodString;
-    columns: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        source: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strict>>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type RedefineTableInput = z.infer<typeof RedefineTableInput>;
-export declare const BoardMediaType = "application/vnd.anchrd.board+json";
-export declare const ArchivedBoardStatusId = "archived";
-export declare const BoardStatusId: z.ZodString;
-export declare const BoardStatus: z.ZodObject<{
-    id: z.ZodString;
-    label: z.ZodString;
-    order: z.ZodNumber;
-    terminal: z.ZodBoolean;
-}, z.core.$strict>;
-export type BoardStatus = z.infer<typeof BoardStatus>;
-export declare const BoardDefaultStatuses: readonly BoardStatus[];
-/**
- * Who a task is on: a person Gate knows, or an agent node in this installation (#285).
- *
- * ⚠️ A `user` id is deliberately NOT validated against Intel's own id shape. Identity is Gate's
- * (see the product boundary), so a rule here would be Intel inventing one about somebody else's
- * identifier — the same reason `GateApplicationId` is a plain bounded string.
- */
-export declare const BoardAssignee: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"user">;
-    id: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    type: z.ZodLiteral<"agent">;
-    nodeId: z.ZodString;
-}, z.core.$strict>], "type">;
-export type BoardAssignee = z.infer<typeof BoardAssignee>;
-/**
- * A task's place among the others, as a fractional index (#285).
- *
- * ⚠️ Server-assigned, and a caller can never send one. A move names its NEIGHBOURS and the server
- * mints a key between theirs, so moving one task writes one task and renumbers nothing — the whole
- * reason a board is not addressed by position the way a table's rows are (`TableRowPosition`).
- * A hand-written key could collide, and two tasks sharing a key have no defined order at all.
- *
- * ⚠️ This CHARACTER CLASS is the truth about a stored key, not `fractional-indexing`, and the two
- * are deliberately not the same set (anchrd/intel#359). A board that arrived through a bundle may
- * spell `"0"`, `"a00"`, `"zzz"` or `"A"` — all of them legal here, none of them readable by that
- * library. Narrowing the regex to what it reads would be a rule on the STORED document, so a board
- * carrying one would stop parsing in all four places a board body is read (the board read, the
- * indexer, the link reader, the bundle import) — unreadable, unsearchable and unmovable at once,
- * over a value its owner never wrote. That is the trap #311, #318 and #321 each walked into from a
- * different side.
- *
- * ⚠️ What every consumer may therefore rely on is exactly what stands here: keys are non-empty
- * strings over `[0-9A-Za-z]` and are ORDERED BY STRING COMPARISON. Nothing may assume more — and
- * `packages/api`'s `orderBetween` is the one place that asks `fractional-indexing` for a key and
- * carries on without it when it refuses a bound.
- */
-export declare const MaxBoardTaskOrderLength = 64;
-export declare const BoardTaskOrder: z.ZodString;
-export declare const BoardTaskId: z.ZodString;
-export declare const BoardTaskLabel: z.ZodString;
-export declare const BoardTaskDate: z.ZodISODate;
-export declare const BoardTaskDescription: z.ZodString;
-/**
- * The tasks one task waits for (#285), each of them at most once (anchrd/intel#318).
- *
- * ⚠️ Board-internal only, enforced on the write path: a dependency on a task in another board would
- * hang this node on a file that can change without anyone here noticing. Across boards the link is
- * `references`, which points at the board NODE and lands in the link graph.
- *
- * ⚠️ Refused rather than folded together, the same shape as the status ids in `ConfigureBoardInput`.
- * A repeat carries no information — but that is a fact about the value, not about the answer: a
- * caller handed back a shorter list than it sent is told nothing, and composes the same one again.
- * The refusal names the mistake once, and the caller is holding the list it has to fix. (The one
- * place a repeat is folded instead is `upgradeStoredBoard`, where there is no caller to tell.)
- *
- * ⚠️ It sits on the STORED task as well as on the two inputs, so a consumer may rely on it rather
- * than defend against it — `createBoardGraph` mints one edge key per pair, and a second one threw
- * the whole graph view off the screen for everybody looking at that board.
- */
-export declare const BoardTaskDependsOn: z.ZodArray<z.ZodString>;
-/**
- * A task's labels, each of them at most once (anchrd/intel#318).
- *
- * ⚠️ The same rule the detail panel has always applied to what a person types — it refuses to add a
- * label the task already carries — stated where every surface meets it, because the MCP write path
- * did not. A repeated label draws the same chip twice on the card, with two remove buttons of which
- * either takes both away, and weights that word higher in the search text (`indexing.ts`).
- */
-export declare const BoardTaskLabels: z.ZodArray<z.ZodString>;
-/**
- * The Intel nodes a task points at, each of them at most once (anchrd/intel#318).
- *
- * They land in the link graph as `text` links, the same way a document's inline links do, so what a
- * board points at is visible from the other side too.
- *
- * ⚠️ Distinct for the same reason as `labels`: the picker in the detail panel already refuses one
- * the task holds, and the link graph counts a repeat once anyway (`ON CONFLICT DO NOTHING`), so a
- * duplicate is a second row in the panel and nothing else — which is exactly the kind of value that
- * has no reading and should not be storable.
- */
-export declare const BoardTaskReferences: z.ZodArray<z.ZodString>;
-export declare const BoardTask: z.ZodObject<{
-    id: z.ZodString;
-    title: z.ZodString;
-    status: z.ZodString;
-    assignee: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"user">;
-        id: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        type: z.ZodLiteral<"agent">;
-        nodeId: z.ZodString;
-    }, z.core.$strict>], "type">>;
-    labels: z.ZodArray<z.ZodString>;
-    startDate: z.ZodNullable<z.ZodISODate>;
-    dueDate: z.ZodNullable<z.ZodISODate>;
-    parentId: z.ZodNullable<z.ZodString>;
-    dependsOn: z.ZodArray<z.ZodString>;
-    order: z.ZodString;
-    description: z.ZodString;
-    references: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export type BoardTask = z.infer<typeof BoardTask>;
-export declare const BoardDocument: z.ZodObject<{
-    statuses: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        label: z.ZodString;
-        order: z.ZodNumber;
-        terminal: z.ZodBoolean;
-    }, z.core.$strict>>;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-        status: z.ZodString;
-        assignee: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            type: z.ZodLiteral<"user">;
-            id: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"agent">;
-            nodeId: z.ZodString;
-        }, z.core.$strict>], "type">>;
-        labels: z.ZodArray<z.ZodString>;
-        startDate: z.ZodNullable<z.ZodISODate>;
-        dueDate: z.ZodNullable<z.ZodISODate>;
-        parentId: z.ZodNullable<z.ZodString>;
-        dependsOn: z.ZodArray<z.ZodString>;
-        order: z.ZodString;
-        description: z.ZodString;
-        references: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type BoardDocument = z.infer<typeof BoardDocument>;
-export declare const BoardMaxTaskDepth = 5;
-export declare const GetBoardInput: z.ZodObject<{
-    nodeId: z.ZodString;
-}, z.core.$strict>;
-export type GetBoardInput = z.infer<typeof GetBoardInput>;
-export declare const NodeBoard: z.ZodObject<{
-    node: z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    board: z.ZodObject<{
-        statuses: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            label: z.ZodString;
-            order: z.ZodNumber;
-            terminal: z.ZodBoolean;
-        }, z.core.$strict>>;
-        tasks: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            title: z.ZodString;
-            status: z.ZodString;
-            assignee: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                type: z.ZodLiteral<"user">;
-                id: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                type: z.ZodLiteral<"agent">;
-                nodeId: z.ZodString;
-            }, z.core.$strict>], "type">>;
-            labels: z.ZodArray<z.ZodString>;
-            startDate: z.ZodNullable<z.ZodISODate>;
-            dueDate: z.ZodNullable<z.ZodISODate>;
-            parentId: z.ZodNullable<z.ZodString>;
-            dependsOn: z.ZodArray<z.ZodString>;
-            order: z.ZodString;
-            description: z.ZodString;
-            references: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-    versionId: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
-export type NodeBoard = z.infer<typeof NodeBoard>;
-export declare const BoardStatusInput: z.ZodObject<{
-    id: z.ZodString;
-    label: z.ZodString;
-    terminal: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export type BoardStatusInput = z.infer<typeof BoardStatusInput>;
-export declare const ConfigureBoardInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    statuses: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        label: z.ZodString;
-        terminal: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type ConfigureBoardInput = z.infer<typeof ConfigureBoardInput>;
-/**
- * A new task (#285).
- *
- * ⚠️ No `baseVersionId`, on this and on every other task operation, and that absence is the
- * feature. A board is addressed by stable task id and never by position, so two agents touching two
- * different tasks cannot collide — demanding a base version would invent the `version_conflict`
- * that #285 exists to remove, and force every caller to read the whole board first.
- */
-export declare const AddBoardTaskInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    title: z.ZodString;
-    status: z.ZodOptional<z.ZodString>;
-    assignee: z.ZodDefault<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"user">;
-        id: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        type: z.ZodLiteral<"agent">;
-        nodeId: z.ZodString;
-    }, z.core.$strict>], "type">>>;
-    labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    startDate: z.ZodDefault<z.ZodNullable<z.ZodISODate>>;
-    dueDate: z.ZodDefault<z.ZodNullable<z.ZodISODate>>;
-    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    description: z.ZodDefault<z.ZodString>;
-    references: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    afterTaskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    beforeTaskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type AddBoardTaskInput = z.infer<typeof AddBoardTaskInput>;
-/**
- * What a task says about itself.
- *
- * ⚠️ Deliberately no `status`, no `parentId` and no `order`: where a task SITS is a move, and a
- * move is the operation that has to mint an order key and re-check the two cycle rules. Folding
- * both into one call would mean every field edit pays for those checks and every move could quietly
- * rewrite a description.
- */
-export declare const UpdateBoardTaskInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    taskId: z.ZodString;
-    title: z.ZodOptional<z.ZodString>;
-    assignee: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"user">;
-        id: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        type: z.ZodLiteral<"agent">;
-        nodeId: z.ZodString;
-    }, z.core.$strict>], "type">>>;
-    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    startDate: z.ZodOptional<z.ZodNullable<z.ZodISODate>>;
-    dueDate: z.ZodOptional<z.ZodNullable<z.ZodISODate>>;
-    dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    description: z.ZodOptional<z.ZodString>;
-    references: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type UpdateBoardTaskInput = z.infer<typeof UpdateBoardTaskInput>;
-export declare const MoveBoardTaskInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    taskId: z.ZodString;
-    status: z.ZodOptional<z.ZodString>;
-    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    afterTaskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    beforeTaskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type MoveBoardTaskInput = z.infer<typeof MoveBoardTaskInput>;
-export declare const DeleteBoardTaskInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    taskId: z.ZodString;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type DeleteBoardTaskInput = z.infer<typeof DeleteBoardTaskInput>;
-/**
- * The way out of a board whose `tasks[]` names one id twice (anchrd/intel#341).
- *
- * ⚠️ It names no task, and that is not an oversight. Such a board holds a pair the caller cannot
- * tell apart — every other operation here addresses a task BY id (#285), so the one thing nobody
- * can say is "the second of the two". The board is what is named, and the server does the one thing
- * that removes the ambiguity: the first entry under an id keeps it, every later one gets a freshly
- * minted id and keeps everything else it carries.
- *
- * ⚠️ It exists because the pair is deliberately NOT folded away on read (`upgradeStoredBoard`,
- * `repeatedBoardId`): two tasks under one id are two whole tasks, and a fold on the read is written
- * back by the next save of any kind. So somebody has to ask for the repair, and this is the asking.
- */
-export declare const RepairBoardTaskIdsInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type RepairBoardTaskIdsInput = z.infer<typeof RepairBoardTaskIdsInput>;
-export declare const BoardTaskResult: z.ZodObject<{
-    node: z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    version: z.ZodObject<{
-        id: z.ZodString;
-        nodeId: z.ZodString;
-        sequence: z.ZodNumber;
-        contentKey: z.ZodString;
-        mediaType: z.ZodString;
-        contentHash: z.ZodString;
-        size: z.ZodNumber;
-        segment: z.ZodNullable<z.ZodEnum<{
-            append: "append";
-            snapshot: "snapshot";
-        }>>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>;
-    task: z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-        status: z.ZodString;
-        assignee: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            type: z.ZodLiteral<"user">;
-            id: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"agent">;
-            nodeId: z.ZodString;
-        }, z.core.$strict>], "type">>;
-        labels: z.ZodArray<z.ZodString>;
-        startDate: z.ZodNullable<z.ZodISODate>;
-        dueDate: z.ZodNullable<z.ZodISODate>;
-        parentId: z.ZodNullable<z.ZodString>;
-        dependsOn: z.ZodArray<z.ZodString>;
-        order: z.ZodString;
-        description: z.ZodString;
-        references: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type BoardTaskResult = z.infer<typeof BoardTaskResult>;
-export declare const DeleteBoardTaskResult: z.ZodObject<{
-    node: z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    version: z.ZodObject<{
-        id: z.ZodString;
-        nodeId: z.ZodString;
-        sequence: z.ZodNumber;
-        contentKey: z.ZodString;
-        mediaType: z.ZodString;
-        contentHash: z.ZodString;
-        size: z.ZodNumber;
-        segment: z.ZodNullable<z.ZodEnum<{
-            append: "append";
-            snapshot: "snapshot";
-        }>>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>;
-    deleted: z.ZodNumber;
-}, z.core.$strict>;
-export type DeleteBoardTaskResult = z.infer<typeof DeleteBoardTaskResult>;
-export declare const ConfigureBoardResult: z.ZodObject<{
-    node: z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    version: z.ZodObject<{
-        id: z.ZodString;
-        nodeId: z.ZodString;
-        sequence: z.ZodNumber;
-        contentKey: z.ZodString;
-        mediaType: z.ZodString;
-        contentHash: z.ZodString;
-        size: z.ZodNumber;
-        segment: z.ZodNullable<z.ZodEnum<{
-            append: "append";
-            snapshot: "snapshot";
-        }>>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>;
-    statuses: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        label: z.ZodString;
-        order: z.ZodNumber;
-        terminal: z.ZodBoolean;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type ConfigureBoardResult = z.infer<typeof ConfigureBoardResult>;
-/**
- * What the repair did, task by task (anchrd/intel#341).
- *
- * ⚠️ `previousId` is the id the entry shared, and it still names a task on this board — the FIRST
- * entry under it, the one that kept it. That is what makes the repair readable: nothing that
- * pointed at that id moved, so a caller can see which of the two the board's `parentId` and
- * `dependsOn` edges have been meaning all along, and move them with `board_task_move` and
- * `board_task_update` if they meant the other one.
- *
- * ⚠️ At least one entry, because a board with nothing to repair is refused rather than answered
- * with an empty list and a new version that changed nothing.
- */
-export declare const RepairBoardTaskIdsResult: z.ZodObject<{
-    node: z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    version: z.ZodObject<{
-        id: z.ZodString;
-        nodeId: z.ZodString;
-        sequence: z.ZodNumber;
-        contentKey: z.ZodString;
-        mediaType: z.ZodString;
-        contentHash: z.ZodString;
-        size: z.ZodNumber;
-        segment: z.ZodNullable<z.ZodEnum<{
-            append: "append";
-            snapshot: "snapshot";
-        }>>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>;
-    renumbered: z.ZodArray<z.ZodObject<{
-        previousId: z.ZodString;
-        task: z.ZodObject<{
-            id: z.ZodString;
-            title: z.ZodString;
-            status: z.ZodString;
-            assignee: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                type: z.ZodLiteral<"user">;
-                id: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                type: z.ZodLiteral<"agent">;
-                nodeId: z.ZodString;
-            }, z.core.$strict>], "type">>;
-            labels: z.ZodArray<z.ZodString>;
-            startDate: z.ZodNullable<z.ZodISODate>;
-            dueDate: z.ZodNullable<z.ZodISODate>;
-            parentId: z.ZodNullable<z.ZodString>;
-            dependsOn: z.ZodArray<z.ZodString>;
-            order: z.ZodString;
-            description: z.ZodString;
-            references: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type RepairBoardTaskIdsResult = z.infer<typeof RepairBoardTaskIdsResult>;
-export declare const AgentMediaType = "application/vnd.anchrd.agent+json";
-export declare const AgentReferenceRole: z.ZodEnum<{
-    "system-message": "system-message";
-    "semantic-context": "semantic-context";
-    memory: "memory";
-}>;
-export type AgentReferenceRole = z.infer<typeof AgentReferenceRole>;
-export declare const AgentReference: z.ZodObject<{
-    nodeId: z.ZodString;
-    role: z.ZodEnum<{
-        "system-message": "system-message";
-        "semantic-context": "semantic-context";
-        memory: "memory";
-    }>;
-}, z.core.$strict>;
-export type AgentReference = z.infer<typeof AgentReference>;
-/**
- * Which kinds of node each role can actually be given (#255).
- *
- * ⚠️ Not every role takes every kind, and the reasons are about what the runtime DOES with a
- * reference rather than about tidiness:
- *
- *   `memory` is a folder because the agent WRITES there — `agent_remember` creates a note inside
- *   it. A single document as memory would mean the agent overwrites the document it was given.
- *
- *   `semantic-context` is a folder because it is a search SPACE, searched per folder by
- *   `loop/scoped-search`. A single document is not a narrower search space; reading it whole is a
- *   different behaviour, and one that gets named before it is introduced, not slipped in.
- *
- *   `system-message` reads single nodes already and takes a document or a table as well as a
- *   folder. A document is the natural case — a skill somebody wrote as ordinary text — and a table
- *   is the same read: the runtime asks intel for the node and prepends its content, which for a
- *   table is its CSV.
- *
- * ⚠️ `folder` stays on `system-message` although a folder carries no content of its own. Every
- * definition written before #255 could only name folders, and taking the combination away here
- * would refuse the next save of an agent that has been working for months — "existing definitions
- * stay valid" is not only about reading them.
- *
- * ⚠️ This is the ONE place the rule lives. The screen offers what it says and the write path
- * refuses what it forbids; a surface that made its own list would eventually disagree with the
- * other, and the one that matters is whichever runs last.
- */
-export declare const AgentReferenceKinds: {
-    readonly "system-message": readonly ["folder", "document", "table"];
-    readonly "semantic-context": readonly ["folder"];
-    readonly memory: readonly ["folder"];
-};
-export declare function agentReferenceAccepts(role: AgentReferenceRole, kind: NodeKind): boolean;
-/** The roles a node of this kind may be given — the same rule, read from the other side. */
-export declare function agentReferenceRolesFor(kind: NodeKind): AgentReferenceRole[];
-export declare const AgentScheduleTarget: z.ZodObject<{
-    kind: z.ZodEnum<{
-        document: "document";
-        flow: "flow";
-    }>;
-    id: z.ZodString;
-}, z.core.$strict>;
-export type AgentScheduleTarget = z.infer<typeof AgentScheduleTarget>;
-export declare const AgentSchedule: z.ZodObject<{
-    cron: z.ZodString;
-    timezone: z.ZodDefault<z.ZodString>;
-    target: z.ZodObject<{
-        kind: z.ZodEnum<{
-            document: "document";
-            flow: "flow";
-        }>;
-        id: z.ZodString;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type AgentSchedule = z.infer<typeof AgentSchedule>;
-export declare const AgentModel: z.ZodObject<{
-    provider: z.ZodEnum<{
-        "workers-ai": "workers-ai";
-        anthropic: "anthropic";
-    }>;
-    model: z.ZodString;
-}, z.core.$strict>;
-export type AgentModel = z.infer<typeof AgentModel>;
-/**
- * One MCP server as the portal names it. The handle is what the portal puts in front of every tool
- * that server offers (`notion_notion-search` belongs to `notion`), and it is the only identifier
- * Intel can both store and recognise again in a live `tools/list`.
- *
- * ⚠️ A handle is never invented from a tool name. Which servers exist is the portal's answer
- * (`portal_list_servers`), and the prefix is only used to attribute a tool to a server that answer
- * already named — see `packages/api/src/tools/tool-servers` for why splitting on the underscore
- * alone would be ambiguous.
- */
-export declare const ToolServerHandle: z.ZodString;
-export type ToolServerHandle = z.infer<typeof ToolServerHandle>;
-/**
- * What a caller may ASK for: whole MCP servers, and nothing about who delegates them (D30).
- *
- * ⚠️ The absence of `delegatedBy` is the point, and it is why the write shape differs from the read
- * shape at all. Intel writes that field from the session it authorized; a caller who could name
- * somebody else would be handing an agent a portal connection they do not have, and the agent would
- * act on it unattended. Leaving the field out of the input makes that structural instead of a
- * runtime overwrite: a body carrying it is a parse error at the boundary, on every surface, and no
- * screen ever has to invent a value it has no business knowing.
- */
-export declare const AgentToolSelection: z.ZodObject<{
-    servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-export type AgentToolSelection = z.infer<typeof AgentToolSelection>;
-/**
- * What is STORED and read back: the selection plus whose portal connection it came from (D30).
- *
- * ⚠️ This is a selection, not a permission. Nothing here grants anything: whether a server is
- * reachable is still decided by one live `tools/list` with `delegatedBy`'s own portal token, so a
- * delegator who loses the server or the connection takes it away from the agent at the next run
- * with no edit to this document.
- *
- * ⚠️ Read shape only. It appears in `AgentDefinition` and never in an input — see
- * `AgentToolSelection` for why the two are deliberately different documents rather than one schema
- * with an optional field.
- */
-export declare const AgentToolDelegation: z.ZodObject<{
-    delegatedBy: z.ZodString;
-    servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-export type AgentToolDelegation = z.infer<typeof AgentToolDelegation>;
-export declare const AgentDefinition: z.ZodObject<{
-    tools: z.ZodDefault<z.ZodNullable<z.ZodObject<{
-        delegatedBy: z.ZodString;
-        servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>>;
-    references: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        nodeId: z.ZodString;
-        role: z.ZodEnum<{
-            "system-message": "system-message";
-            "semantic-context": "semantic-context";
-            memory: "memory";
-        }>;
-    }, z.core.$strict>>>;
-    schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        cron: z.ZodString;
-        timezone: z.ZodDefault<z.ZodString>;
-        target: z.ZodObject<{
-            kind: z.ZodEnum<{
-                document: "document";
-                flow: "flow";
-            }>;
-            id: z.ZodString;
-        }, z.core.$strict>;
-    }, z.core.$strict>>>;
-    model: z.ZodObject<{
-        provider: z.ZodEnum<{
-            "workers-ai": "workers-ai";
-            anthropic: "anthropic";
-        }>;
-        model: z.ZodString;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type AgentDefinition = z.infer<typeof AgentDefinition>;
-/**
- * The same document as `AgentDefinition`, minus the one field a caller may not write.
- *
- * ⚠️ Two schemas rather than one, and the split is load-bearing (#208, D30). Everything an agent IS
- * comes from whoever edits it; **whose portal connection it acts on** does not, because that is an
- * authority the editor would be granting to themselves. So the write shape simply has no place to
- * put it: `{ tools: { servers: [...] } }` is what a screen or an MCP client sends, Intel adds
- * `delegatedBy` from the session, and a body that tries to name one is refused by the strict object
- * before any of it is read. The reading shape keeps the field because a reader must be able to see
- * whose connection an agent runs on.
- */
-export declare const AgentDefinitionInput: z.ZodObject<{
-    tools: z.ZodDefault<z.ZodNullable<z.ZodObject<{
-        servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>>;
-    references: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        nodeId: z.ZodString;
-        role: z.ZodEnum<{
-            "system-message": "system-message";
-            "semantic-context": "semantic-context";
-            memory: "memory";
-        }>;
-    }, z.core.$strict>>>;
-    schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        cron: z.ZodString;
-        timezone: z.ZodDefault<z.ZodString>;
-        target: z.ZodObject<{
-            kind: z.ZodEnum<{
-                document: "document";
-                flow: "flow";
-            }>;
-            id: z.ZodString;
-        }, z.core.$strict>;
-    }, z.core.$strict>>>;
-    model: z.ZodObject<{
-        provider: z.ZodEnum<{
-            "workers-ai": "workers-ai";
-            anthropic: "anthropic";
-        }>;
-        model: z.ZodString;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type AgentDefinitionInput = z.infer<typeof AgentDefinitionInput>;
-export declare const SaveAgentDefinitionInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    baseVersionId: z.ZodNullable<z.ZodString>;
-    definition: z.ZodObject<{
-        tools: z.ZodDefault<z.ZodNullable<z.ZodObject<{
-            servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>>;
-        references: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            nodeId: z.ZodString;
-            role: z.ZodEnum<{
-                "system-message": "system-message";
-                "semantic-context": "semantic-context";
-                memory: "memory";
-            }>;
-        }, z.core.$strict>>>;
-        schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            cron: z.ZodString;
-            timezone: z.ZodDefault<z.ZodString>;
-            target: z.ZodObject<{
-                kind: z.ZodEnum<{
-                    document: "document";
-                    flow: "flow";
-                }>;
-                id: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>>>;
-        model: z.ZodObject<{
-            provider: z.ZodEnum<{
-                "workers-ai": "workers-ai";
-                anthropic: "anthropic";
-            }>;
-            model: z.ZodString;
-        }, z.core.$strict>;
-    }, z.core.$strict>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type SaveAgentDefinitionInput = z.infer<typeof SaveAgentDefinitionInput>;
-export declare const GetAgentInput: z.ZodObject<{
-    nodeId: z.ZodString;
-}, z.core.$strict>;
-export type GetAgentInput = z.infer<typeof GetAgentInput>;
-export declare const PauseAgentInput: z.ZodObject<{
-    nodeId: z.ZodString;
-}, z.core.$strict>;
-export type PauseAgentInput = z.infer<typeof PauseAgentInput>;
-export declare const RunAgentNowInput: z.ZodObject<{
-    nodeId: z.ZodString;
-    target: z.ZodObject<{
-        kind: z.ZodEnum<{
-            document: "document";
-            flow: "flow";
-        }>;
-        id: z.ZodString;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type RunAgentNowInput = z.infer<typeof RunAgentNowInput>;
-/**
- * What one agent has actually cost, read out of Cloudflare's AI Gateway log (#251).
- *
- * ⚠️ Intel computes none of this from tokens and a price table. The gateway publishes the billed
- * figure per call, and that figure is the debit from the Cloudflare balance 1:1 — Cloudflare takes
- * its 5 % when the balance is loaded and passes inference through unchanged (measured 2026-08-07).
- * A second, self-maintained answer beside it would be wrong on the day the two disagreed, and the
- * wrong one would be the one on screen.
- *
- * ⚠️ `status` travels with the numbers and may never be dropped. `runs: []` means "cost nothing"
- * only when `status` is `read`; under `not_configured` or `unreadable` it means "not known", and a
- * screen that renders the two alike reports an outage as a saving.
- */
-export declare const AgentCostStatus: z.ZodEnum<{
-    read: "read";
-    not_configured: "not_configured";
-    unreadable: "unreadable";
-}>;
-export type AgentCostStatus = z.infer<typeof AgentCostStatus>;
-export declare const AgentRunCost: z.ZodObject<{
-    runId: z.ZodString;
-    cost: z.ZodNumber;
-    calls: z.ZodNumber;
-}, z.core.$strict>;
-export type AgentRunCost = z.infer<typeof AgentRunCost>;
-export declare const AgentCostWindow: z.ZodObject<{
-    days: z.ZodNumber;
-    cost: z.ZodNumber;
-    calls: z.ZodNumber;
-    models: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export type AgentCostWindow = z.infer<typeof AgentCostWindow>;
-export declare const AgentCosts: z.ZodObject<{
-    status: z.ZodEnum<{
-        read: "read";
-        not_configured: "not_configured";
-        unreadable: "unreadable";
-    }>;
-    currency: z.ZodLiteral<"USD">;
-    runs: z.ZodArray<z.ZodObject<{
-        runId: z.ZodString;
-        cost: z.ZodNumber;
-        calls: z.ZodNumber;
-    }, z.core.$strict>>;
-    windows: z.ZodArray<z.ZodObject<{
-        days: z.ZodNumber;
-        cost: z.ZodNumber;
-        calls: z.ZodNumber;
-        models: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>>;
-    partial: z.ZodBoolean;
-}, z.core.$strict>;
-export type AgentCosts = z.infer<typeof AgentCosts>;
-/**
- * What the models on offer cost and how much they hold (#257).
- *
- * ⚠️ `source` is per ENTRY and not per response, and that is not over-engineering. Cloudflare
- * publishes figures for the models it serves itself and none at all for the Anthropic models it
- * resells through Unified Billing — so a perfectly healthy read still leaves half the list on a
- * written-out table, and one flag for the whole answer would call either the read stale or the
- * table live.
- */
-export declare const ModelPrice: z.ZodObject<{
-    inputPerMillion: z.ZodNumber;
-    outputPerMillion: z.ZodNumber;
-}, z.core.$strict>;
-export type ModelPrice = z.infer<typeof ModelPrice>;
-export declare const ModelCatalogEntry: z.ZodObject<{
-    provider: z.ZodEnum<{
-        "workers-ai": "workers-ai";
-        anthropic: "anthropic";
-    }>;
-    model: z.ZodString;
-    name: z.ZodString;
-    contextTokens: z.ZodNullable<z.ZodNumber>;
-    price: z.ZodNullable<z.ZodObject<{
-        inputPerMillion: z.ZodNumber;
-        outputPerMillion: z.ZodNumber;
-    }, z.core.$strict>>;
-    source: z.ZodEnum<{
-        cloudflare: "cloudflare";
-        builtin: "builtin";
-    }>;
-}, z.core.$strict>;
-export type ModelCatalogEntry = z.infer<typeof ModelCatalogEntry>;
-export declare const ModelCatalog: z.ZodObject<{
-    entries: z.ZodArray<z.ZodObject<{
-        provider: z.ZodEnum<{
-            "workers-ai": "workers-ai";
-            anthropic: "anthropic";
-        }>;
-        model: z.ZodString;
-        name: z.ZodString;
-        contextTokens: z.ZodNullable<z.ZodNumber>;
-        price: z.ZodNullable<z.ZodObject<{
-            inputPerMillion: z.ZodNumber;
-            outputPerMillion: z.ZodNumber;
-        }, z.core.$strict>>;
-        source: z.ZodEnum<{
-            cloudflare: "cloudflare";
-            builtin: "builtin";
-        }>;
-    }, z.core.$strict>>;
-    liveStatus: z.ZodEnum<{
-        read: "read";
-        not_configured: "not_configured";
-        unreadable: "unreadable";
-    }>;
-}, z.core.$strict>;
-export type ModelCatalog = z.infer<typeof ModelCatalog>;
-export declare const ListAgentsInput: z.ZodObject<{
-    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    includeArchived: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strict>;
-export type ListAgentsInput = z.infer<typeof ListAgentsInput>;
-export declare const CreateAgentInput: z.ZodObject<{
-    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    title: z.ZodString;
-    description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    definition: z.ZodObject<{
-        tools: z.ZodDefault<z.ZodNullable<z.ZodObject<{
-            servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>>;
-        references: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            nodeId: z.ZodString;
-            role: z.ZodEnum<{
-                "system-message": "system-message";
-                "semantic-context": "semantic-context";
-                memory: "memory";
-            }>;
-        }, z.core.$strict>>>;
-        schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            cron: z.ZodString;
-            timezone: z.ZodDefault<z.ZodString>;
-            target: z.ZodObject<{
-                kind: z.ZodEnum<{
-                    document: "document";
-                    flow: "flow";
-                }>;
-                id: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>>>;
-        model: z.ZodObject<{
-            provider: z.ZodEnum<{
-                "workers-ai": "workers-ai";
-                anthropic: "anthropic";
-            }>;
-            model: z.ZodString;
-        }, z.core.$strict>;
-    }, z.core.$strict>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type CreateAgentInput = z.infer<typeof CreateAgentInput>;
-export declare const GateApplicationId: z.ZodString;
-export declare const NodeAgent: z.ZodObject<{
-    node: z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    version: z.ZodNullable<z.ZodObject<{
-        id: z.ZodString;
-        nodeId: z.ZodString;
-        sequence: z.ZodNumber;
-        contentKey: z.ZodString;
-        mediaType: z.ZodString;
-        contentHash: z.ZodString;
-        size: z.ZodNumber;
-        segment: z.ZodNullable<z.ZodEnum<{
-            append: "append";
-            snapshot: "snapshot";
-        }>>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
-    definition: z.ZodNullable<z.ZodObject<{
-        tools: z.ZodDefault<z.ZodNullable<z.ZodObject<{
-            delegatedBy: z.ZodString;
-            servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>>;
-        references: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            nodeId: z.ZodString;
-            role: z.ZodEnum<{
-                "system-message": "system-message";
-                "semantic-context": "semantic-context";
-                memory: "memory";
-            }>;
-        }, z.core.$strict>>>;
-        schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            cron: z.ZodString;
-            timezone: z.ZodDefault<z.ZodString>;
-            target: z.ZodObject<{
-                kind: z.ZodEnum<{
-                    document: "document";
-                    flow: "flow";
-                }>;
-                id: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>>>;
-        model: z.ZodObject<{
-            provider: z.ZodEnum<{
-                "workers-ai": "workers-ai";
-                anthropic: "anthropic";
-            }>;
-            model: z.ZodString;
-        }, z.core.$strict>;
-    }, z.core.$strict>>;
-    applicationId: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
-export type NodeAgent = z.infer<typeof NodeAgent>;
-/**
- * ⚠️ There is NO key field in this file, and adding one back would be the regression (D29, #207).
- *
- * Until #207 the create answer carried the Application key in plain text, once, and a person had to
- * carry it into a Worker secret by hand — which is why an agent created through the screen could
- * never run (#200). The key now goes from Gate straight into the agent runtime over Intel's service
- * binding and is encrypted into that agent's Durable Object; it reaches no browser, no MCP tool
- * result and no response body at all. `NodeAgent` is a `z.strictObject`, so a field named `key`
- * added anywhere in this file is a parse error at the boundary rather than a leak somebody has to
- * spot in review.
- *
- * What `POST /nodes/agents` and `agent_create` answer is therefore exactly what every read answers:
- * the node, its first definition, and the `applicationId` that NAMES the principal without
- * authenticating it.
- */
-export declare const CreatedAgent: z.ZodObject<{
-    node: z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    version: z.ZodNullable<z.ZodObject<{
-        id: z.ZodString;
-        nodeId: z.ZodString;
-        sequence: z.ZodNumber;
-        contentKey: z.ZodString;
-        mediaType: z.ZodString;
-        contentHash: z.ZodString;
-        size: z.ZodNumber;
-        segment: z.ZodNullable<z.ZodEnum<{
-            append: "append";
-            snapshot: "snapshot";
-        }>>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
-    definition: z.ZodNullable<z.ZodObject<{
-        tools: z.ZodDefault<z.ZodNullable<z.ZodObject<{
-            delegatedBy: z.ZodString;
-            servers: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>>;
-        references: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            nodeId: z.ZodString;
-            role: z.ZodEnum<{
-                "system-message": "system-message";
-                "semantic-context": "semantic-context";
-                memory: "memory";
-            }>;
-        }, z.core.$strict>>>;
-        schedules: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            cron: z.ZodString;
-            timezone: z.ZodDefault<z.ZodString>;
-            target: z.ZodObject<{
-                kind: z.ZodEnum<{
-                    document: "document";
-                    flow: "flow";
-                }>;
-                id: z.ZodString;
-            }, z.core.$strict>;
-        }, z.core.$strict>>>;
-        model: z.ZodObject<{
-            provider: z.ZodEnum<{
-                "workers-ai": "workers-ai";
-                anthropic: "anthropic";
-            }>;
-            model: z.ZodString;
-        }, z.core.$strict>;
-    }, z.core.$strict>>;
-    applicationId: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
-export type CreatedAgent = z.infer<typeof CreatedAgent>;
-export declare const RotateAgentKeyInput: z.ZodObject<{
-    nodeId: z.ZodString;
-}, z.core.$strict>;
-export type RotateAgentKeyInput = z.infer<typeof RotateAgentKeyInput>;
-/**
- * What replacing an agent's key answers.
- *
- * ⚠️ No key, and that is the whole shape of D29: Intel asks Gate for a new one, hands it to the
- * runtime over the service binding, and forgets it inside the same call. What the caller gets is
- * the fact that it happened, so a screen can say so — `applicationId` names the principal whose key
- * was replaced, which is a name and not a credential.
- */
-export declare const AgentKeyRotated: z.ZodObject<{
-    nodeId: z.ZodString;
-    applicationId: z.ZodString;
-    rotatedAt: z.ZodISODateTime;
-}, z.core.$strict>;
-export type AgentKeyRotated = z.infer<typeof AgentKeyRotated>;
-export declare const AgentList: z.ZodObject<{
-    items: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type AgentList = z.infer<typeof AgentList>;
-export declare const NodeLinkRelation: z.ZodEnum<{
-    references: "references";
-    related: "related";
-    depends_on: "depends_on";
-    implements: "implements";
-}>;
-export type NodeLinkRelation = z.infer<typeof NodeLinkRelation>;
-export declare const NodeLinkOrigin: z.ZodEnum<{
-    text: "text";
-    manual: "manual";
-}>;
-export type NodeLinkOrigin = z.infer<typeof NodeLinkOrigin>;
-export declare const NodeLink: z.ZodObject<{
-    id: z.ZodString;
-    sourceNodeId: z.ZodString;
-    targetNodeId: z.ZodString;
-    relation: z.ZodEnum<{
-        references: "references";
-        related: "related";
-        depends_on: "depends_on";
-        implements: "implements";
-    }>;
-    origin: z.ZodEnum<{
-        text: "text";
-        manual: "manual";
-    }>;
-    label: z.ZodNullable<z.ZodString>;
-    createdBy: z.ZodString;
-    createdAt: z.ZodISODateTime;
-}, z.core.$strict>;
-export type NodeLink = z.infer<typeof NodeLink>;
-export declare const NodeLinkList: z.ZodObject<{
-    items: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        sourceNodeId: z.ZodString;
-        targetNodeId: z.ZodString;
-        relation: z.ZodEnum<{
-            references: "references";
-            related: "related";
-            depends_on: "depends_on";
-            implements: "implements";
-        }>;
-        origin: z.ZodEnum<{
-            text: "text";
-            manual: "manual";
-        }>;
-        label: z.ZodNullable<z.ZodString>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type NodeLinkList = z.infer<typeof NodeLinkList>;
-export declare const DocumentLinkInlineType = "documentLink";
-export declare const ResolveNodeLinksInput: z.ZodObject<{
-    nodeIds: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export type ResolveNodeLinksInput = z.infer<typeof ResolveNodeLinksInput>;
-export declare const ResolvedNodeLink: z.ZodObject<{
-    nodeId: z.ZodString;
-    title: z.ZodString;
-}, z.core.$strict>;
-export type ResolvedNodeLink = z.infer<typeof ResolvedNodeLink>;
-export declare const ResolveNodeLinksResult: z.ZodObject<{
-    items: z.ZodArray<z.ZodObject<{
-        nodeId: z.ZodString;
-        title: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type ResolveNodeLinksResult = z.infer<typeof ResolveNodeLinksResult>;
-export declare const NodeGraphInput: z.ZodObject<{
-    limit: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strict>;
-export type NodeGraphInput = z.infer<typeof NodeGraphInput>;
-export declare const NodeGraph: z.ZodObject<{
-    nodes: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>>;
-    links: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        sourceNodeId: z.ZodString;
-        targetNodeId: z.ZodString;
-        relation: z.ZodEnum<{
-            references: "references";
-            related: "related";
-            depends_on: "depends_on";
-            implements: "implements";
-        }>;
-        origin: z.ZodEnum<{
-            text: "text";
-            manual: "manual";
-        }>;
-        label: z.ZodNullable<z.ZodString>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type NodeGraph = z.infer<typeof NodeGraph>;
-export declare const BlockNoteMediaType = "application/vnd.anchrd.intel.blocknote+json";
-export declare const BlockNoteDocument: z.ZodObject<{
-    format: z.ZodLiteral<"blocknote">;
-    schemaVersion: z.ZodLiteral<1>;
-    blocks: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    markdown: z.ZodString;
-}, z.core.$strict>;
-export type BlockNoteDocument = z.infer<typeof BlockNoteDocument>;
-export declare const ResourceGrant: z.ZodObject<{
-    id: z.ZodString;
-    resourceId: z.ZodString;
-    principal: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"user">;
-        id: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        type: z.ZodLiteral<"email">;
-        email: z.ZodEmail;
-    }, z.core.$strict>, z.ZodObject<{
-        type: z.ZodLiteral<"organization">;
-    }, z.core.$strict>], "type">;
-    verb: z.ZodEnum<{
-        read: "read";
-        write: "write";
-        execute: "execute";
-        share: "share";
-    }>;
-    expiresAt: z.ZodNullable<z.ZodISODateTime>;
-    createdBy: z.ZodString;
-    createdAt: z.ZodISODateTime;
-}, z.core.$strict>;
-export type ResourceGrant = z.infer<typeof ResourceGrant>;
-export declare const ShareInput: z.ZodObject<{
-    resourceId: z.ZodString;
-    principal: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"user">;
-        id: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        type: z.ZodLiteral<"email">;
-        email: z.ZodEmail;
-    }, z.core.$strict>, z.ZodObject<{
-        type: z.ZodLiteral<"organization">;
-    }, z.core.$strict>], "type">;
-    verb: z.ZodEnum<{
-        read: "read";
-        write: "write";
-        execute: "execute";
-        share: "share";
-    }>;
-    expiresAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type ShareInput = z.infer<typeof ShareInput>;
-export declare const RevokeGrantInput: z.ZodObject<{
-    resourceId: z.ZodString;
-    grantId: z.ZodString;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type RevokeGrantInput = z.infer<typeof RevokeGrantInput>;
-export declare const UnreadableNodes: z.ZodObject<{
-    titles: z.ZodArray<z.ZodString>;
-    hidden: z.ZodNumber;
-}, z.core.$strict>;
-export type UnreadableNodes = z.infer<typeof UnreadableNodes>;
-export declare const ShareResult: z.ZodObject<{
-    grant: z.ZodObject<{
-        id: z.ZodString;
-        resourceId: z.ZodString;
-        principal: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            type: z.ZodLiteral<"user">;
-            id: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"email">;
-            email: z.ZodEmail;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"organization">;
-        }, z.core.$strict>], "type">;
-        verb: z.ZodEnum<{
-            read: "read";
-            write: "write";
-            execute: "execute";
-            share: "share";
-        }>;
-        expiresAt: z.ZodNullable<z.ZodISODateTime>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>;
-    unreadable: z.ZodObject<{
-        titles: z.ZodArray<z.ZodString>;
-        hidden: z.ZodNumber;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-export type ShareResult = z.infer<typeof ShareResult>;
-export declare const ResourceGrantList: z.ZodObject<{
-    resourceId: z.ZodString;
-    applicableVerbs: z.ZodArray<z.ZodEnum<{
-        read: "read";
-        write: "write";
-        execute: "execute";
-        share: "share";
-    }>>;
-    items: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        resourceId: z.ZodString;
-        principal: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            type: z.ZodLiteral<"user">;
-            id: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"email">;
-            email: z.ZodEmail;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"organization">;
-        }, z.core.$strict>], "type">;
-        verb: z.ZodEnum<{
-            read: "read";
-            write: "write";
-            execute: "execute";
-            share: "share";
-        }>;
-        expiresAt: z.ZodNullable<z.ZodISODateTime>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type ResourceGrantList = z.infer<typeof ResourceGrantList>;
-export declare const SearchInput: z.ZodObject<{
-    query: z.ZodString;
-    limit: z.ZodDefault<z.ZodNumber>;
-    scopeId: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type SearchInput = z.infer<typeof SearchInput>;
-export declare const NodeCitation: z.ZodObject<{
-    nodeId: z.ZodString;
-    versionId: z.ZodString;
-    title: z.ZodString;
-    passage: z.ZodString;
-    source: z.ZodString;
-    freshness: z.ZodISODateTime;
-    score: z.ZodNumber;
-    match: z.ZodEnum<{
-        lexical: "lexical";
-        semantic: "semantic";
-        hybrid: "hybrid";
-    }>;
-}, z.core.$strict>;
-export type NodeCitation = z.infer<typeof NodeCitation>;
-export declare const SearchResult: z.ZodObject<{
-    items: z.ZodArray<z.ZodObject<{
-        nodeId: z.ZodString;
-        versionId: z.ZodString;
-        title: z.ZodString;
-        passage: z.ZodString;
-        source: z.ZodString;
-        freshness: z.ZodISODateTime;
-        score: z.ZodNumber;
-        match: z.ZodEnum<{
-            lexical: "lexical";
-            semantic: "semantic";
-            hybrid: "hybrid";
-        }>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type SearchResult = z.infer<typeof SearchResult>;
-export declare const ReindexResult: z.ZodObject<{
-    queued: z.ZodNumber;
-}, z.core.$strict>;
-export type ReindexResult = z.infer<typeof ReindexResult>;
-export declare const RevokeGrantResult: z.ZodObject<{
-    revoked: z.ZodBoolean;
-}, z.core.$strict>;
-export type RevokeGrantResult = z.infer<typeof RevokeGrantResult>;
-export declare const ToolSourceUrl: z.ZodURL;
-export declare const ToolName: z.ZodString;
-export declare const ToolAnnotations: z.ZodObject<{
-    title: z.ZodOptional<z.ZodString>;
-    readOnlyHint: z.ZodOptional<z.ZodBoolean>;
-    destructiveHint: z.ZodOptional<z.ZodBoolean>;
-    idempotentHint: z.ZodOptional<z.ZodBoolean>;
-    openWorldHint: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export type ToolAnnotations = z.infer<typeof ToolAnnotations>;
-export declare const ToolCapability: z.ZodObject<{
-    name: z.ZodString;
-    title: z.ZodNullable<z.ZodString>;
-    description: z.ZodNullable<z.ZodString>;
-    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    outputSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    annotations: z.ZodObject<{
-        title: z.ZodOptional<z.ZodString>;
-        readOnlyHint: z.ZodOptional<z.ZodBoolean>;
-        destructiveHint: z.ZodOptional<z.ZodBoolean>;
-        idempotentHint: z.ZodOptional<z.ZodBoolean>;
-        openWorldHint: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>;
-    fingerprint: z.ZodString;
-}, z.core.$strict>;
-export type ToolCapability = z.infer<typeof ToolCapability>;
-export declare const ToolCatalog: z.ZodObject<{
-    portalConnected: z.ZodBoolean;
-    items: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        title: z.ZodNullable<z.ZodString>;
-        description: z.ZodNullable<z.ZodString>;
-        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        outputSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        annotations: z.ZodObject<{
-            title: z.ZodOptional<z.ZodString>;
-            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
-            destructiveHint: z.ZodOptional<z.ZodBoolean>;
-            idempotentHint: z.ZodOptional<z.ZodBoolean>;
-            openWorldHint: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>;
-        fingerprint: z.ZodString;
-    }, z.core.$strict>>;
-    reached: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-export type ToolCatalog = z.infer<typeof ToolCatalog>;
-/**
- * One MCP server the asking user reaches right now, as the portal itself names it (D30).
- *
- * ⚠️ `toolCount` is a fact about this moment and this user, not a size. It exists so a picker can
- * say "9 tools" instead of showing a handle alone, and it must never be read as what an agent will
- * get: the delegated run asks the portal again, with the delegator's token.
- */
-export declare const ToolServer: z.ZodObject<{
-    handle: z.ZodString;
-    name: z.ZodString;
-    toolCount: z.ZodNumber;
-}, z.core.$strict>;
-export type ToolServer = z.infer<typeof ToolServer>;
-export declare const ToolServerCatalog: z.ZodObject<{
-    portalConnected: z.ZodBoolean;
-    items: z.ZodArray<z.ZodObject<{
-        handle: z.ZodString;
-        name: z.ZodString;
-        toolCount: z.ZodNumber;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type ToolServerCatalog = z.infer<typeof ToolServerCatalog>;
-/**
- * Which of the named servers a tool belongs to, or `null` for none of them.
- *
- * ⚠️ THE TRAP: a tool name does not say where its server name ends.
- *
- * The portal writes `<server>_<tool>`, and both halves may contain underscores — `intel_flow_get`
- * reads equally well as server `intel` with tool `flow_get` and as a server called `intel_flow`
- * with tool `get`. Splitting on the first underscore is therefore a guess that is wrong the day
- * somebody adds a server whose name contains one, and on the API side being wrong means an agent
- * delegated server A quietly reaching server B.
- *
- * So the prefix is never split. It is only ever MATCHED against handles the portal itself named,
- * and the longest match wins: with `intel` and `intel_flow` both declared, `intel_flow_get` belongs
- * to `intel_flow`, which is the only reading in which both declarations stay true.
- *
- * ⚠️ This lives in the contract because HOW A NAME IS READ is a property of the wire, and both
- * surfaces read the same wire: `packages/api` cuts a delegation with it, `packages/ui` groups the
- * tools screen with it (#212). A second implementation in the browser would be the third answer to
- * one question — the underscore rule has already been answered differently in two places once
- * (#106, #107), and the copies disagreed. What deliberately stays OUT of here is everything about
- * reach: which handles are declared, which are enabled, which may be delegated and which one owns
- * the portal's own management tools are decisions with consequences, and they belong to
- * `packages/api/src/tools/tool-servers`. This function only reads a name.
- */
-export declare function serverOf(toolName: string, handles: Iterable<string>): string | null;
-export declare const TestToolInput: z.ZodObject<{
-    name: z.ZodString;
-    arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strict>;
-export type TestToolInput = z.infer<typeof TestToolInput>;
-export declare const ExecuteToolInput: z.ZodObject<{
-    name: z.ZodString;
-    arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strict>;
-export type ExecuteToolInput = z.infer<typeof ExecuteToolInput>;
-export declare const ToolTestResult: z.ZodObject<{
-    isError: z.ZodBoolean;
-    content: z.ZodArray<z.ZodUnknown>;
-    structuredContent: z.ZodOptional<z.ZodUnknown>;
-}, z.core.$strict>;
-export type ToolTestResult = z.infer<typeof ToolTestResult>;
-export declare const FlowNodeId: z.ZodString;
-export declare const FlowPosition: z.ZodObject<{
-    x: z.ZodNumber;
-    y: z.ZodNumber;
-}, z.core.$strict>;
-export declare const SubflowVersionMode: z.ZodEnum<{
-    latest: "latest";
-    follows: "follows";
-    pinned: "pinned";
-}>;
-export type SubflowVersionMode = z.infer<typeof SubflowVersionMode>;
-export declare const SubflowVersion: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    mode: z.ZodLiteral<"latest">;
-}, z.core.$strict>, z.ZodObject<{
-    mode: z.ZodLiteral<"follows">;
-}, z.core.$strict>, z.ZodObject<{
-    mode: z.ZodLiteral<"pinned">;
-    versionId: z.ZodString;
-}, z.core.$strict>], "mode">;
-export type SubflowVersion = z.infer<typeof SubflowVersion>;
-export declare const FlowNodeLayer: z.ZodEnum<{
-    marker: "marker";
-    step: "step";
-    link: "link";
-}>;
-export type FlowNodeLayer = z.infer<typeof FlowNodeLayer>;
-export declare const flowNodeLayer: {
-    readonly trigger: "marker";
-    readonly output: "marker";
-    readonly instruction: "step";
-    readonly condition: "step";
-    readonly subflow: "step";
-    readonly folder: "link";
-    readonly document: "link";
-    readonly upload: "link";
-    readonly table: "link";
-    readonly tool: "link";
-};
-export declare const FlowNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"trigger">;
-    configuration: z.ZodObject<{
-        mode: z.ZodLiteral<"manual">;
-    }, z.core.$strict>;
-    id: z.ZodString;
-    position: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, z.core.$strict>;
-    label: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"instruction">;
-    configuration: z.ZodObject<{
-        prompt: z.ZodString;
-    }, z.core.$strict>;
-    id: z.ZodString;
-    position: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, z.core.$strict>;
-    label: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"folder">;
-    configuration: z.ZodObject<{
-        resourceId: z.ZodString;
-    }, z.core.$strict>;
-    id: z.ZodString;
-    position: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, z.core.$strict>;
-    label: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"document">;
-    configuration: z.ZodObject<{
-        resourceId: z.ZodString;
-    }, z.core.$strict>;
-    id: z.ZodString;
-    position: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, z.core.$strict>;
-    label: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"upload">;
-    configuration: z.ZodObject<{
-        resourceId: z.ZodString;
-    }, z.core.$strict>;
-    id: z.ZodString;
-    position: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, z.core.$strict>;
-    label: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"table">;
-    configuration: z.ZodObject<{
-        resourceId: z.ZodString;
-    }, z.core.$strict>;
-    id: z.ZodString;
-    position: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, z.core.$strict>;
-    label: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"tool">;
-    configuration: z.ZodObject<{
-        toolName: z.ZodString;
-        fingerprint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-        arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strict>;
-    id: z.ZodString;
-    position: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, z.core.$strict>;
-    label: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"condition">;
-    configuration: z.ZodObject<{
-        mode: z.ZodLiteral<"semantic">;
-        instruction: z.ZodString;
-    }, z.core.$strict>;
-    id: z.ZodString;
-    position: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, z.core.$strict>;
-    label: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"subflow">;
-    configuration: z.ZodObject<{
-        flowId: z.ZodString;
-        version: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            mode: z.ZodLiteral<"latest">;
-        }, z.core.$strict>, z.ZodObject<{
-            mode: z.ZodLiteral<"follows">;
-        }, z.core.$strict>, z.ZodObject<{
-            mode: z.ZodLiteral<"pinned">;
-            versionId: z.ZodString;
-        }, z.core.$strict>], "mode">>;
-    }, z.core.$strict>;
-    id: z.ZodString;
-    position: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, z.core.$strict>;
-    label: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"output">;
-    configuration: z.ZodObject<{}, z.core.$strict>;
-    id: z.ZodString;
-    position: z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, z.core.$strict>;
-    label: z.ZodString;
-}, z.core.$strict>], "kind">;
-export type FlowNode = z.infer<typeof FlowNode>;
-export declare const FlowEdgeKind: z.ZodEnum<{
-    flow: "flow";
-    context: "context";
-}>;
-export type FlowEdgeKind = z.infer<typeof FlowEdgeKind>;
-export declare const FlowEdge: z.ZodObject<{
-    id: z.ZodString;
-    source: z.ZodString;
-    target: z.ZodString;
-    kind: z.ZodDefault<z.ZodEnum<{
-        flow: "flow";
-        context: "context";
-    }>>;
-    label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    sourceHandle: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-}, z.core.$strict>;
-export type FlowEdge = z.infer<typeof FlowEdge>;
-export declare const FlowGraph: z.ZodObject<{
-    nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"trigger">;
-        configuration: z.ZodObject<{
-            mode: z.ZodLiteral<"manual">;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"instruction">;
-        configuration: z.ZodObject<{
-            prompt: z.ZodString;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"folder">;
-        configuration: z.ZodObject<{
-            resourceId: z.ZodString;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"document">;
-        configuration: z.ZodObject<{
-            resourceId: z.ZodString;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"upload">;
-        configuration: z.ZodObject<{
-            resourceId: z.ZodString;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"table">;
-        configuration: z.ZodObject<{
-            resourceId: z.ZodString;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"tool">;
-        configuration: z.ZodObject<{
-            toolName: z.ZodString;
-            fingerprint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"condition">;
-        configuration: z.ZodObject<{
-            mode: z.ZodLiteral<"semantic">;
-            instruction: z.ZodString;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"subflow">;
-        configuration: z.ZodObject<{
-            flowId: z.ZodString;
-            version: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                mode: z.ZodLiteral<"latest">;
-            }, z.core.$strict>, z.ZodObject<{
-                mode: z.ZodLiteral<"follows">;
-            }, z.core.$strict>, z.ZodObject<{
-                mode: z.ZodLiteral<"pinned">;
-                versionId: z.ZodString;
-            }, z.core.$strict>], "mode">>;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"output">;
-        configuration: z.ZodObject<{}, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>], "kind">>;
-    edges: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        source: z.ZodString;
-        target: z.ZodString;
-        kind: z.ZodDefault<z.ZodEnum<{
-            flow: "flow";
-            context: "context";
-        }>>;
-        label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-        sourceHandle: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type FlowGraph = z.infer<typeof FlowGraph>;
-export declare const Flow: z.ZodObject<{
-    id: z.ZodString;
-    parentId: z.ZodNullable<z.ZodString>;
-    title: z.ZodString;
-    description: z.ZodNullable<z.ZodString>;
-    ownerId: z.ZodString;
-    currentVersionId: z.ZodNullable<z.ZodString>;
-    publishedVersionId: z.ZodNullable<z.ZodString>;
-    createdAt: z.ZodISODateTime;
-    updatedAt: z.ZodISODateTime;
-    archivedAt: z.ZodNullable<z.ZodISODateTime>;
-}, z.core.$strict>;
-export type Flow = z.infer<typeof Flow>;
-export declare const FlowVersion: z.ZodObject<{
-    id: z.ZodString;
-    flowId: z.ZodString;
-    sequence: z.ZodNumber;
-    graph: z.ZodObject<{
-        nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"trigger">;
-            configuration: z.ZodObject<{
-                mode: z.ZodLiteral<"manual">;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"instruction">;
-            configuration: z.ZodObject<{
-                prompt: z.ZodString;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"folder">;
-            configuration: z.ZodObject<{
-                resourceId: z.ZodString;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"document">;
-            configuration: z.ZodObject<{
-                resourceId: z.ZodString;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"upload">;
-            configuration: z.ZodObject<{
-                resourceId: z.ZodString;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"table">;
-            configuration: z.ZodObject<{
-                resourceId: z.ZodString;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"tool">;
-            configuration: z.ZodObject<{
-                toolName: z.ZodString;
-                fingerprint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-                arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"condition">;
-            configuration: z.ZodObject<{
-                mode: z.ZodLiteral<"semantic">;
-                instruction: z.ZodString;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"subflow">;
-            configuration: z.ZodObject<{
-                flowId: z.ZodString;
-                version: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    mode: z.ZodLiteral<"latest">;
-                }, z.core.$strict>, z.ZodObject<{
-                    mode: z.ZodLiteral<"follows">;
-                }, z.core.$strict>, z.ZodObject<{
-                    mode: z.ZodLiteral<"pinned">;
-                    versionId: z.ZodString;
-                }, z.core.$strict>], "mode">>;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"output">;
-            configuration: z.ZodObject<{}, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>], "kind">>;
-        edges: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            source: z.ZodString;
-            target: z.ZodString;
-            kind: z.ZodDefault<z.ZodEnum<{
-                flow: "flow";
-                context: "context";
-            }>>;
-            label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            sourceHandle: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-    createdBy: z.ZodString;
-    createdAt: z.ZodISODateTime;
-}, z.core.$strict>;
-export type FlowVersion = z.infer<typeof FlowVersion>;
-export declare const FlowDocument: z.ZodObject<{
-    flow: z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        publishedVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    version: z.ZodNullable<z.ZodObject<{
-        id: z.ZodString;
-        flowId: z.ZodString;
-        sequence: z.ZodNumber;
-        graph: z.ZodObject<{
-            nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"trigger">;
-                configuration: z.ZodObject<{
-                    mode: z.ZodLiteral<"manual">;
-                }, z.core.$strict>;
-                id: z.ZodString;
-                position: z.ZodObject<{
-                    x: z.ZodNumber;
-                    y: z.ZodNumber;
-                }, z.core.$strict>;
-                label: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"instruction">;
-                configuration: z.ZodObject<{
-                    prompt: z.ZodString;
-                }, z.core.$strict>;
-                id: z.ZodString;
-                position: z.ZodObject<{
-                    x: z.ZodNumber;
-                    y: z.ZodNumber;
-                }, z.core.$strict>;
-                label: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"folder">;
-                configuration: z.ZodObject<{
-                    resourceId: z.ZodString;
-                }, z.core.$strict>;
-                id: z.ZodString;
-                position: z.ZodObject<{
-                    x: z.ZodNumber;
-                    y: z.ZodNumber;
-                }, z.core.$strict>;
-                label: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"document">;
-                configuration: z.ZodObject<{
-                    resourceId: z.ZodString;
-                }, z.core.$strict>;
-                id: z.ZodString;
-                position: z.ZodObject<{
-                    x: z.ZodNumber;
-                    y: z.ZodNumber;
-                }, z.core.$strict>;
-                label: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"upload">;
-                configuration: z.ZodObject<{
-                    resourceId: z.ZodString;
-                }, z.core.$strict>;
-                id: z.ZodString;
-                position: z.ZodObject<{
-                    x: z.ZodNumber;
-                    y: z.ZodNumber;
-                }, z.core.$strict>;
-                label: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"table">;
-                configuration: z.ZodObject<{
-                    resourceId: z.ZodString;
-                }, z.core.$strict>;
-                id: z.ZodString;
-                position: z.ZodObject<{
-                    x: z.ZodNumber;
-                    y: z.ZodNumber;
-                }, z.core.$strict>;
-                label: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"tool">;
-                configuration: z.ZodObject<{
-                    toolName: z.ZodString;
-                    fingerprint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-                    arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                }, z.core.$strict>;
-                id: z.ZodString;
-                position: z.ZodObject<{
-                    x: z.ZodNumber;
-                    y: z.ZodNumber;
-                }, z.core.$strict>;
-                label: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"condition">;
-                configuration: z.ZodObject<{
-                    mode: z.ZodLiteral<"semantic">;
-                    instruction: z.ZodString;
-                }, z.core.$strict>;
-                id: z.ZodString;
-                position: z.ZodObject<{
-                    x: z.ZodNumber;
-                    y: z.ZodNumber;
-                }, z.core.$strict>;
-                label: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"subflow">;
-                configuration: z.ZodObject<{
-                    flowId: z.ZodString;
-                    version: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                        mode: z.ZodLiteral<"latest">;
-                    }, z.core.$strict>, z.ZodObject<{
-                        mode: z.ZodLiteral<"follows">;
-                    }, z.core.$strict>, z.ZodObject<{
-                        mode: z.ZodLiteral<"pinned">;
-                        versionId: z.ZodString;
-                    }, z.core.$strict>], "mode">>;
-                }, z.core.$strict>;
-                id: z.ZodString;
-                position: z.ZodObject<{
-                    x: z.ZodNumber;
-                    y: z.ZodNumber;
-                }, z.core.$strict>;
-                label: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"output">;
-                configuration: z.ZodObject<{}, z.core.$strict>;
-                id: z.ZodString;
-                position: z.ZodObject<{
-                    x: z.ZodNumber;
-                    y: z.ZodNumber;
-                }, z.core.$strict>;
-                label: z.ZodString;
-            }, z.core.$strict>], "kind">>;
-            edges: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                source: z.ZodString;
-                target: z.ZodString;
-                kind: z.ZodDefault<z.ZodEnum<{
-                    flow: "flow";
-                    context: "context";
-                }>>;
-                label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-                sourceHandle: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type FlowDocument = z.infer<typeof FlowDocument>;
-export declare const FlowVersionSummary: z.ZodObject<{
-    id: z.ZodString;
-    flowId: z.ZodString;
-    sequence: z.ZodNumber;
-    createdBy: z.ZodString;
-    createdAt: z.ZodISODateTime;
-    published: z.ZodBoolean;
-}, z.core.$strict>;
-export type FlowVersionSummary = z.infer<typeof FlowVersionSummary>;
-export declare const FlowVersionList: z.ZodObject<{
-    flowId: z.ZodString;
-    items: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        flowId: z.ZodString;
-        sequence: z.ZodNumber;
-        createdBy: z.ZodString;
-        createdAt: z.ZodISODateTime;
-        published: z.ZodBoolean;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type FlowVersionList = z.infer<typeof FlowVersionList>;
-export declare const GetFlowVersionInput: z.ZodObject<{
-    flowId: z.ZodString;
-    versionId: z.ZodString;
-}, z.core.$strict>;
-export type GetFlowVersionInput = z.infer<typeof GetFlowVersionInput>;
-export declare const FlowList: z.ZodObject<{
-    items: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        parentId: z.ZodNullable<z.ZodString>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        ownerId: z.ZodString;
-        currentVersionId: z.ZodNullable<z.ZodString>;
-        publishedVersionId: z.ZodNullable<z.ZodString>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        archivedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>>;
-    withCalls: z.ZodDefault<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-export type FlowList = z.infer<typeof FlowList>;
-export declare const ReferencedNode: z.ZodObject<{
-    id: z.ZodString;
-    title: z.ZodString;
-}, z.core.$strict>;
-export type ReferencedNode = z.infer<typeof ReferencedNode>;
-export declare const FlowRequirements: z.ZodObject<{
-    flowId: z.ZodString;
-    versionId: z.ZodNullable<z.ZodString>;
-    nodes: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-    }, z.core.$strict>>;
-    hiddenNodes: z.ZodNumber;
-    tools: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export type FlowRequirements = z.infer<typeof FlowRequirements>;
-export declare const FlowValidation: z.ZodObject<{
-    flowId: z.ZodString;
-    versionId: z.ZodNullable<z.ZodString>;
-    problems: z.ZodArray<z.ZodObject<{
-        code: z.ZodString;
-        detail: z.ZodString;
-    }, z.core.$strict>>;
-    checkedAt: z.ZodISODateTime;
-}, z.core.$strict>;
-export type FlowValidation = z.infer<typeof FlowValidation>;
-export declare const CreateFlowInput: z.ZodObject<{
-    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    title: z.ZodString;
-    description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type CreateFlowInput = z.infer<typeof CreateFlowInput>;
-export declare const UpdateFlowInput: z.ZodObject<{
-    flowId: z.ZodString;
-    baseUpdatedAt: z.ZodISODateTime;
-    title: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type UpdateFlowInput = z.infer<typeof UpdateFlowInput>;
-export declare const ArchiveFlowInput: z.ZodObject<{
-    flowId: z.ZodString;
-    baseUpdatedAt: z.ZodISODateTime;
-    archived: z.ZodBoolean;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type ArchiveFlowInput = z.infer<typeof ArchiveFlowInput>;
-export declare const ListFlowsInput: z.ZodObject<{
-    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    includeArchived: z.ZodOptional<z.ZodBoolean>;
-    archivedOnly: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export type ListFlowsInput = z.infer<typeof ListFlowsInput>;
-export declare const GetFlowInput: z.ZodObject<{
-    flowId: z.ZodString;
-}, z.core.$strict>;
-export type GetFlowInput = z.infer<typeof GetFlowInput>;
-export declare const SaveFlowVersionInput: z.ZodObject<{
-    flowId: z.ZodString;
-    baseVersionId: z.ZodNullable<z.ZodString>;
-    graph: z.ZodObject<{
-        nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"trigger">;
-            configuration: z.ZodObject<{
-                mode: z.ZodLiteral<"manual">;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"instruction">;
-            configuration: z.ZodObject<{
-                prompt: z.ZodString;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"folder">;
-            configuration: z.ZodObject<{
-                resourceId: z.ZodString;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"document">;
-            configuration: z.ZodObject<{
-                resourceId: z.ZodString;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"upload">;
-            configuration: z.ZodObject<{
-                resourceId: z.ZodString;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"table">;
-            configuration: z.ZodObject<{
-                resourceId: z.ZodString;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"tool">;
-            configuration: z.ZodObject<{
-                toolName: z.ZodString;
-                fingerprint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-                arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"condition">;
-            configuration: z.ZodObject<{
-                mode: z.ZodLiteral<"semantic">;
-                instruction: z.ZodString;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"subflow">;
-            configuration: z.ZodObject<{
-                flowId: z.ZodString;
-                version: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    mode: z.ZodLiteral<"latest">;
-                }, z.core.$strict>, z.ZodObject<{
-                    mode: z.ZodLiteral<"follows">;
-                }, z.core.$strict>, z.ZodObject<{
-                    mode: z.ZodLiteral<"pinned">;
-                    versionId: z.ZodString;
-                }, z.core.$strict>], "mode">>;
-            }, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"output">;
-            configuration: z.ZodObject<{}, z.core.$strict>;
-            id: z.ZodString;
-            position: z.ZodObject<{
-                x: z.ZodNumber;
-                y: z.ZodNumber;
-            }, z.core.$strict>;
-            label: z.ZodString;
-        }, z.core.$strict>], "kind">>;
-        edges: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            source: z.ZodString;
-            target: z.ZodString;
-            kind: z.ZodDefault<z.ZodEnum<{
-                flow: "flow";
-                context: "context";
-            }>>;
-            label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            sourceHandle: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type SaveFlowVersionInput = z.infer<typeof SaveFlowVersionInput>;
-export declare const PublishFlowInput: z.ZodObject<{
-    flowId: z.ZodString;
-    versionId: z.ZodString;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type PublishFlowInput = z.infer<typeof PublishFlowInput>;
-export declare const UnpublishFlowInput: z.ZodObject<{
-    flowId: z.ZodString;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type UnpublishFlowInput = z.infer<typeof UnpublishFlowInput>;
-export declare const PreviewFlowPublishInput: z.ZodObject<{
-    flowId: z.ZodString;
-    versionId: z.ZodString;
-}, z.core.$strict>;
-export type PreviewFlowPublishInput = z.infer<typeof PreviewFlowPublishInput>;
-export declare const FlowPublishCall: z.ZodObject<{
-    nodeId: z.ZodString;
-    nodeLabel: z.ZodString;
-    calleeId: z.ZodString;
-    calleeTitle: z.ZodString;
-    mode: z.ZodEnum<{
-        latest: "latest";
-        follows: "follows";
-        pinned: "pinned";
-    }>;
-    versionId: z.ZodNullable<z.ZodString>;
-    versionSequence: z.ZodNullable<z.ZodNumber>;
-    freezes: z.ZodBoolean;
-    available: z.ZodBoolean;
-}, z.core.$strict>;
-export type FlowPublishCall = z.infer<typeof FlowPublishCall>;
-export declare const FlowPublishPreview: z.ZodObject<{
-    flowId: z.ZodString;
-    versionId: z.ZodString;
-    calls: z.ZodArray<z.ZodObject<{
-        nodeId: z.ZodString;
-        nodeLabel: z.ZodString;
-        calleeId: z.ZodString;
-        calleeTitle: z.ZodString;
-        mode: z.ZodEnum<{
-            latest: "latest";
-            follows: "follows";
-            pinned: "pinned";
-        }>;
-        versionId: z.ZodNullable<z.ZodString>;
-        versionSequence: z.ZodNullable<z.ZodNumber>;
-        freezes: z.ZodBoolean;
-        available: z.ZodBoolean;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type FlowPublishPreview = z.infer<typeof FlowPublishPreview>;
-export declare const RelationNodeKind: z.ZodEnum<{
-    folder: "folder";
-    document: "document";
-    attachment: "attachment";
-    table: "table";
-    agent: "agent";
-    board: "board";
-    flow: "flow";
-}>;
-export type RelationNodeKind = z.infer<typeof RelationNodeKind>;
-export declare const RelationNode: z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodEnum<{
-        folder: "folder";
-        document: "document";
-        attachment: "attachment";
-        table: "table";
-        agent: "agent";
-        board: "board";
-        flow: "flow";
-    }>;
-    title: z.ZodString;
-    inScope: z.ZodBoolean;
-}, z.core.$strict>;
-export type RelationNode = z.infer<typeof RelationNode>;
-export declare const RelationEdge: z.ZodObject<{
-    id: z.ZodString;
-    source: z.ZodString;
-    target: z.ZodString;
-    relation: z.ZodEnum<{
-        calls: "calls";
-        reads: "reads";
-    }>;
-}, z.core.$strict>;
-export type RelationEdge = z.infer<typeof RelationEdge>;
-export declare const RelationGraphScope: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    of: z.ZodLiteral<"folder">;
-    folderId: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>, z.ZodObject<{
-    of: z.ZodLiteral<"flow">;
-    flowId: z.ZodString;
-}, z.core.$strict>], "of">;
-export type RelationGraphScope = z.infer<typeof RelationGraphScope>;
-export declare const RelationGraphInput: z.ZodObject<{
-    scope: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        of: z.ZodLiteral<"folder">;
-        folderId: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        of: z.ZodLiteral<"flow">;
-        flowId: z.ZodString;
-    }, z.core.$strict>], "of">;
-    limit: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strict>;
-export type RelationGraphInput = z.infer<typeof RelationGraphInput>;
-export declare const RelationGraph: z.ZodObject<{
-    scope: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        of: z.ZodLiteral<"folder">;
-        folderId: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        of: z.ZodLiteral<"flow">;
-        flowId: z.ZodString;
-    }, z.core.$strict>], "of">;
-    nodes: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-            flow: "flow";
-        }>;
-        title: z.ZodString;
-        inScope: z.ZodBoolean;
-    }, z.core.$strict>>;
-    edges: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        source: z.ZodString;
-        target: z.ZodString;
-        relation: z.ZodEnum<{
-            calls: "calls";
-            reads: "reads";
-        }>;
-    }, z.core.$strict>>;
-    omitted: z.ZodNumber;
-    limit: z.ZodNumber;
-}, z.core.$strict>;
-export type RelationGraph = z.infer<typeof RelationGraph>;
-export declare const FlowRunStatus: z.ZodEnum<{
-    queued: "queued";
-    running: "running";
-    completed: "completed";
-    failed: "failed";
-    cancelled: "cancelled";
-}>;
-export type FlowRunStatus = z.infer<typeof FlowRunStatus>;
-export declare const FlowRun: z.ZodObject<{
-    id: z.ZodString;
-    flowId: z.ZodString;
-    versionId: z.ZodString;
-    status: z.ZodEnum<{
-        queued: "queued";
-        running: "running";
-        completed: "completed";
-        failed: "failed";
-        cancelled: "cancelled";
-    }>;
-    currentNodeId: z.ZodNullable<z.ZodString>;
-    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    output: z.ZodNullable<z.ZodUnknown>;
-    error: z.ZodNullable<z.ZodString>;
-    initiatedBy: z.ZodString;
-    parentRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    parentNodeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    createdAt: z.ZodISODateTime;
-    updatedAt: z.ZodISODateTime;
-    completedAt: z.ZodNullable<z.ZodISODateTime>;
-}, z.core.$strict>;
-export type FlowRun = z.infer<typeof FlowRun>;
-export declare const FlowRunTrailEntry: z.ZodObject<{
-    runId: z.ZodString;
-    flowId: z.ZodString;
-    flowTitle: z.ZodString;
-    nodeId: z.ZodNullable<z.ZodString>;
-    nodeLabel: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
-export type FlowRunTrailEntry = z.infer<typeof FlowRunTrailEntry>;
-export declare const FlowRunStep: z.ZodObject<{
-    run: z.ZodObject<{
-        id: z.ZodString;
-        flowId: z.ZodString;
-        versionId: z.ZodString;
-        status: z.ZodEnum<{
-            queued: "queued";
-            running: "running";
-            completed: "completed";
-            failed: "failed";
-            cancelled: "cancelled";
-        }>;
-        currentNodeId: z.ZodNullable<z.ZodString>;
-        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        output: z.ZodNullable<z.ZodUnknown>;
-        error: z.ZodNullable<z.ZodString>;
-        initiatedBy: z.ZodString;
-        parentRunId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-        parentNodeId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-        completedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strict>;
-    node: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"trigger">;
-        configuration: z.ZodObject<{
-            mode: z.ZodLiteral<"manual">;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"instruction">;
-        configuration: z.ZodObject<{
-            prompt: z.ZodString;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"folder">;
-        configuration: z.ZodObject<{
-            resourceId: z.ZodString;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"document">;
-        configuration: z.ZodObject<{
-            resourceId: z.ZodString;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"upload">;
-        configuration: z.ZodObject<{
-            resourceId: z.ZodString;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"table">;
-        configuration: z.ZodObject<{
-            resourceId: z.ZodString;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"tool">;
-        configuration: z.ZodObject<{
-            toolName: z.ZodString;
-            fingerprint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-            arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"condition">;
-        configuration: z.ZodObject<{
-            mode: z.ZodLiteral<"semantic">;
-            instruction: z.ZodString;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"subflow">;
-        configuration: z.ZodObject<{
-            flowId: z.ZodString;
-            version: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                mode: z.ZodLiteral<"latest">;
-            }, z.core.$strict>, z.ZodObject<{
-                mode: z.ZodLiteral<"follows">;
-            }, z.core.$strict>, z.ZodObject<{
-                mode: z.ZodLiteral<"pinned">;
-                versionId: z.ZodString;
-            }, z.core.$strict>], "mode">>;
-        }, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"output">;
-        configuration: z.ZodObject<{}, z.core.$strict>;
-        id: z.ZodString;
-        position: z.ZodObject<{
-            x: z.ZodNumber;
-            y: z.ZodNumber;
-        }, z.core.$strict>;
-        label: z.ZodString;
-    }, z.core.$strict>], "kind">>;
-    trail: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        runId: z.ZodString;
-        flowId: z.ZodString;
-        flowTitle: z.ZodString;
-        nodeId: z.ZodNullable<z.ZodString>;
-        nodeLabel: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-export type FlowRunStep = z.infer<typeof FlowRunStep>;
-export declare const StartFlowRunInput: z.ZodObject<{
-    flowId: z.ZodString;
-    input: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    parent: z.ZodDefault<z.ZodNullable<z.ZodObject<{
-        runId: z.ZodString;
-        nodeId: z.ZodString;
-    }, z.core.$strict>>>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type StartFlowRunInput = z.infer<typeof StartFlowRunInput>;
-export declare const GetFlowRunInput: z.ZodObject<{
-    runId: z.ZodString;
-}, z.core.$strict>;
-export type GetFlowRunInput = z.infer<typeof GetFlowRunInput>;
-export declare const CancelFlowRunInput: z.ZodObject<{
-    runId: z.ZodString;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type CancelFlowRunInput = z.infer<typeof CancelFlowRunInput>;
-export declare const CompleteFlowRunStepInput: z.ZodObject<{
-    runId: z.ZodString;
-    nodeId: z.ZodString;
-    outcome: z.ZodEnum<{
-        completed: "completed";
-        failed: "failed";
-    }>;
-    branch: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    output: z.ZodDefault<z.ZodNullable<z.ZodUnknown>>;
-    error: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    idempotencyKey: z.ZodString;
-}, z.core.$strict>;
-export type CompleteFlowRunStepInput = z.infer<typeof CompleteFlowRunStepInput>;
-export declare const FlowRunTrigger: z.ZodEnum<{
-    manual: "manual";
-    subflow: "subflow";
-}>;
-export type FlowRunTrigger = z.infer<typeof FlowRunTrigger>;
-export declare const FlowRunFailure: z.ZodObject<{
-    nodeId: z.ZodString;
-    nodeLabel: z.ZodString;
-    detail: z.ZodString;
-    calledRunId: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
-export type FlowRunFailure = z.infer<typeof FlowRunFailure>;
-export declare const FlowRunSummary: z.ZodObject<{
-    id: z.ZodString;
-    flowId: z.ZodString;
-    versionId: z.ZodString;
-    status: z.ZodEnum<{
-        queued: "queued";
-        running: "running";
-        completed: "completed";
-        failed: "failed";
-        cancelled: "cancelled";
-    }>;
-    trigger: z.ZodEnum<{
-        manual: "manual";
-        subflow: "subflow";
-    }>;
-    startedAt: z.ZodISODateTime;
-    completedAt: z.ZodNullable<z.ZodISODateTime>;
-    durationMs: z.ZodNullable<z.ZodNumber>;
-    initiatedBy: z.ZodString;
-    parentRunId: z.ZodNullable<z.ZodString>;
-    failure: z.ZodNullable<z.ZodObject<{
-        nodeId: z.ZodString;
-        nodeLabel: z.ZodString;
-        detail: z.ZodString;
-        calledRunId: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type FlowRunSummary = z.infer<typeof FlowRunSummary>;
-export declare const ListFlowRunsInput: z.ZodObject<{
-    flowId: z.ZodString;
-    failedOnly: z.ZodDefault<z.ZodBoolean>;
-    limit: z.ZodDefault<z.ZodNumber>;
-    cursor: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-}, z.core.$strict>;
-export type ListFlowRunsInput = z.infer<typeof ListFlowRunsInput>;
-export declare const FlowRunList: z.ZodObject<{
-    items: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        flowId: z.ZodString;
-        versionId: z.ZodString;
-        status: z.ZodEnum<{
-            queued: "queued";
-            running: "running";
-            completed: "completed";
-            failed: "failed";
-            cancelled: "cancelled";
-        }>;
-        trigger: z.ZodEnum<{
-            manual: "manual";
-            subflow: "subflow";
-        }>;
-        startedAt: z.ZodISODateTime;
-        completedAt: z.ZodNullable<z.ZodISODateTime>;
-        durationMs: z.ZodNullable<z.ZodNumber>;
-        initiatedBy: z.ZodString;
-        parentRunId: z.ZodNullable<z.ZodString>;
-        failure: z.ZodNullable<z.ZodObject<{
-            nodeId: z.ZodString;
-            nodeLabel: z.ZodString;
-            detail: z.ZodString;
-            calledRunId: z.ZodNullable<z.ZodString>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    nextCursor: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
-export type FlowRunList = z.infer<typeof FlowRunList>;
-export declare const FlowRunStepRecord: z.ZodObject<{
-    nodeId: z.ZodString;
-    nodeLabel: z.ZodString;
-    outcome: z.ZodEnum<{
-        completed: "completed";
-        failed: "failed";
-    }>;
-    branch: z.ZodNullable<z.ZodString>;
-    detail: z.ZodNullable<z.ZodString>;
-    calledRunId: z.ZodNullable<z.ZodString>;
-    completedAt: z.ZodISODateTime;
-}, z.core.$strict>;
-export type FlowRunStepRecord = z.infer<typeof FlowRunStepRecord>;
-export declare const FlowRunHistory: z.ZodObject<{
-    runId: z.ZodString;
-    flowId: z.ZodString;
-    status: z.ZodEnum<{
-        queued: "queued";
-        running: "running";
-        completed: "completed";
-        failed: "failed";
-        cancelled: "cancelled";
-    }>;
-    steps: z.ZodArray<z.ZodObject<{
-        nodeId: z.ZodString;
-        nodeLabel: z.ZodString;
-        outcome: z.ZodEnum<{
-            completed: "completed";
-            failed: "failed";
-        }>;
-        branch: z.ZodNullable<z.ZodString>;
-        detail: z.ZodNullable<z.ZodString>;
-        calledRunId: z.ZodNullable<z.ZodString>;
-        completedAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
-    trail: z.ZodArray<z.ZodObject<{
-        runId: z.ZodString;
-        flowId: z.ZodString;
-        flowTitle: z.ZodString;
-        nodeId: z.ZodNullable<z.ZodString>;
-        nodeLabel: z.ZodNullable<z.ZodString>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type FlowRunHistory = z.infer<typeof FlowRunHistory>;
-export declare const BundleManifestFilename = "manifest.json";
-export declare const BundleEntryKind: z.ZodEnum<{
-    folder: "folder";
-    document: "document";
-    attachment: "attachment";
-    table: "table";
-    agent: "agent";
-    board: "board";
-    flow: "flow";
-}>;
-export type BundleEntryKind = z.infer<typeof BundleEntryKind>;
-export declare const BundleManifestEntry: z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodEnum<{
-        folder: "folder";
-        document: "document";
-        attachment: "attachment";
-        table: "table";
-        agent: "agent";
-        board: "board";
-        flow: "flow";
-    }>;
-    title: z.ZodString;
-    description: z.ZodNullable<z.ZodString>;
-    mediaType: z.ZodNullable<z.ZodString>;
-    path: z.ZodString;
-}, z.core.$strict>;
-export type BundleManifestEntry = z.infer<typeof BundleManifestEntry>;
-export declare const BundleExclusion: z.ZodEnum<{
-    "version-history": "version-history";
-    grants: "grants";
-    "flow-runs": "flow-runs";
-    "archived-nodes": "archived-nodes";
-}>;
-export type BundleExclusion = z.infer<typeof BundleExclusion>;
-export declare const BundleManifest: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    exportedAt: z.ZodISODateTime;
-    rootId: z.ZodNullable<z.ZodString>;
-    entries: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodEnum<{
-            folder: "folder";
-            document: "document";
-            attachment: "attachment";
-            table: "table";
-            agent: "agent";
-            board: "board";
-            flow: "flow";
-        }>;
-        title: z.ZodString;
-        description: z.ZodNullable<z.ZodString>;
-        mediaType: z.ZodNullable<z.ZodString>;
-        path: z.ZodString;
-    }, z.core.$strict>>;
-    excluded: z.ZodArray<z.ZodEnum<{
-        "version-history": "version-history";
-        grants: "grants";
-        "flow-runs": "flow-runs";
-        "archived-nodes": "archived-nodes";
-    }>>;
-}, z.core.$strict>;
-export type BundleManifest = z.infer<typeof BundleManifest>;
-export declare const BundleImportResult: z.ZodObject<{
-    nodes: z.ZodNumber;
-    flows: z.ZodNumber;
-    rootNodeIds: z.ZodArray<z.ZodString>;
-    replayed: z.ZodBoolean;
-}, z.core.$strict>;
-export type BundleImportResult = z.infer<typeof BundleImportResult>;