bitfire-lark-mcp 1.0.0

package/dist/mcp-server/shared/types.d.ts

@@ -0,0 +1,40 @@
+import * as larkmcp from '../../mcp-tool';
+import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { LarkAuthHandler } from '../../auth';
+export type McpServerType = 'oapi' | 'recall';
+export type McpServerTransport = 'stdio' | 'sse' | 'streamable';
+export declare const mcpServerOptionSchema: z.ZodObject<{
+    tools: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    language: z.ZodOptional<z.ZodEnum<["zh", "en"]>>;
+    toolNameCase: z.ZodOptional<z.ZodEnum<["snake", "camel"]>>;
+    tokenMode: z.ZodOptional<z.ZodEnum<["auto", "user_access_token", "tenant_access_token"]>>;
+}, "strip", z.ZodTypeAny, {
+    language?: "en" | "zh" | undefined;
+    tokenMode?: "auto" | "user_access_token" | "tenant_access_token" | undefined;
+    tools?: string | string[] | undefined;
+    toolNameCase?: "snake" | "camel" | undefined;
+}, {
+    language?: "en" | "zh" | undefined;
+    tokenMode?: "auto" | "user_access_token" | "tenant_access_token" | undefined;
+    tools?: string | string[] | undefined;
+    toolNameCase?: "snake" | "camel" | undefined;
+}>;
+export interface McpServerOptions {
+    appId?: string;
+    appSecret?: string;
+    domain?: string;
+    tools?: string[];
+    language?: 'zh' | 'en';
+    toolNameCase?: larkmcp.ToolNameCase;
+    tokenMode?: larkmcp.TokenMode;
+    userAccessToken?: string | larkmcp.SettableValue;
+    oauth?: boolean;
+    scope?: string[];
+    mode?: McpServerTransport;
+    host?: string;
+    port?: number;
+}
+export type InitTransportServerFunction = (getNewServer: (options?: McpServerOptions, authHandler?: LarkAuthHandler) => McpServer, mcpServerOptions: McpServerOptions, authOptions?: {
+    needAuthFlow: boolean;
+}) => void | Promise<void>;

package/dist/mcp-server/shared/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mcpServerOptionSchema = void 0;
+const zod_1 = require("zod");
+exports.mcpServerOptionSchema = zod_1.z.object({
+    tools: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional(),
+    language: zod_1.z.enum(['zh', 'en']).optional(),
+    toolNameCase: zod_1.z.enum(['snake', 'camel']).optional(),
+    tokenMode: zod_1.z.enum(['auto', 'user_access_token', 'tenant_access_token']).optional(),
+});

package/dist/mcp-server/transport/index.d.ts

@@ -0,0 +1,3 @@
+export * from './stdio';
+export * from './sse';
+export * from './streamable';

package/dist/mcp-server/transport/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./stdio"), exports);
+__exportStar(require("./sse"), exports);
+__exportStar(require("./streamable"), exports);

package/dist/mcp-server/transport/sse.d.ts

@@ -0,0 +1,2 @@
+import { InitTransportServerFunction } from '../shared';
+export declare const initSSEServer: InitTransportServerFunction;

package/dist/mcp-server/transport/sse.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initSSEServer = void 0;
+const express_1 = __importDefault(require("express"));
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const auth_1 = require("../../auth");
+const utils_1 = require("./utils");
+const logger_1 = require("../../utils/logger");
+const initSSEServer = (getNewServer, options, { needAuthFlow } = { needAuthFlow: false }) => {
+    const { userAccessToken, port, host, oauth } = options;
+    if (!port || !host) {
+        throw new Error('[Lark MCP] Port and host are required');
+    }
+    const app = (0, express_1.default)();
+    const transports = new Map();
+    let authHandler;
+    if (!userAccessToken && needAuthFlow) {
+        authHandler = new auth_1.LarkAuthHandler(app, options);
+        if (oauth) {
+            authHandler.setupRoutes();
+        }
+    }
+    const authMiddleware = (req, res, next) => {
+        var _a;
+        if (authHandler && oauth) {
+            authHandler.authenticateRequest(req, res, next);
+        }
+        else {
+            const authToken = (_a = req.headers.authorization) === null || _a === void 0 ? void 0 : _a.split(' ')[1];
+            if (authToken) {
+                req.auth = { token: authToken, clientId: 'client_id_for_local_auth', scopes: [] };
+            }
+            next();
+        }
+    };
+    app.get('/sse', authMiddleware, async (req, res) => {
+        var _a;
+        logger_1.logger.info(`[SSEServerTransport] Received GET SSE request`);
+        const token = (_a = req.auth) === null || _a === void 0 ? void 0 : _a.token;
+        const { data } = (0, utils_1.parseMCPServerOptionsFromRequest)(req);
+        const server = getNewServer({ ...options, ...data, userAccessToken: data.userAccessToken || token }, authHandler);
+        const transport = new sse_js_1.SSEServerTransport('/messages', res);
+        transports.set(transport.sessionId, transport);
+        res.on('close', () => {
+            transport.close();
+            server.close();
+            transports.delete(transport.sessionId);
+        });
+        await server.connect(transport);
+    });
+    app.post('/messages', authMiddleware, async (req, res) => {
+        console.log('Received POST messages request');
+        logger_1.logger.info(`[SSEServerTransport] Received POST messages request`);
+        const sessionId = req.query.sessionId;
+        const transport = transports.get(sessionId);
+        if (!transport) {
+            res.status(400).send('No transport found for sessionId');
+            return;
+        }
+        await transport.handlePostMessage(req, res);
+    });
+    console.log('⚠️ SSE Mode is deprecated and will be removed in a future version. Please use Streamable mode instead.');
+    app.listen(port, host, (error) => {
+        if (error) {
+            logger_1.logger.error(`[SSEServerTransport] Server error: ${error}`);
+            process.exit(1);
+        }
+        console.log(`📡 SSE endpoint: http://${host}:${port}/sse`);
+        logger_1.logger.info(`[SSEServerTransport] SSE endpoint: http://${host}:${port}/sse`);
+    });
+};
+exports.initSSEServer = initSSEServer;

package/dist/mcp-server/transport/stdio.d.ts

@@ -0,0 +1,2 @@
+import { InitTransportServerFunction } from '../shared';
+export declare const initStdioServer: InitTransportServerFunction;

package/dist/mcp-server/transport/stdio.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initStdioServer = void 0;
+const express_1 = __importDefault(require("express"));
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const auth_1 = require("../../auth");
+const auth_2 = require("../../auth");
+const logger_1 = require("../../utils/logger");
+const initStdioServer = async (getNewServer, options, { needAuthFlow } = { needAuthFlow: false }) => {
+    const { userAccessToken, appId, oauth } = options;
+    let authHandler;
+    if (!userAccessToken && needAuthFlow) {
+        const app = (0, express_1.default)();
+        app.use(express_1.default.json());
+        authHandler = new auth_2.LarkAuthHandlerLocal(app, options);
+        if (oauth) {
+            authHandler.setupRoutes();
+        }
+    }
+    const transport = new stdio_js_1.StdioServerTransport();
+    const userAccessTokenValue = userAccessToken
+        ? userAccessToken
+        : appId
+            ? { getter: async () => await auth_1.authStore.getLocalAccessToken(appId) }
+            : undefined;
+    const mcpServer = getNewServer({ ...options, userAccessToken: userAccessTokenValue }, authHandler);
+    logger_1.logger.info(`[StdioServerTransport] Connecting to MCP Server, userAccessToken: ${Boolean(userAccessToken)}, appId: ${appId}`);
+    mcpServer.connect(transport).catch((error) => {
+        logger_1.logger.error(`[StdioServerTransport] MCP Connect Error: ${error}`);
+        process.exit(1);
+    });
+};
+exports.initStdioServer = initStdioServer;

package/dist/mcp-server/transport/streamable.d.ts

@@ -0,0 +1,2 @@
+import { InitTransportServerFunction } from '../shared';
+export declare const initStreamableServer: InitTransportServerFunction;

package/dist/mcp-server/transport/streamable.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initStreamableServer = void 0;
+const express_1 = __importDefault(require("express"));
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const utils_1 = require("./utils");
+const auth_1 = require("../../auth");
+const logger_1 = require("../../utils/logger");
+const initStreamableServer = (getNewServer, options, { needAuthFlow } = { needAuthFlow: false }) => {
+    const { userAccessToken, oauth, port, host } = options;
+    if (!port || !host) {
+        throw new Error('[Lark MCP] Port and host are required');
+    }
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json());
+    let authHandler;
+    if (!userAccessToken && needAuthFlow) {
+        authHandler = new auth_1.LarkAuthHandler(app, options);
+        if (oauth) {
+            authHandler.setupRoutes();
+        }
+    }
+    const authMiddleware = (req, res, next) => {
+        var _a;
+        if (authHandler && oauth) {
+            authHandler.authenticateRequest(req, res, next);
+        }
+        else {
+            const authToken = (_a = req.headers.authorization) === null || _a === void 0 ? void 0 : _a.split(' ')[1];
+            if (authToken) {
+                req.auth = { token: authToken, clientId: 'client_id_for_local_auth', scopes: [] };
+            }
+            next();
+        }
+    };
+    app.post('/mcp', authMiddleware, async (req, res) => {
+        var _a;
+        const token = (_a = req.auth) === null || _a === void 0 ? void 0 : _a.token;
+        const { data } = (0, utils_1.parseMCPServerOptionsFromRequest)(req);
+        const server = getNewServer({ ...options, ...data, userAccessToken: data.userAccessToken || token }, authHandler);
+        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+        res.on('close', () => {
+            transport.close();
+            server.close();
+        });
+        await server.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+    });
+    const handleMethodNotAllowed = async (_req, res) => {
+        res
+            .writeHead(405)
+            .end(JSON.stringify({ jsonrpc: '2.0', error: { code: -32000, message: 'Method not allowed.' }, id: null }));
+    };
+    app.get('/mcp', async (req, res) => {
+        try {
+            console.log('Received GET MCP request');
+            logger_1.logger.info(`[StreamableServerTransport] Received GET MCP request`);
+            await handleMethodNotAllowed(req, res);
+        }
+        catch (error) {
+            (0, utils_1.sendJsonRpcError)(res, error);
+        }
+    });
+    app.delete('/mcp', async (req, res) => {
+        try {
+            console.log('Received DELETE MCP request');
+            logger_1.logger.info(`[StreamableServerTransport] Received DELETE MCP request`);
+            await handleMethodNotAllowed(req, res);
+        }
+        catch (error) {
+            (0, utils_1.sendJsonRpcError)(res, error);
+        }
+    });
+    app.listen(port, host, (error) => {
+        if (error) {
+            logger_1.logger.error(`[StreamableServerTransport] Server error: ${error}`);
+            process.exit(1);
+        }
+        console.log(`📡 Streamable endpoint: http://${host}:${port}/mcp`);
+        logger_1.logger.info(`[StreamableServerTransport] Streamable endpoint: http://${host}:${port}/mcp`);
+    });
+};
+exports.initStreamableServer = initStreamableServer;

package/dist/mcp-server/transport/utils.d.ts

@@ -0,0 +1,16 @@
+import { Request, Response } from 'express';
+import { McpServerOptions } from '../shared';
+export declare enum JSONRPCErrorCodes {
+    PARSE_ERROR = -32700,
+    INVALID_REQUEST = -32600,
+    METHOD_NOT_FOUND = -32601,
+    INVALID_PARAMS = -32602,
+    INTERNAL_ERROR = -32603
+}
+export declare function parseMCPServerOptionsFromRequest(req: Request): {
+    data: McpServerOptions;
+    success: boolean;
+    message?: string;
+};
+export declare function sendJsonRpcError(res: Response, error: Error, httpCode?: number, code?: JSONRPCErrorCodes, id?: number | null): void;
+export declare function sendResponseError(res: Response, error: Error, httpCode?: number): void;

package/dist/mcp-server/transport/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONRPCErrorCodes = void 0;
+exports.parseMCPServerOptionsFromRequest = parseMCPServerOptionsFromRequest;
+exports.sendJsonRpcError = sendJsonRpcError;
+exports.sendResponseError = sendResponseError;
+const shared_1 = require("../shared");
+var JSONRPCErrorCodes;
+(function (JSONRPCErrorCodes) {
+    JSONRPCErrorCodes[JSONRPCErrorCodes["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+    JSONRPCErrorCodes[JSONRPCErrorCodes["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+    JSONRPCErrorCodes[JSONRPCErrorCodes["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+    JSONRPCErrorCodes[JSONRPCErrorCodes["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+    JSONRPCErrorCodes[JSONRPCErrorCodes["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+})(JSONRPCErrorCodes || (exports.JSONRPCErrorCodes = JSONRPCErrorCodes = {}));
+function parseMCPServerOptionsFromRequest(req) {
+    const result = shared_1.mcpServerOptionSchema.safeParse(req.query || {});
+    if (!result.success) {
+        return { data: {}, success: false, message: result.error.message };
+    }
+    return { data: result.data, success: true };
+}
+function sendJsonRpcError(res, error, httpCode = 500, code = JSONRPCErrorCodes.INTERNAL_ERROR, id = null) {
+    console.error(error);
+    if (!res.headersSent) {
+        res.status(httpCode).json({ jsonrpc: '2.0', error: { code, message: error.message }, id });
+    }
+}
+function sendResponseError(res, error, httpCode = 500) {
+    console.error(error);
+    if (!res.headersSent) {
+        res.status(httpCode).send(error.message);
+    }
+}

package/dist/mcp-tool/constants.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Commonly used tools in MCP
+ */
+import { ToolName } from './tools';
+export declare enum PresetName {
+    /**
+     * Default preset including IM, Bitable, Doc and Contact tools
+     */
+    LIGHT = "preset.light",
+    /**
+     * Default preset including IM, Bitable, Doc and Contact tools
+     */
+    DEFAULT = "preset.default",
+    /**
+     * IM related tools for chat and message operations
+     */
+    IM_DEFAULT = "preset.im.default",
+    /**
+     * Base preset for base operations
+     */
+    BASE_DEFAULT = "preset.base.default",
+    /**
+     * Base tools with batch operations
+     */
+    BASE_BATCH = "preset.base.batch",
+    /**
+     * Document related tools for content and permission operations
+     */
+    DOC_DEFAULT = "preset.doc.default",
+    /**
+     * Task management related tools
+     */
+    TASK_DEFAULT = "preset.task.default",
+    /**
+     * Calendar event management tools
+     */
+    CALENDAR_DEFAULT = "preset.calendar.default"
+}
+export declare const presetLightToolNames: ToolName[];
+export declare const presetContactToolNames: ToolName[];
+export declare const presetImToolNames: ToolName[];
+export declare const presetBaseCommonToolNames: ToolName[];
+export declare const presetBaseToolNames: ToolName[];
+export declare const presetBaseRecordBatchToolNames: ToolName[];
+export declare const presetDocToolNames: ToolName[];
+export declare const presetTaskToolNames: ToolName[];
+export declare const presetCalendarToolNames: ToolName[];
+export declare const defaultToolNames: ToolName[];
+export declare const presetTools: Record<PresetName, ToolName[]>;

package/dist/mcp-tool/constants.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * Commonly used tools in MCP
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presetTools = exports.defaultToolNames = exports.presetCalendarToolNames = exports.presetTaskToolNames = exports.presetDocToolNames = exports.presetBaseRecordBatchToolNames = exports.presetBaseToolNames = exports.presetBaseCommonToolNames = exports.presetImToolNames = exports.presetContactToolNames = exports.presetLightToolNames = exports.PresetName = void 0;
+var PresetName;
+(function (PresetName) {
+    /**
+     * Default preset including IM, Bitable, Doc and Contact tools
+     */
+    PresetName["LIGHT"] = "preset.light";
+    /**
+     * Default preset including IM, Bitable, Doc and Contact tools
+     */
+    PresetName["DEFAULT"] = "preset.default";
+    /**
+     * IM related tools for chat and message operations
+     */
+    PresetName["IM_DEFAULT"] = "preset.im.default";
+    /**
+     * Base preset for base operations
+     */
+    PresetName["BASE_DEFAULT"] = "preset.base.default";
+    /**
+     * Base tools with batch operations
+     */
+    PresetName["BASE_BATCH"] = "preset.base.batch";
+    /**
+     * Document related tools for content and permission operations
+     */
+    PresetName["DOC_DEFAULT"] = "preset.doc.default";
+    /**
+     * Task management related tools
+     */
+    PresetName["TASK_DEFAULT"] = "preset.task.default";
+    /**
+     * Calendar event management tools
+     */
+    PresetName["CALENDAR_DEFAULT"] = "preset.calendar.default";
+})(PresetName || (exports.PresetName = PresetName = {}));
+exports.presetLightToolNames = [
+    'im.v1.message.list',
+    'im.v1.message.create',
+    'im.v1.chat.search',
+    'contact.v3.user.batchGetId',
+    'docx.v1.document.rawContent',
+    'docx.builtin.readFullContent',
+    'docx.builtin.import',
+    'docx.builtin.search',
+    'wiki.v2.space.getNode',
+    'bitable.v1.appTableRecord.search',
+    'bitable.v1.appTableRecord.batchCreate',
+];
+exports.presetContactToolNames = ['contact.v3.user.batchGetId'];
+exports.presetImToolNames = [
+    'im.v1.chat.create',
+    'im.v1.chat.list',
+    'im.v1.chatMembers.get',
+    'im.v1.message.create',
+    'im.v1.message.list',
+];
+exports.presetBaseCommonToolNames = [
+    'bitable.v1.app.create',
+    'bitable.v1.appTable.create',
+    'bitable.v1.appTable.list',
+    'bitable.v1.appTableField.list',
+    'bitable.v1.appTableRecord.search',
+];
+exports.presetBaseToolNames = [
+    ...exports.presetBaseCommonToolNames,
+    'bitable.v1.appTableRecord.create',
+    'bitable.v1.appTableRecord.update',
+];
+exports.presetBaseRecordBatchToolNames = [
+    ...exports.presetBaseCommonToolNames,
+    'bitable.v1.appTableRecord.batchCreate',
+    'bitable.v1.appTableRecord.batchUpdate',
+];
+exports.presetDocToolNames = [
+    'docx.v1.document.rawContent',
+    'docx.builtin.readFullContent',
+    'docx.builtin.import',
+    'docx.builtin.search',
+    'drive.v1.permissionMember.create',
+    'wiki.v2.space.getNode',
+    'wiki.v1.node.search',
+    'board.v1.whiteboardNode.list',
+];
+exports.presetTaskToolNames = [
+    'task.v2.task.create',
+    'task.v2.task.patch',
+    'task.v2.task.addMembers',
+    'task.v2.task.addReminders',
+];
+exports.presetCalendarToolNames = [
+    'calendar.v4.calendarEvent.create',
+    'calendar.v4.calendarEvent.patch',
+    'calendar.v4.calendarEvent.get',
+    'calendar.v4.freebusy.list',
+    'calendar.v4.calendar.primary',
+];
+exports.defaultToolNames = [
+    ...exports.presetImToolNames,
+    ...exports.presetBaseToolNames,
+    ...exports.presetDocToolNames,
+    ...exports.presetContactToolNames,
+];
+exports.presetTools = {
+    [PresetName.LIGHT]: exports.presetLightToolNames,
+    [PresetName.DEFAULT]: exports.defaultToolNames,
+    [PresetName.IM_DEFAULT]: exports.presetImToolNames,
+    [PresetName.BASE_DEFAULT]: exports.presetBaseToolNames,
+    [PresetName.BASE_BATCH]: exports.presetBaseRecordBatchToolNames,
+    [PresetName.DOC_DEFAULT]: exports.presetDocToolNames,
+    [PresetName.TASK_DEFAULT]: exports.presetTaskToolNames,
+    [PresetName.CALENDAR_DEFAULT]: exports.presetCalendarToolNames,
+};

package/dist/mcp-tool/document-tool/index.d.ts

@@ -0,0 +1 @@
+export * from './recall';

package/dist/mcp-tool/document-tool/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./recall"), exports);

package/dist/mcp-tool/document-tool/read-full-content/extract-text.d.ts

@@ -0,0 +1,53 @@
+import type { DocxBlockTextElement, DocxBlockText, DocxBlockItem, DocxBlockTable } from './types';
+/** 从文本元素列表中提取纯文本 */
+export declare function extractTextFromElements(elements?: DocxBlockTextElement[]): string;
+/** 从 block.text 提取纯文本 */
+export declare function extractBlockText(block?: {
+    text?: DocxBlockText;
+} | null): string;
+/** Block 类型枚举（与飞书 API 一致） */
+export declare const BLOCK_TYPE: {
+    readonly PAGE: 1;
+    readonly TEXT: 2;
+    readonly HEADING1: 3;
+    readonly HEADING2: 4;
+    readonly HEADING3: 5;
+    readonly HEADING4: 6;
+    readonly HEADING5: 7;
+    readonly HEADING6: 8;
+    readonly HEADING7: 9;
+    readonly HEADING8: 10;
+    readonly HEADING9: 11;
+    readonly BULLET: 12;
+    readonly ORDERED: 13;
+    readonly CODE: 14;
+    readonly QUOTE: 15;
+    readonly TODO: 17;
+    readonly BITABLE: 18;
+    readonly CALLOUT: 19;
+    readonly CHAT_CARD: 20;
+    readonly DIAGRAM: 21;
+    readonly DIVIDER: 22;
+    readonly FILE: 23;
+    readonly GRID: 24;
+    readonly GRID_COLUMN: 25;
+    readonly IFRAME: 26;
+    readonly IMAGE: 27;
+    readonly ISV: 28;
+    readonly MINDNOTE: 29;
+    readonly SHEET: 30;
+    readonly TABLE: 31;
+    readonly TABLE_CELL: 32;
+    readonly VIEW: 33;
+    readonly QUOTE_CONTAINER: 34;
+    readonly TASK: 35;
+    readonly OKR: 36;
+    readonly BOARD: 37;
+    readonly LINK_PREVIEW: 38;
+    /** 画板（文档内嵌画板，部分 API 版本返回 43） */
+    readonly BOARD_DOCX: 43;
+};
+/** 标题层级对应 Markdown 前缀 */
+export declare function headingPrefix(blockType: number): string;
+/** 将表格块及其子单元格块格式化为 Markdown 表格 */
+export declare function formatTableMarkdown(tableBlock: DocxBlockItem, cellBlocks: DocxBlockItem[], tableProp?: DocxBlockTable['property']): string;