castor-mcp 0.6.0

package/build/tool-definitions.js

@@ -0,0 +1,1811 @@
+import { parseArgs } from "./tools/args.js";
+import { listSpaces, ListSpacesArgsSchema, getSpace, GetSpaceArgsSchema, getPage, GetPageArgsSchema, createPage, CreatePageArgsSchema, updatePage, UpdatePageArgsSchema, searchContent, SearchContentArgsSchema, } from "./tools/spaces-pages.js";
+import { UNTRUSTED_CONTENT_NOTE } from "./tools/spaces-pages.js";
+import { adminGetSpacePermissions, AdminGetSpacePermissionsArgsSchema } from "./tools/admin.js";
+import { listContent, ListContentArgsSchema, deletePage, DeletePageArgsSchema, getPageHistory, GetPageHistoryArgsSchema, getPageMacroBodyByHash, GetPageMacroBodyByHashArgsSchema, getPageMacroBodyById, GetPageMacroBodyByIdArgsSchema, listPageProperties, ListPagePropertiesArgsSchema, getPageProperty, GetPagePropertyArgsSchema, createPageProperty, CreatePagePropertyArgsSchema, updatePageProperty, UpdatePagePropertyArgsSchema, deletePageProperty, DeletePagePropertyArgsSchema, deletePageVersion, DeletePageVersionArgsSchema, scanContent, ScanContentArgsSchema, convertContentBody, ConvertContentBodyArgsSchema, } from "./tools/content.js";
+import { getPageWatchers, GetPageWatchersArgsSchema, listPageChildren, ListPageChildrenArgsSchema, listPageChildrenOfType, ListPageChildrenOfTypeArgsSchema, listPageComments, ListPageCommentsArgsSchema, listPageDescendants, ListPageDescendantsArgsSchema, listPageDescendantsOfType, ListPageDescendantsOfTypeArgsSchema, countDescendantPages, CountDescendantPagesArgsSchema, updatePageRestrictions, UpdatePageRestrictionsArgsSchema, getPageRestrictionsByOperation, GetPageRestrictionsByOperationArgsSchema, getPageRestrictionsForOperation, GetPageRestrictionsForOperationArgsSchema, getPageRelevantViewRestrictions, GetPageRelevantViewRestrictionsArgsSchema, publishLegacyBlueprintDraft, PublishLegacyBlueprintDraftArgsSchema, publishSharedBlueprintDraft, PublishSharedBlueprintDraftArgsSchema, } from "./tools/content-structure.js";
+import { listPageLabels, ListPageLabelsArgsSchema, addPageLabels, AddPageLabelsArgsSchema, deletePageLabel, DeletePageLabelArgsSchema, getRelatedLabels, GetRelatedLabelsArgsSchema, searchLabels, SearchLabelsArgsSchema, getPopularLabels, GetPopularLabelsArgsSchema, getRecentLabels, GetRecentLabelsArgsSchema, listSpaceLabels, ListSpaceLabelsArgsSchema, getSpaceRelatedLabels, GetSpaceRelatedLabelsArgsSchema, getSpacePopularLabels, GetSpacePopularLabelsArgsSchema, getSpaceRecentLabels, GetSpaceRecentLabelsArgsSchema, } from "./tools/labels.js";
+import { getBulkPageChildren, GetBulkPageChildrenArgsSchema, bulkDeletePages, BulkDeletePagesArgsSchema, getDeletableDescendantCounts, GetDeletableDescendantCountsArgsSchema, getBulkDeleteLimits, GetBulkDeleteLimitsArgsSchema, previewBulkDelete, PreviewBulkDeleteArgsSchema, getSpaceRootPages, GetSpaceRootPagesArgsSchema, } from "./tools/bulk-pages.js";
+import { listPageAttachments, ListPageAttachmentsArgsSchema, createAttachment, CreateAttachmentArgsSchema, deleteAttachment, DeleteAttachmentArgsSchema, updateAttachmentMetadata, UpdateAttachmentMetadataArgsSchema, updateAttachmentData, UpdateAttachmentDataArgsSchema, getAttachmentExtractedText, GetAttachmentExtractedTextArgsSchema, moveAttachment, MoveAttachmentArgsSchema, deleteAttachmentVersion, DeleteAttachmentVersionArgsSchema, } from "./tools/attachments.js";
+import { createSpace, CreateSpaceArgsSchema, createPrivateSpace, CreatePrivateSpaceArgsSchema, createPersonalSpace, CreatePersonalSpaceArgsSchema, deleteSpace, DeleteSpaceArgsSchema, updateSpace, UpdateSpaceArgsSchema, archiveSpace, ArchiveSpaceArgsSchema, addSpaceCategory, AddSpaceCategoryArgsSchema, removeSpaceCategory, RemoveSpaceCategoryArgsSchema, listSpaceContent, ListSpaceContentArgsSchema, listSpaceContentOfType, ListSpaceContentOfTypeArgsSchema, listSpaceProperties, ListSpacePropertiesArgsSchema, createSpaceProperty, CreateSpacePropertyArgsSchema, getSpaceProperty, GetSpacePropertyArgsSchema, updateSpaceProperty, UpdateSpacePropertyArgsSchema, deleteSpaceProperty, DeleteSpacePropertyArgsSchema, restoreSpace, RestoreSpaceArgsSchema, emptySpaceTrash, EmptySpaceTrashArgsSchema, listSpaceTrash, ListSpaceTrashArgsSchema, getSpaceWatchers, GetSpaceWatchersArgsSchema, } from "./tools/spaces-admin.js";
+import { listGlobalPermissions, ListGlobalPermissionsArgsSchema, setGlobalPermissions, SetGlobalPermissionsArgsSchema, getAnonymousGlobalPermissions, GetAnonymousGlobalPermissionsArgsSchema, grantAnonymousGlobalPermissions, GrantAnonymousGlobalPermissionsArgsSchema, revokeAnonymousGlobalPermissions, RevokeAnonymousGlobalPermissionsArgsSchema, getGroupGlobalPermissions, GetGroupGlobalPermissionsArgsSchema, grantGroupGlobalPermissions, GrantGroupGlobalPermissionsArgsSchema, revokeGroupGlobalPermissions, RevokeGroupGlobalPermissionsArgsSchema, getUnlicensedGlobalPermissions, GetUnlicensedGlobalPermissionsArgsSchema, grantUnlicensedGlobalPermissions, GrantUnlicensedGlobalPermissionsArgsSchema, revokeUnlicensedGlobalPermissions, RevokeUnlicensedGlobalPermissionsArgsSchema, getUserGlobalPermissions, GetUserGlobalPermissionsArgsSchema, grantUserGlobalPermissions, GrantUserGlobalPermissionsArgsSchema, revokeUserGlobalPermissions, RevokeUserGlobalPermissionsArgsSchema, setSpacePermissions, SetSpacePermissionsArgsSchema, getSpaceAnonymousPermissions, GetSpaceAnonymousPermissionsArgsSchema, grantSpaceAnonymousPermissions, GrantSpaceAnonymousPermissionsArgsSchema, revokeSpaceAnonymousPermissions, RevokeSpaceAnonymousPermissionsArgsSchema, getSpaceGroupPermissions, GetSpaceGroupPermissionsArgsSchema, grantSpaceGroupPermissions, GrantSpaceGroupPermissionsArgsSchema, revokeSpaceGroupPermissions, RevokeSpaceGroupPermissionsArgsSchema, getSpaceUserPermissions, GetSpaceUserPermissionsArgsSchema, grantSpaceUserPermissions, GrantSpaceUserPermissionsArgsSchema, revokeSpaceUserPermissions, RevokeSpaceUserPermissionsArgsSchema, } from "./tools/permissions.js";
+import { getGlobalColorScheme, GetGlobalColorSchemeArgsSchema, updateGlobalColorScheme, UpdateGlobalColorSchemeArgsSchema, getDefaultGlobalColorScheme, GetDefaultGlobalColorSchemeArgsSchema, resetGlobalColorScheme, ResetGlobalColorSchemeArgsSchema, getSpaceColorScheme, GetSpaceColorSchemeArgsSchema, updateSpaceColorScheme, UpdateSpaceColorSchemeArgsSchema, resetSpaceColorScheme, ResetSpaceColorSchemeArgsSchema, getSpaceColorSchemeType, GetSpaceColorSchemeTypeArgsSchema, updateSpaceColorSchemeType, UpdateSpaceColorSchemeTypeArgsSchema, } from "./tools/color-schemes.js";
+import { getAccessMode, GetAccessModeArgsSchema, listGroups, ListGroupsArgsSchema, getGroup, GetGroupArgsSchema, getGroupAncestors, GetGroupAncestorsArgsSchema, getGroupNestedMembers, GetGroupNestedMembersArgsSchema, getGroupParents, GetGroupParentsArgsSchema, getGroupMembers, GetGroupMembersArgsSchema, getUser, GetUserArgsSchema, addUserToGroup, AddUserToGroupArgsSchema, removeUserFromGroup, RemoveUserFromGroupArgsSchema, getAnonymousUserInfo, GetAnonymousUserInfoArgsSchema, getCurrentUser, GetCurrentUserArgsSchema, updateCurrentUser, UpdateCurrentUserArgsSchema, changeCurrentUserPassword, ChangeCurrentUserPasswordArgsSchema, listUsers, ListUsersArgsSchema, getUserGroups, GetUserGroupsArgsSchema, updateUserSettings, UpdateUserSettingsArgsSchema, removeContentWatcher, RemoveContentWatcherArgsSchema, isWatchingContent, IsWatchingContentArgsSchema, addContentWatcher, AddContentWatcherArgsSchema, removeSpaceWatcher, RemoveSpaceWatcherArgsSchema, isWatchingSpace, IsWatchingSpaceArgsSchema, addSpaceWatcher, AddSpaceWatcherArgsSchema, } from "./tools/users-groups.js";
+import { adminCreateGroup, AdminCreateGroupArgsSchema, adminDeleteGroup, AdminDeleteGroupArgsSchema, adminCreatePersonalSpaceForUser, AdminCreatePersonalSpaceForUserArgsSchema, adminCreateUser, AdminCreateUserArgsSchema, adminDeleteUser, AdminDeleteUserArgsSchema, adminUpdateUser, AdminUpdateUserArgsSchema, adminDisableUser, AdminDisableUserArgsSchema, adminEnableUser, AdminEnableUserArgsSchema, adminChangeUserPassword, AdminChangeUserPasswordArgsSchema, adminListActiveUsers, AdminListActiveUsersArgsSchema, } from "./tools/admin-users-groups.js";
+import { adminListWebhooks, AdminListWebhooksArgsSchema, adminCreateWebhook, AdminCreateWebhookArgsSchema, adminDeleteWebhook, AdminDeleteWebhookArgsSchema, adminGetWebhook, AdminGetWebhookArgsSchema, adminUpdateWebhook, AdminUpdateWebhookArgsSchema, adminGetWebhookLatestInvocations, AdminGetWebhookLatestInvocationsArgsSchema, adminGetWebhookStatistics, AdminGetWebhookStatisticsArgsSchema, adminGetWebhookStatisticsSummary, AdminGetWebhookStatisticsSummaryArgsSchema, adminTestWebhook, AdminTestWebhookArgsSchema, } from "./tools/webhooks.js";
+import { adminCreateSiteBackupJob, AdminCreateSiteBackupJobArgsSchema, adminCreateSpaceBackupJob, AdminCreateSpaceBackupJobArgsSchema, adminFindBackupRestoreJobs, AdminFindBackupRestoreJobsArgsSchema, adminGetBackupRestoreJob, AdminGetBackupRestoreJobArgsSchema, adminCancelBackupRestoreJob, AdminCancelBackupRestoreJobArgsSchema, adminDownloadBackupFile, AdminDownloadBackupFileArgsSchema, adminCancelAllQueuedBackupRestoreJobs, AdminCancelAllQueuedBackupRestoreJobsArgsSchema, adminListRestoreFiles, AdminListRestoreFilesArgsSchema, adminCreateSiteRestoreJob, AdminCreateSiteRestoreJobArgsSchema, adminCreateSpaceRestoreJob, AdminCreateSpaceRestoreJobArgsSchema, adminCreateSiteRestoreJobFromUpload, AdminCreateSiteRestoreJobFromUploadArgsSchema, adminCreateSpaceRestoreJobFromUpload, AdminCreateSpaceRestoreJobFromUploadArgsSchema, } from "./tools/backup-restore.js";
+import { getReindexStatus, GetReindexStatusArgsSchema, triggerReindex, TriggerReindexArgsSchema, resetReindexJob, ResetReindexJobArgsSchema, unindexAllContent, UnindexAllContentArgsSchema, } from "./tools/index-management.js";
+import { adminGetAuditRecords, AdminGetAuditRecordsArgsSchema, adminGetClusterNodeStatuses, AdminGetClusterNodeStatusesArgsSchema, getInstanceMetrics, GetInstanceMetricsArgsSchema, adminListLongTasks, AdminListLongTasksArgsSchema, adminGetLongTask, AdminGetLongTaskArgsSchema, searchEntities, SearchEntitiesArgsSchema, getServerInformation, GetServerInformationArgsSchema, } from "./tools/system.js";
+export const TOOL_DEFINITIONS = {
+    list_spaces: {
+        description: "List Confluence spaces, optionally filtered by type (global or personal).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: { type: "string", enum: ["global", "personal"], description: "Filter by space type." },
+            },
+        },
+        handler: (server, args) => listSpaces(server.requireUserClient(), parseArgs(ListSpacesArgsSchema, args ?? {})),
+    },
+    get_space: {
+        description: "Get a single Confluence space by key.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string", description: 'Space key, e.g. "TEST".' } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => getSpace(server.requireUserClient(), parseArgs(GetSpaceArgsSchema, args)),
+    },
+    get_page: {
+        description: "Get a single Confluence page by ID, including its body (storage format HTML) and current " +
+            "version number. See skill://spaces-pages for CQL/versioning guidance." + UNTRUSTED_CONTENT_NOTE,
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string", description: "Content/page ID." } },
+            required: ["pageId"],
+        },
+        handler: (server, args) => getPage(server.requireUserClient(), parseArgs(GetPageArgsSchema, args)),
+    },
+    create_page: {
+        description: "Create a new Confluence page in a space. Body must be storage-format HTML.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                spaceKey: { type: "string" },
+                title: { type: "string" },
+                body: { type: "string", description: "Storage-format HTML, e.g. \"<p>Hello</p>\"." },
+            },
+            required: ["spaceKey", "title", "body"],
+        },
+        handler: (server, args) => createPage(server.requireUserClient(), parseArgs(CreatePageArgsSchema, args)),
+    },
+    update_page: {
+        description: "Update a Confluence page's title and body. Call get_page first to obtain currentVersion — " +
+            "this tool replaces the full page content, and a stale version fails with 409. " +
+            "See skill://spaces-pages.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pageId: { type: "string" },
+                currentVersion: { type: "number", description: "From get_page's version field." },
+                title: { type: "string" },
+                body: { type: "string", description: "Full replacement storage-format HTML." },
+            },
+            required: ["pageId", "currentVersion", "title", "body"],
+        },
+        handler: (server, args) => updatePage(server.requireUserClient(), parseArgs(UpdatePageArgsSchema, args)),
+    },
+    search_content: {
+        description: "Search Confluence content using CQL (preferred over any other search mechanism). " +
+            "See skill://spaces-pages for CQL syntax." + UNTRUSTED_CONTENT_NOTE,
+        inputSchema: {
+            type: "object",
+            properties: {
+                cql: { type: "string" },
+                limit: { type: "number", description: "Max results (default 25, capped at 100)." },
+            },
+            required: ["cql"],
+        },
+        handler: (server, args) => searchContent(server.requireUserClient(), parseArgs(SearchContentArgsSchema, args)),
+    },
+    admin_get_space_permissions: {
+        description: "Get all permission grants (user/group/anonymous) on a Confluence space. Requires space-admin " +
+            "permission. Only registered when CONFLUENCE_ADMIN_TOKEN is configured.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminGetSpacePermissions(server.requireAdminClient(), parseArgs(AdminGetSpacePermissionsArgsSchema, args)),
+    },
+    list_content: {
+        description: "List Confluence content (pages, blog posts, etc.) with optional filters. Broader than " +
+            "search_content (no CQL) and list_spaces (any content type, not just spaces). " +
+            "See skill://content for real gotchas across this tool surface.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                spaceKey: { type: "string" },
+                type: { type: "string", description: 'e.g. "page", "blogpost".' },
+                title: { type: "string" },
+                status: { type: "string", description: 'e.g. "current", "trashed", "draft".' },
+                limit: { type: "number" },
+            },
+        },
+        handler: (server, args) => listContent(server.requireUserClient(), parseArgs(ListContentArgsSchema, args ?? {})),
+    },
+    delete_page: {
+        description: "Delete a Confluence page. Omit status to trash a current page; to permanently purge an " +
+            "already-trashed page, pass status=\"trashed\" (matching its current status — confirmed " +
+            "live, passing \"current\" here does nothing, it just re-trashes an already-trashed page).",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, status: { type: "string" } },
+            required: ["pageId"],
+        },
+        handler: (server, args) => deletePage(server.requireUserClient(), parseArgs(DeletePageArgsSchema, args)),
+    },
+    get_page_history: {
+        description: "Get a page's history metadata (created/last-updated by and when).",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" } },
+            required: ["pageId"],
+        },
+        handler: (server, args) => getPageHistory(server.requireUserClient(), parseArgs(GetPageHistoryArgsSchema, args)),
+    },
+    get_page_macro_body_by_hash: {
+        description: "Get a macro's rendered body by hash, for a specific page version. Deprecated by Atlassian " +
+            "in favor of get_page_macro_body_by_id — but confirmed live that this endpoint also accepts " +
+            "a real macroId as the hash value, so get_page_macro_body_by_id is the simpler choice " +
+            "(macroId is a real attribute on the page's storage-format body, not a separately-computed " +
+            "hash)." + UNTRUSTED_CONTENT_NOTE,
+        inputSchema: {
+            type: "object",
+            properties: {
+                pageId: { type: "string" },
+                version: { type: "number" },
+                hash: { type: "string" },
+            },
+            required: ["pageId", "version", "hash"],
+        },
+        handler: (server, args) => getPageMacroBodyByHash(server.requireUserClient(), parseArgs(GetPageMacroBodyByHashArgsSchema, args)),
+    },
+    get_page_macro_body_by_id: {
+        description: "Get a macro's rendered body by its macro ID, for a specific page version." + UNTRUSTED_CONTENT_NOTE,
+        inputSchema: {
+            type: "object",
+            properties: {
+                pageId: { type: "string" },
+                version: { type: "number" },
+                macroId: { type: "string" },
+            },
+            required: ["pageId", "version", "macroId"],
+        },
+        handler: (server, args) => getPageMacroBodyById(server.requireUserClient(), parseArgs(GetPageMacroBodyByIdArgsSchema, args)),
+    },
+    list_page_properties: {
+        description: "List all custom properties (key/value metadata) stored on a page.",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" } },
+            required: ["pageId"],
+        },
+        handler: (server, args) => listPageProperties(server.requireUserClient(), parseArgs(ListPagePropertiesArgsSchema, args)),
+    },
+    get_page_property: {
+        description: "Get a single custom property by key from a page.",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, key: { type: "string" } },
+            required: ["pageId", "key"],
+        },
+        handler: (server, args) => getPageProperty(server.requireUserClient(), parseArgs(GetPagePropertyArgsSchema, args)),
+    },
+    create_page_property: {
+        description: "Create a custom property (key/value metadata) on a page. Fails if the key already exists — use update_page_property instead.",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, key: { type: "string" }, value: {} },
+            required: ["pageId", "key", "value"],
+        },
+        handler: (server, args) => createPageProperty(server.requireUserClient(), parseArgs(CreatePagePropertyArgsSchema, args)),
+    },
+    update_page_property: {
+        description: "Update an existing page property's value. Call get_page_property or list_page_properties first to obtain currentVersion.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pageId: { type: "string" },
+                key: { type: "string" },
+                value: {},
+                currentVersion: { type: "number" },
+            },
+            required: ["pageId", "key", "value", "currentVersion"],
+        },
+        handler: (server, args) => updatePageProperty(server.requireUserClient(), parseArgs(UpdatePagePropertyArgsSchema, args)),
+    },
+    delete_page_property: {
+        description: "Delete a custom property from a page.",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, key: { type: "string" } },
+            required: ["pageId", "key"],
+        },
+        handler: (server, args) => deletePageProperty(server.requireUserClient(), parseArgs(DeletePagePropertyArgsSchema, args)),
+    },
+    delete_page_version: {
+        description: "Permanently delete one historical version of a page (not the current version).",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, versionNumber: { type: "number" } },
+            required: ["pageId", "versionNumber"],
+        },
+        handler: (server, args) => deletePageVersion(server.requireUserClient(), parseArgs(DeletePageVersionArgsSchema, args)),
+    },
+    scan_content: {
+        description: "Scan all content in a space via cursor-based pagination — for bulk/migration-style traversal, " +
+            "not interactive browsing (use list_content or search_content for that).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                spaceKey: { type: "string" },
+                type: { type: "string" },
+                cursor: { type: "string" },
+                limit: { type: "number" },
+            },
+        },
+        handler: (server, args) => scanContent(server.requireUserClient(), parseArgs(ScanContentArgsSchema, args ?? {})),
+    },
+    convert_content_body: {
+        description: 'Convert content body between representations, e.g. "storage" (HTML-like XML) to "view" (rendered HTML).' + UNTRUSTED_CONTENT_NOTE,
+        inputSchema: {
+            type: "object",
+            properties: {
+                value: { type: "string" },
+                from: { type: "string" },
+                to: { type: "string" },
+            },
+            required: ["value", "from", "to"],
+        },
+        handler: (server, args) => convertContentBody(server.requireUserClient(), parseArgs(ConvertContentBodyArgsSchema, args)),
+    },
+    get_page_watchers: {
+        description: "List users watching a page.",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" } },
+            required: ["pageId"],
+        },
+        handler: (server, args) => getPageWatchers(server.requireUserClient(), parseArgs(GetPageWatchersArgsSchema, args)),
+    },
+    list_page_children: {
+        description: "List a page's direct children (any content type).",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" } },
+            required: ["pageId"],
+        },
+        handler: (server, args) => listPageChildren(server.requireUserClient(), parseArgs(ListPageChildrenArgsSchema, args)),
+    },
+    list_page_children_of_type: {
+        description: 'List a page\'s direct children of a given type, e.g. "page", "comment", "attachment".',
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, type: { type: "string" } },
+            required: ["pageId", "type"],
+        },
+        handler: (server, args) => listPageChildrenOfType(server.requireUserClient(), parseArgs(ListPageChildrenOfTypeArgsSchema, args)),
+    },
+    list_page_comments: {
+        description: "List a page's comments." + UNTRUSTED_CONTENT_NOTE,
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" } },
+            required: ["pageId"],
+        },
+        handler: (server, args) => listPageComments(server.requireUserClient(), parseArgs(ListPageCommentsArgsSchema, args)),
+    },
+    list_page_descendants: {
+        description: "List the content types that have descendants under this page (e.g. \"comment\", " +
+            "\"attachment\") — Confluence's own API does not return descendant content directly here, " +
+            "only which types exist; call list_page_descendants_of_type with one of the returned types " +
+            "to get actual content.",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" } },
+            required: ["pageId"],
+        },
+        handler: (server, args) => listPageDescendants(server.requireUserClient(), parseArgs(ListPageDescendantsArgsSchema, args)),
+    },
+    list_page_descendants_of_type: {
+        description: "List all of a page's descendants of a given content type (e.g. \"comment\", " +
+            "\"attachment\" — see list_page_descendants for which types exist under a given page). " +
+            "Confirmed live: type=\"page\" 500s server-side on this Confluence version even though it's " +
+            "a documented example type elsewhere in Atlassian's API docs — a real server-side " +
+            "limitation, not specific to this tool.",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, type: { type: "string" } },
+            required: ["pageId", "type"],
+        },
+        handler: (server, args) => listPageDescendantsOfType(server.requireUserClient(), parseArgs(ListPageDescendantsOfTypeArgsSchema, args)),
+    },
+    count_descendant_pages: {
+        description: "Count how many descendant pages a page has.",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" } },
+            required: ["pageId"],
+        },
+        handler: (server, args) => countDescendantPages(server.requireUserClient(), parseArgs(CountDescendantPagesArgsSchema, args)),
+    },
+    update_page_restrictions: {
+        description: "Replace a page's view/edit restrictions with the given list. Each entry sets who (by " +
+            "username/group name) can perform one operation (e.g. \"read\", \"update\") — replaces any " +
+            "existing restriction for that operation entirely, does not merge.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pageId: { type: "string" },
+                restrictions: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            operation: { type: "string" },
+                            usernames: { type: "array", items: { type: "string" } },
+                            groupNames: { type: "array", items: { type: "string" } },
+                        },
+                        required: ["operation"],
+                    },
+                },
+            },
+            required: ["pageId", "restrictions"],
+        },
+        handler: (server, args) => updatePageRestrictions(server.requireUserClient(), parseArgs(UpdatePageRestrictionsArgsSchema, args)),
+    },
+    get_page_restrictions_by_operation: {
+        description: "Get all of a page's restrictions, grouped by operation.",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" } },
+            required: ["pageId"],
+        },
+        handler: (server, args) => getPageRestrictionsByOperation(server.requireUserClient(), parseArgs(GetPageRestrictionsByOperationArgsSchema, args)),
+    },
+    get_page_restrictions_for_operation: {
+        description: 'Get a page\'s restrictions for one specific operation, e.g. "read" or "update".',
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, operationKey: { type: "string" } },
+            required: ["pageId", "operationKey"],
+        },
+        handler: (server, args) => getPageRestrictionsForOperation(server.requireUserClient(), parseArgs(GetPageRestrictionsForOperationArgsSchema, args)),
+    },
+    get_page_relevant_view_restrictions: {
+        description: "Get a page's effective view restrictions, including those inherited from ancestor pages.",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" } },
+            required: ["pageId"],
+        },
+        handler: (server, args) => getPageRelevantViewRestrictions(server.requireUserClient(), parseArgs(GetPageRelevantViewRestrictionsArgsSchema, args)),
+    },
+    publish_legacy_blueprint_draft: {
+        description: "Publish an in-progress blueprint draft (legacy editor) as a real page. The draftId comes " +
+            "from Confluence's own editor UI — there is no API to create or list drafts.",
+        inputSchema: {
+            type: "object",
+            properties: { draftId: { type: "string" }, title: { type: "string" }, spaceKey: { type: "string" } },
+            required: ["draftId", "title", "spaceKey"],
+        },
+        handler: (server, args) => publishLegacyBlueprintDraft(server.requireUserClient(), parseArgs(PublishLegacyBlueprintDraftArgsSchema, args)),
+    },
+    publish_shared_blueprint_draft: {
+        description: "Publish an in-progress blueprint draft (shared/collaborative editor) as a real page. The " +
+            "draftId comes from Confluence's own editor UI — there is no API to create or list drafts.",
+        inputSchema: {
+            type: "object",
+            properties: { draftId: { type: "string" }, title: { type: "string" }, spaceKey: { type: "string" } },
+            required: ["draftId", "title", "spaceKey"],
+        },
+        handler: (server, args) => publishSharedBlueprintDraft(server.requireUserClient(), parseArgs(PublishSharedBlueprintDraftArgsSchema, args)),
+    },
+    list_page_labels: {
+        description: "List labels on a page.",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" } },
+            required: ["pageId"],
+        },
+        handler: (server, args) => listPageLabels(server.requireUserClient(), parseArgs(ListPageLabelsArgsSchema, args)),
+    },
+    add_page_labels: {
+        description: "Add one or more labels to a page.",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, names: { type: "array", items: { type: "string" } } },
+            required: ["pageId", "names"],
+        },
+        handler: (server, args) => addPageLabels(server.requireUserClient(), parseArgs(AddPageLabelsArgsSchema, args)),
+    },
+    delete_page_label: {
+        description: "Remove a label from a page.",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, label: { type: "string" } },
+            required: ["pageId", "label"],
+        },
+        handler: (server, args) => deletePageLabel(server.requireUserClient(), parseArgs(DeletePageLabelArgsSchema, args)),
+    },
+    get_related_labels: {
+        description: "Get labels commonly used together with a given label, globally (returns global labels only).",
+        inputSchema: {
+            type: "object",
+            properties: { labelName: { type: "string" } },
+            required: ["labelName"],
+        },
+        handler: (server, args) => getRelatedLabels(server.requireUserClient(), parseArgs(GetRelatedLabelsArgsSchema, args)),
+    },
+    search_labels: {
+        description: "Search labels by name, namespace, space, or owner.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                spaceKey: { type: "string" },
+                owner: { type: "string" },
+                namespace: { type: "string" },
+                labelName: { type: "string" },
+            },
+        },
+        handler: (server, args) => searchLabels(server.requireUserClient(), parseArgs(SearchLabelsArgsSchema, args ?? {})),
+    },
+    get_popular_labels: {
+        description: "Get the most popular labels instance-wide.",
+        inputSchema: { type: "object", properties: {} },
+        handler: (server, args) => getPopularLabels(server.requireUserClient(), parseArgs(GetPopularLabelsArgsSchema, args ?? {})),
+    },
+    get_recent_labels: {
+        description: "Get recently used labels instance-wide.",
+        inputSchema: { type: "object", properties: {} },
+        handler: (server, args) => getRecentLabels(server.requireUserClient(), parseArgs(GetRecentLabelsArgsSchema, args ?? {})),
+    },
+    list_space_labels: {
+        description: "List all labels used anywhere in a space.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => listSpaceLabels(server.requireUserClient(), parseArgs(ListSpaceLabelsArgsSchema, args)),
+    },
+    get_space_related_labels: {
+        description: "Get labels commonly used together with a given label, within one space.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, labelName: { type: "string" } },
+            required: ["spaceKey", "labelName"],
+        },
+        handler: (server, args) => getSpaceRelatedLabels(server.requireUserClient(), parseArgs(GetSpaceRelatedLabelsArgsSchema, args)),
+    },
+    get_space_popular_labels: {
+        description: "Get the most popular labels within a space.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => getSpacePopularLabels(server.requireUserClient(), parseArgs(GetSpacePopularLabelsArgsSchema, args)),
+    },
+    get_space_recent_labels: {
+        description: "Get recently used labels within a space.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => getSpaceRecentLabels(server.requireUserClient(), parseArgs(GetSpaceRecentLabelsArgsSchema, args)),
+    },
+    get_bulk_page_children: {
+        description: "Get a page's children via the bulk/cursor-paginated endpoint (for large-scale traversal).",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, cursor: { type: "string" }, limit: { type: "number" } },
+            required: ["pageId"],
+        },
+        handler: (server, args) => getBulkPageChildren(server.requireUserClient(), parseArgs(GetBulkPageChildrenArgsSchema, args)),
+    },
+    bulk_delete_pages: {
+        description: "Permanently delete multiple pages in one request. DESTRUCTIVE and irreversible for pages " +
+            "without descendants excluded. Strongly consider preview_bulk_delete or " +
+            "get_deletable_descendant_counts first to see what would be affected.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pages: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            contentId: { type: "string" },
+                            deleteAllDescendants: { type: "boolean" },
+                            excludedDescendantIds: { type: "array", items: { type: "string" } },
+                        },
+                        required: ["contentId"],
+                    },
+                },
+            },
+            required: ["pages"],
+        },
+        handler: (server, args) => bulkDeletePages(server.requireUserClient(), parseArgs(BulkDeletePagesArgsSchema, args)),
+    },
+    get_deletable_descendant_counts: {
+        description: "Count how many descendants each of the given pages has that would be deleted alongside it.",
+        inputSchema: {
+            type: "object",
+            properties: { pageIds: { type: "array", items: { type: "number" } } },
+            required: ["pageIds"],
+        },
+        handler: (server, args) => getDeletableDescendantCounts(server.requireUserClient(), parseArgs(GetDeletableDescendantCountsArgsSchema, args)),
+    },
+    get_bulk_delete_limits: {
+        description: "Get the instance's limits on how many pages can be bulk-deleted in one request.",
+        inputSchema: { type: "object", properties: {} },
+        handler: (server, args) => getBulkDeleteLimits(server.requireUserClient(), parseArgs(GetBulkDeleteLimitsArgsSchema, args ?? {})),
+    },
+    preview_bulk_delete: {
+        description: "Preview the effect of a bulk_delete_pages call without deleting anything — same input shape.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pages: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            contentId: { type: "string" },
+                            deleteAllDescendants: { type: "boolean" },
+                            excludedDescendantIds: { type: "array", items: { type: "string" } },
+                        },
+                        required: ["contentId"],
+                    },
+                },
+            },
+            required: ["pages"],
+        },
+        handler: (server, args) => previewBulkDelete(server.requireUserClient(), parseArgs(PreviewBulkDeleteArgsSchema, args)),
+    },
+    get_space_root_pages: {
+        description: "Get a space's top-level (root) pages via the bulk/cursor-paginated endpoint.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, cursor: { type: "string" }, limit: { type: "number" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => getSpaceRootPages(server.requireUserClient(), parseArgs(GetSpaceRootPagesArgsSchema, args)),
+    },
+    list_page_attachments: {
+        description: "List a page's attachments, optionally filtered by filename or media type.",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, filename: { type: "string" }, mediaType: { type: "string" } },
+            required: ["pageId"],
+        },
+        handler: (server, args) => listPageAttachments(server.requireUserClient(), parseArgs(ListPageAttachmentsArgsSchema, args)),
+    },
+    create_attachment: {
+        description: "Upload a new attachment to a page. Content must be base64-encoded.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pageId: { type: "string" },
+                filename: { type: "string" },
+                contentBase64: { type: "string" },
+                mediaType: { type: "string" },
+                comment: { type: "string" },
+            },
+            required: ["pageId", "filename", "contentBase64"],
+        },
+        handler: (server, args) => createAttachment(server.requireUserClient(), parseArgs(CreateAttachmentArgsSchema, args)),
+    },
+    delete_attachment: {
+        description: "Permanently delete an attachment (all versions).",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, attachmentId: { type: "string" } },
+            required: ["pageId", "attachmentId"],
+        },
+        handler: (server, args) => deleteAttachment(server.requireUserClient(), parseArgs(DeleteAttachmentArgsSchema, args)),
+    },
+    update_attachment_metadata: {
+        description: "Rename an attachment (update its title). Call list_page_attachments first to obtain currentVersion.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pageId: { type: "string" },
+                attachmentId: { type: "string" },
+                title: { type: "string" },
+                currentVersion: { type: "number" },
+            },
+            required: ["pageId", "attachmentId", "title", "currentVersion"],
+        },
+        handler: (server, args) => updateAttachmentMetadata(server.requireUserClient(), parseArgs(UpdateAttachmentMetadataArgsSchema, args)),
+    },
+    update_attachment_data: {
+        description: "Upload new binary content for an existing attachment, creating a new version. Content must " +
+            "be base64-encoded. filename is required and becomes the attachment's title — pass its " +
+            "existing filename (from list_page_attachments) to keep the name unchanged.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pageId: { type: "string" },
+                attachmentId: { type: "string" },
+                filename: { type: "string" },
+                contentBase64: { type: "string" },
+                mediaType: { type: "string" },
+                comment: { type: "string" },
+            },
+            required: ["pageId", "attachmentId", "filename", "contentBase64"],
+        },
+        handler: (server, args) => updateAttachmentData(server.requireUserClient(), parseArgs(UpdateAttachmentDataArgsSchema, args)),
+    },
+    get_attachment_extracted_text: {
+        description: "Get Confluence's extracted plain text from an attachment (e.g. for PDFs/Office docs it has indexed)." + UNTRUSTED_CONTENT_NOTE,
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, attachmentId: { type: "string" } },
+            required: ["pageId", "attachmentId"],
+        },
+        handler: (server, args) => getAttachmentExtractedText(server.requireUserClient(), parseArgs(GetAttachmentExtractedTextArgsSchema, args)),
+    },
+    move_attachment: {
+        description: "Rename an attachment's filename, or move it to a different page.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pageId: { type: "string" },
+                attachmentId: { type: "string" },
+                newName: { type: "string" },
+                newContentId: { type: "string" },
+            },
+            required: ["pageId", "attachmentId"],
+        },
+        handler: (server, args) => moveAttachment(server.requireUserClient(), parseArgs(MoveAttachmentArgsSchema, args)),
+    },
+    delete_attachment_version: {
+        description: "Permanently delete one historical version of an attachment (not the current version).",
+        inputSchema: {
+            type: "object",
+            properties: { pageId: { type: "string" }, attachmentId: { type: "string" }, version: { type: "number" } },
+            required: ["pageId", "attachmentId", "version"],
+        },
+        handler: (server, args) => deleteAttachmentVersion(server.requireUserClient(), parseArgs(DeleteAttachmentVersionArgsSchema, args)),
+    },
+    create_space: {
+        description: "Create a new global Confluence space. See skill://spaces-admin for real gotchas across this tool surface.",
+        inputSchema: {
+            type: "object",
+            properties: { key: { type: "string" }, name: { type: "string" }, description: { type: "string" } },
+            required: ["key", "name"],
+        },
+        handler: (server, args) => createSpace(server.requireUserClient(), parseArgs(CreateSpaceArgsSchema, args)),
+    },
+    create_private_space: {
+        description: "Create a new private space (visible only to its creator until permissions are granted).",
+        inputSchema: {
+            type: "object",
+            properties: { key: { type: "string" }, name: { type: "string" }, description: { type: "string" } },
+            required: ["key", "name"],
+        },
+        handler: (server, args) => createPrivateSpace(server.requireUserClient(), parseArgs(CreatePrivateSpaceArgsSchema, args)),
+    },
+    create_personal_space: {
+        description: "Create the personal space for the acting user (one per user, key derived automatically).",
+        inputSchema: {
+            type: "object",
+            properties: { description: { type: "string" }, isPrivate: { type: "boolean" } },
+        },
+        handler: (server, args) => createPersonalSpace(server.requireUserClient(), parseArgs(CreatePersonalSpaceArgsSchema, args ?? {})),
+    },
+    delete_space: {
+        description: "Permanently delete a space and all its content. DESTRUCTIVE, asynchronous, and irreversible.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => deleteSpace(server.requireUserClient(), parseArgs(DeleteSpaceArgsSchema, args)),
+    },
+    update_space: {
+        description: "Update a space's name and/or description.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, name: { type: "string" }, description: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => updateSpace(server.requireUserClient(), parseArgs(UpdateSpaceArgsSchema, args)),
+    },
+    archive_space: {
+        description: "Archive a space, making it read-only and hidden from default space listings.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => archiveSpace(server.requireUserClient(), parseArgs(ArchiveSpaceArgsSchema, args)),
+    },
+    add_space_category: {
+        description: "Add a category label to a space.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, categoryName: { type: "string" } },
+            required: ["spaceKey", "categoryName"],
+        },
+        handler: (server, args) => addSpaceCategory(server.requireUserClient(), parseArgs(AddSpaceCategoryArgsSchema, args)),
+    },
+    remove_space_category: {
+        description: "Remove a category label from a space.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, categoryName: { type: "string" } },
+            required: ["spaceKey", "categoryName"],
+        },
+        handler: (server, args) => removeSpaceCategory(server.requireUserClient(), parseArgs(RemoveSpaceCategoryArgsSchema, args)),
+    },
+    list_space_content: {
+        description: "Get a space's content index, grouped by content type.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => listSpaceContent(server.requireUserClient(), parseArgs(ListSpaceContentArgsSchema, args)),
+    },
+    list_space_content_of_type: {
+        description: 'List a space\'s content of a given type, e.g. "page", "blogpost".',
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, type: { type: "string" } },
+            required: ["spaceKey", "type"],
+        },
+        handler: (server, args) => listSpaceContentOfType(server.requireUserClient(), parseArgs(ListSpaceContentOfTypeArgsSchema, args)),
+    },
+    list_space_properties: {
+        description: "List all custom properties (key/value metadata) stored on a space.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => listSpaceProperties(server.requireUserClient(), parseArgs(ListSpacePropertiesArgsSchema, args)),
+    },
+    create_space_property: {
+        description: "Create a custom property on a space. Fails if the key already exists — use update_space_property instead.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, key: { type: "string" }, value: {} },
+            required: ["spaceKey", "key", "value"],
+        },
+        handler: (server, args) => createSpaceProperty(server.requireUserClient(), parseArgs(CreateSpacePropertyArgsSchema, args)),
+    },
+    get_space_property: {
+        description: "Get a single custom property by key from a space.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, key: { type: "string" } },
+            required: ["spaceKey", "key"],
+        },
+        handler: (server, args) => getSpaceProperty(server.requireUserClient(), parseArgs(GetSpacePropertyArgsSchema, args)),
+    },
+    update_space_property: {
+        description: "Update an existing space property's value. Call get_space_property first to obtain currentVersion.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, key: { type: "string" }, value: {}, currentVersion: { type: "number" } },
+            required: ["spaceKey", "key", "value", "currentVersion"],
+        },
+        handler: (server, args) => updateSpaceProperty(server.requireUserClient(), parseArgs(UpdateSpacePropertyArgsSchema, args)),
+    },
+    delete_space_property: {
+        description: "Delete a custom property from a space.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, key: { type: "string" } },
+            required: ["spaceKey", "key"],
+        },
+        handler: (server, args) => deleteSpaceProperty(server.requireUserClient(), parseArgs(DeleteSpacePropertyArgsSchema, args)),
+    },
+    admin_restore_space: {
+        description: "Restore a previously deleted space, if still within the recovery window. Admin operation.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => restoreSpace(server.requireAdminClient(), parseArgs(RestoreSpaceArgsSchema, args)),
+    },
+    empty_space_trash: {
+        description: "Permanently delete all trashed content in a space in one operation. DESTRUCTIVE, asynchronous, and irreversible.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => emptySpaceTrash(server.requireUserClient(), parseArgs(EmptySpaceTrashArgsSchema, args)),
+    },
+    list_space_trash: {
+        description: "List a space's trashed (soft-deleted) content.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => listSpaceTrash(server.requireUserClient(), parseArgs(ListSpaceTrashArgsSchema, args)),
+    },
+    get_space_watchers: {
+        description: "List users watching a space.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => getSpaceWatchers(server.requireUserClient(), parseArgs(GetSpaceWatchersArgsSchema, args)),
+    },
+    admin_list_global_permissions: {
+        description: "List all global permission grants instance-wide. See skill://permissions for real gotchas across this tool surface.",
+        inputSchema: { type: "object", properties: {} },
+        requiresAdmin: true,
+        handler: (server, args) => listGlobalPermissions(server.requireAdminClient(), parseArgs(ListGlobalPermissionsArgsSchema, args ?? {})),
+    },
+    admin_set_global_permissions: {
+        description: "Replace global permissions for multiple users/groups in one call.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                subjects: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            userKey: { type: "string" },
+                            groupName: { type: "string" },
+                            operations: { type: "array", items: { type: "object" } },
+                        },
+                        required: ["operations"],
+                    },
+                },
+            },
+            required: ["subjects"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => setGlobalPermissions(server.requireAdminClient(), parseArgs(SetGlobalPermissionsArgsSchema, args)),
+    },
+    admin_get_anonymous_global_permissions: {
+        description: "Get global permissions granted to anonymous (unauthenticated) users.",
+        inputSchema: { type: "object", properties: {} },
+        requiresAdmin: true,
+        handler: (server, args) => getAnonymousGlobalPermissions(server.requireAdminClient(), parseArgs(GetAnonymousGlobalPermissionsArgsSchema, args ?? {})),
+    },
+    admin_grant_anonymous_global_permissions: {
+        description: "Grant global permissions to anonymous (unauthenticated) users.",
+        inputSchema: {
+            type: "object",
+            properties: { operations: { type: "array", items: { type: "object" } } },
+            required: ["operations"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => grantAnonymousGlobalPermissions(server.requireAdminClient(), parseArgs(GrantAnonymousGlobalPermissionsArgsSchema, args)),
+    },
+    admin_revoke_anonymous_global_permissions: {
+        description: "Revoke global permissions from anonymous (unauthenticated) users.",
+        inputSchema: {
+            type: "object",
+            properties: { operations: { type: "array", items: { type: "object" } } },
+            required: ["operations"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => revokeAnonymousGlobalPermissions(server.requireAdminClient(), parseArgs(RevokeAnonymousGlobalPermissionsArgsSchema, args)),
+    },
+    admin_get_group_global_permissions: {
+        description: "Get global permissions granted to a group.",
+        inputSchema: {
+            type: "object",
+            properties: { groupName: { type: "string" } },
+            required: ["groupName"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => getGroupGlobalPermissions(server.requireAdminClient(), parseArgs(GetGroupGlobalPermissionsArgsSchema, args)),
+    },
+    admin_grant_group_global_permissions: {
+        description: "Grant global permissions to a group.",
+        inputSchema: {
+            type: "object",
+            properties: { groupName: { type: "string" }, operations: { type: "array", items: { type: "object" } } },
+            required: ["groupName", "operations"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => grantGroupGlobalPermissions(server.requireAdminClient(), parseArgs(GrantGroupGlobalPermissionsArgsSchema, args)),
+    },
+    admin_revoke_group_global_permissions: {
+        description: "Revoke global permissions from a group.",
+        inputSchema: {
+            type: "object",
+            properties: { groupName: { type: "string" }, operations: { type: "array", items: { type: "object" } } },
+            required: ["groupName", "operations"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => revokeGroupGlobalPermissions(server.requireAdminClient(), parseArgs(RevokeGroupGlobalPermissionsArgsSchema, args)),
+    },
+    admin_get_unlicensed_global_permissions: {
+        description: "Get global permissions granted to unlicensed users.",
+        inputSchema: { type: "object", properties: {} },
+        requiresAdmin: true,
+        handler: (server, args) => getUnlicensedGlobalPermissions(server.requireAdminClient(), parseArgs(GetUnlicensedGlobalPermissionsArgsSchema, args ?? {})),
+    },
+    admin_grant_unlicensed_global_permissions: {
+        description: "Grant global permissions to unlicensed users.",
+        inputSchema: {
+            type: "object",
+            properties: { operations: { type: "array", items: { type: "object" } } },
+            required: ["operations"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => grantUnlicensedGlobalPermissions(server.requireAdminClient(), parseArgs(GrantUnlicensedGlobalPermissionsArgsSchema, args)),
+    },
+    admin_revoke_unlicensed_global_permissions: {
+        description: "Revoke global permissions from unlicensed users.",
+        inputSchema: {
+            type: "object",
+            properties: { operations: { type: "array", items: { type: "object" } } },
+            required: ["operations"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => revokeUnlicensedGlobalPermissions(server.requireAdminClient(), parseArgs(RevokeUnlicensedGlobalPermissionsArgsSchema, args)),
+    },
+    admin_get_user_global_permissions: {
+        description: "Get global permissions granted to a specific user.",
+        inputSchema: {
+            type: "object",
+            properties: { user: { type: "string" } },
+            required: ["user"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => getUserGlobalPermissions(server.requireAdminClient(), parseArgs(GetUserGlobalPermissionsArgsSchema, args)),
+    },
+    admin_grant_user_global_permissions: {
+        description: "Grant global permissions to a specific user.",
+        inputSchema: {
+            type: "object",
+            properties: { user: { type: "string" }, operations: { type: "array", items: { type: "object" } } },
+            required: ["user", "operations"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => grantUserGlobalPermissions(server.requireAdminClient(), parseArgs(GrantUserGlobalPermissionsArgsSchema, args)),
+    },
+    admin_revoke_user_global_permissions: {
+        description: "Revoke global permissions from a specific user.",
+        inputSchema: {
+            type: "object",
+            properties: { user: { type: "string" }, operations: { type: "array", items: { type: "object" } } },
+            required: ["user", "operations"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => revokeUserGlobalPermissions(server.requireAdminClient(), parseArgs(RevokeUserGlobalPermissionsArgsSchema, args)),
+    },
+    admin_set_space_permissions: {
+        description: "Replace space permissions for multiple users/groups in one call.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                spaceKey: { type: "string" },
+                subjects: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            userKey: { type: "string" },
+                            groupName: { type: "string" },
+                            operations: { type: "array", items: { type: "object" } },
+                        },
+                        required: ["operations"],
+                    },
+                },
+            },
+            required: ["spaceKey", "subjects"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => setSpacePermissions(server.requireAdminClient(), parseArgs(SetSpacePermissionsArgsSchema, args)),
+    },
+    admin_get_space_anonymous_permissions: {
+        description: "Get a space's permissions granted to anonymous (unauthenticated) users.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => getSpaceAnonymousPermissions(server.requireAdminClient(), parseArgs(GetSpaceAnonymousPermissionsArgsSchema, args)),
+    },
+    admin_grant_space_anonymous_permissions: {
+        description: "Grant space permissions to anonymous (unauthenticated) users.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, operations: { type: "array", items: { type: "object" } } },
+            required: ["spaceKey", "operations"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => grantSpaceAnonymousPermissions(server.requireAdminClient(), parseArgs(GrantSpaceAnonymousPermissionsArgsSchema, args)),
+    },
+    admin_revoke_space_anonymous_permissions: {
+        description: "Revoke space permissions from anonymous (unauthenticated) users.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, operations: { type: "array", items: { type: "object" } } },
+            required: ["spaceKey", "operations"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => revokeSpaceAnonymousPermissions(server.requireAdminClient(), parseArgs(RevokeSpaceAnonymousPermissionsArgsSchema, args)),
+    },
+    admin_get_space_group_permissions: {
+        description: "Get a space's permissions granted to a group.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, groupName: { type: "string" } },
+            required: ["spaceKey", "groupName"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => getSpaceGroupPermissions(server.requireAdminClient(), parseArgs(GetSpaceGroupPermissionsArgsSchema, args)),
+    },
+    admin_grant_space_group_permissions: {
+        description: "Grant space permissions to a group.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                spaceKey: { type: "string" },
+                groupName: { type: "string" },
+                operations: { type: "array", items: { type: "object" } },
+            },
+            required: ["spaceKey", "groupName", "operations"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => grantSpaceGroupPermissions(server.requireAdminClient(), parseArgs(GrantSpaceGroupPermissionsArgsSchema, args)),
+    },
+    admin_revoke_space_group_permissions: {
+        description: "Revoke space permissions from a group.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                spaceKey: { type: "string" },
+                groupName: { type: "string" },
+                operations: { type: "array", items: { type: "object" } },
+            },
+            required: ["spaceKey", "groupName", "operations"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => revokeSpaceGroupPermissions(server.requireAdminClient(), parseArgs(RevokeSpaceGroupPermissionsArgsSchema, args)),
+    },
+    admin_get_space_user_permissions: {
+        description: "Get a space's permissions granted to a specific user.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, userKey: { type: "string" } },
+            required: ["spaceKey", "userKey"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => getSpaceUserPermissions(server.requireAdminClient(), parseArgs(GetSpaceUserPermissionsArgsSchema, args)),
+    },
+    admin_grant_space_user_permissions: {
+        description: "Grant space permissions to a specific user.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                spaceKey: { type: "string" },
+                userKey: { type: "string" },
+                operations: { type: "array", items: { type: "object" } },
+            },
+            required: ["spaceKey", "userKey", "operations"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => grantSpaceUserPermissions(server.requireAdminClient(), parseArgs(GrantSpaceUserPermissionsArgsSchema, args)),
+    },
+    admin_revoke_space_user_permissions: {
+        description: "Revoke space permissions from a specific user.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                spaceKey: { type: "string" },
+                userKey: { type: "string" },
+                operations: { type: "array", items: { type: "object" } },
+            },
+            required: ["spaceKey", "userKey", "operations"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => revokeSpaceUserPermissions(server.requireAdminClient(), parseArgs(RevokeSpaceUserPermissionsArgsSchema, args)),
+    },
+    get_global_color_scheme: {
+        description: "Get the instance-wide default color scheme (light and dark theme variants).",
+        inputSchema: { type: "object", properties: {} },
+        handler: (server, args) => getGlobalColorScheme(server.requireUserClient(), parseArgs(GetGlobalColorSchemeArgsSchema, args ?? {})),
+    },
+    update_global_color_scheme: {
+        description: "Replace the instance-wide default color scheme. Pass the full scheme object (get_global_color_scheme first).",
+        inputSchema: {
+            type: "object",
+            properties: { scheme: { type: "object" } },
+            required: ["scheme"],
+        },
+        handler: (server, args) => updateGlobalColorScheme(server.requireUserClient(), parseArgs(UpdateGlobalColorSchemeArgsSchema, args)),
+    },
+    get_default_global_color_scheme: {
+        description: "Get Confluence's built-in default color scheme (not the instance's current customization, if any).",
+        inputSchema: { type: "object", properties: {} },
+        handler: (server, args) => getDefaultGlobalColorScheme(server.requireUserClient(), parseArgs(GetDefaultGlobalColorSchemeArgsSchema, args ?? {})),
+    },
+    reset_global_color_scheme: {
+        description: "Reset the instance-wide color scheme to Confluence's built-in default.",
+        inputSchema: { type: "object", properties: {} },
+        handler: (server, args) => resetGlobalColorScheme(server.requireUserClient(), parseArgs(ResetGlobalColorSchemeArgsSchema, args ?? {})),
+    },
+    get_space_color_scheme: {
+        description: "Get a space's color scheme (light and dark theme variants).",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => getSpaceColorScheme(server.requireUserClient(), parseArgs(GetSpaceColorSchemeArgsSchema, args)),
+    },
+    update_space_color_scheme: {
+        description: "Replace a space's color scheme. Pass the full scheme object (get_space_color_scheme first).",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, scheme: { type: "object" } },
+            required: ["spaceKey", "scheme"],
+        },
+        handler: (server, args) => updateSpaceColorScheme(server.requireUserClient(), parseArgs(UpdateSpaceColorSchemeArgsSchema, args)),
+    },
+    reset_space_color_scheme: {
+        description: "Reset a space's color scheme to the instance default.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => resetSpaceColorScheme(server.requireUserClient(), parseArgs(ResetSpaceColorSchemeArgsSchema, args)),
+    },
+    get_space_color_scheme_type: {
+        description: 'Get whether a space uses the instance default color scheme ("global") or its own ("custom").',
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => getSpaceColorSchemeType(server.requireUserClient(), parseArgs(GetSpaceColorSchemeTypeArgsSchema, args)),
+    },
+    update_space_color_scheme_type: {
+        description: 'Set a space to use the instance default color scheme ("global") or its own ("custom").',
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" }, type: { type: "string" } },
+            required: ["spaceKey", "type"],
+        },
+        handler: (server, args) => updateSpaceColorSchemeType(server.requireUserClient(), parseArgs(UpdateSpaceColorSchemeTypeArgsSchema, args)),
+    },
+    get_access_mode: {
+        description: "Get the instance's access mode (e.g. read-only maintenance mode status).",
+        inputSchema: { type: "object", properties: {} },
+        handler: (server, args) => getAccessMode(server.requireUserClient(), parseArgs(GetAccessModeArgsSchema, args ?? {})),
+    },
+    admin_list_groups: {
+        description: "List all groups on the instance.",
+        inputSchema: { type: "object", properties: {} },
+        requiresAdmin: true,
+        handler: (server, args) => listGroups(server.requireAdminClient(), parseArgs(ListGroupsArgsSchema, args ?? {})),
+    },
+    admin_get_group: {
+        description: "Get a group by name.",
+        inputSchema: {
+            type: "object",
+            properties: { groupName: { type: "string" } },
+            required: ["groupName"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => getGroup(server.requireAdminClient(), parseArgs(GetGroupArgsSchema, args)),
+    },
+    admin_get_group_ancestors: {
+        description: "Get a group's ancestor groups (groups it is nested within).",
+        inputSchema: {
+            type: "object",
+            properties: { groupName: { type: "string" } },
+            required: ["groupName"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => getGroupAncestors(server.requireAdminClient(), parseArgs(GetGroupAncestorsArgsSchema, args)),
+    },
+    admin_get_group_nested_members: {
+        description: "Get a group's members, including members inherited from nested sub-groups.",
+        inputSchema: {
+            type: "object",
+            properties: { groupName: { type: "string" } },
+            required: ["groupName"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => getGroupNestedMembers(server.requireAdminClient(), parseArgs(GetGroupNestedMembersArgsSchema, args)),
+    },
+    admin_get_group_parents: {
+        description: "Get the groups that directly nest a given group.",
+        inputSchema: {
+            type: "object",
+            properties: { groupName: { type: "string" } },
+            required: ["groupName"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => getGroupParents(server.requireAdminClient(), parseArgs(GetGroupParentsArgsSchema, args)),
+    },
+    admin_get_group_members: {
+        description: "Get a group's direct members (not including nested sub-group members).",
+        inputSchema: {
+            type: "object",
+            properties: { groupName: { type: "string" } },
+            required: ["groupName"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => getGroupMembers(server.requireAdminClient(), parseArgs(GetGroupMembersArgsSchema, args)),
+    },
+    get_user: {
+        description: "Get a user by username or key. See skill://users-groups for real gotchas across this tool surface.",
+        inputSchema: {
+            type: "object",
+            properties: { username: { type: "string" }, key: { type: "string" } },
+        },
+        handler: (server, args) => getUser(server.requireUserClient(), parseArgs(GetUserArgsSchema, args)),
+    },
+    admin_add_user_to_group: {
+        description: "Add a user to a group.",
+        inputSchema: {
+            type: "object",
+            properties: { username: { type: "string" }, groupName: { type: "string" } },
+            required: ["username", "groupName"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => addUserToGroup(server.requireAdminClient(), parseArgs(AddUserToGroupArgsSchema, args)),
+    },
+    admin_remove_user_from_group: {
+        description: "Remove a user from a group.",
+        inputSchema: {
+            type: "object",
+            properties: { username: { type: "string" }, groupName: { type: "string" } },
+            required: ["username", "groupName"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => removeUserFromGroup(server.requireAdminClient(), parseArgs(RemoveUserFromGroupArgsSchema, args)),
+    },
+    get_anonymous_user_info: {
+        description: "Get information about how Confluence represents the anonymous user type.",
+        inputSchema: { type: "object", properties: {} },
+        handler: (server, args) => getAnonymousUserInfo(server.requireUserClient(), parseArgs(GetAnonymousUserInfoArgsSchema, args ?? {})),
+    },
+    get_current_user: {
+        description: "Get the acting user's own account details.",
+        inputSchema: { type: "object", properties: {} },
+        handler: (server, args) => getCurrentUser(server.requireUserClient(), parseArgs(GetCurrentUserArgsSchema, args ?? {})),
+    },
+    update_current_user: {
+        description: "Update the acting user's own full name and/or email. currentPassword is required by Confluence when changing email.",
+        inputSchema: {
+            type: "object",
+            properties: { fullName: { type: "string" }, email: { type: "string" }, currentPassword: { type: "string" } },
+        },
+        handler: (server, args) => updateCurrentUser(server.requireUserClient(), parseArgs(UpdateCurrentUserArgsSchema, args ?? {})),
+    },
+    change_current_user_password: {
+        description: "Change the acting user's own password.",
+        inputSchema: {
+            type: "object",
+            properties: { oldPassword: { type: "string" }, newPassword: { type: "string" } },
+            required: ["oldPassword", "newPassword"],
+        },
+        handler: (server, args) => changeCurrentUserPassword(server.requireUserClient(), parseArgs(ChangeCurrentUserPasswordArgsSchema, args)),
+    },
+    list_users: {
+        description: "List registered users on the instance.",
+        inputSchema: { type: "object", properties: {} },
+        handler: (server, args) => listUsers(server.requireUserClient(), parseArgs(ListUsersArgsSchema, args ?? {})),
+    },
+    get_user_groups: {
+        description: "Get the groups a user belongs to.",
+        inputSchema: {
+            type: "object",
+            properties: { username: { type: "string" }, key: { type: "string" } },
+        },
+        handler: (server, args) => getUserGroups(server.requireUserClient(), parseArgs(GetUserGroupsArgsSchema, args)),
+    },
+    update_user_settings: {
+        description: "Update a user's preference settings (e.g. locale).",
+        inputSchema: {
+            type: "object",
+            properties: { username: { type: "string" }, locale: { type: "string" } },
+            required: ["username"],
+        },
+        handler: (server, args) => updateUserSettings(server.requireUserClient(), parseArgs(UpdateUserSettingsArgsSchema, args)),
+    },
+    remove_content_watcher: {
+        description: "Stop the acting user watching a piece of content.",
+        inputSchema: {
+            type: "object",
+            properties: { contentId: { type: "string" } },
+            required: ["contentId"],
+        },
+        handler: (server, args) => removeContentWatcher(server.requireUserClient(), parseArgs(RemoveContentWatcherArgsSchema, args)),
+    },
+    is_watching_content: {
+        description: "Check whether the acting user is watching a piece of content.",
+        inputSchema: {
+            type: "object",
+            properties: { contentId: { type: "string" } },
+            required: ["contentId"],
+        },
+        handler: (server, args) => isWatchingContent(server.requireUserClient(), parseArgs(IsWatchingContentArgsSchema, args)),
+    },
+    add_content_watcher: {
+        description: "Make the acting user watch a piece of content.",
+        inputSchema: {
+            type: "object",
+            properties: { contentId: { type: "string" } },
+            required: ["contentId"],
+        },
+        handler: (server, args) => addContentWatcher(server.requireUserClient(), parseArgs(AddContentWatcherArgsSchema, args)),
+    },
+    remove_space_watcher: {
+        description: "Stop the acting user watching a space.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => removeSpaceWatcher(server.requireUserClient(), parseArgs(RemoveSpaceWatcherArgsSchema, args)),
+    },
+    is_watching_space: {
+        description: "Check whether the acting user is watching a space.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => isWatchingSpace(server.requireUserClient(), parseArgs(IsWatchingSpaceArgsSchema, args)),
+    },
+    add_space_watcher: {
+        description: "Make the acting user watch a space.",
+        inputSchema: {
+            type: "object",
+            properties: { spaceKey: { type: "string" } },
+            required: ["spaceKey"],
+        },
+        handler: (server, args) => addSpaceWatcher(server.requireUserClient(), parseArgs(AddSpaceWatcherArgsSchema, args)),
+    },
+    admin_create_group: {
+        description: "Create a new group.",
+        inputSchema: {
+            type: "object",
+            properties: { name: { type: "string" } },
+            required: ["name"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminCreateGroup(server.requireAdminClient(), parseArgs(AdminCreateGroupArgsSchema, args)),
+    },
+    admin_delete_group: {
+        description: "Permanently delete a group. DESTRUCTIVE — members lose whatever access this group granted.",
+        inputSchema: {
+            type: "object",
+            properties: { groupName: { type: "string" } },
+            required: ["groupName"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminDeleteGroup(server.requireAdminClient(), parseArgs(AdminDeleteGroupArgsSchema, args)),
+    },
+    admin_create_personal_space_for_user: {
+        description: "Create the personal space for a given user (admin-initiated, vs. create_personal_space which creates the acting user's own).",
+        inputSchema: {
+            type: "object",
+            properties: { username: { type: "string" }, description: { type: "string" }, isPrivate: { type: "boolean" } },
+            required: ["username"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminCreatePersonalSpaceForUser(server.requireAdminClient(), parseArgs(AdminCreatePersonalSpaceForUserArgsSchema, args)),
+    },
+    admin_create_user: {
+        description: "Create a new user account. Omit password to require the user to set their own via an emailed link.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                userName: { type: "string" },
+                fullName: { type: "string" },
+                email: { type: "string" },
+                password: { type: "string" },
+                notifyViaEmail: { type: "boolean" },
+            },
+            required: ["userName", "fullName", "email"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminCreateUser(server.requireAdminClient(), parseArgs(AdminCreateUserArgsSchema, args)),
+    },
+    admin_delete_user: {
+        description: "Permanently delete a user account. DESTRUCTIVE. Does not delete their personal space " +
+            "(confirmed live) — it's left behind at ~<username>; delete it separately with delete_space if wanted.",
+        inputSchema: {
+            type: "object",
+            properties: { username: { type: "string" } },
+            required: ["username"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminDeleteUser(server.requireAdminClient(), parseArgs(AdminDeleteUserArgsSchema, args)),
+    },
+    admin_update_user: {
+        description: "Update another user's full name and/or email.",
+        inputSchema: {
+            type: "object",
+            properties: { username: { type: "string" }, fullName: { type: "string" }, email: { type: "string" } },
+            required: ["username"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminUpdateUser(server.requireAdminClient(), parseArgs(AdminUpdateUserArgsSchema, args)),
+    },
+    admin_disable_user: {
+        description: "Disable a user account, blocking login without deleting the account or its content.",
+        inputSchema: {
+            type: "object",
+            properties: { username: { type: "string" } },
+            required: ["username"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminDisableUser(server.requireAdminClient(), parseArgs(AdminDisableUserArgsSchema, args)),
+    },
+    admin_enable_user: {
+        description: "Re-enable a previously disabled user account.",
+        inputSchema: {
+            type: "object",
+            properties: { username: { type: "string" } },
+            required: ["username"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminEnableUser(server.requireAdminClient(), parseArgs(AdminEnableUserArgsSchema, args)),
+    },
+    admin_change_user_password: {
+        description: "Set another user's password.",
+        inputSchema: {
+            type: "object",
+            properties: { username: { type: "string" }, password: { type: "string" } },
+            required: ["username", "password"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminChangeUserPassword(server.requireAdminClient(), parseArgs(AdminChangeUserPasswordArgsSchema, args)),
+    },
+    admin_list_active_users: {
+        description: "List all active (non-disabled) user accounts.",
+        inputSchema: { type: "object", properties: {} },
+        requiresAdmin: true,
+        handler: (server, args) => adminListActiveUsers(server.requireAdminClient(), parseArgs(AdminListActiveUsersArgsSchema, args ?? {})),
+    },
+    admin_list_webhooks: {
+        description: "List registered webhooks, optionally filtered by event type. See skill://webhooks for real gotchas across this tool surface.",
+        inputSchema: {
+            type: "object",
+            properties: { event: { type: "string" } },
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminListWebhooks(server.requireAdminClient(), parseArgs(AdminListWebhooksArgsSchema, args ?? {})),
+    },
+    admin_create_webhook: {
+        description: 'Create a new webhook. events lists what triggers it, e.g. ["page_created", "page_updated"].',
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string" },
+                url: { type: "string" },
+                events: { type: "array", items: { type: "string" } },
+                active: { type: "boolean" },
+            },
+            required: ["name", "url", "events"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminCreateWebhook(server.requireAdminClient(), parseArgs(AdminCreateWebhookArgsSchema, args)),
+    },
+    admin_delete_webhook: {
+        description: "Permanently delete a webhook.",
+        inputSchema: {
+            type: "object",
+            properties: { webhookId: { type: "string" } },
+            required: ["webhookId"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminDeleteWebhook(server.requireAdminClient(), parseArgs(AdminDeleteWebhookArgsSchema, args)),
+    },
+    admin_get_webhook: {
+        description: "Get a webhook by ID.",
+        inputSchema: {
+            type: "object",
+            properties: { webhookId: { type: "string" } },
+            required: ["webhookId"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminGetWebhook(server.requireAdminClient(), parseArgs(AdminGetWebhookArgsSchema, args)),
+    },
+    admin_update_webhook: {
+        description: "Replace a webhook's configuration. Pass the full desired configuration (get_webhook first).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                webhookId: { type: "string" },
+                name: { type: "string" },
+                url: { type: "string" },
+                events: { type: "array", items: { type: "string" } },
+                active: { type: "boolean" },
+            },
+            required: ["webhookId", "name", "url", "events"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminUpdateWebhook(server.requireAdminClient(), parseArgs(AdminUpdateWebhookArgsSchema, args)),
+    },
+    admin_get_webhook_latest_invocations: {
+        description: "Get a webhook's most recent invocation attempts.",
+        inputSchema: {
+            type: "object",
+            properties: { webhookId: { type: "string" } },
+            required: ["webhookId"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminGetWebhookLatestInvocations(server.requireAdminClient(), parseArgs(AdminGetWebhookLatestInvocationsArgsSchema, args)),
+    },
+    admin_get_webhook_statistics: {
+        description: "Get a webhook's invocation statistics.",
+        inputSchema: {
+            type: "object",
+            properties: { webhookId: { type: "string" } },
+            required: ["webhookId"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminGetWebhookStatistics(server.requireAdminClient(), parseArgs(AdminGetWebhookStatisticsArgsSchema, args)),
+    },
+    admin_get_webhook_statistics_summary: {
+        description: "Get a summary of a webhook's invocation statistics.",
+        inputSchema: {
+            type: "object",
+            properties: { webhookId: { type: "string" } },
+            required: ["webhookId"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminGetWebhookStatisticsSummary(server.requireAdminClient(), parseArgs(AdminGetWebhookStatisticsSummaryArgsSchema, args)),
+    },
+    admin_test_webhook: {
+        description: "Send a test payload to a URL to verify it can receive webhook calls, without creating a real webhook.",
+        inputSchema: {
+            type: "object",
+            properties: { url: { type: "string" } },
+            required: ["url"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminTestWebhook(server.requireAdminClient(), parseArgs(AdminTestWebhookArgsSchema, args)),
+    },
+    admin_create_site_backup_job: {
+        description: "Start an instance-wide backup job. Asynchronous — poll with admin_get_backup_restore_job. " +
+            "See skill://instance-maintenance for real gotchas across this tool surface, including which " +
+            "operations here are genuinely irreversible.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                skipAttachments: { type: "boolean" },
+                keepPermanently: { type: "boolean" },
+                fileNamePrefix: { type: "string" },
+            },
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminCreateSiteBackupJob(server.requireAdminClient(), parseArgs(AdminCreateSiteBackupJobArgsSchema, args ?? {})),
+    },
+    admin_create_space_backup_job: {
+        description: "Start a backup job for one or more spaces. Asynchronous — poll with admin_get_backup_restore_job.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                spaceKeys: { type: "array", items: { type: "string" } },
+                keepPermanently: { type: "boolean" },
+                fileNamePrefix: { type: "string" },
+            },
+            required: ["spaceKeys"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminCreateSpaceBackupJob(server.requireAdminClient(), parseArgs(AdminCreateSpaceBackupJobArgsSchema, args)),
+    },
+    admin_find_backup_restore_jobs: {
+        description: "Search backup/restore jobs by owner, space, scope, or operation type. Pass at least " +
+            "jobScope or jobOperation — confirmed live, with neither this returns an empty list even " +
+            "when real jobs exist.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                owner: { type: "string" },
+                spaceKey: { type: "string" },
+                jobScope: { type: "string" },
+                jobOperation: { type: "string" },
+            },
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminFindBackupRestoreJobs(server.requireAdminClient(), parseArgs(AdminFindBackupRestoreJobsArgsSchema, args ?? {})),
+    },
+    admin_get_backup_restore_job: {
+        description: "Get a backup/restore job's status by ID.",
+        inputSchema: {
+            type: "object",
+            properties: { jobId: { type: "string" } },
+            required: ["jobId"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminGetBackupRestoreJob(server.requireAdminClient(), parseArgs(AdminGetBackupRestoreJobArgsSchema, args)),
+    },
+    admin_cancel_backup_restore_job: {
+        description: "Cancel a running or queued backup/restore job.",
+        inputSchema: {
+            type: "object",
+            properties: { jobId: { type: "string" } },
+            required: ["jobId"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminCancelBackupRestoreJob(server.requireAdminClient(), parseArgs(AdminCancelBackupRestoreJobArgsSchema, args)),
+    },
+    admin_download_backup_file: {
+        description: "Download a completed backup job's file. Inlined as base64 if small; otherwise only size/type " +
+            "metadata is returned (backup files can be many megabytes — never embedded wholesale).",
+        inputSchema: {
+            type: "object",
+            properties: { jobId: { type: "string" } },
+            required: ["jobId"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminDownloadBackupFile(server.requireAdminClient(), parseArgs(AdminDownloadBackupFileArgsSchema, args)),
+    },
+    admin_cancel_all_queued_backup_restore_jobs: {
+        description: "Cancel every currently queued (not yet running) backup/restore job.",
+        inputSchema: { type: "object", properties: {} },
+        requiresAdmin: true,
+        handler: (server, args) => adminCancelAllQueuedBackupRestoreJobs(server.requireAdminClient(), parseArgs(AdminCancelAllQueuedBackupRestoreJobsArgsSchema, args ?? {})),
+    },
+    admin_list_restore_files: {
+        description: "List backup files available in the server's restore directory, ready to restore from by filename.",
+        inputSchema: {
+            type: "object",
+            properties: { jobScope: { type: "string" } },
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminListRestoreFiles(server.requireAdminClient(), parseArgs(AdminListRestoreFilesArgsSchema, args ?? {})),
+    },
+    admin_create_site_restore_job: {
+        description: "Restore the entire instance from a backup file already in the restore directory (see " +
+            "admin_list_restore_files). DESTRUCTIVE — replaces live content with the backup's contents.",
+        inputSchema: {
+            type: "object",
+            properties: { fileName: { type: "string" }, skipReindex: { type: "boolean" } },
+            required: ["fileName"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminCreateSiteRestoreJob(server.requireAdminClient(), parseArgs(AdminCreateSiteRestoreJobArgsSchema, args)),
+    },
+    admin_create_space_restore_job: {
+        description: "Restore a space from a backup file already in the restore directory (see admin_list_restore_files). " +
+            "DESTRUCTIVE — replaces the space's live content with the backup's contents.",
+        inputSchema: {
+            type: "object",
+            properties: { fileName: { type: "string" }, skipReindex: { type: "boolean" } },
+            required: ["fileName"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminCreateSpaceRestoreJob(server.requireAdminClient(), parseArgs(AdminCreateSpaceRestoreJobArgsSchema, args)),
+    },
+    admin_create_site_restore_job_from_upload: {
+        description: "Upload a backup zip and restore the entire instance from it. Content must be base64-encoded. " +
+            "DESTRUCTIVE — replaces live content with the backup's contents.",
+        inputSchema: {
+            type: "object",
+            properties: { filename: { type: "string" }, contentBase64: { type: "string" }, skipReindex: { type: "boolean" } },
+            required: ["filename", "contentBase64"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminCreateSiteRestoreJobFromUpload(server.requireAdminClient(), parseArgs(AdminCreateSiteRestoreJobFromUploadArgsSchema, args)),
+    },
+    admin_create_space_restore_job_from_upload: {
+        description: "Upload a space backup zip and restore that space from it. Content must be base64-encoded. " +
+            "DESTRUCTIVE — replaces the space's live content with the backup's contents.",
+        inputSchema: {
+            type: "object",
+            properties: { filename: { type: "string" }, contentBase64: { type: "string" }, skipReindex: { type: "boolean" } },
+            required: ["filename", "contentBase64"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminCreateSpaceRestoreJobFromUpload(server.requireAdminClient(), parseArgs(AdminCreateSpaceRestoreJobFromUploadArgsSchema, args)),
+    },
+    get_reindex_status: {
+        description: "Get the search index rebuild's current status.",
+        inputSchema: { type: "object", properties: {} },
+        handler: (server, args) => getReindexStatus(server.requireUserClient(), parseArgs(GetReindexStatusArgsSchema, args ?? {})),
+    },
+    trigger_reindex: {
+        description: "Rebuild the search index (instance-wide, or one space if spaceKey is given). Resource-" +
+            "intensive and disrupts search while running. Requires confirm: true. See " +
+            "skill://instance-maintenance for real gotchas across this tool surface.",
+        inputSchema: {
+            type: "object",
+            properties: { confirm: { type: "boolean" }, spaceKey: { type: "string" } },
+            required: ["confirm"],
+        },
+        handler: (server, args) => triggerReindex(server.requireUserClient(), parseArgs(TriggerReindexArgsSchema, args)),
+    },
+    reset_reindex_job: {
+        description: "Reset a stuck or errored reindex job's status.",
+        inputSchema: { type: "object", properties: {} },
+        handler: (server, args) => resetReindexJob(server.requireUserClient(), parseArgs(ResetReindexJobArgsSchema, args ?? {})),
+    },
+    unindex_all_content: {
+        description: "Remove ALL content from the search index. Search returns nothing until trigger_reindex " +
+            "completes. Requires confirm: true.",
+        inputSchema: {
+            type: "object",
+            properties: { confirm: { type: "boolean" } },
+            required: ["confirm"],
+        },
+        handler: (server, args) => unindexAllContent(server.requireUserClient(), parseArgs(UnindexAllContentArgsSchema, args)),
+    },
+    admin_get_audit_records: {
+        description: "Get instance audit log records.",
+        inputSchema: { type: "object", properties: {} },
+        requiresAdmin: true,
+        handler: (server, args) => adminGetAuditRecords(server.requireAdminClient(), parseArgs(AdminGetAuditRecordsArgsSchema, args ?? {})),
+    },
+    admin_get_cluster_node_statuses: {
+        description: "Get the status of each node in a Data Center cluster (single-node instances return one entry).",
+        inputSchema: { type: "object", properties: {} },
+        requiresAdmin: true,
+        handler: (server, args) => adminGetClusterNodeStatuses(server.requireAdminClient(), parseArgs(AdminGetClusterNodeStatusesArgsSchema, args ?? {})),
+    },
+    get_instance_metrics: {
+        description: "Get instance-wide usage metrics (e.g. user/space/content counts).",
+        inputSchema: { type: "object", properties: {} },
+        handler: (server, args) => getInstanceMetrics(server.requireUserClient(), parseArgs(GetInstanceMetricsArgsSchema, args ?? {})),
+    },
+    admin_list_long_tasks: {
+        description: "List currently running or recently completed long-running background tasks.",
+        inputSchema: { type: "object", properties: {} },
+        requiresAdmin: true,
+        handler: (server, args) => adminListLongTasks(server.requireAdminClient(), parseArgs(AdminListLongTasksArgsSchema, args ?? {})),
+    },
+    admin_get_long_task: {
+        description: "Get a long-running background task's status by ID.",
+        inputSchema: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"],
+        },
+        requiresAdmin: true,
+        handler: (server, args) => adminGetLongTask(server.requireAdminClient(), parseArgs(AdminGetLongTaskArgsSchema, args)),
+    },
+    search_entities: {
+        description: "Search across all entity types (content, spaces, users) using CQL — broader than " +
+            "search_content, which is content-only. See skill://system for real gotchas across this " +
+            "tool surface." + UNTRUSTED_CONTENT_NOTE,
+        inputSchema: {
+            type: "object",
+            properties: {
+                cql: { type: "string" },
+                limit: { type: "number" },
+                includeArchivedSpaces: { type: "boolean" },
+            },
+            required: ["cql"],
+        },
+        handler: (server, args) => searchEntities(server.requireUserClient(), parseArgs(SearchEntitiesArgsSchema, args)),
+    },
+    get_server_information: {
+        description: "Get Confluence server version and build information.",
+        inputSchema: { type: "object", properties: {} },
+        handler: (server, args) => getServerInformation(server.requireUserClient(), parseArgs(GetServerInformationArgsSchema, args ?? {})),
+    },
+    get_api_references: {
+        description: "Get references to Confluence DC API documentation and implemented endpoints.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                category: { type: "string", enum: ["user", "admin"], description: "Omit for a category overview." },
+                tag: { type: "string" },
+                search: { type: "string" },
+            },
+        },
+        handler: (server, args) => server.handleGetApiReferences(args),
+    },
+};
+/**
+ * Pure filter used by the ListTools handler — admin-flagged tools are dropped entirely from the
+ * advertised tool list when no admin client is configured, not just rejected at call time.
+ */
+export function listableToolEntries(adminAvailable) {
+    return Object.entries(TOOL_DEFINITIONS).filter(([, def]) => !def.requiresAdmin || adminAvailable);
+}
+//# sourceMappingURL=tool-definitions.js.map