@powerhousedao/reactor-mcp 4.1.0-dev.4 → 4.1.0-dev.40

package/dist/src/tools/reactor.d.ts

@@ -0,0 +1,847 @@
+import type { IDocumentDriveServer } from "document-drive";
+import { type DocumentModelState } from "document-model";
+import { z } from "zod";
+import type { ToolSchema, ToolWithCallback } from "./types.js";
+export declare const createDocumentTool: {
+    readonly name: "createDocument";
+    readonly description: "Create a new document.\n     Unless the user specifies otherwise, and a drive named \"vetra\" is available, add the document after creating it to that drive using \"addActions\" tool with a \"ADD_FILE\" action to the drive document.";
+    readonly inputSchema: {
+        readonly documentType: z.ZodString;
+        readonly documentId: z.ZodOptional<z.ZodString>;
+    };
+    readonly outputSchema: {
+        readonly documentId: z.ZodString;
+    };
+};
+export declare const getDocumentTool: {
+    readonly name: "getDocument";
+    readonly description: "Retrieve a document by its ID";
+    readonly inputSchema: {
+        readonly id: z.ZodString;
+    };
+    readonly outputSchema: {
+        readonly document: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    };
+};
+export declare const getDocumentsTool: {
+    readonly name: "getDocuments";
+    readonly description: "List documents in a drive";
+    readonly inputSchema: {
+        readonly parentId: z.ZodString;
+    };
+    readonly outputSchema: {
+        readonly documentIds: z.ZodArray<z.ZodString, "many">;
+    };
+};
+export declare const deleteDocumentTool: {
+    readonly name: "deleteDocument";
+    readonly description: "Delete a document";
+    readonly inputSchema: {
+        readonly documentId: z.ZodString;
+    };
+    readonly outputSchema: {
+        readonly success: z.ZodBoolean;
+    };
+};
+export declare const addActionsTool: {
+    readonly name: "addActions";
+    readonly description: "Adds actions to a document. Prefer adding multiples actions at once to reduce the number of steps.";
+    readonly inputSchema: {
+        readonly documentId: z.ZodString;
+        readonly actions: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            input: z.ZodUnknown;
+            scope: z.ZodString;
+            context: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+        }, "strict", z.ZodTypeAny, {
+            type: string;
+            scope: string;
+            input?: unknown;
+            context?: {} | undefined;
+        }, {
+            type: string;
+            scope: string;
+            input?: unknown;
+            context?: {} | undefined;
+        }>, "many">;
+    };
+    readonly outputSchema: {
+        readonly success: z.ZodBoolean;
+    };
+};
+export declare const getDrivesTool: {
+    readonly name: "getDrives";
+    readonly description: "List all drives";
+    readonly inputSchema: {};
+    readonly outputSchema: {
+        readonly driveIds: z.ZodArray<z.ZodString, "many">;
+    };
+};
+export declare const addDriveTool: {
+    readonly name: "addDrive";
+    readonly description: "Create a new drive";
+    readonly inputSchema: {
+        readonly driveInput: z.ZodObject<{
+            global: z.ZodObject<{
+                name: z.ZodString;
+                icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                icon?: string | null | undefined;
+            }, {
+                name: string;
+                icon?: string | null | undefined;
+            }>;
+            id: z.ZodOptional<z.ZodString>;
+            slug: z.ZodOptional<z.ZodString>;
+            preferredEditor: z.ZodOptional<z.ZodString>;
+            local: z.ZodOptional<z.ZodObject<{
+                availableOffline: z.ZodOptional<z.ZodBoolean>;
+                sharingType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, "strip", z.ZodTypeAny, {
+                availableOffline?: boolean | undefined;
+                sharingType?: string | null | undefined;
+            }, {
+                availableOffline?: boolean | undefined;
+                sharingType?: string | null | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            global: {
+                name: string;
+                icon?: string | null | undefined;
+            };
+            id?: string | undefined;
+            slug?: string | undefined;
+            preferredEditor?: string | undefined;
+            local?: {
+                availableOffline?: boolean | undefined;
+                sharingType?: string | null | undefined;
+            } | undefined;
+        }, {
+            global: {
+                name: string;
+                icon?: string | null | undefined;
+            };
+            id?: string | undefined;
+            slug?: string | undefined;
+            preferredEditor?: string | undefined;
+            local?: {
+                availableOffline?: boolean | undefined;
+                sharingType?: string | null | undefined;
+            } | undefined;
+        }>;
+    };
+    readonly outputSchema: {
+        readonly driveId: z.ZodString;
+    };
+};
+export declare const getDriveTool: {
+    readonly name: "getDrive";
+    readonly description: "Get a specific drive";
+    readonly inputSchema: {
+        readonly driveId: z.ZodString;
+        readonly options: z.ZodOptional<z.ZodObject<{
+            revisions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            checkHashes: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            revisions?: Record<string, number> | undefined;
+            checkHashes?: boolean | undefined;
+        }, {
+            revisions?: Record<string, number> | undefined;
+            checkHashes?: boolean | undefined;
+        }>>;
+    };
+    readonly outputSchema: {
+        readonly drive: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    };
+};
+export declare const deleteDriveTool: {
+    readonly name: "deleteDrive";
+    readonly description: "Delete a drive";
+    readonly inputSchema: {
+        readonly driveId: z.ZodString;
+    };
+    readonly outputSchema: {
+        readonly success: z.ZodBoolean;
+    };
+};
+export declare const addRemoteDriveTool: {
+    readonly name: "addRemoteDrive";
+    readonly description: "Connect to a remote drive";
+    readonly inputSchema: {
+        readonly url: z.ZodString;
+        readonly options: z.ZodObject<{
+            availableOffline: z.ZodBoolean;
+            sharingType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            pullFilter: z.ZodOptional<z.ZodObject<{
+                branch: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+                documentId: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+                documentType: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+                scope: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+            }, "strip", z.ZodTypeAny, {
+                scope?: string[] | null | undefined;
+                documentType?: string[] | null | undefined;
+                documentId?: string[] | null | undefined;
+                branch?: string[] | null | undefined;
+            }, {
+                scope?: string[] | null | undefined;
+                documentType?: string[] | null | undefined;
+                documentId?: string[] | null | undefined;
+                branch?: string[] | null | undefined;
+            }>>;
+            pullInterval: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            availableOffline: boolean;
+            sharingType?: string | null | undefined;
+            pullFilter?: {
+                scope?: string[] | null | undefined;
+                documentType?: string[] | null | undefined;
+                documentId?: string[] | null | undefined;
+                branch?: string[] | null | undefined;
+            } | undefined;
+            pullInterval?: number | undefined;
+        }, {
+            availableOffline: boolean;
+            sharingType?: string | null | undefined;
+            pullFilter?: {
+                scope?: string[] | null | undefined;
+                documentType?: string[] | null | undefined;
+                documentId?: string[] | null | undefined;
+                branch?: string[] | null | undefined;
+            } | undefined;
+            pullInterval?: number | undefined;
+        }>;
+    };
+    readonly outputSchema: {
+        readonly driveId: z.ZodString;
+    };
+};
+type Properties<T> = Required<{
+    [K in keyof T]: z.ZodType<T[K], any, T[K]>;
+}>;
+export declare const getDocumentModelSchemaTool: {
+    readonly name: "getDocumentModelSchema";
+    readonly description: "Get the schema of a document model";
+    readonly inputSchema: {
+        readonly type: z.ZodString;
+    };
+    readonly outputSchema: {
+        readonly schema: z.ZodObject<Properties<DocumentModelState>>;
+    };
+};
+export declare const getDocumentModelsTool: {
+    readonly name: "getDocumentModels";
+    readonly description: "Get the list of document models";
+    readonly inputSchema: {};
+    readonly outputSchema: {
+        readonly documentModels: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            description: z.ZodString;
+            extension: z.ZodString;
+            authorName: z.ZodString;
+            authorWebsite: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            name: string;
+            description: string;
+            extension: string;
+            authorName: string;
+            authorWebsite: string;
+        }, {
+            type: string;
+            name: string;
+            description: string;
+            extension: string;
+            authorName: string;
+            authorWebsite: string;
+        }>, "many">;
+    };
+};
+type ToolRecord<T extends readonly ToolSchema[]> = {
+    [K in T[number]["name"]]: ToolWithCallback<Extract<T[number], {
+        name: K;
+    }>>;
+};
+declare const allTools: readonly [{
+    readonly name: "getDocument";
+    readonly description: "Retrieve a document by its ID";
+    readonly inputSchema: {
+        readonly id: z.ZodString;
+    };
+    readonly outputSchema: {
+        readonly document: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    };
+}, {
+    readonly name: "createDocument";
+    readonly description: "Create a new document.\n     Unless the user specifies otherwise, and a drive named \"vetra\" is available, add the document after creating it to that drive using \"addActions\" tool with a \"ADD_FILE\" action to the drive document.";
+    readonly inputSchema: {
+        readonly documentType: z.ZodString;
+        readonly documentId: z.ZodOptional<z.ZodString>;
+    };
+    readonly outputSchema: {
+        readonly documentId: z.ZodString;
+    };
+}, {
+    readonly name: "getDocuments";
+    readonly description: "List documents in a drive";
+    readonly inputSchema: {
+        readonly parentId: z.ZodString;
+    };
+    readonly outputSchema: {
+        readonly documentIds: z.ZodArray<z.ZodString, "many">;
+    };
+}, {
+    readonly name: "deleteDocument";
+    readonly description: "Delete a document";
+    readonly inputSchema: {
+        readonly documentId: z.ZodString;
+    };
+    readonly outputSchema: {
+        readonly success: z.ZodBoolean;
+    };
+}, {
+    readonly name: "addActions";
+    readonly description: "Adds actions to a document. Prefer adding multiples actions at once to reduce the number of steps.";
+    readonly inputSchema: {
+        readonly documentId: z.ZodString;
+        readonly actions: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            input: z.ZodUnknown;
+            scope: z.ZodString;
+            context: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+        }, "strict", z.ZodTypeAny, {
+            type: string;
+            scope: string;
+            input?: unknown;
+            context?: {} | undefined;
+        }, {
+            type: string;
+            scope: string;
+            input?: unknown;
+            context?: {} | undefined;
+        }>, "many">;
+    };
+    readonly outputSchema: {
+        readonly success: z.ZodBoolean;
+    };
+}, {
+    readonly name: "getDrives";
+    readonly description: "List all drives";
+    readonly inputSchema: {};
+    readonly outputSchema: {
+        readonly driveIds: z.ZodArray<z.ZodString, "many">;
+    };
+}, {
+    readonly name: "addDrive";
+    readonly description: "Create a new drive";
+    readonly inputSchema: {
+        readonly driveInput: z.ZodObject<{
+            global: z.ZodObject<{
+                name: z.ZodString;
+                icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                icon?: string | null | undefined;
+            }, {
+                name: string;
+                icon?: string | null | undefined;
+            }>;
+            id: z.ZodOptional<z.ZodString>;
+            slug: z.ZodOptional<z.ZodString>;
+            preferredEditor: z.ZodOptional<z.ZodString>;
+            local: z.ZodOptional<z.ZodObject<{
+                availableOffline: z.ZodOptional<z.ZodBoolean>;
+                sharingType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, "strip", z.ZodTypeAny, {
+                availableOffline?: boolean | undefined;
+                sharingType?: string | null | undefined;
+            }, {
+                availableOffline?: boolean | undefined;
+                sharingType?: string | null | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            global: {
+                name: string;
+                icon?: string | null | undefined;
+            };
+            id?: string | undefined;
+            slug?: string | undefined;
+            preferredEditor?: string | undefined;
+            local?: {
+                availableOffline?: boolean | undefined;
+                sharingType?: string | null | undefined;
+            } | undefined;
+        }, {
+            global: {
+                name: string;
+                icon?: string | null | undefined;
+            };
+            id?: string | undefined;
+            slug?: string | undefined;
+            preferredEditor?: string | undefined;
+            local?: {
+                availableOffline?: boolean | undefined;
+                sharingType?: string | null | undefined;
+            } | undefined;
+        }>;
+    };
+    readonly outputSchema: {
+        readonly driveId: z.ZodString;
+    };
+}, {
+    readonly name: "getDrive";
+    readonly description: "Get a specific drive";
+    readonly inputSchema: {
+        readonly driveId: z.ZodString;
+        readonly options: z.ZodOptional<z.ZodObject<{
+            revisions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            checkHashes: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            revisions?: Record<string, number> | undefined;
+            checkHashes?: boolean | undefined;
+        }, {
+            revisions?: Record<string, number> | undefined;
+            checkHashes?: boolean | undefined;
+        }>>;
+    };
+    readonly outputSchema: {
+        readonly drive: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    };
+}, {
+    readonly name: "deleteDrive";
+    readonly description: "Delete a drive";
+    readonly inputSchema: {
+        readonly driveId: z.ZodString;
+    };
+    readonly outputSchema: {
+        readonly success: z.ZodBoolean;
+    };
+}, {
+    readonly name: "addRemoteDrive";
+    readonly description: "Connect to a remote drive";
+    readonly inputSchema: {
+        readonly url: z.ZodString;
+        readonly options: z.ZodObject<{
+            availableOffline: z.ZodBoolean;
+            sharingType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            pullFilter: z.ZodOptional<z.ZodObject<{
+                branch: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+                documentId: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+                documentType: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+                scope: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+            }, "strip", z.ZodTypeAny, {
+                scope?: string[] | null | undefined;
+                documentType?: string[] | null | undefined;
+                documentId?: string[] | null | undefined;
+                branch?: string[] | null | undefined;
+            }, {
+                scope?: string[] | null | undefined;
+                documentType?: string[] | null | undefined;
+                documentId?: string[] | null | undefined;
+                branch?: string[] | null | undefined;
+            }>>;
+            pullInterval: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            availableOffline: boolean;
+            sharingType?: string | null | undefined;
+            pullFilter?: {
+                scope?: string[] | null | undefined;
+                documentType?: string[] | null | undefined;
+                documentId?: string[] | null | undefined;
+                branch?: string[] | null | undefined;
+            } | undefined;
+            pullInterval?: number | undefined;
+        }, {
+            availableOffline: boolean;
+            sharingType?: string | null | undefined;
+            pullFilter?: {
+                scope?: string[] | null | undefined;
+                documentType?: string[] | null | undefined;
+                documentId?: string[] | null | undefined;
+                branch?: string[] | null | undefined;
+            } | undefined;
+            pullInterval?: number | undefined;
+        }>;
+    };
+    readonly outputSchema: {
+        readonly driveId: z.ZodString;
+    };
+}, {
+    readonly name: "getDocumentModelSchema";
+    readonly description: "Get the schema of a document model";
+    readonly inputSchema: {
+        readonly type: z.ZodString;
+    };
+    readonly outputSchema: {
+        readonly schema: z.ZodObject<Properties<DocumentModelState>>;
+    };
+}, {
+    readonly name: "getDocumentModels";
+    readonly description: "Get the list of document models";
+    readonly inputSchema: {};
+    readonly outputSchema: {
+        readonly documentModels: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            description: z.ZodString;
+            extension: z.ZodString;
+            authorName: z.ZodString;
+            authorWebsite: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            name: string;
+            description: string;
+            extension: string;
+            authorName: string;
+            authorWebsite: string;
+        }, {
+            type: string;
+            name: string;
+            description: string;
+            extension: string;
+            authorName: string;
+            authorWebsite: string;
+        }>, "many">;
+    };
+}];
+export type ReactorMcpTools = ToolRecord<typeof allTools>;
+export declare function createReactorMcpProvider(reactor: IDocumentDriveServer): Promise<{
+    readonly tools: {
+        readonly getDocument: {
+            readonly name: "getDocument";
+            readonly description: "Retrieve a document by its ID";
+            readonly inputSchema: {
+                readonly id: z.ZodString;
+            };
+            readonly outputSchema: {
+                readonly document: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+            };
+        } & {
+            callback: (args: {
+                id: string;
+            }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
+        };
+        readonly createDocument: {
+            readonly name: "createDocument";
+            readonly description: "Create a new document.\n     Unless the user specifies otherwise, and a drive named \"vetra\" is available, add the document after creating it to that drive using \"addActions\" tool with a \"ADD_FILE\" action to the drive document.";
+            readonly inputSchema: {
+                readonly documentType: z.ZodString;
+                readonly documentId: z.ZodOptional<z.ZodString>;
+            };
+            readonly outputSchema: {
+                readonly documentId: z.ZodString;
+            };
+        } & {
+            callback: (args: {
+                documentType: string;
+                documentId?: string | undefined;
+            }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
+        };
+        readonly getDocuments: {
+            readonly name: "getDocuments";
+            readonly description: "List documents in a drive";
+            readonly inputSchema: {
+                readonly parentId: z.ZodString;
+            };
+            readonly outputSchema: {
+                readonly documentIds: z.ZodArray<z.ZodString, "many">;
+            };
+        } & {
+            callback: (args: {
+                parentId: string;
+            }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
+        };
+        readonly deleteDocument: {
+            readonly name: "deleteDocument";
+            readonly description: "Delete a document";
+            readonly inputSchema: {
+                readonly documentId: z.ZodString;
+            };
+            readonly outputSchema: {
+                readonly success: z.ZodBoolean;
+            };
+        } & {
+            callback: (args: {
+                documentId: string;
+            }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
+        };
+        readonly addActions: {
+            readonly name: "addActions";
+            readonly description: "Adds actions to a document. Prefer adding multiples actions at once to reduce the number of steps.";
+            readonly inputSchema: {
+                readonly documentId: z.ZodString;
+                readonly actions: z.ZodArray<z.ZodObject<{
+                    type: z.ZodString;
+                    input: z.ZodUnknown;
+                    scope: z.ZodString;
+                    context: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
+                }, "strict", z.ZodTypeAny, {
+                    type: string;
+                    scope: string;
+                    input?: unknown;
+                    context?: {} | undefined;
+                }, {
+                    type: string;
+                    scope: string;
+                    input?: unknown;
+                    context?: {} | undefined;
+                }>, "many">;
+            };
+            readonly outputSchema: {
+                readonly success: z.ZodBoolean;
+            };
+        } & {
+            callback: (args: {
+                documentId: string;
+                actions: {
+                    type: string;
+                    scope: string;
+                    input?: unknown;
+                    context?: {} | undefined;
+                }[];
+            }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
+        };
+        readonly getDrives: {
+            readonly name: "getDrives";
+            readonly description: "List all drives";
+            readonly inputSchema: {};
+            readonly outputSchema: {
+                readonly driveIds: z.ZodArray<z.ZodString, "many">;
+            };
+        } & {
+            callback: (args: {}) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
+        };
+        readonly addDrive: {
+            readonly name: "addDrive";
+            readonly description: "Create a new drive";
+            readonly inputSchema: {
+                readonly driveInput: z.ZodObject<{
+                    global: z.ZodObject<{
+                        name: z.ZodString;
+                        icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, "strip", z.ZodTypeAny, {
+                        name: string;
+                        icon?: string | null | undefined;
+                    }, {
+                        name: string;
+                        icon?: string | null | undefined;
+                    }>;
+                    id: z.ZodOptional<z.ZodString>;
+                    slug: z.ZodOptional<z.ZodString>;
+                    preferredEditor: z.ZodOptional<z.ZodString>;
+                    local: z.ZodOptional<z.ZodObject<{
+                        availableOffline: z.ZodOptional<z.ZodBoolean>;
+                        sharingType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    }, "strip", z.ZodTypeAny, {
+                        availableOffline?: boolean | undefined;
+                        sharingType?: string | null | undefined;
+                    }, {
+                        availableOffline?: boolean | undefined;
+                        sharingType?: string | null | undefined;
+                    }>>;
+                }, "strip", z.ZodTypeAny, {
+                    global: {
+                        name: string;
+                        icon?: string | null | undefined;
+                    };
+                    id?: string | undefined;
+                    slug?: string | undefined;
+                    preferredEditor?: string | undefined;
+                    local?: {
+                        availableOffline?: boolean | undefined;
+                        sharingType?: string | null | undefined;
+                    } | undefined;
+                }, {
+                    global: {
+                        name: string;
+                        icon?: string | null | undefined;
+                    };
+                    id?: string | undefined;
+                    slug?: string | undefined;
+                    preferredEditor?: string | undefined;
+                    local?: {
+                        availableOffline?: boolean | undefined;
+                        sharingType?: string | null | undefined;
+                    } | undefined;
+                }>;
+            };
+            readonly outputSchema: {
+                readonly driveId: z.ZodString;
+            };
+        } & {
+            callback: (args: {
+                driveInput: {
+                    global: {
+                        name: string;
+                        icon?: string | null | undefined;
+                    };
+                    id?: string | undefined;
+                    slug?: string | undefined;
+                    preferredEditor?: string | undefined;
+                    local?: {
+                        availableOffline?: boolean | undefined;
+                        sharingType?: string | null | undefined;
+                    } | undefined;
+                };
+            }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
+        };
+        readonly getDrive: {
+            readonly name: "getDrive";
+            readonly description: "Get a specific drive";
+            readonly inputSchema: {
+                readonly driveId: z.ZodString;
+                readonly options: z.ZodOptional<z.ZodObject<{
+                    revisions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                    checkHashes: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    revisions?: Record<string, number> | undefined;
+                    checkHashes?: boolean | undefined;
+                }, {
+                    revisions?: Record<string, number> | undefined;
+                    checkHashes?: boolean | undefined;
+                }>>;
+            };
+            readonly outputSchema: {
+                readonly drive: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+            };
+        } & {
+            callback: (args: {
+                driveId: string;
+                options?: {
+                    revisions?: Record<string, number> | undefined;
+                    checkHashes?: boolean | undefined;
+                } | undefined;
+            }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
+        };
+        readonly deleteDrive: {
+            readonly name: "deleteDrive";
+            readonly description: "Delete a drive";
+            readonly inputSchema: {
+                readonly driveId: z.ZodString;
+            };
+            readonly outputSchema: {
+                readonly success: z.ZodBoolean;
+            };
+        } & {
+            callback: (args: {
+                driveId: string;
+            }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
+        };
+        readonly addRemoteDrive: {
+            readonly name: "addRemoteDrive";
+            readonly description: "Connect to a remote drive";
+            readonly inputSchema: {
+                readonly url: z.ZodString;
+                readonly options: z.ZodObject<{
+                    availableOffline: z.ZodBoolean;
+                    sharingType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    pullFilter: z.ZodOptional<z.ZodObject<{
+                        branch: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+                        documentId: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+                        documentType: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+                        scope: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
+                    }, "strip", z.ZodTypeAny, {
+                        scope?: string[] | null | undefined;
+                        documentType?: string[] | null | undefined;
+                        documentId?: string[] | null | undefined;
+                        branch?: string[] | null | undefined;
+                    }, {
+                        scope?: string[] | null | undefined;
+                        documentType?: string[] | null | undefined;
+                        documentId?: string[] | null | undefined;
+                        branch?: string[] | null | undefined;
+                    }>>;
+                    pullInterval: z.ZodOptional<z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    availableOffline: boolean;
+                    sharingType?: string | null | undefined;
+                    pullFilter?: {
+                        scope?: string[] | null | undefined;
+                        documentType?: string[] | null | undefined;
+                        documentId?: string[] | null | undefined;
+                        branch?: string[] | null | undefined;
+                    } | undefined;
+                    pullInterval?: number | undefined;
+                }, {
+                    availableOffline: boolean;
+                    sharingType?: string | null | undefined;
+                    pullFilter?: {
+                        scope?: string[] | null | undefined;
+                        documentType?: string[] | null | undefined;
+                        documentId?: string[] | null | undefined;
+                        branch?: string[] | null | undefined;
+                    } | undefined;
+                    pullInterval?: number | undefined;
+                }>;
+            };
+            readonly outputSchema: {
+                readonly driveId: z.ZodString;
+            };
+        } & {
+            callback: (args: {
+                options: {
+                    availableOffline: boolean;
+                    sharingType?: string | null | undefined;
+                    pullFilter?: {
+                        scope?: string[] | null | undefined;
+                        documentType?: string[] | null | undefined;
+                        documentId?: string[] | null | undefined;
+                        branch?: string[] | null | undefined;
+                    } | undefined;
+                    pullInterval?: number | undefined;
+                };
+                url: string;
+            }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
+        };
+        readonly getDocumentModels: {
+            readonly name: "getDocumentModels";
+            readonly description: "Get the list of document models";
+            readonly inputSchema: {};
+            readonly outputSchema: {
+                readonly documentModels: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    type: z.ZodString;
+                    description: z.ZodString;
+                    extension: z.ZodString;
+                    authorName: z.ZodString;
+                    authorWebsite: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    type: string;
+                    name: string;
+                    description: string;
+                    extension: string;
+                    authorName: string;
+                    authorWebsite: string;
+                }, {
+                    type: string;
+                    name: string;
+                    description: string;
+                    extension: string;
+                    authorName: string;
+                    authorWebsite: string;
+                }>, "many">;
+            };
+        } & {
+            callback: (args: {}) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
+        };
+        readonly getDocumentModelSchema: {
+            readonly name: "getDocumentModelSchema";
+            readonly description: "Get the schema of a document model";
+            readonly inputSchema: {
+                readonly type: z.ZodString;
+            };
+            readonly outputSchema: {
+                readonly schema: z.ZodObject<Properties<DocumentModelState>>;
+            };
+        } & {
+            callback: (args: {
+                type: string;
+            }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
+        };
+    };
+    readonly resources: {};
+    readonly prompts: {};
+}>;
+export {};
+//# sourceMappingURL=reactor.d.ts.map