obsidian-mcp-server 3.1.2 → 3.1.4

package/dist/mcp-server/tools/definitions/index.d.ts

@@ -39,6 +39,7 @@ export declare const readToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
         }>;
         target: import("zod").ZodString;
     }, import("zod/v4/core").$strip>>;
+    includeLinks: import("zod").ZodDefault<import("zod").ZodBoolean>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         format: import("zod").ZodLiteral<"content">;
@@ -55,6 +56,13 @@ export declare const readToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
             mtime: import("zod").ZodNumber;
             size: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
+        outgoingLinks: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            target: import("zod").ZodString;
+            type: import("zod").ZodEnum<{
+                markdown: "markdown";
+                wikilink: "wikilink";
+            }>;
+        }, import("zod/v4/core").$strip>>>;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         format: import("zod").ZodLiteral<"document-map">;
         path: import("zod").ZodString;
@@ -84,7 +92,7 @@ export declare const readToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "The target path is outside OBSIDIAN_READ_PATHS (and OBSIDIAN_WRITE_PATHS, since write paths imply read access).";
-    readonly recovery: "Use a path inside the configured read scope. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured read scope. The error data echoes the active scope.";
 }, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -94,7 +102,7 @@ export declare const readToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
-    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -104,12 +112,12 @@ export declare const readToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "periodic_disabled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
-    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     path: import("zod").ZodOptional<import("zod").ZodString>;
     extension: import("zod").ZodOptional<import("zod").ZodString>;
     nameRegex: import("zod").ZodOptional<import("zod").ZodString>;
-    depth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    depth: import("zod").ZodDefault<import("zod").ZodNumber>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     path: import("zod").ZodString;
     entries: import("zod").ZodArray<import("zod").ZodObject<{
@@ -139,7 +147,7 @@ export declare const readToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "regex_invalid";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "The supplied `nameRegex` is not a valid ECMAScript regex.";
-    readonly recovery: "Test the pattern (e.g. `^Project.*\\.md$`) in a JS regex tester, or omit nameRegex to disable filtering.";
+    readonly recovery: "Use a valid ECMAScript regex (e.g. `^Project.*\\.md$`), or omit nameRegex to disable filtering.";
 }, {
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
@@ -167,7 +175,7 @@ export declare const readToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "The target path is outside OBSIDIAN_READ_PATHS (and OBSIDIAN_WRITE_PATHS, since write paths imply read access).";
-    readonly recovery: "Use a path inside the configured read scope. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured read scope. The error data echoes the active scope.";
 }, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -181,9 +189,9 @@ export declare const readToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     }>;
     query: import("zod").ZodOptional<import("zod").ZodString>;
     logic: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
-    contextLength: import("zod").ZodOptional<import("zod").ZodNumber>;
+    contextLength: import("zod").ZodDefault<import("zod").ZodNumber>;
     pathPrefix: import("zod").ZodOptional<import("zod").ZodString>;
-    maxMatchesPerHit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    maxMatchesPerHit: import("zod").ZodDefault<import("zod").ZodNumber>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         mode: import("zod").ZodLiteral<"text">;
@@ -280,7 +288,32 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
-    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured write scope. The error data echoes the active scope.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Section append targets a path that does not resolve to an existing note (PATCH requires the file to exist).";
+    readonly recovery: "Verify the path with obsidian_list_notes, or omit `section` to fall back to whole-file append (which creates the note if missing).";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Create the periodic note first or pass an explicit path target.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
+}, {
+    readonly reason: "section_target_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`section` was provided but the named heading/block/frontmatter field does not exist in the note.";
+    readonly recovery: "Call obsidian_get_note with format document-map to discover available targets, or pass createTargetIfMissing: true to bring it into existence.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         type: import("zod").ZodLiteral<"path">;
@@ -305,7 +338,7 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
-    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured write scope. The error data echoes the active scope.";
 }, {
     readonly reason: "cancelled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.InvalidRequest;
@@ -320,7 +353,7 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
-    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -330,7 +363,7 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "periodic_disabled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
-    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     operation: import("zod").ZodEnum<{
         set: "set";
@@ -377,7 +410,7 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "`get` requires the path to be readable; `set`/`delete` require it to be inside OBSIDIAN_WRITE_PATHS, with OBSIDIAN_READ_ONLY=false.";
-    readonly recovery: "Use a path inside the configured scope, or unset OBSIDIAN_READ_ONLY for writes. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured scope. The error data echoes the active scope.";
 }, {
     readonly reason: "value_required";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
@@ -392,7 +425,7 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
-    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -402,7 +435,7 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "periodic_disabled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
-    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         type: import("zod").ZodLiteral<"path">;
@@ -457,7 +490,7 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "`list` requires the path to be readable; `add`/`remove` require it to be inside OBSIDIAN_WRITE_PATHS, with OBSIDIAN_READ_ONLY=false.";
-    readonly recovery: "Use a path inside the configured scope, or unset OBSIDIAN_READ_ONLY for writes. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured scope. The error data echoes the active scope.";
 }, {
     readonly reason: "tags_required";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
@@ -472,7 +505,7 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
-    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -482,7 +515,7 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "periodic_disabled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
-    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         type: import("zod").ZodLiteral<"path">;
@@ -542,7 +575,7 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
-    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured write scope. The error data echoes the active scope.";
 }, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -552,7 +585,7 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
-    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -562,7 +595,7 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "periodic_disabled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
-    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
 }, {
     readonly reason: "section_target_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
@@ -605,12 +638,12 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes. (The pre-read also requires the path to be readable.)";
-    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured write scope. The error data echoes the active scope.";
 }, {
     readonly reason: "regex_invalid";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "A `useRegex: true` replacement supplied a `search` pattern that is not a valid ECMAScript regex.";
-    readonly recovery: "Test the pattern in a JS regex tester, or set useRegex to false to match `search` as a literal string.";
+    readonly recovery: "Use a valid ECMAScript regex, or set useRegex to false to match `search` as a literal string.";
 }, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -620,7 +653,7 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
-    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -630,7 +663,7 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "periodic_disabled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
-    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         type: import("zod").ZodLiteral<"path">;
@@ -675,7 +708,32 @@ export declare const writeToolDefinitions: (import("@cyanheads/mcp-ts-core").Too
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
-    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured write scope. The error data echoes the active scope.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Section replace targets a path that does not resolve to an existing note (PATCH requires the file to exist).";
+    readonly recovery: "Verify the path with obsidian_list_notes, or omit `section` to fall back to whole-file write (which creates the note when it is absent).";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Create the periodic note first or pass an explicit path target.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
+}, {
+    readonly reason: "section_target_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`section` was provided but the named heading/block/frontmatter field does not exist in the note.";
+    readonly recovery: "Call obsidian_get_note with format document-map to discover available targets.";
 }]>)[];
 /** Combined base set — preserves the previous registration order. */
 export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
@@ -716,7 +774,32 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
-    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured write scope. The error data echoes the active scope.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Section append targets a path that does not resolve to an existing note (PATCH requires the file to exist).";
+    readonly recovery: "Verify the path with obsidian_list_notes, or omit `section` to fall back to whole-file append (which creates the note if missing).";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Create the periodic note first or pass an explicit path target.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
+}, {
+    readonly reason: "section_target_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`section` was provided but the named heading/block/frontmatter field does not exist in the note.";
+    readonly recovery: "Call obsidian_get_note with format document-map to discover available targets, or pass createTargetIfMissing: true to bring it into existence.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         type: import("zod").ZodLiteral<"path">;
@@ -741,7 +824,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
-    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured write scope. The error data echoes the active scope.";
 }, {
     readonly reason: "cancelled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.InvalidRequest;
@@ -756,7 +839,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
-    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -766,7 +849,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "periodic_disabled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
-    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     format: import("zod").ZodEnum<{
         content: "content";
@@ -798,6 +881,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
         }>;
         target: import("zod").ZodString;
     }, import("zod/v4/core").$strip>>;
+    includeLinks: import("zod").ZodDefault<import("zod").ZodBoolean>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         format: import("zod").ZodLiteral<"content">;
@@ -814,6 +898,13 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
             mtime: import("zod").ZodNumber;
             size: import("zod").ZodNumber;
         }, import("zod/v4/core").$strip>;
+        outgoingLinks: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+            target: import("zod").ZodString;
+            type: import("zod").ZodEnum<{
+                markdown: "markdown";
+                wikilink: "wikilink";
+            }>;
+        }, import("zod/v4/core").$strip>>>;
     }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
         format: import("zod").ZodLiteral<"document-map">;
         path: import("zod").ZodString;
@@ -843,7 +934,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "The target path is outside OBSIDIAN_READ_PATHS (and OBSIDIAN_WRITE_PATHS, since write paths imply read access).";
-    readonly recovery: "Use a path inside the configured read scope. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured read scope. The error data echoes the active scope.";
 }, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -853,7 +944,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
-    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -863,12 +954,12 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "periodic_disabled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
-    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     path: import("zod").ZodOptional<import("zod").ZodString>;
     extension: import("zod").ZodOptional<import("zod").ZodString>;
     nameRegex: import("zod").ZodOptional<import("zod").ZodString>;
-    depth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    depth: import("zod").ZodDefault<import("zod").ZodNumber>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     path: import("zod").ZodString;
     entries: import("zod").ZodArray<import("zod").ZodObject<{
@@ -898,7 +989,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "regex_invalid";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "The supplied `nameRegex` is not a valid ECMAScript regex.";
-    readonly recovery: "Test the pattern (e.g. `^Project.*\\.md$`) in a JS regex tester, or omit nameRegex to disable filtering.";
+    readonly recovery: "Use a valid ECMAScript regex (e.g. `^Project.*\\.md$`), or omit nameRegex to disable filtering.";
 }, {
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
@@ -960,7 +1051,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "`get` requires the path to be readable; `set`/`delete` require it to be inside OBSIDIAN_WRITE_PATHS, with OBSIDIAN_READ_ONLY=false.";
-    readonly recovery: "Use a path inside the configured scope, or unset OBSIDIAN_READ_ONLY for writes. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured scope. The error data echoes the active scope.";
 }, {
     readonly reason: "value_required";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
@@ -975,7 +1066,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
-    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -985,7 +1076,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "periodic_disabled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
-    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     target: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         type: import("zod").ZodLiteral<"path">;
@@ -1040,7 +1131,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "`list` requires the path to be readable; `add`/`remove` require it to be inside OBSIDIAN_WRITE_PATHS, with OBSIDIAN_READ_ONLY=false.";
-    readonly recovery: "Use a path inside the configured scope, or unset OBSIDIAN_READ_ONLY for writes. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured scope. The error data echoes the active scope.";
 }, {
     readonly reason: "tags_required";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
@@ -1055,7 +1146,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
-    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -1065,7 +1156,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "periodic_disabled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
-    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     path: import("zod").ZodString;
     failIfMissing: import("zod").ZodDefault<import("zod").ZodBoolean>;
@@ -1078,7 +1169,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "The target path is outside OBSIDIAN_READ_PATHS (and OBSIDIAN_WRITE_PATHS, since write paths imply read access).";
-    readonly recovery: "Use a path inside the configured read scope. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured read scope. The error data echoes the active scope.";
 }, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -1143,7 +1234,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
-    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured write scope. The error data echoes the active scope.";
 }, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -1153,7 +1244,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
-    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -1163,7 +1254,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "periodic_disabled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
-    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
 }, {
     readonly reason: "section_target_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
@@ -1206,12 +1297,12 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes. (The pre-read also requires the path to be readable.)";
-    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured write scope. The error data echoes the active scope.";
 }, {
     readonly reason: "regex_invalid";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "A `useRegex: true` replacement supplied a `search` pattern that is not a valid ECMAScript regex.";
-    readonly recovery: "Test the pattern in a JS regex tester, or set useRegex to false to match `search` as a literal string.";
+    readonly recovery: "Use a valid ECMAScript regex, or set useRegex to false to match `search` as a literal string.";
 }, {
     readonly reason: "note_missing";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -1221,7 +1312,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "no_active_file";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Target was `active` but no file is currently open in Obsidian.";
-    readonly recovery: "Open a note in Obsidian or pass an explicit path target instead.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
 }, {
     readonly reason: "periodic_not_found";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
@@ -1231,7 +1322,7 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "periodic_disabled";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
-    readonly recovery: "Enable the period in Obsidian's Periodic Notes plugin settings, or pass an explicit path target instead.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
 }]> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     mode: import("zod").ZodEnum<{
         text: "text";
@@ -1240,9 +1331,9 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     }>;
     query: import("zod").ZodOptional<import("zod").ZodString>;
     logic: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
-    contextLength: import("zod").ZodOptional<import("zod").ZodNumber>;
+    contextLength: import("zod").ZodDefault<import("zod").ZodNumber>;
     pathPrefix: import("zod").ZodOptional<import("zod").ZodString>;
-    maxMatchesPerHit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    maxMatchesPerHit: import("zod").ZodDefault<import("zod").ZodNumber>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
     result: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
         mode: import("zod").ZodLiteral<"text">;
@@ -1343,7 +1434,32 @@ export declare const baseToolDefinitions: (import("@cyanheads/mcp-ts-core").Tool
     readonly reason: "path_forbidden";
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.Forbidden;
     readonly when: "The target path is outside OBSIDIAN_WRITE_PATHS, or OBSIDIAN_READ_ONLY=true denies all writes.";
-    readonly recovery: "Use a path inside the configured write scope, or unset OBSIDIAN_READ_ONLY. The error data echoes the active scope; check the server startup banner for the active configuration.";
+    readonly recovery: "Use a path inside the configured write scope. The error data echoes the active scope.";
+}, {
+    readonly reason: "note_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Section replace targets a path that does not resolve to an existing note (PATCH requires the file to exist).";
+    readonly recovery: "Verify the path with obsidian_list_notes, or omit `section` to fall back to whole-file write (which creates the note when it is absent).";
+}, {
+    readonly reason: "no_active_file";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `active` but no file is currently open in Obsidian.";
+    readonly recovery: "Call obsidian_open_in_ui to focus a file, or pass an explicit path target instead.";
+}, {
+    readonly reason: "periodic_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Target was `periodic` but no matching periodic note exists.";
+    readonly recovery: "Create the periodic note first or pass an explicit path target.";
+}, {
+    readonly reason: "periodic_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "Target was `periodic` but the requested period is not enabled in Obsidian's Periodic Notes plugin settings.";
+    readonly recovery: "Pass an explicit path target — the requested period is disabled in the operator's Periodic Notes plugin.";
+}, {
+    readonly reason: "section_target_missing";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "`section` was provided but the named heading/block/frontmatter field does not exist in the note.";
+    readonly recovery: "Call obsidian_get_note with format document-map to discover available targets.";
 }]>)[];
 /** Command-palette tools — opt-in via `OBSIDIAN_ENABLE_COMMANDS=true`; suppressed by `OBSIDIAN_READ_ONLY=true`. */
 export declare const commandToolDefinitions: (import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{

package/dist/mcp-server/tools/definitions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAiBH,gFAAgF;AAChF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAM/B,CAAC;AAEF,kFAAkF;AAClF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAQhC,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAoD,CAAC;AAErF,mHAAmH;AACnH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;+CAAiD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAiBH,gFAAgF;AAChF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAM/B,CAAC;AAEF,kFAAkF;AAClF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAQhC,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAoD,CAAC;AAErF,mHAAmH;AACnH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;+CAAiD,CAAC"}