@baruchiro/paperless-mcp 0.0.0-test1 → 0.0.0

package/build/api/PaperlessAPI.d.ts

@@ -0,0 +1,26 @@
+import { BulkEditDocumentsResult, Correspondent, Document, DocumentsResponse, DocumentType, GetCorrespondentsResponse, GetDocumentTypesResponse, GetTagsResponse, Tag } from "./types";
+export declare class PaperlessAPI {
+    private readonly baseUrl;
+    private readonly token;
+    constructor(baseUrl: string, token: string);
+    request<T = any>(path: string, options?: RequestInit): Promise<T>;
+    bulkEditDocuments(documents: number[], method: string, parameters?: {}): Promise<BulkEditDocumentsResult>;
+    postDocument(file: File, metadata?: Record<string, string | string[] | number | number[]>): Promise<string>;
+    getDocuments(query?: string): Promise<DocumentsResponse>;
+    getDocument(id: number): Promise<Document>;
+    searchDocuments(query: string): Promise<DocumentsResponse>;
+    downloadDocument(id: number, asOriginal?: boolean): Promise<import("axios").AxiosResponse<any, any>>;
+    getTags(): Promise<GetTagsResponse>;
+    createTag(data: Partial<Tag>): Promise<Tag>;
+    updateTag(id: number, data: Partial<Tag>): Promise<Tag>;
+    deleteTag(id: number): Promise<void>;
+    getCorrespondents(): Promise<GetCorrespondentsResponse>;
+    createCorrespondent(data: Partial<Correspondent>): Promise<Correspondent>;
+    updateCorrespondent(id: number, data: Partial<Correspondent>): Promise<Correspondent>;
+    deleteCorrespondent(id: number): Promise<void>;
+    getDocumentTypes(): Promise<GetDocumentTypesResponse>;
+    createDocumentType(data: Partial<DocumentType>): Promise<DocumentType>;
+    updateDocumentType(id: number, data: Partial<DocumentType>): Promise<DocumentType>;
+    deleteDocumentType(id: number): Promise<void>;
+    bulkEditObjects(objects: any, objectType: any, operation: any, parameters?: {}): Promise<any>;
+}

package/build/api/PaperlessAPI.js

@@ -0,0 +1,233 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaperlessAPI = void 0;
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const utils_1 = require("./utils");
+class PaperlessAPI {
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+        this.baseUrl = baseUrl;
+        this.token = token;
+    }
+    request(path_1) {
+        return __awaiter(this, arguments, void 0, function* (path, options = {}) {
+            const url = `${this.baseUrl}/api${path}`;
+            const isJson = !options.body || typeof options.body === "string";
+            const mergedHeaders = Object.assign(Object.assign({ Authorization: `Token ${this.token}`, Accept: "application/json; version=5", "Accept-Language": "en-US,en;q=0.9" }, (isJson ? { "Content-Type": "application/json" } : {})), (0, utils_1.headersToObject)(options.headers));
+            try {
+                const response = yield (0, axios_1.default)({
+                    url,
+                    method: options.method || "GET",
+                    headers: mergedHeaders,
+                    data: options.body,
+                });
+                const body = response.data;
+                if (response.status < 200 || response.status >= 300) {
+                    console.error({
+                        error: "Error executing request",
+                        url,
+                        options,
+                        status: response.status,
+                        response: body,
+                    });
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                return body;
+            }
+            catch (error) {
+                console.error({
+                    error: "Error executing request",
+                    message: error instanceof Error ? error.message : String(error),
+                    url,
+                    options,
+                });
+                throw error;
+            }
+        });
+    }
+    // Document operations
+    bulkEditDocuments(documents_1, method_1) {
+        return __awaiter(this, arguments, void 0, function* (documents, method, parameters = {}) {
+            return this.request("/documents/bulk_edit/", {
+                method: "POST",
+                body: JSON.stringify({
+                    documents,
+                    method,
+                    parameters,
+                }),
+            });
+        });
+    }
+    postDocument(file_1) {
+        return __awaiter(this, arguments, void 0, function* (file, metadata = {}) {
+            const formData = new form_data_1.default();
+            formData.append("document", file);
+            // Add optional metadata fields
+            if (metadata.title)
+                formData.append("title", metadata.title);
+            if (metadata.created)
+                formData.append("created", metadata.created);
+            if (metadata.correspondent)
+                formData.append("correspondent", metadata.correspondent);
+            if (metadata.document_type)
+                formData.append("document_type", metadata.document_type);
+            if (metadata.storage_path)
+                formData.append("storage_path", metadata.storage_path);
+            if (metadata.tags) {
+                metadata.tags.forEach((tag) => formData.append("tags", tag));
+            }
+            if (metadata.archive_serial_number) {
+                formData.append("archive_serial_number", metadata.archive_serial_number);
+            }
+            if (metadata.custom_fields) {
+                metadata.custom_fields.forEach((field) => formData.append("custom_fields", field));
+            }
+            const response = yield axios_1.default.post(`${this.baseUrl}/api/documents/post_document/`, formData, {
+                headers: Object.assign({ Authorization: `Token ${this.token}` }, formData.getHeaders()),
+            });
+            if (response.status < 200 || response.status >= 300) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return response.data;
+        });
+    }
+    getDocuments() {
+        return __awaiter(this, arguments, void 0, function* (query = "") {
+            return this.request(`/documents/${query}`);
+        });
+    }
+    getDocument(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(`/documents/${id}/`);
+        });
+    }
+    searchDocuments(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request(`/documents/?query=${encodeURIComponent(query)}`);
+            return response;
+        });
+    }
+    downloadDocument(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, asOriginal = false) {
+            const query = asOriginal ? "?original=true" : "";
+            const response = yield axios_1.default.get(`${this.baseUrl}/api/documents/${id}/download/${query}`, {
+                headers: {
+                    Authorization: `Token ${this.token}`,
+                },
+                responseType: "arraybuffer",
+            });
+            return response;
+        });
+    }
+    // Tag operations
+    getTags() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("/tags/");
+        });
+    }
+    createTag(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("/tags/", {
+                method: "POST",
+                body: JSON.stringify(data),
+            });
+        });
+    }
+    updateTag(id, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(`/tags/${id}/`, {
+                method: "PUT",
+                body: JSON.stringify(data),
+            });
+        });
+    }
+    deleteTag(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(`/tags/${id}/`, {
+                method: "DELETE",
+            });
+        });
+    }
+    // Correspondent operations
+    getCorrespondents() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("/correspondents/");
+        });
+    }
+    createCorrespondent(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("/correspondents/", {
+                method: "POST",
+                body: JSON.stringify(data),
+            });
+        });
+    }
+    updateCorrespondent(id, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(`/correspondents/${id}/`, {
+                method: "PUT",
+                body: JSON.stringify(data),
+            });
+        });
+    }
+    deleteCorrespondent(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(`/correspondents/${id}/`, {
+                method: "DELETE",
+            });
+        });
+    }
+    // Document type operations
+    getDocumentTypes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("/document_types/");
+        });
+    }
+    createDocumentType(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request("/document_types/", {
+                method: "POST",
+                body: JSON.stringify(data),
+            });
+        });
+    }
+    updateDocumentType(id, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(`/document_types/${id}/`, {
+                method: "PUT",
+                body: JSON.stringify(data),
+            });
+        });
+    }
+    deleteDocumentType(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(`/document_types/${id}/`, {
+                method: "DELETE",
+            });
+        });
+    }
+    // Bulk object operations
+    bulkEditObjects(objects_1, objectType_1, operation_1) {
+        return __awaiter(this, arguments, void 0, function* (objects, objectType, operation, parameters = {}) {
+            return this.request("/bulk_edit_objects/", {
+                method: "POST",
+                body: JSON.stringify(Object.assign({ objects, object_type: objectType, operation }, parameters)),
+            });
+        });
+    }
+}
+exports.PaperlessAPI = PaperlessAPI;

package/build/api/types.d.ts

@@ -0,0 +1,89 @@
+export interface Tag {
+    id: number;
+    slug: string;
+    name: string;
+    color: string;
+    text_color: string;
+    match: string;
+    matching_algorithm: number;
+    is_insensitive: boolean;
+    is_inbox_tag: boolean;
+    document_count: number;
+    owner: number | null;
+    user_can_change: boolean;
+}
+export interface PaginationResponse<T> {
+    count: number;
+    next: string | null;
+    previous: string | null;
+    all: number[];
+    results: T[];
+}
+export interface GetTagsResponse extends PaginationResponse<Tag> {
+}
+export interface DocumentsResponse extends PaginationResponse<Document> {
+}
+export interface Document {
+    id: number;
+    correspondent: number | null;
+    document_type: number | null;
+    storage_path: string | null;
+    title: string;
+    content: string | null;
+    tags: number[];
+    created: string;
+    created_date: string;
+    modified: string;
+    added: string;
+    deleted_at: string | null;
+    archive_serial_number: string | null;
+    original_file_name: string;
+    archived_file_name: string;
+    owner: number | null;
+    user_can_change: boolean;
+    is_shared_by_requester: boolean;
+    notes: any[];
+    custom_fields: any[];
+    page_count: number;
+    mime_type: string;
+    __search_hit__?: SearchHit;
+}
+export interface SearchHit {
+    score: number;
+    highlights: string;
+    note_highlights: string;
+    rank: number;
+}
+export interface Correspondent {
+    id: number;
+    slug: string;
+    name: string;
+    match: string;
+    matching_algorithm: number;
+    is_insensitive: boolean;
+    document_count: number;
+    last_correspondence: string;
+    owner: number | null;
+    permissions: any;
+    user_can_change: boolean;
+}
+export interface GetCorrespondentsResponse extends PaginationResponse<Correspondent> {
+}
+export interface DocumentType {
+    id: number;
+    slug: string;
+    name: string;
+    match: string;
+    matching_algorithm: number;
+    is_insensitive: boolean;
+    document_count: number;
+    last_correspondence: string;
+    owner: number | null;
+    permissions: any;
+    user_can_change: boolean;
+}
+export interface GetDocumentTypesResponse extends PaginationResponse<DocumentType> {
+}
+export interface BulkEditDocumentsResult {
+    result: string;
+}

package/build/api/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/api/utils.d.ts

@@ -0,0 +1 @@
+export declare const headersToObject: (headers: any) => Record<string, string>;

package/build/api/utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.headersToObject = void 0;
+const headersToObject = (headers) => {
+    if (!headers)
+        return {};
+    if (typeof headers.forEach === "function") {
+        const obj = {};
+        headers.forEach((value, key) => {
+            obj[key] = value;
+        });
+        return obj;
+    }
+    return headers;
+};
+exports.headersToObject = headersToObject;

package/build/index.d.ts

@@ -0,0 +1 @@
+export {};

package/build/index.js

@@ -0,0 +1,160 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const express_1 = __importDefault(require("express"));
+const PaperlessAPI_1 = require("./api/PaperlessAPI");
+const correspondents_1 = require("./tools/correspondents");
+const documents_1 = require("./tools/documents");
+const documentTypes_1 = require("./tools/documentTypes");
+const tags_1 = require("./tools/tags");
+// Simple CLI argument parsing
+const args = process.argv.slice(2);
+const useHttp = args.includes("--http");
+let port = 3000;
+const portIndex = args.indexOf("--port");
+if (portIndex !== -1 && args[portIndex + 1]) {
+    const parsed = parseInt(args[portIndex + 1], 10);
+    if (!isNaN(parsed))
+        port = parsed;
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        let baseUrl;
+        let token;
+        if (useHttp) {
+            baseUrl = process.env.PAPERLESS_URL;
+            token = process.env.API_KEY;
+            if (!baseUrl || !token) {
+                console.error("When using --http, PAPERLESS_URL and API_KEY environment variables must be set.");
+                process.exit(1);
+            }
+        }
+        else {
+            baseUrl = args[0];
+            token = args[1];
+            if (!baseUrl || !token) {
+                console.error("Usage: paperless-mcp <baseUrl> <token> [--http] [--port <port>]");
+                console.error("Example: paperless-mcp http://localhost:8000 your-api-token --http --port 3000");
+                console.error("When using --http, PAPERLESS_URL and API_KEY environment variables must be set.");
+                process.exit(1);
+            }
+        }
+        // Initialize API client and server once
+        const api = new PaperlessAPI_1.PaperlessAPI(baseUrl, token);
+        const server = new mcp_js_1.McpServer({ name: "paperless-ngx", version: "1.0.0" });
+        (0, documents_1.registerDocumentTools)(server, api);
+        (0, tags_1.registerTagTools)(server, api);
+        (0, correspondents_1.registerCorrespondentTools)(server, api);
+        (0, documentTypes_1.registerDocumentTypeTools)(server, api);
+        if (useHttp) {
+            const app = (0, express_1.default)();
+            app.use(express_1.default.json());
+            // Store transports for each session
+            const sseTransports = {};
+            app.post("/mcp", (req, res) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                        sessionIdGenerator: undefined,
+                    });
+                    res.on("close", () => {
+                        transport.close();
+                    });
+                    yield server.connect(transport);
+                    yield transport.handleRequest(req, res, req.body);
+                }
+                catch (error) {
+                    console.error("Error handling MCP request:", error);
+                    if (!res.headersSent) {
+                        res.status(500).json({
+                            jsonrpc: "2.0",
+                            error: {
+                                code: -32603,
+                                message: "Internal server error",
+                            },
+                            id: null,
+                        });
+                    }
+                }
+            }));
+            app.get("/mcp", (req, res) => __awaiter(this, void 0, void 0, function* () {
+                res.writeHead(405).end(JSON.stringify({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32000,
+                        message: "Method not allowed.",
+                    },
+                    id: null,
+                }));
+            }));
+            app.delete("/mcp", (req, res) => __awaiter(this, void 0, void 0, function* () {
+                res.writeHead(405).end(JSON.stringify({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32000,
+                        message: "Method not allowed.",
+                    },
+                    id: null,
+                }));
+            }));
+            app.get("/sse", (req, res) => __awaiter(this, void 0, void 0, function* () {
+                console.log("SSE request received");
+                try {
+                    const transport = new sse_js_1.SSEServerTransport("/messages", res);
+                    sseTransports[transport.sessionId] = transport;
+                    res.on("close", () => {
+                        delete sseTransports[transport.sessionId];
+                        transport.close();
+                    });
+                    yield server.connect(transport);
+                }
+                catch (error) {
+                    console.error("Error handling SSE request:", error);
+                    if (!res.headersSent) {
+                        res.status(500).json({
+                            jsonrpc: "2.0",
+                            error: {
+                                code: -32603,
+                                message: "Internal server error",
+                            },
+                            id: null,
+                        });
+                    }
+                }
+            }));
+            app.post("/messages", (req, res) => __awaiter(this, void 0, void 0, function* () {
+                const sessionId = req.query.sessionId;
+                const transport = sseTransports[sessionId];
+                if (transport) {
+                    yield transport.handlePostMessage(req, res, req.body);
+                }
+                else {
+                    res.status(400).send("No transport found for sessionId");
+                }
+            }));
+            app.listen(port, () => {
+                console.log(`MCP Stateless Streamable HTTP Server listening on port ${port}`);
+            });
+        }
+        else {
+            const transport = new stdio_js_1.StdioServerTransport();
+            yield server.connect(transport);
+            console.log("MCP server running with stdio transport");
+        }
+    });
+}
+main().catch((e) => console.error(e.message));

package/build/tools/correspondents.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp";
+export declare function registerCorrespondentTools(server: McpServer, api: any): void;

package/build/tools/correspondents.js

@@ -0,0 +1,117 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCorrespondentTools = registerCorrespondentTools;
+const zod_1 = require("zod");
+const middlewares_1 = require("./utils/middlewares");
+const queryString_1 = require("./utils/queryString");
+function registerCorrespondentTools(server, api) {
+    server.tool("list_correspondents", {
+        page: zod_1.z.number().optional(),
+        page_size: zod_1.z.number().optional(),
+        name__icontains: zod_1.z.string().optional(),
+        name__iendswith: zod_1.z.string().optional(),
+        name__iexact: zod_1.z.string().optional(),
+        name__istartswith: zod_1.z.string().optional(),
+        ordering: zod_1.z.string().optional(),
+    }, (0, middlewares_1.errorMiddleware)((args, extra) => __awaiter(this, void 0, void 0, function* () {
+        if (!api)
+            throw new Error("Please configure API connection first");
+        const queryString = (0, queryString_1.buildQueryString)(args);
+        const response = yield api.request(`/correspondents/${queryString ? `?${queryString}` : ""}`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response),
+                },
+            ],
+        };
+    })));
+    server.tool("get_correspondent", { id: zod_1.z.number() }, (0, middlewares_1.errorMiddleware)((args, extra) => __awaiter(this, void 0, void 0, function* () {
+        if (!api)
+            throw new Error("Please configure API connection first");
+        const response = yield api.request(`/correspondents/${args.id}/`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(response) }],
+        };
+    })));
+    server.tool("create_correspondent", {
+        name: zod_1.z.string(),
+        match: zod_1.z.string().optional(),
+        matching_algorithm: zod_1.z
+            .enum(["any", "all", "exact", "regular expression", "fuzzy"])
+            .optional(),
+    }, (0, middlewares_1.errorMiddleware)((args, extra) => __awaiter(this, void 0, void 0, function* () {
+        if (!api)
+            throw new Error("Please configure API connection first");
+        const response = yield api.createCorrespondent(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(response) }],
+        };
+    })));
+    server.tool("update_correspondent", {
+        id: zod_1.z.number(),
+        name: zod_1.z.string(),
+        match: zod_1.z.string().optional(),
+        matching_algorithm: zod_1.z
+            .enum(["any", "all", "exact", "regular expression", "fuzzy"])
+            .optional(),
+    }, (0, middlewares_1.errorMiddleware)((args, extra) => __awaiter(this, void 0, void 0, function* () {
+        if (!api)
+            throw new Error("Please configure API connection first");
+        const response = yield api.request(`/correspondents/${args.id}/`, {
+            method: "PUT",
+            body: JSON.stringify(args),
+        });
+        return {
+            content: [{ type: "text", text: JSON.stringify(response) }],
+        };
+    })));
+    server.tool("delete_correspondent", { id: zod_1.z.number() }, (0, middlewares_1.errorMiddleware)((args, extra) => __awaiter(this, void 0, void 0, function* () {
+        if (!api)
+            throw new Error("Please configure API connection first");
+        yield api.request(`/correspondents/${args.id}/`, { method: "DELETE" });
+        return {
+            content: [
+                { type: "text", text: JSON.stringify({ status: "deleted" }) },
+            ],
+        };
+    })));
+    server.tool("bulk_edit_correspondents", {
+        correspondent_ids: zod_1.z.array(zod_1.z.number()),
+        operation: zod_1.z.enum(["set_permissions", "delete"]),
+        owner: zod_1.z.number().optional(),
+        permissions: zod_1.z
+            .object({
+            view: zod_1.z.object({
+                users: zod_1.z.array(zod_1.z.number()).optional(),
+                groups: zod_1.z.array(zod_1.z.number()).optional(),
+            }),
+            change: zod_1.z.object({
+                users: zod_1.z.array(zod_1.z.number()).optional(),
+                groups: zod_1.z.array(zod_1.z.number()).optional(),
+            }),
+        })
+            .optional(),
+        merge: zod_1.z.boolean().optional(),
+    }, (0, middlewares_1.errorMiddleware)((args, extra) => __awaiter(this, void 0, void 0, function* () {
+        if (!api)
+            throw new Error("Please configure API connection first");
+        return api.bulkEditObjects(args.correspondent_ids, "correspondents", args.operation, args.operation === "set_permissions"
+            ? {
+                owner: args.owner,
+                permissions: args.permissions,
+                merge: args.merge,
+            }
+            : {});
+    })));
+}

package/build/tools/documentTypes.d.ts

@@ -0,0 +1 @@
+export declare function registerDocumentTypeTools(server: any, api: any): void;