@anchrd/colab-sdk 0.0.0-stage → 0.1.1

package/dist/users/users.d.ts

@@ -0,0 +1,254 @@
+import { z } from "zod";
+export declare const UserId: z.ZodTemplateLiteral<`user_${string}`>;
+export declare const UserKind: z.ZodEnum<{
+    machine: "machine";
+    human: "human";
+}>;
+export type UserKind = z.infer<typeof UserKind>;
+export declare const UserStatus: z.ZodEnum<{
+    archived: "archived";
+    invited: "invited";
+    expired: "expired";
+    disabled: "disabled";
+}>;
+export type UserStatus = z.infer<typeof UserStatus>;
+export declare const MachineKind: z.ZodEnum<{
+    operator: "operator";
+    external: "external";
+}>;
+export type MachineKind = z.infer<typeof MachineKind>;
+export declare const OperatorProvider: z.ZodEnum<{
+    claude: "claude";
+    codex: "codex";
+    gemini: "gemini";
+}>;
+export type OperatorProvider = z.infer<typeof OperatorProvider>;
+export declare const MessageMachine: z.ZodObject<{
+    kind: z.ZodEnum<{
+        operator: "operator";
+        external: "external";
+    }>;
+    provider: z.ZodNullable<z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        gemini: "gemini";
+    }>>;
+}, z.core.$strict>;
+export type MessageMachine = z.infer<typeof MessageMachine>;
+export declare const MachineFacts: z.ZodObject<{
+    kind: z.ZodEnum<{
+        operator: "operator";
+        external: "external";
+    }>;
+    responsibleId: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+}, z.core.$strict>;
+export type MachineFacts = z.infer<typeof MachineFacts>;
+export declare const UserListInput: z.ZodObject<{
+    kind: z.ZodOptional<z.ZodEnum<{
+        machine: "machine";
+        human: "human";
+    }>>;
+    archived: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>;
+    search: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodUnion<readonly [z.ZodTemplateLiteral<`user_${string}`>, z.ZodTemplateLiteral<`invitation_${string}`>]>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type UserListInput = z.infer<typeof UserListInput>;
+export declare const UserListItem: z.ZodObject<{
+    userId: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+    invitationId: z.ZodNullable<z.ZodTemplateLiteral<`invitation_${string}`>>;
+    kind: z.ZodEnum<{
+        machine: "machine";
+        human: "human";
+    }>;
+    name: z.ZodString;
+    email: z.ZodNullable<z.ZodString>;
+    roles: z.ZodArray<z.ZodObject<{
+        roleId: z.ZodTemplateLiteral<`role_${string}`>;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    status: z.ZodNullable<z.ZodEnum<{
+        archived: "archived";
+        invited: "invited";
+        expired: "expired";
+        disabled: "disabled";
+    }>>;
+    machine: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            operator: "operator";
+            external: "external";
+        }>;
+        responsibleId: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+    }, z.core.$strict>>;
+    statusAt: z.ZodNullable<z.ZodISODateTime>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type UserListItem = z.infer<typeof UserListItem>;
+export declare const UserList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        userId: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+        invitationId: z.ZodNullable<z.ZodTemplateLiteral<`invitation_${string}`>>;
+        kind: z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>;
+        name: z.ZodString;
+        email: z.ZodNullable<z.ZodString>;
+        roles: z.ZodArray<z.ZodObject<{
+            roleId: z.ZodTemplateLiteral<`role_${string}`>;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        status: z.ZodNullable<z.ZodEnum<{
+            archived: "archived";
+            invited: "invited";
+            expired: "expired";
+            disabled: "disabled";
+        }>>;
+        machine: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                operator: "operator";
+                external: "external";
+            }>;
+            responsibleId: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+        }, z.core.$strict>>;
+        statusAt: z.ZodNullable<z.ZodISODateTime>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodUnion<readonly [z.ZodTemplateLiteral<`user_${string}`>, z.ZodTemplateLiteral<`invitation_${string}`>]>>;
+}, z.core.$strict>;
+export type UserList = z.infer<typeof UserList>;
+export declare const OwnRoleList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        roleId: z.ZodTemplateLiteral<`role_${string}`>;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type OwnRoleList = z.infer<typeof OwnRoleList>;
+export declare const UserGetInput: z.ZodObject<{
+    userId: z.ZodTemplateLiteral<`user_${string}`>;
+}, z.core.$strict>;
+export type UserGetInput = z.infer<typeof UserGetInput>;
+export declare const SignInMethod: z.ZodEnum<{
+    password: "password";
+    google: "google";
+    microsoft: "microsoft";
+    passkey: "passkey";
+    key: "key";
+}>;
+export type SignInMethod = z.infer<typeof SignInMethod>;
+export declare const User: z.ZodObject<{
+    userId: z.ZodTemplateLiteral<`user_${string}`>;
+    kind: z.ZodEnum<{
+        machine: "machine";
+        human: "human";
+    }>;
+    name: z.ZodString;
+    email: z.ZodNullable<z.ZodString>;
+    roles: z.ZodArray<z.ZodObject<{
+        roleId: z.ZodTemplateLiteral<`role_${string}`>;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    status: z.ZodNullable<z.ZodEnum<{
+        archived: "archived";
+        invited: "invited";
+        expired: "expired";
+        disabled: "disabled";
+    }>>;
+    machine: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            operator: "operator";
+            external: "external";
+        }>;
+        responsibleId: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+    }, z.core.$strict>>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type User = z.infer<typeof User>;
+export declare const MachineKeyFacts: z.ZodObject<{
+    start: z.ZodString;
+    end: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    createdBy: z.ZodNullable<z.ZodObject<{
+        userId: z.ZodTemplateLiteral<`user_${string}`>;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    lastUsedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type MachineKeyFacts = z.infer<typeof MachineKeyFacts>;
+export declare const UserDetail: z.ZodObject<{
+    userId: z.ZodTemplateLiteral<`user_${string}`>;
+    kind: z.ZodEnum<{
+        machine: "machine";
+        human: "human";
+    }>;
+    name: z.ZodString;
+    email: z.ZodNullable<z.ZodString>;
+    roles: z.ZodArray<z.ZodObject<{
+        roleId: z.ZodTemplateLiteral<`role_${string}`>;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    status: z.ZodNullable<z.ZodEnum<{
+        archived: "archived";
+        invited: "invited";
+        expired: "expired";
+        disabled: "disabled";
+    }>>;
+    machine: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            operator: "operator";
+            external: "external";
+        }>;
+        responsibleId: z.ZodNullable<z.ZodTemplateLiteral<`user_${string}`>>;
+    }, z.core.$strict>>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    signIn: z.ZodArray<z.ZodEnum<{
+        password: "password";
+        google: "google";
+        microsoft: "microsoft";
+        passkey: "passkey";
+        key: "key";
+    }>>;
+    lastActiveAt: z.ZodNullable<z.ZodISODateTime>;
+    counts: z.ZodObject<{
+        roles: z.ZodNumber;
+        apps: z.ZodNumber;
+        events: z.ZodNumber;
+    }, z.core.$strict>;
+    keyFacts: z.ZodNullable<z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        createdBy: z.ZodNullable<z.ZodObject<{
+            userId: z.ZodTemplateLiteral<`user_${string}`>;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        lastUsedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type UserDetail = z.infer<typeof UserDetail>;
+export declare const UserUpdateInput: z.ZodObject<{
+    userId: z.ZodTemplateLiteral<`user_${string}`>;
+    name: z.ZodOptional<z.ZodString>;
+    roleIds: z.ZodOptional<z.ZodArray<z.ZodTemplateLiteral<`role_${string}`>>>;
+}, z.core.$strict>;
+export type UserUpdateInput = z.infer<typeof UserUpdateInput>;
+export declare const UserDisableInput: z.ZodObject<{
+    userId: z.ZodTemplateLiteral<`user_${string}`>;
+}, z.core.$strict>;
+export type UserDisableInput = z.infer<typeof UserDisableInput>;
+export declare const UserEnableInput: z.ZodObject<{
+    userId: z.ZodTemplateLiteral<`user_${string}`>;
+}, z.core.$strict>;
+export type UserEnableInput = z.infer<typeof UserEnableInput>;
+export declare const UserTestInput: z.ZodObject<{
+    userId: z.ZodTemplateLiteral<`user_${string}`>;
+}, z.core.$strict>;
+export type UserTestInput = z.infer<typeof UserTestInput>;
+export declare const UserTestResult: z.ZodObject<{
+    accepted: z.ZodBoolean;
+    cause: z.ZodOptional<z.ZodString>;
+    to: z.ZodString;
+}, z.core.$strict>;
+export type UserTestResult = z.infer<typeof UserTestResult>;

package/dist/users/users.js

@@ -0,0 +1,125 @@
+import { z } from "zod";
+import { idSchema } from "../ids/ids.js";
+import { Delivery, InvitationId, RoleChip } from "../invitations/invitations.js";
+import { Flag, Limit } from "../list-input.js";
+import { Name } from "../profile/profile.js";
+import { RoleId } from "../roles/roles.js";
+// People and machines (Einstellungen › Nutzer, #25): the inputs of the `access_user_*` tools and
+// their answers. A machine is a user with a key instead of a password (Betrieb › Operator und
+// Maschinen); renaming, roles and locking go through these tools for both.
+export const UserId = idSchema("user");
+export const UserKind = z.enum(["human", "machine"]);
+// Only a deviation is a status (Einstellungen › Nutzer): an open invitation, one whose link has
+// expired, a locked account, an archived machine. Everybody else has none.
+export const UserStatus = z.enum(["invited", "expired", "disabled", "archived"]);
+// The two kinds of machine (E84, E85): `operator`, a Claude-Operator Colab runs itself with a token
+// per run and no key ("Operator · Claude"); `external`, one that signs in with its key ("Maschine ·
+// extern").
+export const MachineKind = z.enum(["operator", "external"]);
+// The providers of the catalog (`operatorProviders` in `operators.ts`). Here, beside the kinds, so a
+// schema of `nodes` or `messages` can name it without importing `operators`, which reaches `nodes`
+// through `dashboards`.
+export const OperatorProvider = z.enum(["claude", "codex", "gemini"]);
+// What a machine is beside its name (#348, #403, E77, E80, E85): its kind from `access`, and for an
+// Operator the provider it runs at from `operator`; null for one whose row is gone there. A chat
+// message's author and a person in the user list carry it.
+export const MessageMachine = z.strictObject({
+    kind: MachineKind,
+    provider: OperatorProvider.nullable(),
+});
+// What only a machine has (E76): its kind and the person its disturbances reach. Null for a person.
+export const MachineFacts = z.strictObject({
+    kind: MachineKind,
+    // At first whoever created it; null for one whose responsible person is unknown.
+    responsibleId: UserId.nullable(),
+});
+export const UserListInput = z.strictObject({
+    // An open invitation always goes to a person: it is listed under `human`, never under `machine`.
+    kind: UserKind.optional(),
+    // The archive instead (#447): only archived people and machines, no invitation. Leaving it out
+    // lists everyone who is not archived, locked ones and open invitations included.
+    archived: Flag.optional(),
+    // Part of the name or the address, case-insensitive.
+    search: z.string().trim().min(1).max(200).optional(),
+    cursor: z.union([UserId, InvitationId]).optional(),
+    limit: Limit.optional(),
+});
+// One row of the list: a person, a machine, or an open invitation (then `invitationId` is set and
+// `userId` is null; the name stays empty until the person chooses one).
+export const UserListItem = z.strictObject({
+    userId: UserId.nullable(),
+    invitationId: InvitationId.nullable(),
+    kind: UserKind,
+    name: z.string(),
+    // A machine has no address of its own.
+    email: z.string().nullable(),
+    roles: z.array(RoleChip),
+    status: UserStatus.nullable(),
+    machine: MachineFacts.nullable(),
+    // The date the status names (#240): since when an account is locked ("Gesperrt · seit …"), until
+    // when an invitation runs or since when it has run out ("Eingeladen · bis …"). Null without one.
+    statusAt: z.iso.datetime().nullable(),
+    createdAt: z.iso.datetime(),
+});
+export const UserList = z.strictObject({
+    items: z.array(UserListItem),
+    nextCursor: z.union([UserId, InvitationId]).nullable(),
+});
+// The person's own roles at `GET /auth/roles` (Einstellungen › Profil, #30): only to look at, so no
+// tool and no parameter that could name somebody else. An archived role gives no rights and is left out.
+export const OwnRoleList = z.strictObject({ items: z.array(RoleChip) });
+export const UserGetInput = z.strictObject({ userId: UserId });
+// How an account signs in: a password, a provider, a passkey, or a machine's key.
+export const SignInMethod = z.enum(["password", "google", "microsoft", "passkey", "key"]);
+// One user with what the detail page shows: Art, Anmeldung, Zuletzt aktiv, Dabei seit, and the counts
+// of the tabs Rollen, Apps and Protokoll.
+export const User = z.strictObject({
+    userId: UserId,
+    kind: UserKind,
+    name: z.string(),
+    email: z.string().nullable(),
+    roles: z.array(RoleChip),
+    status: UserStatus.nullable(),
+    machine: MachineFacts.nullable(),
+    createdAt: z.iso.datetime(),
+    updatedAt: z.iso.datetime(),
+});
+// The key of an external machine as the tab Schlüssel shows it (#367, E84): never the key and never
+// its hash, only its first six and last four letters. `end` is null for a key made before #367, which
+// stored no end; `createdBy` is null when that is unknown or the account is gone.
+export const MachineKeyFacts = z.strictObject({
+    start: z.string(),
+    end: z.string().nullable(),
+    createdAt: z.iso.datetime(),
+    createdBy: z.strictObject({ userId: UserId, name: z.string() }).nullable(),
+    lastUsedAt: z.iso.datetime().nullable(),
+});
+export const UserDetail = User.extend({
+    signIn: z.array(SignInMethod),
+    lastActiveAt: z.iso.datetime().nullable(),
+    counts: z.strictObject({
+        roles: z.number().int(),
+        apps: z.number().int(),
+        events: z.number().int(),
+    }),
+    // Null for a person, a Claude-Operator and a machine without a key. ⚠️ Never call it `key`: `/mcp`
+    // redacts a field of that name whole (`redactSecrets` in `shared`), and the AI would read
+    // "[redacted]" where the UI reads the facts.
+    keyFacts: MachineKeyFacts.nullable(),
+});
+// Renames and sets the roles. `roleIds` is the WHOLE set: what is missing is taken away, an empty
+// list takes every role.
+export const UserUpdateInput = z
+    .strictObject({
+    userId: UserId,
+    name: Name.optional(),
+    roleIds: z.array(RoleId).max(50).optional(),
+})
+    .refine((input) => input.name !== undefined || input.roleIds !== undefined, {
+    message: "Name a field to change: name or roleIds.",
+});
+export const UserDisableInput = z.strictObject({ userId: UserId });
+export const UserEnableInput = z.strictObject({ userId: UserId });
+export const UserTestInput = z.strictObject({ userId: UserId });
+// The real result of the delivery, for the one who asked (Funktionen › E-Mails, Testmail).
+export const UserTestResult = Delivery.extend({ to: z.string() });

package/dist/validation/validation.d.ts

@@ -0,0 +1,106 @@
+import { z } from "zod";
+export declare const validationBoardId: "node_0000000000000000000000VA1D";
+export declare const ValidationBoardId: z.ZodLiteral<"node_0000000000000000000000VA1D">;
+export type ValidationBoardId = z.infer<typeof ValidationBoardId>;
+export declare const TicketColumn: z.ZodObject<{
+    columnId: z.ZodTemplateLiteral<`column_${string}`>;
+    name: z.ZodNullable<z.ZodString>;
+    type: z.ZodNullable<z.ZodEnum<{
+        backlog: "backlog";
+        open: "open";
+        progress: "progress";
+        done: "done";
+        discarded: "discarded";
+        blocked: "blocked";
+        archive: "archive";
+    }>>;
+}, z.core.$strict>;
+export type TicketColumn = z.infer<typeof TicketColumn>;
+export declare const TicketMove: z.ZodObject<{
+    from: z.ZodNullable<z.ZodObject<{
+        columnId: z.ZodTemplateLiteral<`column_${string}`>;
+        name: z.ZodNullable<z.ZodString>;
+        type: z.ZodNullable<z.ZodEnum<{
+            backlog: "backlog";
+            open: "open";
+            progress: "progress";
+            done: "done";
+            discarded: "discarded";
+            blocked: "blocked";
+            archive: "archive";
+        }>>;
+    }, z.core.$strict>>;
+    to: z.ZodObject<{
+        columnId: z.ZodTemplateLiteral<`column_${string}`>;
+        name: z.ZodNullable<z.ZodString>;
+        type: z.ZodNullable<z.ZodEnum<{
+            backlog: "backlog";
+            open: "open";
+            progress: "progress";
+            done: "done";
+            discarded: "discarded";
+            blocked: "blocked";
+            archive: "archive";
+        }>>;
+    }, z.core.$strict>;
+    movedBy: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strict>;
+    movedAt: z.ZodISODateTime;
+    comment: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type TicketMove = z.infer<typeof TicketMove>;
+export declare const TicketSubject: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    kind: z.ZodEnum<{
+        file: "file";
+        folder: "folder";
+        document: "document";
+        table: "table";
+        board: "board";
+        task: "task";
+        dashboard: "dashboard";
+    }>;
+    name: z.ZodString;
+    path: z.ZodObject<{
+        section: z.ZodEnum<{
+            users: "users";
+            own: "own";
+            shared: "shared";
+        }>;
+        items: z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TicketSubject = z.infer<typeof TicketSubject>;
+export declare const TicketSubjectRef: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    kind: z.ZodEnum<{
+        file: "file";
+        folder: "folder";
+        document: "document";
+        table: "table";
+        board: "board";
+        task: "task";
+        dashboard: "dashboard";
+    }>;
+    path: z.ZodObject<{
+        section: z.ZodEnum<{
+            users: "users";
+            own: "own";
+            shared: "shared";
+        }>;
+        items: z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TicketSubjectRef = z.infer<typeof TicketSubjectRef>;

package/dist/validation/validation.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { ColumnId, ColumnType } from "../columns/columns.js";
+import { NodeId, NodeKind, NodePath, NodePerson } from "../nodes/nodes.js";
+// The validation (#47, Seiten › Validierung, E33, E48, E67): one board per Colab, a ticket per
+// document, table and file, and the history of every ticket. The board is a node with a fixed id
+// that stands in no area of the tree; its tickets are tasks whose node is the one they validate. A
+// node's own status is `NodeValidation` in `nodes.ts`, beside the node it describes.
+// ⚠️ The board's fixed id: the same in every Colab, made on its first use (`ensureValidationBoard`
+// in `intelligence`), never in a folder. A ULID of zeros and `VA1D`, so no `createId` makes it.
+export const validationBoardId = "node_0000000000000000000000VA1D";
+export const ValidationBoardId = z
+    .literal(validationBoardId)
+    .describe("The validation board, the same id in every Colab.");
+// A column a ticket left or entered. Its name and type as they stand now; both null when the
+// company has removed the column since.
+export const TicketColumn = z.strictObject({
+    columnId: ColumnId,
+    name: z.string().nullable(),
+    type: ColumnType.nullable(),
+});
+// One line of a ticket's history ("Verlauf"): every move, by Colab's bookkeeping or by hand.
+export const TicketMove = z.strictObject({
+    // Null for the line that opened the ticket.
+    from: TicketColumn.nullable(),
+    to: TicketColumn,
+    // Who moved it; for a move of the bookkeeping, whoever wrote the change that caused it.
+    movedBy: NodePerson,
+    movedAt: z.iso.datetime(),
+    // What the mover wrote with it, null without a word.
+    comment: z.string().nullable(),
+});
+// The node a ticket validates, as the caller can read it.
+export const TicketSubject = z.strictObject({
+    nodeId: NodeId,
+    kind: NodeKind,
+    name: z.string(),
+    path: NodePath,
+});
+// A ticket on a card: which node it validates, and where it stands as the caller reads it (#209:
+// three `.INSTRUCTIONS` on one board are told apart by their place).
+export const TicketSubjectRef = z.strictObject({ nodeId: NodeId, kind: NodeKind, path: NodePath });

package/dist/versions/versions.d.ts

@@ -0,0 +1,100 @@
+import { z } from "zod";
+export declare const VersionId: z.ZodTemplateLiteral<`version_${string}`>;
+export type VersionId = z.infer<typeof VersionId>;
+export declare const versionKinds: readonly ["document", "table", "file"];
+export declare const NodeVersionListInput: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type NodeVersionListInput = z.infer<typeof NodeVersionListInput>;
+export declare const NodeVersionGetInput: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    versionId: z.ZodTemplateLiteral<`version_${string}`>;
+}, z.core.$strict>;
+export type NodeVersionGetInput = z.infer<typeof NodeVersionGetInput>;
+export declare const NodeVersionCreateInput: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    fromVersionId: z.ZodTemplateLiteral<`version_${string}`>;
+    rev: z.ZodNumber;
+}, z.core.$strict>;
+export type NodeVersionCreateInput = z.infer<typeof NodeVersionCreateInput>;
+export declare const NodeVersion: z.ZodObject<{
+    versionId: z.ZodTemplateLiteral<`version_${string}`>;
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    number: z.ZodNumber;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    createdBy: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strict>;
+    appHandle: z.ZodNullable<z.ZodString>;
+    restoredFrom: z.ZodNullable<z.ZodNumber>;
+    current: z.ZodBoolean;
+    size: z.ZodNumber;
+}, z.core.$strict>;
+export type NodeVersion = z.infer<typeof NodeVersion>;
+export declare const NodeVersionList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        versionId: z.ZodTemplateLiteral<`version_${string}`>;
+        nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+        number: z.ZodNumber;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        createdBy: z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+        }, z.core.$strict>;
+        appHandle: z.ZodNullable<z.ZodString>;
+        restoredFrom: z.ZodNullable<z.ZodNumber>;
+        current: z.ZodBoolean;
+        size: z.ZodNumber;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    rev: z.ZodNumber;
+}, z.core.$strict>;
+export type NodeVersionList = z.infer<typeof NodeVersionList>;
+export declare const NodeVersionDetail: z.ZodObject<{
+    versionId: z.ZodTemplateLiteral<`version_${string}`>;
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    number: z.ZodNumber;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    createdBy: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strict>;
+    appHandle: z.ZodNullable<z.ZodString>;
+    restoredFrom: z.ZodNullable<z.ZodNumber>;
+    current: z.ZodBoolean;
+    size: z.ZodNumber;
+    secret: z.ZodOptional<z.ZodLiteral<true>>;
+    locked: z.ZodOptional<z.ZodBoolean>;
+    content: z.ZodNullable<z.ZodString>;
+    mediaType: z.ZodNullable<z.ZodString>;
+    columns: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            number: "number";
+            date: "date";
+            email: "email";
+            text: "text";
+            chip: "chip";
+        }>;
+    }, z.core.$strict>>>;
+    rev: z.ZodNumber;
+}, z.core.$strict>;
+export type NodeVersionDetail = z.infer<typeof NodeVersionDetail>;