@anchrd/colab-sdk 0.0.0-stage → 0.1.1

package/dist/nodes/nodes.d.ts

@@ -0,0 +1,673 @@
+import { z } from "zod";
+export declare const NodeId: z.ZodTemplateLiteral<`node_${string}`>;
+export type NodeId = z.infer<typeof NodeId>;
+export declare const SecretId: z.ZodTemplateLiteral<`secret_${string}`>;
+export type SecretId = z.infer<typeof SecretId>;
+export declare const SecretFields: {
+    secret: z.ZodOptional<z.ZodLiteral<true>>;
+    locked: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const nodeKinds: readonly ["folder", "document", "table", "board", "task", "dashboard", "file"];
+export declare const NodeKind: z.ZodEnum<{
+    file: "file";
+    folder: "folder";
+    document: "document";
+    table: "table";
+    board: "board";
+    task: "task";
+    dashboard: "dashboard";
+}>;
+export type NodeKind = z.infer<typeof NodeKind>;
+export declare const responsibleKinds: readonly ["document", "table", "file"];
+export declare const BoardSystem: z.ZodEnum<{
+    validation: "validation";
+}>;
+export type BoardSystem = z.infer<typeof BoardSystem>;
+export declare const BoardShownKind: z.ZodEnum<{
+    board: "board";
+    validation: "validation";
+    process: "process";
+}>;
+export type BoardShownKind = z.infer<typeof BoardShownKind>;
+export declare const NodeSection: z.ZodEnum<{
+    users: "users";
+    own: "own";
+    shared: "shared";
+}>;
+export type NodeSection = z.infer<typeof NodeSection>;
+export declare const NodeSort: z.ZodEnum<{
+    name: "name";
+    status: "status";
+    kind: "kind";
+    updated: "updated";
+}>;
+export type NodeSort = z.infer<typeof NodeSort>;
+export declare const NodeQuery: z.ZodString;
+export declare const NodeListInput: z.ZodObject<{
+    parentId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
+    section: z.ZodOptional<z.ZodEnum<{
+        users: "users";
+        own: "own";
+        shared: "shared";
+    }>>;
+    query: z.ZodOptional<z.ZodString>;
+    includeHidden: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        name: "name";
+        status: "status";
+        kind: "kind";
+        updated: "updated";
+    }>>;
+    foldersFirst: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    archived: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>;
+    nodeIds: z.ZodOptional<z.ZodPreprocess<z.ZodArray<z.ZodTemplateLiteral<`node_${string}`>>, unknown>>;
+}, z.core.$strict>;
+export type NodeListInput = z.infer<typeof NodeListInput>;
+export declare const NodePerson: z.ZodObject<{
+    userId: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    kind: z.ZodNullable<z.ZodEnum<{
+        machine: "machine";
+        human: "human";
+    }>>;
+}, z.core.$strict>;
+export type NodePerson = z.infer<typeof NodePerson>;
+export declare const NodePath: 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>;
+export type NodePath = z.infer<typeof NodePath>;
+export declare const NodeListItem: 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;
+    hidden: z.ZodBoolean;
+    rootOf: z.ZodNullable<z.ZodString>;
+    rootImage: z.ZodNullable<z.ZodString>;
+    createdBy: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strict>;
+    responsible: z.ZodNullable<z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strict>>;
+    size: z.ZodNullable<z.ZodNumber>;
+    updatedAt: z.ZodISODateTime;
+    sharedWith: z.ZodNumber;
+    archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    status: z.ZodNullable<z.ZodEnum<{
+        backlog: "backlog";
+        open: "open";
+        progress: "progress";
+        done: "done";
+        discarded: "discarded";
+        blocked: "blocked";
+        archive: "archive";
+    }>>;
+    system: z.ZodNullable<z.ZodEnum<{
+        validation: "validation";
+    }>>;
+    boardKind: z.ZodNullable<z.ZodEnum<{
+        board: "board";
+        validation: "validation";
+        process: "process";
+    }>>;
+    path: z.ZodOptional<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>>;
+    count: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    secret: z.ZodOptional<z.ZodLiteral<true>>;
+    rootArchived: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>;
+export type NodeListItem = z.infer<typeof NodeListItem>;
+export declare const NodeList: z.ZodObject<{
+    items: z.ZodArray<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;
+        hidden: z.ZodBoolean;
+        rootOf: z.ZodNullable<z.ZodString>;
+        rootImage: z.ZodNullable<z.ZodString>;
+        createdBy: z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+        }, z.core.$strict>;
+        responsible: z.ZodNullable<z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+        }, z.core.$strict>>;
+        size: z.ZodNullable<z.ZodNumber>;
+        updatedAt: z.ZodISODateTime;
+        sharedWith: z.ZodNumber;
+        archivedAt: z.ZodNullable<z.ZodISODateTime>;
+        status: z.ZodNullable<z.ZodEnum<{
+            backlog: "backlog";
+            open: "open";
+            progress: "progress";
+            done: "done";
+            discarded: "discarded";
+            blocked: "blocked";
+            archive: "archive";
+        }>>;
+        system: z.ZodNullable<z.ZodEnum<{
+            validation: "validation";
+        }>>;
+        boardKind: z.ZodNullable<z.ZodEnum<{
+            board: "board";
+            validation: "validation";
+            process: "process";
+        }>>;
+        path: z.ZodOptional<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>>;
+        count: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        secret: z.ZodOptional<z.ZodLiteral<true>>;
+        rootArchived: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    rootId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
+    instructions: z.ZodOptional<z.ZodObject<{
+        chain: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            status: z.ZodNullable<z.ZodString>;
+            markdown: z.ZodString;
+        }, z.core.$strict>>;
+        hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type NodeList = z.infer<typeof NodeList>;
+export declare const NodeHitFoundIn: z.ZodObject<{
+    kind: z.ZodEnum<{
+        column: "column";
+        page: "page";
+        title: "title";
+        text: "text";
+        card: "card";
+    }>;
+    label: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type NodeHitFoundIn = z.infer<typeof NodeHitFoundIn>;
+export declare const NodeHit: 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>;
+    snippet: z.ZodString;
+    foundIn: z.ZodObject<{
+        kind: z.ZodEnum<{
+            column: "column";
+            page: "page";
+            title: "title";
+            text: "text";
+            card: "card";
+        }>;
+        label: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    rank: z.ZodNumber;
+    status: z.ZodNullable<z.ZodEnum<{
+        backlog: "backlog";
+        open: "open";
+        progress: "progress";
+        done: "done";
+        discarded: "discarded";
+        blocked: "blocked";
+        archive: "archive";
+    }>>;
+    updatedAt: z.ZodISODateTime;
+    boardKind: z.ZodNullable<z.ZodEnum<{
+        board: "board";
+        validation: "validation";
+        process: "process";
+    }>>;
+    secret: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>;
+export type NodeHit = z.infer<typeof NodeHit>;
+export declare const NodeHitGroup: z.ZodObject<{
+    parentId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
+    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>;
+    count: z.ZodNumber;
+}, z.core.$strict>;
+export type NodeHitGroup = z.infer<typeof NodeHitGroup>;
+export declare const NodeSearch: z.ZodObject<{
+    items: z.ZodArray<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>;
+        snippet: z.ZodString;
+        foundIn: z.ZodObject<{
+            kind: z.ZodEnum<{
+                column: "column";
+                page: "page";
+                title: "title";
+                text: "text";
+                card: "card";
+            }>;
+            label: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        rank: z.ZodNumber;
+        status: z.ZodNullable<z.ZodEnum<{
+            backlog: "backlog";
+            open: "open";
+            progress: "progress";
+            done: "done";
+            discarded: "discarded";
+            blocked: "blocked";
+            archive: "archive";
+        }>>;
+        updatedAt: z.ZodISODateTime;
+        boardKind: z.ZodNullable<z.ZodEnum<{
+            board: "board";
+            validation: "validation";
+            process: "process";
+        }>>;
+        secret: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+    groups: z.ZodArray<z.ZodObject<{
+        parentId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
+        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>;
+        count: z.ZodNumber;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    semantic: z.ZodEnum<{
+        ok: "ok";
+        unavailable: "unavailable";
+    }>;
+}, z.core.$strict>;
+export type NodeSearch = z.infer<typeof NodeSearch>;
+export declare const SearchIndexState: z.ZodObject<{
+    running: z.ZodBoolean;
+    last: z.ZodNullable<z.ZodObject<{
+        requestedBy: z.ZodString;
+        requestedAt: z.ZodISODateTime;
+        startedAt: z.ZodNullable<z.ZodISODateTime>;
+        completedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SearchIndexState = z.infer<typeof SearchIndexState>;
+export declare const NodeGetInput: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+}, z.core.$strict>;
+export type NodeGetInput = z.infer<typeof NodeGetInput>;
+export declare const NodeValidation: z.ZodObject<{
+    ticketId: z.ZodTemplateLiteral<`node_${string}`>;
+    column: z.ZodObject<{
+        columnId: z.ZodTemplateLiteral<`column_${string}`>;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            backlog: "backlog";
+            open: "open";
+            progress: "progress";
+            done: "done";
+            discarded: "discarded";
+            blocked: "blocked";
+            archive: "archive";
+        }>;
+    }, z.core.$strict>;
+    validUntil: z.ZodNullable<z.ZodISODateTime>;
+    responsible: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strict>;
+    content: z.ZodString;
+}, z.core.$strict>;
+export type NodeValidation = z.infer<typeof NodeValidation>;
+export declare const NodeDetail: z.ZodObject<{
+    secretId: z.ZodOptional<z.ZodTemplateLiteral<`secret_${string}`>>;
+    secretBy: z.ZodOptional<z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strict>>;
+    secretSetAt: z.ZodOptional<z.ZodISODateTime>;
+    unlockedUntil: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+    secret: z.ZodOptional<z.ZodLiteral<true>>;
+    locked: z.ZodOptional<z.ZodBoolean>;
+    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;
+    hidden: z.ZodBoolean;
+    rootOf: z.ZodNullable<z.ZodString>;
+    system: z.ZodNullable<z.ZodEnum<{
+        validation: "validation";
+    }>>;
+    boardKind: z.ZodNullable<z.ZodEnum<{
+        board: "board";
+        validation: "validation";
+        process: "process";
+    }>>;
+    parentId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
+    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>;
+    createdBy: z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strict>;
+    responsible: z.ZodNullable<z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+    }, z.core.$strict>>;
+    rights: z.ZodObject<{
+        write: z.ZodBoolean;
+        share: z.ZodBoolean;
+    }, z.core.$strict>;
+    hiddenCount: z.ZodNullable<z.ZodNumber>;
+    size: z.ZodNullable<z.ZodNumber>;
+    rev: z.ZodNumber;
+    archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    purge: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    validation: z.ZodNullable<z.ZodObject<{
+        ticketId: z.ZodTemplateLiteral<`node_${string}`>;
+        column: z.ZodObject<{
+            columnId: z.ZodTemplateLiteral<`column_${string}`>;
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                backlog: "backlog";
+                open: "open";
+                progress: "progress";
+                done: "done";
+                discarded: "discarded";
+                blocked: "blocked";
+                archive: "archive";
+            }>;
+        }, z.core.$strict>;
+        validUntil: z.ZodNullable<z.ZodISODateTime>;
+        responsible: z.ZodObject<{
+            userId: z.ZodString;
+            name: z.ZodNullable<z.ZodString>;
+            kind: z.ZodNullable<z.ZodEnum<{
+                machine: "machine";
+                human: "human";
+            }>>;
+        }, z.core.$strict>;
+        content: z.ZodString;
+    }, z.core.$strict>>;
+    instructions: z.ZodOptional<z.ZodObject<{
+        chain: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            status: z.ZodNullable<z.ZodString>;
+            markdown: z.ZodString;
+        }, z.core.$strict>>;
+        hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    instruction: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type NodeDetail = z.infer<typeof NodeDetail>;
+export declare const NodeUpdateInput: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    rev: z.ZodNumber;
+    name: z.ZodOptional<z.ZodString>;
+    responsibleId: z.ZodOptional<z.ZodTemplateLiteral<`user_${string}`>>;
+}, z.core.$strict>;
+export type NodeUpdateInput = z.infer<typeof NodeUpdateInput>;
+export declare const NodeMoveInput: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    parentId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
+}, z.core.$strict>;
+export type NodeMoveInput = z.infer<typeof NodeMoveInput>;
+export declare const NodeReader: z.ZodObject<{
+    userId: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    kind: z.ZodNullable<z.ZodEnum<{
+        machine: "machine";
+        human: "human";
+    }>>;
+    right: z.ZodEnum<{
+        share: "share";
+        write: "write";
+        read: "read";
+    }>;
+    origin: z.ZodEnum<{
+        creator: "creator";
+        direct: "direct";
+        inherited: "inherited";
+    }>;
+    fromNodeId: z.ZodTemplateLiteral<`node_${string}`>;
+}, z.core.$strict>;
+export type NodeReader = z.infer<typeof NodeReader>;
+export declare const NodeMoved: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    parentId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
+    readers: z.ZodArray<z.ZodObject<{
+        userId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        kind: z.ZodNullable<z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>>;
+        right: z.ZodEnum<{
+            share: "share";
+            write: "write";
+            read: "read";
+        }>;
+        origin: z.ZodEnum<{
+            creator: "creator";
+            direct: "direct";
+            inherited: "inherited";
+        }>;
+        fromNodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type NodeMoved = z.infer<typeof NodeMoved>;
+export declare const FolderCreateInput: z.ZodObject<{
+    parentId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
+    name: z.ZodString;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type FolderCreateInput = z.infer<typeof FolderCreateInput>;
+export declare const FolderCreated: z.ZodObject<{
+    nodeId: z.ZodTemplateLiteral<`node_${string}`>;
+    kind: z.ZodLiteral<"folder">;
+    name: z.ZodString;
+    hidden: z.ZodBoolean;
+    parentId: z.ZodNullable<z.ZodTemplateLiteral<`node_${string}`>>;
+    rev: z.ZodNumber;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type FolderCreated = z.infer<typeof FolderCreated>;
+export declare const IntelligenceUserListInput: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    nodeId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
+    readersOnly: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export type IntelligenceUserListInput = z.infer<typeof IntelligenceUserListInput>;
+export declare const IntelligenceUser: z.ZodObject<{
+    userId: z.ZodString;
+    kind: z.ZodEnum<{
+        machine: "machine";
+        human: "human";
+    }>;
+    name: z.ZodString;
+    email: z.ZodString;
+    image: z.ZodNullable<z.ZodString>;
+    machine: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            operator: "operator";
+            external: "external";
+        }>;
+        provider: z.ZodNullable<z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            gemini: "gemini";
+        }>>;
+    }, z.core.$strict>>;
+    canRead: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type IntelligenceUser = z.infer<typeof IntelligenceUser>;
+export declare const IntelligenceUserList: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        userId: z.ZodString;
+        kind: z.ZodEnum<{
+            machine: "machine";
+            human: "human";
+        }>;
+        name: z.ZodString;
+        email: z.ZodString;
+        image: z.ZodNullable<z.ZodString>;
+        machine: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                operator: "operator";
+                external: "external";
+            }>;
+            provider: z.ZodNullable<z.ZodEnum<{
+                claude: "claude";
+                codex: "codex";
+                gemini: "gemini";
+            }>>;
+        }, z.core.$strict>>;
+        canRead: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type IntelligenceUserList = z.infer<typeof IntelligenceUserList>;