@anchrd/intel-contract 0.13.0 → 0.15.0

package/dist/contract/node.js

@@ -0,0 +1,310 @@
+import { z } from "zod";
+import { IdempotencyKey, IntelId, IsoDateTime } from "./contract.js";
+// What this installation is equipped to do — deployment facts, never the caller's permissions
+// (those stay behind each door, where `/session` deliberately does not carry them). `agentRuntime`
+// says whether an agent Worker is bound at all (#190): without it the UI offers no "New agent" and
+// an agent node explains itself instead of rendering views that could only end in a 503.
+// The fourth kind is `table` (#40), the fifth is `agent` (#139) and the sixth is `board` (#285).
+// Each is a kind of node, not a kind of thing: it hangs in the same folder tree, inherits the same
+// folder grants, carries the same immutable versions and the same R2 body as a document
+// (ADR-0004 §1, ADR-0005 §1). Only the media type and the operations below differ.
+//
+// ⚠️ `agent` being optional is load-bearing (ADR-0005 §1): an installation without a single agent
+// node is complete, not unfinished, and nothing here asks anyone to classify a document as a skill
+// or a policy in order to file it. The same holds for `board`: it is a file somebody may make, not
+// a place the tree grows a special corner for — which is exactly why a board is one node carrying
+// its tasks and not a folder that only tasks may live in (#285).
+export const NodeKind = z.enum(["folder", "document", "attachment", "table"]);
+export const Node = z.strictObject({
+    id: IntelId,
+    parentId: IntelId.nullable(),
+    kind: NodeKind,
+    title: z.string().min(1).max(240),
+    description: z.string().max(2_000).nullable(),
+    ownerId: IntelId,
+    currentVersionId: IntelId.nullable(),
+    createdAt: IsoDateTime,
+    updatedAt: IsoDateTime,
+    archivedAt: IsoDateTime.nullable(),
+});
+// What one table version carries (#135). An `append` holds only the rows one write added; a
+// `snapshot` holds the complete table — header and every row — so reading starts at the newest
+// snapshot and everything before it is history rather than content. Defining a table writes the
+// first snapshot; updating, deleting, and redefining write the later ones. Documents and
+// attachments carry `null`: each of their versions is complete by construction, and the word would
+// say nothing about them.
+export const NodeVersionSegment = z.enum(["append", "snapshot"]);
+export const NodeVersion = z.strictObject({
+    id: IntelId,
+    nodeId: IntelId,
+    sequence: z.number().int().positive(),
+    contentKey: z.string().min(1),
+    mediaType: z.string().min(1).max(160),
+    contentHash: z.string().regex(/^[a-f0-9]{64}$/),
+    size: z.number().int().nonnegative(),
+    segment: NodeVersionSegment.nullable(),
+    createdBy: IntelId,
+    createdAt: IsoDateTime,
+});
+export const ListNodesInput = z.strictObject({
+    parentId: IntelId.nullable()
+        .default(null)
+        .describe("Folder to list the direct children of. `null` lists the top level."),
+    includeArchived: z
+        .boolean()
+        .default(false)
+        .describe("Include archived nodes beside the live ones instead of hiding them."),
+    // ⚠️ Overrides `parentId` rather than narrowing beside it: what is archived is asked for across
+    // the whole tree, because that is the only useful question. Somebody looking for what they threw
+    // away does not know which folder it was in — if they did, they would not be looking (#113).
+    // A separate flag rather than a third state on `includeArchived`, so no existing caller changes
+    // meaning — and `.optional()` rather than `.default(false)` for the same reason `ListFlowsInput`
+    // carries it that way: a default makes the field required in the PARSED type, and every existing
+    // caller would have to answer a question it is not asking.
+    archivedOnly: z
+        .boolean()
+        .optional()
+        .describe("List only archived nodes, across the whole tree. Overrides parentId rather than narrowing it: somebody looking for what they threw away does not know which folder it was in."),
+});
+export const GetNodeInput = z.strictObject({
+    nodeId: IntelId.describe("Node to read, from node_list or search."),
+});
+// One pinned version of one node (#147). Both IDs, always: a version ID alone would let anyone
+// holding an ID read content whose node-level ACL they never passed, and a citation names both.
+export const GetNodeVersionInput = z.strictObject({
+    nodeId: IntelId.describe("Node the version belongs to. Required even though the version id is unique: access is decided on the node."),
+    versionId: IntelId.describe("Version to read, from node_version_list or a search citation."),
+});
+export const CreateNodeInput = z.strictObject({
+    parentId: IntelId.nullable()
+        .default(null)
+        .describe("Folder to file the new node in. `null` puts it at the top level."),
+    kind: NodeKind.describe("What the node is. A folder holds others and has no content; document, attachment and table each carry their own body, written afterwards by node_version_create, node_attachment_create or node_table_create."),
+    title: z
+        .string()
+        .trim()
+        .min(1)
+        .max(240)
+        .describe("What the node is called. Shown in the tree and searched."),
+    description: z
+        .string()
+        .trim()
+        .max(2_000)
+        .nullable()
+        .default(null)
+        .describe("Optional sentence about the node, for readers rather than for search ranking."),
+    idempotencyKey: IdempotencyKey,
+});
+/**
+ * The version a write is made against, in the one form both writers of node content take it.
+ *
+ * ⚠️ Nullable and required are not the same thing, and here they stand together (#437). `null` is
+ * how a node that has no version yet is addressed, and it is the only way to write its first
+ * content; leaving the field out says nothing at all and is refused. Whoever leaves it out is
+ * almost always holding a node created one call earlier, and the plain type error they used to get
+ * — "expected string, received undefined" — reads as "this field must be an id", about a field that
+ * cannot have one yet. Both refusals therefore name both ways instead.
+ *
+ * ⚠️ It stays required once a version exists, and that is what it is for: a mismatch is answered
+ * with a `409` rather than by overwriting somebody else's newer version.
+ *
+ * ⚠️ The bounds remain `IntelId`'s. The repeated `min(1)` adds no rule — it only puts the sentence
+ * on the second value that gets tried after `undefined`, the empty string.
+ *
+ * ⚠️ The sentence says what the field TAKES, not what the caller did wrong. It answers a wrong type
+ * as well as an absent field, and "is required" would be false about the first — which would be
+ * this same ticket one corner further on. A value that is merely too long keeps Zod's own `Too
+ * big`: that one is already a true statement about what was sent.
+ */
+function baseVersion(rule) {
+    return z.union([IntelId.min(1, { error: rule }), z.null()], { error: rule });
+}
+export const SaveNodeVersionInput = z.strictObject({
+    nodeId: IntelId.describe("Document node to append a version to."),
+    baseVersionId: baseVersion("baseVersionId takes the `currentVersionId` from node_get, or null when the node has no version yet — and it has to be sent.").describe("The version this edit was made against — `currentVersionId` from node_get. If the node has moved on since, the call is refused rather than overwriting the newer version; pass `null` only for a node that has no version yet."),
+    content: z
+        .string()
+        .max(10_000_000)
+        .describe("The complete new content. Versions are whole documents, not patches."),
+    mediaType: z
+        .string()
+        .min(1)
+        .max(160)
+        .default("text/markdown")
+        .describe("Media type of `content`. Leave at text/markdown unless writing another format."),
+    idempotencyKey: IdempotencyKey,
+});
+export const SaveAttachmentInput = z.strictObject({
+    nodeId: IntelId.describe("Attachment node to append bytes to."),
+    baseVersionId: baseVersion("baseVersionId takes the `currentVersionId` from node_get, or null for the first upload — and it has to be sent.").describe("The version these bytes replace — `currentVersionId` from node_get, or `null` for the first upload. A stale value is refused rather than overwriting."),
+    contentBase64: z
+        .string()
+        .min(1)
+        .max(20_000_000)
+        .describe("The file, base64-encoded. Around 15 MB of bytes; larger files take the HTTP door, which streams."),
+    mediaType: z
+        .string()
+        .min(1)
+        .max(160)
+        .describe("Media type of the decoded bytes, e.g. application/pdf."),
+    idempotencyKey: IdempotencyKey,
+});
+export const UpdateNodeInput = z
+    .strictObject({
+    nodeId: IntelId.describe("Node to change."),
+    baseUpdatedAt: IsoDateTime.describe("`updatedAt` as node_get last reported it. A newer value on the server means somebody else changed the node first and the call is refused."),
+    title: z
+        .string()
+        .trim()
+        .min(1)
+        .max(240)
+        .optional()
+        .describe("New title. Omit to leave it as it is."),
+    description: z
+        .string()
+        .trim()
+        .max(2_000)
+        .nullable()
+        .optional()
+        .describe("New description, or `null` to clear it. Omit to leave it as it is."),
+    parentId: IntelId.nullable()
+        .optional()
+        .describe("Folder to move the node into, or `null` for the top level. Omit to leave it where it is."),
+    idempotencyKey: IdempotencyKey,
+})
+    .refine((input) => input.title !== undefined || input.description !== undefined || input.parentId !== undefined, { message: "At least one change is required" });
+export const ArchiveNodeInput = z.strictObject({
+    nodeId: IntelId.describe("Node to archive or restore."),
+    baseUpdatedAt: IsoDateTime.describe("`updatedAt` as node_get last reported it. A newer value on the server means somebody else changed the node first and the call is refused."),
+    archived: z
+        .boolean()
+        .describe("`true` archives the node, `false` restores it. Archiving hides a node from listings and search; nothing is deleted and every version stays readable."),
+    idempotencyKey: IdempotencyKey,
+});
+// ⚠️ `withChildren` belongs to the LEVEL, not to the node (#59). Whether something has children
+// THIS reader may see is not a property of the thing — two readers get different answers. As a
+// field on the node, every other place that returns a node would have to compute it as well or
+// lie; as a list beside the entries it costs only the one answer that needs it.
+export const NodeList = z.strictObject({
+    items: z.array(Node),
+    withChildren: z.array(IntelId).default([]),
+});
+export const NodeVersionList = z.strictObject({ items: z.array(NodeVersion) });
+export const NodeDocument = z.strictObject({
+    node: Node,
+    version: NodeVersion.nullable(),
+    content: z.string().nullable(),
+});
+export const NodeAttachment = z.strictObject({
+    node: Node,
+    version: NodeVersion,
+    resourceUri: z.string().regex(/^intel:\/\/nodes\/[^/]+\/attachment$/),
+});
+// The table as a grid rather than as text: the server owns the one CSV reader, so no surface has to
+// grow a second one that would disagree with it about quoting.
+export const NodeTable = z.strictObject({
+    node: Node,
+    columns: z.array(z.string()),
+    rows: z.array(z.array(z.string())),
+    // The newest append, or `null` while the table has no header yet.
+    versionId: IntelId.nullable(),
+});
+export const NodeLinkRelation = z.enum(["references", "related", "depends_on", "implements"]);
+// Where the link came from. `text` links are derived from a document's content and are rewritten
+// whenever it is saved; `manual` links were made in the dialog #41 removed and are now history.
+//
+// ⚠️ This is provenance, never a second sort of relationship. Nothing offers the reader a choice
+// between them, and nothing may start writing `manual` again — that would be the two ways of saying
+// one thing that #41 exists to end. It exists so that saving a document cannot delete a link
+// somebody made before there was another way to make one.
+export const NodeLinkOrigin = z.enum(["text", "manual"]);
+export const NodeLink = z.strictObject({
+    id: IntelId,
+    sourceNodeId: IntelId,
+    targetNodeId: IntelId,
+    relation: NodeLinkRelation,
+    origin: NodeLinkOrigin,
+    label: z.string().trim().min(1).max(120).nullable(),
+    createdBy: IntelId,
+    createdAt: IsoDateTime,
+});
+export const NodeLinkList = z.strictObject({ items: z.array(NodeLink) });
+// The inline element a document link is, inside a BlockNote document (#41).
+//
+// ⚠️ The ID and nothing else. No title and no path travel with it: a stored title would go stale
+// the moment the target is renamed, a stored path the moment it is moved — and either one would
+// put a name the reader may not see into a document they may.
+export const DocumentLinkInlineType = "documentLink";
+export const ResolveNodeLinksInput = z.strictObject({
+    nodeIds: z
+        .array(IntelId)
+        .min(1)
+        .max(200)
+        .describe("The link targets to name, as found in a document's documentLink elements. Unreachable and deleted targets are simply absent from the answer, so a shorter list than asked for is normal."),
+});
+export const ResolvedNodeLink = z.strictObject({
+    nodeId: IntelId,
+    title: z.string().min(1).max(240),
+});
+// ⚠️ Only what the asking reader may see is in here, and an unreachable target is simply absent —
+// never a row with an empty title, never a count, never a "restricted" marker. The list is what one
+// side of a document link is drawn from, and an entry that says "something is here" is exactly the
+// leak this schema has to make impossible to write by accident. Deleted and unreadable therefore
+// look identical from the outside, which is the point.
+export const ResolveNodeLinksResult = z.strictObject({
+    items: z.array(ResolvedNodeLink),
+});
+export const NodeGraphInput = z.strictObject({
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(500)
+        .default(250)
+        .describe("How many nodes the graph may carry. The links returned are the ones between them."),
+});
+export const NodeGraph = z.strictObject({
+    nodes: z.array(Node),
+    links: z.array(NodeLink),
+});
+export const BlockNoteMediaType = "application/vnd.anchrd.intel.blocknote+json";
+export const BlockNoteDocument = z.strictObject({
+    format: z.literal("blocknote"),
+    schemaVersion: z.literal(1),
+    blocks: z.array(z.record(z.string(), z.unknown())),
+    markdown: z.string(),
+});
+// `scopeId` is a cut, never a grant (#126): it narrows an answer the actor is already entitled to
+// and can only ever remove rows. Without it the search stays global over everything visible, which
+// is why it is optional rather than nullable — an absent field and `null` would otherwise be two
+// spellings of the same request.
+export const SearchInput = z.strictObject({
+    query: z
+        .string()
+        .trim()
+        .min(1)
+        .max(500)
+        .describe("What to look for, in the reader's own words. Matched both lexically and semantically, so a question works as well as keywords."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(10)
+        .describe("How many citations to return, best first."),
+    scopeId: IntelId.optional().describe("Optional folder node id. When given, only nodes filed in that folder or beneath it are searched."),
+});
+export const NodeCitation = z.strictObject({
+    nodeId: IntelId,
+    versionId: IntelId,
+    title: z.string(),
+    passage: z.string(),
+    source: z.string(),
+    freshness: IsoDateTime,
+    score: z.number().min(0).max(1),
+    match: z.enum(["lexical", "semantic", "hybrid"]),
+});
+export const SearchResult = z.strictObject({
+    items: z.array(NodeCitation),
+});
+export const ReindexResult = z.strictObject({ queued: z.number().int().nonnegative() });

package/dist/contract/share.d.ts

@@ -0,0 +1,142 @@
+import { z } from "zod";
+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 ListGrantsInput: z.ZodObject<{
+    resourceId: z.ZodString;
+}, z.core.$strict>;
+export type ListGrantsInput = z.infer<typeof ListGrantsInput>;
+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 RevokeGrantResult: z.ZodObject<{
+    revoked: z.ZodBoolean;
+}, z.core.$strict>;
+export type RevokeGrantResult = z.infer<typeof RevokeGrantResult>;

package/dist/contract/share.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { IdempotencyKey, IntelId, IsoDateTime } from "./contract.js";
+// ⚠️ There is no `ContextPolicy`, and it is not coming back in this shape (#76). It said whether a
+// document should be pinned into a context, be found by relevance, or be named explicitly — an
+// instruction to a retrieval Intel does not perform. Intel hands out references and the agent
+// fetches what it needs (D24), so nothing here could ever have read it, and nothing did.
+//
+// Semantic search stays: as an MCP tool the agent calls, over everything or over one area.
+// One verb per grant, granted independently (ADR-0004 §2). Not a ladder: seeing a process must be
+// separable from being allowed to start it, and `execute` is meaningful only where a flow can live.
+export const ResourceVerb = z.enum(["read", "write", "execute", "share"]);
+export const SharePrincipal = z.discriminatedUnion("type", [
+    z.strictObject({ type: z.literal("user"), id: IntelId }),
+    z.strictObject({ type: z.literal("email"), email: z.email() }),
+    z.strictObject({ type: z.literal("organization") }),
+]);
+export const ListGrantsInput = z.strictObject({
+    resourceId: IntelId.describe("Node whose direct grants to list. Access inherited from a folder above is not a grant on this node and is not listed here."),
+});
+export const ResourceGrant = z.strictObject({
+    id: IntelId,
+    resourceId: IntelId,
+    principal: SharePrincipal,
+    verb: ResourceVerb,
+    expiresAt: IsoDateTime.nullable(),
+    createdBy: IntelId,
+    createdAt: IsoDateTime,
+});
+export const ShareInput = z.strictObject({
+    resourceId: IntelId.describe("Node to grant access to. A grant on a folder is inherited by everything beneath it, which is the usual way to share a whole area."),
+    principal: SharePrincipal.describe("Who gets the access: a Gate user by id, someone by verified email address, or the whole organization."),
+    verb: ResourceVerb.describe("What they may do. Each verb is granted on its own and none implies another: `read` reads, `write` writes, `execute` runs a flow, `share` passes access on. Seeing a process is deliberately separable from being allowed to start it."),
+    expiresAt: IsoDateTime.nullable()
+        .default(null)
+        .describe("When the grant stops working, or `null` for one that does not expire on its own."),
+    idempotencyKey: IdempotencyKey,
+});
+export const RevokeGrantInput = z.strictObject({
+    resourceId: IntelId.describe("Node the grant sits on. Named alongside the grant id so access is decided on the node."),
+    grantId: IntelId.describe("The grant to withdraw, from node_grant_list."),
+    idempotencyKey: IdempotencyKey,
+});
+// What a grant does not cover, reported to whoever just made it. A flow in the shared folder may
+// read a document outside it, and the run is re-authorized against the person running it — so the
+// grant can be complete and the flow still stop for them (ADR-0004 §4).
+//
+// ⚠️ `titles` holds only the documents the sharer may see; everything else is in `hidden` as a
+// number. A warning must not become a way of reading titles out of the tree.
+export const UnreadableNodes = z.strictObject({
+    titles: z.array(z.string().min(1).max(240)),
+    hidden: z.number().int().nonnegative(),
+});
+// The grant is in the answer, so the warning cannot be mistaken for a refusal: it is written first
+// and described afterwards. Blocking would force everyone who uses a central policy document to
+// duplicate it, which is the opposite of what one tree is for (ADR-0004 §4).
+export const ShareResult = z.strictObject({
+    grant: ResourceGrant,
+    unreadable: UnreadableNodes,
+});
+// `applicableVerbs` travels with the list because the answer is the business layer's, not the
+// screen's: a document has nothing to execute, so `execute` is not offered on one (ADR-0004 §2).
+export const ResourceGrantList = z.strictObject({
+    resourceId: IntelId,
+    applicableVerbs: z.array(ResourceVerb).min(1),
+    items: z.array(ResourceGrant),
+});
+export const RevokeGrantResult = z.strictObject({ revoked: z.boolean() });

package/dist/contract/table.d.ts

@@ -0,0 +1,162 @@
+import { z } from "zod";
+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 AppendTableRowsResult: z.ZodObject<{
+    node: z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            table: "table";
+            attachment: "attachment";
+        }>;
+        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";
+            table: "table";
+            attachment: "attachment";
+        }>;
+        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";
+            table: "table";
+            attachment: "attachment";
+        }>;
+        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>;