obsidian-mcp-server 2.0.7 → 3.1.0

package/dist/mcp-server/transports/httpTransport.js

@@ -1,208 +0,0 @@
-/**
- * @fileoverview Configures and starts the Streamable HTTP MCP transport using Hono.
- * This module integrates the `@modelcontextprotocol/sdk`'s `StreamableHTTPServerTransport`
- * into a Hono web server. Its responsibilities include:
- * - Creating a Hono server instance.
- * - Applying and configuring middleware for CORS, rate limiting, and authentication (JWT/OAuth).
- * - Defining the routes (`/mcp` endpoint for POST, GET, DELETE) to handle the MCP lifecycle.
- * - Orchestrating session management by mapping session IDs to SDK transport instances.
- * - Implementing port-binding logic with automatic retry on conflicts.
- *
- * The underlying implementation of the MCP Streamable HTTP specification, including
- * Server-Sent Events (SSE) for streaming, is handled by the SDK's transport class.
- *
- * Specification Reference:
- * https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/transports.mdx#streamable-http
- * @module src/mcp-server/transports/httpTransport
- */
-import { serve } from "@hono/node-server";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
-import { Hono } from "hono";
-import { cors } from "hono/cors";
-import http from "http";
-import { randomUUID } from "node:crypto";
-import { config } from "../../config/index.js";
-import { BaseErrorCode, McpError } from "../../types-global/errors.js";
-import { logger, rateLimiter, requestContextService, } from "../../utils/index.js";
-import { jwtAuthMiddleware, oauthMiddleware, } from "./auth/index.js";
-import { httpErrorHandler } from "./httpErrorHandler.js";
-const HTTP_PORT = config.mcpHttpPort;
-const HTTP_HOST = config.mcpHttpHost;
-const MCP_ENDPOINT_PATH = "/mcp";
-const MAX_PORT_RETRIES = 15;
-// The transports map will store active sessions, keyed by session ID.
-// NOTE: This is an in-memory session store, which is a known limitation for scalability.
-// It will not work in a multi-process (clustered) or serverless environment.
-// For a scalable deployment, this would need to be replaced with a distributed
-// store like Redis or Memcached.
-const transports = {};
-async function isPortInUse(port, host, parentContext) {
-    const checkContext = requestContextService.createRequestContext({
-        ...parentContext,
-        operation: "isPortInUse",
-        port,
-        host,
-    });
-    return new Promise((resolve) => {
-        const tempServer = http.createServer();
-        tempServer
-            .once("error", (err) => {
-            resolve(err.code === "EADDRINUSE");
-        })
-            .once("listening", () => {
-            tempServer.close(() => resolve(false));
-        })
-            .listen(port, host);
-    });
-}
-function startHttpServerWithRetry(app, initialPort, host, maxRetries, parentContext) {
-    const startContext = requestContextService.createRequestContext({
-        ...parentContext,
-        operation: "startHttpServerWithRetry",
-    });
-    return new Promise(async (resolve, reject) => {
-        for (let i = 0; i <= maxRetries; i++) {
-            const currentPort = initialPort + i;
-            const attemptContext = {
-                ...startContext,
-                port: currentPort,
-                attempt: i + 1,
-            };
-            if (await isPortInUse(currentPort, host, attemptContext)) {
-                logger.warning(`Port ${currentPort} is in use, retrying...`, attemptContext);
-                continue;
-            }
-            try {
-                const serverInstance = serve({ fetch: app.fetch, port: currentPort, hostname: host }, (info) => {
-                    const serverAddress = `http://${info.address}:${info.port}${MCP_ENDPOINT_PATH}`;
-                    logger.info(`HTTP transport listening at ${serverAddress}`, {
-                        ...attemptContext,
-                        address: serverAddress,
-                    });
-                    if (process.stdout.isTTY) {
-                        console.log(`\n🚀 MCP Server running at: ${serverAddress}\n`);
-                    }
-                });
-                resolve(serverInstance);
-                return;
-            }
-            catch (err) {
-                if (err.code !== "EADDRINUSE") {
-                    reject(err);
-                    return;
-                }
-            }
-        }
-        reject(new Error("Failed to bind to any port after multiple retries."));
-    });
-}
-export async function startHttpTransport(createServerInstanceFn, parentContext) {
-    const app = new Hono();
-    const transportContext = requestContextService.createRequestContext({
-        ...parentContext,
-        component: "HttpTransportSetup",
-    });
-    app.use("*", cors({
-        origin: config.mcpAllowedOrigins || [],
-        allowMethods: ["GET", "POST", "DELETE", "OPTIONS"],
-        allowHeaders: [
-            "Content-Type",
-            "Mcp-Session-Id",
-            "Last-Event-ID",
-            "Authorization",
-        ],
-        credentials: true,
-    }));
-    app.use("*", async (c, next) => {
-        c.res.headers.set("X-Content-Type-Options", "nosniff");
-        await next();
-    });
-    app.use(MCP_ENDPOINT_PATH, async (c, next) => {
-        // NOTE (Security): The 'x-forwarded-for' header is used for rate limiting.
-        // This is only secure if the server is run behind a trusted proxy that
-        // correctly sets or validates this header.
-        const clientIp = c.req.header("x-forwarded-for")?.split(",")[0].trim() || "unknown_ip";
-        const context = requestContextService.createRequestContext({
-            operation: "httpRateLimitCheck",
-            ipAddress: clientIp,
-        });
-        // Let the centralized error handler catch rate limit errors
-        rateLimiter.check(clientIp, context);
-        await next();
-    });
-    if (config.mcpAuthMode === "oauth") {
-        app.use(MCP_ENDPOINT_PATH, oauthMiddleware);
-    }
-    else {
-        app.use(MCP_ENDPOINT_PATH, jwtAuthMiddleware);
-    }
-    // Centralized Error Handling
-    app.onError(httpErrorHandler);
-    app.post(MCP_ENDPOINT_PATH, async (c) => {
-        const postContext = requestContextService.createRequestContext({
-            ...transportContext,
-            operation: "handlePost",
-        });
-        const body = await c.req.json();
-        const sessionId = c.req.header("mcp-session-id");
-        let transport = sessionId
-            ? transports[sessionId]
-            : undefined;
-        if (isInitializeRequest(body)) {
-            // If a transport already exists for a session, it's a re-initialization.
-            if (transport) {
-                logger.warning("Re-initializing existing session.", {
-                    ...postContext,
-                    sessionId,
-                });
-                await transport.close(); // This will trigger the onclose handler.
-            }
-            // Create a new transport for a new session.
-            const newTransport = new StreamableHTTPServerTransport({
-                sessionIdGenerator: () => randomUUID(),
-                onsessioninitialized: (newId) => {
-                    transports[newId] = newTransport;
-                    logger.info(`HTTP Session created: ${newId}`, {
-                        ...postContext,
-                        newSessionId: newId,
-                    });
-                },
-            });
-            // Set up cleanup logic for when the transport is closed.
-            newTransport.onclose = () => {
-                const closedSessionId = newTransport.sessionId;
-                if (closedSessionId && transports[closedSessionId]) {
-                    delete transports[closedSessionId];
-                    logger.info(`HTTP Session closed: ${closedSessionId}`, {
-                        ...postContext,
-                        closedSessionId,
-                    });
-                }
-            };
-            // Connect the new transport to a new server instance.
-            const server = await createServerInstanceFn();
-            await server.connect(newTransport);
-            transport = newTransport;
-        }
-        else if (!transport) {
-            // If it's not an initialization request and no transport was found, it's an error.
-            throw new McpError(BaseErrorCode.NOT_FOUND, "Invalid or expired session ID.");
-        }
-        // Pass the request to the transport to handle.
-        return await transport.handleRequest(c.env.incoming, c.env.outgoing, body);
-    });
-    // A reusable handler for GET and DELETE requests which operate on existing sessions.
-    const handleSessionRequest = async (c) => {
-        const sessionId = c.req.header("mcp-session-id");
-        const transport = sessionId ? transports[sessionId] : undefined;
-        if (!transport) {
-            throw new McpError(BaseErrorCode.NOT_FOUND, "Session not found or expired.");
-        }
-        // Let the transport handle the streaming (GET) or termination (DELETE) request.
-        return await transport.handleRequest(c.env.incoming, c.env.outgoing);
-    };
-    app.get(MCP_ENDPOINT_PATH, handleSessionRequest);
-    app.delete(MCP_ENDPOINT_PATH, handleSessionRequest);
-    return startHttpServerWithRetry(app, HTTP_PORT, HTTP_HOST, MAX_PORT_RETRIES, transportContext);
-}

package/dist/mcp-server/transports/stdioTransport.d.ts

@@ -1,42 +0,0 @@
-/**
- * @fileoverview Handles the setup and connection for the Stdio MCP transport.
- * Implements the MCP Specification 2025-03-26 for stdio transport.
- * This transport communicates directly over standard input (stdin) and
- * standard output (stdout), typically used when the MCP server is launched
- * as a child process by a host application.
- *
- * Specification Reference:
- * https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/transports.mdx#stdio
- *
- * --- Authentication Note ---
- * As per the MCP Authorization Specification (2025-03-26, Section 1.2),
- * STDIO transports SHOULD NOT implement HTTP-based authentication flows.
- * Authorization is typically handled implicitly by the host application
- * controlling the server process. This implementation follows that guideline.
- *
- * @see {@link https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/authorization.mdx | MCP Authorization Specification}
- * @module src/mcp-server/transports/stdioTransport
- */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { RequestContext } from "../../utils/index.js";
-/**
- * Connects a given `McpServer` instance to the Stdio transport.
- * This function initializes the SDK's `StdioServerTransport`, which manages
- * communication over `process.stdin` and `process.stdout` according to the
- * MCP stdio transport specification.
- *
- * MCP Spec Points Covered by SDK's `StdioServerTransport`:
- * - Reads JSON-RPC messages (requests, notifications, responses, batches) from stdin.
- * - Writes JSON-RPC messages to stdout.
- * - Handles newline delimiters and ensures no embedded newlines in output messages.
- * - Ensures only valid MCP messages are written to stdout.
- *
- * Logging via the `logger` utility MAY result in output to stderr, which is
- * permitted by the spec for logging purposes.
- *
- * @param server - The `McpServer` instance.
- * @param parentContext - The logging and tracing context from the calling function.
- * @returns A promise that resolves when the Stdio transport is successfully connected.
- * @throws {Error} If the connection fails during setup.
- */
-export declare function connectStdioTransport(server: McpServer, parentContext: RequestContext): Promise<void>;

package/dist/mcp-server/transports/stdioTransport.js

@@ -1,63 +0,0 @@
-/**
- * @fileoverview Handles the setup and connection for the Stdio MCP transport.
- * Implements the MCP Specification 2025-03-26 for stdio transport.
- * This transport communicates directly over standard input (stdin) and
- * standard output (stdout), typically used when the MCP server is launched
- * as a child process by a host application.
- *
- * Specification Reference:
- * https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/transports.mdx#stdio
- *
- * --- Authentication Note ---
- * As per the MCP Authorization Specification (2025-03-26, Section 1.2),
- * STDIO transports SHOULD NOT implement HTTP-based authentication flows.
- * Authorization is typically handled implicitly by the host application
- * controlling the server process. This implementation follows that guideline.
- *
- * @see {@link https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/basic/authorization.mdx | MCP Authorization Specification}
- * @module src/mcp-server/transports/stdioTransport
- */
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { ErrorHandler, logger } from "../../utils/index.js";
-/**
- * Connects a given `McpServer` instance to the Stdio transport.
- * This function initializes the SDK's `StdioServerTransport`, which manages
- * communication over `process.stdin` and `process.stdout` according to the
- * MCP stdio transport specification.
- *
- * MCP Spec Points Covered by SDK's `StdioServerTransport`:
- * - Reads JSON-RPC messages (requests, notifications, responses, batches) from stdin.
- * - Writes JSON-RPC messages to stdout.
- * - Handles newline delimiters and ensures no embedded newlines in output messages.
- * - Ensures only valid MCP messages are written to stdout.
- *
- * Logging via the `logger` utility MAY result in output to stderr, which is
- * permitted by the spec for logging purposes.
- *
- * @param server - The `McpServer` instance.
- * @param parentContext - The logging and tracing context from the calling function.
- * @returns A promise that resolves when the Stdio transport is successfully connected.
- * @throws {Error} If the connection fails during setup.
- */
-export async function connectStdioTransport(server, parentContext) {
-    const operationContext = {
-        ...parentContext,
-        operation: "connectStdioTransport",
-        transportType: "Stdio",
-    };
-    logger.debug("Attempting to connect stdio transport...", operationContext);
-    try {
-        logger.debug("Creating StdioServerTransport instance...", operationContext);
-        const transport = new StdioServerTransport();
-        logger.debug("Connecting McpServer instance to StdioServerTransport...", operationContext);
-        await server.connect(transport);
-        logger.info("MCP Server connected and listening via stdio transport.", operationContext);
-        if (process.stdout.isTTY) {
-            console.log(`\n🚀 MCP Server running in STDIO mode.\n   (MCP Spec: 2025-03-26 Stdio Transport)\n`);
-        }
-    }
-    catch (err) {
-        ErrorHandler.handleError(err, { ...operationContext, critical: true });
-        throw err; // Re-throw after handling to allow caller to react if necessary
-    }
-}

package/dist/services/obsidianRestAPI/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * @module ObsidianRestApiService Barrel File
- * @description
- * Exports the singleton instance of the Obsidian REST API service and related types.
- */
-export * from "./types.js";
-export { ObsidianRestApiService } from "./service.js";
-export * as activeFileMethods from "./methods/activeFileMethods.js";
-export * as commandMethods from "./methods/commandMethods.js";
-export * as openMethods from "./methods/openMethods.js";
-export * as patchMethods from "./methods/patchMethods.js";
-export * as periodicNoteMethods from "./methods/periodicNoteMethods.js";
-export * as searchMethods from "./methods/searchMethods.js";
-export * as vaultMethods from "./methods/vaultMethods.js";
-export { VaultCacheService } from "./vaultCache/index.js";

package/dist/services/obsidianRestAPI/index.js

@@ -1,17 +0,0 @@
-/**
- * @module ObsidianRestApiService Barrel File
- * @description
- * Exports the singleton instance of the Obsidian REST API service and related types.
- */
-export * from "./types.js"; // Export all types
-// Removed singleton export
-export { ObsidianRestApiService } from "./service.js"; // Export the class itself
-// Export method modules if direct access is desired, though typically accessed via service instance
-export * as activeFileMethods from "./methods/activeFileMethods.js";
-export * as commandMethods from "./methods/commandMethods.js";
-export * as openMethods from "./methods/openMethods.js";
-export * as patchMethods from "./methods/patchMethods.js";
-export * as periodicNoteMethods from "./methods/periodicNoteMethods.js";
-export * as searchMethods from "./methods/searchMethods.js";
-export * as vaultMethods from "./methods/vaultMethods.js";
-export { VaultCacheService } from "./vaultCache/index.js";

package/dist/services/obsidianRestAPI/methods/activeFileMethods.d.ts

@@ -1,38 +0,0 @@
-/**
- * @module ActiveFileMethods
- * @description
- * Methods for interacting with the currently active file in Obsidian via the REST API.
- */
-import { RequestContext } from "../../../utils/index.js";
-import { NoteJson, RequestFunction } from "../types.js";
-/**
- * Gets the content of the currently active file in Obsidian.
- * @param _request - The internal request function from the service instance.
- * @param format - 'markdown' or 'json' (for NoteJson).
- * @param context - Request context.
- * @returns The file content (string) or NoteJson object.
- */
-export declare function getActiveFile(_request: RequestFunction, format: "markdown" | "json" | undefined, context: RequestContext): Promise<string | NoteJson>;
-/**
- * Updates (overwrites) the content of the currently active file.
- * @param _request - The internal request function from the service instance.
- * @param content - The new content.
- * @param context - Request context.
- * @returns {Promise<void>} Resolves on success (204 No Content).
- */
-export declare function updateActiveFile(_request: RequestFunction, content: string, context: RequestContext): Promise<void>;
-/**
- * Appends content to the end of the currently active file.
- * @param _request - The internal request function from the service instance.
- * @param content - The content to append.
- * @param context - Request context.
- * @returns {Promise<void>} Resolves on success (204 No Content).
- */
-export declare function appendActiveFile(_request: RequestFunction, content: string, context: RequestContext): Promise<void>;
-/**
- * Deletes the currently active file.
- * @param _request - The internal request function from the service instance.
- * @param context - Request context.
- * @returns {Promise<void>} Resolves on success (204 No Content).
- */
-export declare function deleteActiveFile(_request: RequestFunction, context: RequestContext): Promise<void>;

package/dist/services/obsidianRestAPI/methods/activeFileMethods.js

@@ -1,62 +0,0 @@
-/**
- * @module ActiveFileMethods
- * @description
- * Methods for interacting with the currently active file in Obsidian via the REST API.
- */
-/**
- * Gets the content of the currently active file in Obsidian.
- * @param _request - The internal request function from the service instance.
- * @param format - 'markdown' or 'json' (for NoteJson).
- * @param context - Request context.
- * @returns The file content (string) or NoteJson object.
- */
-export async function getActiveFile(_request, format = "markdown", context) {
-    const acceptHeader = format === "json" ? "application/vnd.olrapi.note+json" : "text/markdown";
-    return _request({
-        method: "GET",
-        url: `/active/`,
-        headers: { Accept: acceptHeader },
-    }, context, "getActiveFile");
-}
-/**
- * Updates (overwrites) the content of the currently active file.
- * @param _request - The internal request function from the service instance.
- * @param content - The new content.
- * @param context - Request context.
- * @returns {Promise<void>} Resolves on success (204 No Content).
- */
-export async function updateActiveFile(_request, content, context) {
-    await _request({
-        method: "PUT",
-        url: `/active/`,
-        headers: { "Content-Type": "text/markdown" },
-        data: content,
-    }, context, "updateActiveFile");
-}
-/**
- * Appends content to the end of the currently active file.
- * @param _request - The internal request function from the service instance.
- * @param content - The content to append.
- * @param context - Request context.
- * @returns {Promise<void>} Resolves on success (204 No Content).
- */
-export async function appendActiveFile(_request, content, context) {
-    await _request({
-        method: "POST",
-        url: `/active/`,
-        headers: { "Content-Type": "text/markdown" },
-        data: content,
-    }, context, "appendActiveFile");
-}
-/**
- * Deletes the currently active file.
- * @param _request - The internal request function from the service instance.
- * @param context - Request context.
- * @returns {Promise<void>} Resolves on success (204 No Content).
- */
-export async function deleteActiveFile(_request, context) {
-    await _request({
-        method: "DELETE",
-        url: `/active/`,
-    }, context, "deleteActiveFile");
-}

package/dist/services/obsidianRestAPI/methods/commandMethods.d.ts

@@ -1,22 +0,0 @@
-/**
- * @module CommandMethods
- * @description
- * Methods for interacting with Obsidian commands via the REST API.
- */
-import { RequestContext } from "../../../utils/index.js";
-import { ObsidianCommand, RequestFunction } from "../types.js";
-/**
- * Executes a registered Obsidian command by its ID.
- * @param _request - The internal request function from the service instance.
- * @param commandId - The ID of the command (e.g., "app:go-back").
- * @param context - Request context.
- * @returns {Promise<void>} Resolves on success (204 No Content).
- */
-export declare function executeCommand(_request: RequestFunction, commandId: string, context: RequestContext): Promise<void>;
-/**
- * Lists all available Obsidian commands.
- * @param _request - The internal request function from the service instance.
- * @param context - Request context.
- * @returns A list of available commands.
- */
-export declare function listCommands(_request: RequestFunction, context: RequestContext): Promise<ObsidianCommand[]>;

package/dist/services/obsidianRestAPI/methods/commandMethods.js

@@ -1,31 +0,0 @@
-/**
- * @module CommandMethods
- * @description
- * Methods for interacting with Obsidian commands via the REST API.
- */
-/**
- * Executes a registered Obsidian command by its ID.
- * @param _request - The internal request function from the service instance.
- * @param commandId - The ID of the command (e.g., "app:go-back").
- * @param context - Request context.
- * @returns {Promise<void>} Resolves on success (204 No Content).
- */
-export async function executeCommand(_request, commandId, context) {
-    await _request({
-        method: "POST",
-        url: `/commands/${encodeURIComponent(commandId)}/`,
-    }, context, "executeCommand");
-}
-/**
- * Lists all available Obsidian commands.
- * @param _request - The internal request function from the service instance.
- * @param context - Request context.
- * @returns A list of available commands.
- */
-export async function listCommands(_request, context) {
-    const response = await _request({
-        method: "GET",
-        url: "/commands/",
-    }, context, "listCommands");
-    return response.commands;
-}

package/dist/services/obsidianRestAPI/methods/openMethods.d.ts

@@ -1,16 +0,0 @@
-/**
- * @module OpenMethods
- * @description
- * Methods for opening files in Obsidian via the REST API.
- */
-import { RequestContext } from "../../../utils/index.js";
-import { RequestFunction } from "../types.js";
-/**
- * Opens a specific file in Obsidian. Creates the file if it doesn't exist.
- * @param _request - The internal request function from the service instance.
- * @param filePath - Vault-relative path to the file.
- * @param newLeaf - Whether to open the file in a new editor tab (leaf).
- * @param context - Request context.
- * @returns {Promise<void>} Resolves on success (200 OK, but no body expected).
- */
-export declare function openFile(_request: RequestFunction, filePath: string, newLeaf: boolean | undefined, context: RequestContext): Promise<void>;

package/dist/services/obsidianRestAPI/methods/openMethods.js

@@ -1,21 +0,0 @@
-/**
- * @module OpenMethods
- * @description
- * Methods for opening files in Obsidian via the REST API.
- */
-/**
- * Opens a specific file in Obsidian. Creates the file if it doesn't exist.
- * @param _request - The internal request function from the service instance.
- * @param filePath - Vault-relative path to the file.
- * @param newLeaf - Whether to open the file in a new editor tab (leaf).
- * @param context - Request context.
- * @returns {Promise<void>} Resolves on success (200 OK, but no body expected).
- */
-export async function openFile(_request, filePath, newLeaf = false, context) {
-    // This endpoint returns 200 OK, not 204
-    await _request({
-        method: "POST",
-        url: `/open/${encodeURIComponent(filePath)}`,
-        params: { newLeaf },
-    }, context, "openFile");
-}

package/dist/services/obsidianRestAPI/methods/patchMethods.d.ts

@@ -1,37 +0,0 @@
-/**
- * @module PatchMethods
- * @description
- * Methods for performing granular PATCH operations within notes via the Obsidian REST API.
- */
-import { RequestContext } from "../../../utils/index.js";
-import { PatchOptions, Period, RequestFunction } from "../types.js";
-/**
- * Patches a specific file in the vault.
- * @param _request - The internal request function from the service instance.
- * @param filePath - Vault-relative path to the file.
- * @param content - The content to insert/replace (string or JSON for tables/frontmatter).
- * @param options - Patch operation details (operation, targetType, target, etc.).
- * @param context - Request context.
- * @returns {Promise<void>} Resolves on success (200 OK).
- */
-export declare function patchFile(_request: RequestFunction, filePath: string, content: string | object, // Allow object for JSON content type
-options: PatchOptions, context: RequestContext): Promise<void>;
-/**
- * Patches the currently active file in Obsidian.
- * @param _request - The internal request function from the service instance.
- * @param content - The content to insert/replace.
- * @param options - Patch operation details.
- * @param context - Request context.
- * @returns {Promise<void>} Resolves on success (200 OK).
- */
-export declare function patchActiveFile(_request: RequestFunction, content: string | object, options: PatchOptions, context: RequestContext): Promise<void>;
-/**
- * Patches a periodic note.
- * @param _request - The internal request function from the service instance.
- * @param period - The period type ('daily', 'weekly', etc.).
- * @param content - The content to insert/replace.
- * @param options - Patch operation details.
- * @param context - Request context.
- * @returns {Promise<void>} Resolves on success (200 OK).
- */
-export declare function patchPeriodicNote(_request: RequestFunction, period: Period, content: string | object, options: PatchOptions, context: RequestContext): Promise<void>;