@umbraco-cms/mcp-dev 16.0.0-beta.1 → 16.0.0-beta.2

package/dist/index.cjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-"use strict"; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
+"use strict"; function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 var _process = require('process'); var _process2 = _interopRequireDefault(_process);
 
@@ -815,12 +815,12 @@ var StdioServerTransport = class {
     (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
   }
   send(message) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve();
+        resolve2();
       } else {
-        this._stdout.once("drain", resolve);
+        this._stdout.once("drain", resolve2);
       }
     });
   }
@@ -1029,7 +1029,7 @@ var Protocol = class {
    * Do not use this method to emit notifications! Use notification() instead.
    */
   request(request, resultSchema, options) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       var _a, _b, _c, _d, _e;
       if (!this._transport) {
         reject(new Error("Not connected"));
@@ -1077,7 +1077,7 @@ var Protocol = class {
         }
         try {
           const result = resultSchema.parse(response.result);
-          resolve(result);
+          resolve2(result);
         } catch (error) {
           reject(error);
         }
@@ -1954,7 +1954,7 @@ function stringifyRegExpWithFlags(regex, refs) {
   }
   try {
     new RegExp(pattern);
-  } catch (e) {
+  } catch (e2) {
     console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
     return regex.source;
   }
@@ -2284,7 +2284,7 @@ function decideAdditionalProperties(def, refs) {
 function safeIsOptional(schema) {
   try {
     return schema.isOptional();
-  } catch (e2) {
+  } catch (e3) {
     return true;
   }
 }
@@ -3238,44 +3238,32 @@ var _axios = require('axios'); var _axios2 = _interopRequireDefault(_axios);
 // src/orval/client/umbraco-axios.ts
 var _qs = require('qs'); var _qs2 = _interopRequireDefault(_qs);
 
-
-// src/helpers/config/env.ts
-
-var envSchema = _zod.z.object({
-  UMBRACO_CLIENT_ID: _zod.z.string(),
-  UMBRACO_CLIENT_SECRET: _zod.z.string(),
-  UMBRACO_BASE_URL: _zod.z.string().url(),
-  UMBRACO_EXCLUDE_TOOLS: _zod.z.string().optional().transform((val) => _optionalChain([val, 'optionalAccess', _46 => _46.split, 'call', _47 => _47(","), 'access', _48 => _48.map, 'call', _49 => _49((tool) => tool.trim())])).pipe(_zod.z.array(_zod.z.string()).optional()),
-  UMBRACO_INCLUDE_TOOLS: _zod.z.string().optional().transform((val) => _optionalChain([val, 'optionalAccess', _50 => _50.split, 'call', _51 => _51(","), 'access', _52 => _52.map, 'call', _53 => _53((tool) => tool.trim()), 'access', _54 => _54.filter, 'call', _55 => _55(Boolean)])).pipe(_zod.z.array(_zod.z.string()).optional()),
-  // Collection-level filtering
-  UMBRACO_INCLUDE_TOOL_COLLECTIONS: _zod.z.string().optional().transform((val) => _optionalChain([val, 'optionalAccess', _56 => _56.split, 'call', _57 => _57(","), 'access', _58 => _58.map, 'call', _59 => _59((collection) => collection.trim()), 'access', _60 => _60.filter, 'call', _61 => _61(Boolean)])).pipe(_zod.z.array(_zod.z.string()).optional()),
-  UMBRACO_EXCLUDE_TOOL_COLLECTIONS: _zod.z.string().optional().transform((val) => _optionalChain([val, 'optionalAccess', _62 => _62.split, 'call', _63 => _63(","), 'access', _64 => _64.map, 'call', _65 => _65((collection) => collection.trim()), 'access', _66 => _66.filter, 'call', _67 => _67(Boolean)])).pipe(_zod.z.array(_zod.z.string()).optional())
-});
-var env_default = envSchema.parse(process.env);
-
-// src/orval/client/umbraco-axios.ts
-var client_id = env_default.UMBRACO_CLIENT_ID;
-var client_secret = env_default.UMBRACO_CLIENT_SECRET;
+var authConfig = null;
+function initializeUmbracoAxios(config) {
+  authConfig = config;
+  const { clientId, clientSecret, baseUrl } = config;
+  if (!baseUrl)
+    throw new Error("Missing required configuration: baseUrl");
+  if (!clientId)
+    throw new Error("Missing required configuration: clientId");
+  if (!clientSecret && clientId !== "umbraco-swagger")
+    throw new Error("Missing required configuration: clientSecret");
+  UmbracoAxios.defaults.baseURL = baseUrl;
+}
 var grant_type = "client_credentials";
-var baseURL = env_default.UMBRACO_BASE_URL;
-if (!baseURL)
-  throw new Error("Missing required environment variable: UMBRACO_BASE_URL");
-if (!client_id)
-  throw new Error("Missing required environment variable: UMBRACO_CLIENT_ID");
-if (!client_secret && client_id !== "umbraco-swagger")
-  throw new Error(
-    "Missing required environment variable: UMBRACO_CLIENT_SECRET"
-  );
 var tokenPath = "/umbraco/management/api/v1/security/back-office/token";
-var UmbracoAxios = _axios2.default.create({ baseURL });
+var UmbracoAxios = _axios2.default.create();
 var accessToken = null;
 var tokenExpiry = null;
 var fetchAccessToken = async () => {
+  if (!authConfig) {
+    throw new Error("UmbracoAxios not initialized. Call initializeUmbracoAxios first.");
+  }
   const response = await _axios2.default.post(
-    `${baseURL}${tokenPath}`,
+    `${authConfig.baseUrl}${tokenPath}`,
     {
-      client_id,
-      client_secret: _nullishCoalesce(client_secret, () => ( "")),
+      client_id: authConfig.clientId,
+      client_secret: _nullishCoalesce(authConfig.clientSecret, () => ( "")),
       grant_type
     },
     {
@@ -5851,28 +5839,28 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const getPartialViewByPath = (path, options) => {
+  const getPartialViewByPath = (path3, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/partial-view/${path}`,
+        url: `/umbraco/management/api/v1/partial-view/${path3}`,
         method: "GET"
       },
       options
     );
   };
-  const deletePartialViewByPath = (path, options) => {
+  const deletePartialViewByPath = (path3, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/partial-view/${path}`,
+        url: `/umbraco/management/api/v1/partial-view/${path3}`,
         method: "DELETE"
       },
       options
     );
   };
-  const putPartialViewByPath = (path, updatePartialViewRequestModel, options) => {
+  const putPartialViewByPath = (path3, updatePartialViewRequestModel, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/partial-view/${path}`,
+        url: `/umbraco/management/api/v1/partial-view/${path3}`,
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         data: updatePartialViewRequestModel
@@ -5880,10 +5868,10 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const putPartialViewByPathRename = (path, renamePartialViewRequestModel, options) => {
+  const putPartialViewByPathRename = (path3, renamePartialViewRequestModel, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/partial-view/${path}/rename`,
+        url: `/umbraco/management/api/v1/partial-view/${path3}/rename`,
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         data: renamePartialViewRequestModel
@@ -5902,19 +5890,19 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const getPartialViewFolderByPath = (path, options) => {
+  const getPartialViewFolderByPath = (path3, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/partial-view/folder/${path}`,
+        url: `/umbraco/management/api/v1/partial-view/folder/${path3}`,
         method: "GET"
       },
       options
     );
   };
-  const deletePartialViewFolderByPath = (path, options) => {
+  const deletePartialViewFolderByPath = (path3, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/partial-view/folder/${path}`,
+        url: `/umbraco/management/api/v1/partial-view/folder/${path3}`,
         method: "DELETE"
       },
       options
@@ -6152,28 +6140,28 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const getScriptByPath = (path, options) => {
+  const getScriptByPath = (path3, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/script/${path}`,
+        url: `/umbraco/management/api/v1/script/${path3}`,
         method: "GET"
       },
       options
     );
   };
-  const deleteScriptByPath = (path, options) => {
+  const deleteScriptByPath = (path3, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/script/${path}`,
+        url: `/umbraco/management/api/v1/script/${path3}`,
         method: "DELETE"
       },
       options
     );
   };
-  const putScriptByPath = (path, updateScriptRequestModel, options) => {
+  const putScriptByPath = (path3, updateScriptRequestModel, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/script/${path}`,
+        url: `/umbraco/management/api/v1/script/${path3}`,
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         data: updateScriptRequestModel
@@ -6181,10 +6169,10 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const putScriptByPathRename = (path, renameScriptRequestModel, options) => {
+  const putScriptByPathRename = (path3, renameScriptRequestModel, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/script/${path}/rename`,
+        url: `/umbraco/management/api/v1/script/${path3}/rename`,
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         data: renameScriptRequestModel
@@ -6203,19 +6191,19 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const getScriptFolderByPath = (path, options) => {
+  const getScriptFolderByPath = (path3, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/script/folder/${path}`,
+        url: `/umbraco/management/api/v1/script/folder/${path3}`,
         method: "GET"
       },
       options
     );
   };
-  const deleteScriptFolderByPath = (path, options) => {
+  const deleteScriptFolderByPath = (path3, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/script/folder/${path}`,
+        url: `/umbraco/management/api/v1/script/folder/${path3}`,
         method: "DELETE"
       },
       options
@@ -6429,28 +6417,28 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const getStylesheetByPath = (path, options) => {
+  const getStylesheetByPath = (path3, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/stylesheet/${path}`,
+        url: `/umbraco/management/api/v1/stylesheet/${path3}`,
         method: "GET"
       },
       options
     );
   };
-  const deleteStylesheetByPath = (path, options) => {
+  const deleteStylesheetByPath = (path3, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/stylesheet/${path}`,
+        url: `/umbraco/management/api/v1/stylesheet/${path3}`,
         method: "DELETE"
       },
       options
     );
   };
-  const putStylesheetByPath = (path, updateStylesheetRequestModel, options) => {
+  const putStylesheetByPath = (path3, updateStylesheetRequestModel, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/stylesheet/${path}`,
+        url: `/umbraco/management/api/v1/stylesheet/${path3}`,
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         data: updateStylesheetRequestModel
@@ -6458,10 +6446,10 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const putStylesheetByPathRename = (path, renameStylesheetRequestModel, options) => {
+  const putStylesheetByPathRename = (path3, renameStylesheetRequestModel, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/stylesheet/${path}/rename`,
+        url: `/umbraco/management/api/v1/stylesheet/${path3}/rename`,
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         data: renameStylesheetRequestModel
@@ -6480,19 +6468,19 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const getStylesheetFolderByPath = (path, options) => {
+  const getStylesheetFolderByPath = (path3, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/stylesheet/folder/${path}`,
+        url: `/umbraco/management/api/v1/stylesheet/folder/${path3}`,
         method: "GET"
       },
       options
     );
   };
-  const deleteStylesheetFolderByPath = (path, options) => {
+  const deleteStylesheetFolderByPath = (path3, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/stylesheet/folder/${path}`,
+        url: `/umbraco/management/api/v1/stylesheet/folder/${path3}`,
         method: "DELETE"
       },
       options
@@ -7343,7 +7331,7 @@ var getTemporaryFileAPI = () => ({
     formData.append("File", postTemporaryFileBody2.File);
     const headers = {
       ...formData.getHeaders(),
-      ..._optionalChain([options, 'optionalAccess', _68 => _68.headers])
+      ..._optionalChain([options, 'optionalAccess', _46 => _46.headers])
     };
     return UmbracoManagementClient(
       {
@@ -7411,7 +7399,7 @@ var CreateUmbracoTool = (name, description, schema, handler, enabled) => () => (
       const errorDetails = error instanceof Error ? {
         message: error.message,
         cause: error.cause,
-        response: _optionalChain([error, 'access', _69 => _69.response, 'optionalAccess', _70 => _70.data])
+        response: _optionalChain([error, 'access', _47 => _47.response, 'optionalAccess', _48 => _48.data])
       } : error;
       return {
         content: [
@@ -13633,6 +13621,26 @@ var GetDataTypeTool = CreateUmbracoTool(
 );
 var get_data_type_default = GetDataTypeTool;
 
+// src/umb-management-api/tools/data-type/get/get-data-type-configuration.ts
+var GetDataTypeConfigurationTool = CreateUmbracoTool(
+  "get-data-type-configuration",
+  "Gets global data type configuration settings including change permissions and default list view IDs",
+  {},
+  async () => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getDataTypeConfiguration();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response, null, 2)
+        }
+      ]
+    };
+  }
+);
+var get_data_type_configuration_default = GetDataTypeConfigurationTool;
+
 // src/umb-management-api/tools/data-type/put/update-data-type.ts
 
 var UpdateDataTypeTool = CreateUmbracoTool(
@@ -14024,6 +14032,7 @@ var DataTypeCollection = {
       tools.push(get_references_data_type_default());
       tools.push(is_used_data_type_default());
       tools.push(get_data_type_default());
+      tools.push(get_data_type_configuration_default());
     }
     if (AuthorizationPolicies.TreeAccessDataTypes(user)) {
       tools.push(get_root_default());
@@ -14308,7 +14317,7 @@ function createContainerHierarchy(properties) {
         id,
         name: groupName,
         type: "Group",
-        parent: _optionalChain([prop, 'optionalAccess', _71 => _71.tab]) ? { id: containerIds.get(prop.tab) } : null,
+        parent: _optionalChain([prop, 'optionalAccess', _49 => _49.tab]) ? { id: containerIds.get(prop.tab) } : null,
         sortOrder: index
       };
     })
@@ -15838,6 +15847,49 @@ var GetDocumentBlueprintRootTool = CreateUmbracoTool(
 );
 var get_root_default4 = GetDocumentBlueprintRootTool;
 
+// src/umb-management-api/tools/document-blueprint/get/get-document-blueprint-scaffold.ts
+var GetDocumentBlueprintScaffoldTool = CreateUmbracoTool(
+  "get-document-blueprint-scaffold",
+  `Get scaffold information for a document blueprint
+  Use this to retrieve the scaffold structure and default values for a document blueprint, typically used when creating new documents from blueprints.`,
+  getDocumentBlueprintByIdScaffoldParams.shape,
+  async ({ id }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getDocumentBlueprintByIdScaffold(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_document_blueprint_scaffold_default = GetDocumentBlueprintScaffoldTool;
+
+// src/umb-management-api/tools/document-blueprint/post/create-document-blueprint-from-document.ts
+var CreateDocumentBlueprintFromDocumentTool = CreateUmbracoTool(
+  "create-document-blueprint-from-document",
+  `Create a new document blueprint from an existing document
+  Use this to create a blueprint template based on an existing document, preserving its structure and content for reuse.`,
+  postDocumentBlueprintFromDocumentBody.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.postDocumentBlueprintFromDocument(model);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  },
+  (user) => user.fallbackPermissions.includes("Umb.Document.CreateBlueprint")
+);
+var create_document_blueprint_from_document_default = CreateDocumentBlueprintFromDocumentTool;
+
 // src/umb-management-api/tools/document-blueprint/index.ts
 var DocumentBlueprintCollection = {
   metadata: {
@@ -15856,6 +15908,8 @@ var DocumentBlueprintCollection = {
       tools.push(get_ancestors_default4());
       tools.push(get_children_default4());
       tools.push(get_root_default4());
+      tools.push(get_document_blueprint_scaffold_default());
+      tools.push(create_document_blueprint_from_document_default());
     }
     return tools;
   }
@@ -16131,6 +16185,156 @@ var SearchDocumentTool = CreateUmbracoTool(
 );
 var search_document_default = SearchDocumentTool;
 
+// src/umb-management-api/tools/document/get/get-collection-document-by-id.ts
+
+var GetCollectionDocumentByIdTool = CreateUmbracoTool(
+  "get-collection-document-by-id",
+  `Get a collection of document items
+  Use this to retrieve a filtered and paginated collection of document items based on various criteria like data type, ordering, and filtering.`,
+  _zod.z.object({
+    ...getCollectionDocumentByIdParams.shape,
+    ...getCollectionDocumentByIdQueryParams.shape
+  }).shape,
+  async ({ id, dataTypeId, orderBy, orderDirection, filter, skip, take }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getCollectionDocumentById(id, {
+      dataTypeId,
+      orderBy,
+      orderDirection,
+      filter,
+      skip,
+      take
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_collection_document_by_id_default = GetCollectionDocumentByIdTool;
+
+// src/umb-management-api/tools/document/get/get-document-are-referenced.ts
+var GetDocumentAreReferencedTool = CreateUmbracoTool(
+  "get-document-are-referenced",
+  `Check if document items are referenced
+  Use this to verify if specific document items are being referenced by other content before deletion or modification.`,
+  getDocumentAreReferencedQueryParams.shape,
+  async ({ id, skip, take }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getDocumentAreReferenced({ id, skip, take });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_document_are_referenced_default = GetDocumentAreReferencedTool;
+
+// src/umb-management-api/tools/document/get/get-document-by-id-referenced-by.ts
+
+var GetDocumentByIdReferencedByTool = CreateUmbracoTool(
+  "get-document-by-id-referenced-by",
+  `Get items that reference a specific document item
+  Use this to find all content, documents, or other items that are currently referencing a specific document item.`,
+  _zod.z.object({
+    ...getDocumentByIdReferencedByParams.shape,
+    ...getDocumentByIdReferencedByQueryParams.shape
+  }).shape,
+  async ({ id, skip, take }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getDocumentByIdReferencedBy(id, { skip, take });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_document_by_id_referenced_by_default = GetDocumentByIdReferencedByTool;
+
+// src/umb-management-api/tools/document/get/get-document-by-id-referenced-descendants.ts
+
+var GetDocumentByIdReferencedDescendantsTool = CreateUmbracoTool(
+  "get-document-by-id-referenced-descendants",
+  `Get descendant references for a document item
+  Use this to find all descendant references (child items) that are being referenced for a specific document item.
+
+  Useful for:
+  \u2022 Impact analysis: Before deleting a document folder, see what content would be affected
+  \u2022 Dependency tracking: Find all content using documents from a specific folder hierarchy
+  \u2022 Content auditing: Identify which descendant document items are actually being used`,
+  _zod.z.object({
+    ...getDocumentByIdReferencedDescendantsParams.shape,
+    ...getDocumentByIdReferencedDescendantsQueryParams.shape
+  }).shape,
+  async ({ id, skip, take }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getDocumentByIdReferencedDescendants(id, { skip, take });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_document_by_id_referenced_descendants_default = GetDocumentByIdReferencedDescendantsTool;
+
+// src/umb-management-api/tools/document/get/get-recycle-bin-document-original-parent.ts
+var GetRecycleBinDocumentOriginalParentTool = CreateUmbracoTool(
+  "get-recycle-bin-document-original-parent",
+  `Get the original parent location of a document item in the recycle bin
+  Returns information about where the document item was located before deletion.`,
+  getRecycleBinDocumentByIdOriginalParentParams.shape,
+  async ({ id }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getRecycleBinDocumentByIdOriginalParent(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_recycle_bin_document_original_parent_default = GetRecycleBinDocumentOriginalParentTool;
+
+// src/umb-management-api/tools/document/get/get-recycle-bin-document-referenced-by.ts
+var GetRecycleBinDocumentReferencedByTool = CreateUmbracoTool(
+  "get-recycle-bin-document-referenced-by",
+  `Get references to deleted document items in the recycle bin
+  Use this to find content that still references deleted document items before permanently deleting them.`,
+  getRecycleBinDocumentReferencedByQueryParams.shape,
+  async ({ skip, take }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getRecycleBinDocumentReferencedBy({ skip, take });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_recycle_bin_document_referenced_by_default = GetRecycleBinDocumentReferencedByTool;
+
 // src/umb-management-api/tools/document/post/post-document-public-access.ts
 
 var PostDocumentPublicAccessTool = CreateUmbracoTool(
@@ -16182,6 +16386,12 @@ var validate_document_default = ValidateDocumentTool;
 
 // src/umb-management-api/tools/document/post/copy-document.ts
 
+var copyDocumentSchema = _zod.z.object({
+  parentId: _zod.z.string().uuid("Must be a valid document UUID of the parent node").optional(),
+  idToCopy: _zod.z.string().uuid("Must be a valid document UUID that belongs to the parent document's children"),
+  relateToOriginal: _zod.z.boolean().describe("Relate the copy to the original document. This is usually set to false unless specified."),
+  includeDescendants: _zod.z.boolean().describe("If true, all descendant documents (children, grandchildren, etc.) will also be copied. This is usually set to false unless specified.")
+});
 var CopyDocumentTool = CreateUmbracoTool(
   "copy-document",
   `Copy a document to a new location. This is also the recommended way to create new documents. 
@@ -16202,13 +16412,17 @@ var CopyDocumentTool = CreateUmbracoTool(
     Example workflows:
     1. Copy only: copy-document (creates draft copy)
     2. Copy and update: copy-document \u2192 search-document \u2192 update-document \u2192 publish-document`,
-  {
-    id: _zod.z.string().uuid(),
-    data: _zod.z.object(postDocumentByIdCopyBody.shape)
-  },
+  copyDocumentSchema.shape,
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.postDocumentByIdCopy(model.id, model.data);
+    const payload = {
+      target: model.parentId ? {
+        id: model.parentId
+      } : void 0,
+      relateToOriginal: model.relateToOriginal,
+      includeDescendants: model.includeDescendants
+    };
+    const response = await client.postDocumentByIdCopy(model.idToCopy, payload);
     return {
       content: [
         {
@@ -16229,6 +16443,7 @@ var createDocumentSchema = _zod.z.object({
   documentTypeId: _zod.z.string().uuid("Must be a valid document type type UUID"),
   parentId: _zod.z.string().uuid("Must be a valid document UUID").optional(),
   name: _zod.z.string(),
+  cultures: _zod.z.array(_zod.z.string()).optional().describe("Array of culture codes. If not provided or empty array, will create single variant with null culture."),
   values: _zod.z.array(
     _zod.z.object({
       editorAlias: _zod.z.string(),
@@ -16241,7 +16456,10 @@ var createDocumentSchema = _zod.z.object({
 });
 var CreateDocumentTool = CreateUmbracoTool(
   "create-document",
-  `Creates a document,
+  `Creates a document with support for multiple cultures.
+
+  If cultures parameter is provided, a variant will be created for each culture code.
+  If cultures parameter is not provided or is an empty array, will create a single variant with null culture (original behavior).
 
   Always follow these requirements when creating documents exactly, do not deviate in any way.
 
@@ -16847,6 +17065,17 @@ var CreateDocumentTool = CreateUmbracoTool(
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
     const documentId = _uuid.v4.call(void 0, );
+    let culturesToUse = [];
+    if (model.cultures === void 0 || model.cultures.length === 0) {
+      culturesToUse = [null];
+    } else {
+      culturesToUse = model.cultures;
+    }
+    const variants = culturesToUse.map((culture) => ({
+      culture,
+      name: model.name,
+      segment: null
+    }));
     const payload = {
       id: documentId,
       documentType: {
@@ -16857,13 +17086,7 @@ var CreateDocumentTool = CreateUmbracoTool(
       } : void 0,
       template: null,
       values: model.values,
-      variants: [
-        {
-          culture: null,
-          name: model.name,
-          segment: null
-        }
-      ]
+      variants
     };
     const response = await client.postDocument(payload);
     return {
@@ -16991,7 +17214,7 @@ var PublishDocumentWithDescendantsTool = CreateUmbracoTool(
     let attempts = 0;
     while (attempts < maxAttempts) {
       attempts++;
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
       try {
         const statusResponse = await client.getDocumentByIdPublishWithDescendantsResultByTaskId(
           model.id,
@@ -17354,6 +17577,12 @@ var DocumentCollection = {
       tools.push(get_recycle_bin_children_default());
       tools.push(search_document_default());
       tools.push(validate_document_default());
+      tools.push(get_collection_document_by_id_default());
+      tools.push(get_document_are_referenced_default());
+      tools.push(get_document_by_id_referenced_by_default());
+      tools.push(get_document_by_id_referenced_descendants_default());
+      tools.push(get_recycle_bin_document_original_parent_default());
+      tools.push(get_recycle_bin_document_referenced_by_default());
     }
     if (AuthorizationPolicies.SectionAccessForContentTree(user)) {
       tools.push(get_root_default5());
@@ -17471,28 +17700,357 @@ var DocumentVersionCollection = {
 };
 
 // src/umb-management-api/tools/media/post/create-media.ts
+
+
+
+// src/umb-management-api/tools/media/post/helpers/media-upload-helpers.ts
+var _fs = require('fs'); var fs = _interopRequireWildcard(_fs); var fs2 = _interopRequireWildcard(_fs);
+var _os = require('os'); var os = _interopRequireWildcard(_os); var os2 = _interopRequireWildcard(_os);
+var _path = require('path'); var path = _interopRequireWildcard(_path); var path2 = _interopRequireWildcard(_path);
+
+var _mimetypes = require('mime-types'); var _mimetypes2 = _interopRequireDefault(_mimetypes);
+function getExtensionFromMimeType(mimeType) {
+  if (!mimeType) return void 0;
+  const baseMimeType = mimeType.split(";")[0].trim();
+  const extension = _mimetypes2.default.extension(baseMimeType);
+  return extension ? `.${extension}` : void 0;
+}
+function validateMediaTypeForSvg(filePath, fileUrl, fileName, mediaTypeName) {
+  const isSvg = _optionalChain([filePath, 'optionalAccess', _50 => _50.toLowerCase, 'call', _51 => _51(), 'access', _52 => _52.endsWith, 'call', _53 => _53(".svg")]) || _optionalChain([fileUrl, 'optionalAccess', _54 => _54.toLowerCase, 'call', _55 => _55(), 'access', _56 => _56.endsWith, 'call', _57 => _57(".svg")]) || fileName.toLowerCase().endsWith(".svg");
+  if (isSvg && mediaTypeName === "Image") {
+    console.warn("SVG detected - using Vector Graphic media type instead of Image");
+    return "Vector Graphic (SVG)";
+  }
+  return mediaTypeName;
+}
+async function fetchMediaTypeId(client, mediaTypeName) {
+  const response = await client.getItemMediaTypeSearch({ query: mediaTypeName });
+  const mediaType = response.items.find(
+    (mt) => mt.name.toLowerCase() === mediaTypeName.toLowerCase()
+  );
+  if (!mediaType) {
+    const availableTypes = response.items.map((mt) => mt.name).join(", ");
+    throw new Error(
+      `Media type '${mediaTypeName}' not found. Available types: ${availableTypes || "None found"}`
+    );
+  }
+  return mediaType.id;
+}
+function getEditorAlias(mediaTypeName) {
+  return mediaTypeName === "Image" ? "Umbraco.ImageCropper" : "Umbraco.UploadField";
+}
+function buildValueStructure(mediaTypeName, temporaryFileId) {
+  const base = {
+    alias: "umbracoFile",
+    editorAlias: getEditorAlias(mediaTypeName),
+    entityType: "media-property-value"
+  };
+  if (mediaTypeName === "Image") {
+    return {
+      ...base,
+      value: {
+        crops: [],
+        culture: null,
+        segment: null,
+        focalPoint: {
+          top: 0.5,
+          right: 0.5
+        },
+        temporaryFileId
+      }
+    };
+  }
+  return {
+    ...base,
+    value: { temporaryFileId }
+  };
+}
+async function createFileStream(sourceType, filePath, fileUrl, fileAsBase64, fileName, temporaryFileId) {
+  let tempFilePath = null;
+  let readStream;
+  switch (sourceType) {
+    case "filePath":
+      if (!filePath) {
+        throw new Error("filePath is required when sourceType is 'filePath'");
+      }
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`File not found: ${filePath}`);
+      }
+      readStream = fs.createReadStream(filePath);
+      break;
+    case "url":
+      if (!fileUrl) {
+        throw new Error("fileUrl is required when sourceType is 'url'");
+      }
+      try {
+        const response = await _axios2.default.get(fileUrl, {
+          responseType: "arraybuffer",
+          timeout: 3e4,
+          validateStatus: (status) => status < 500
+          // Don't throw on 4xx errors
+        });
+        if (response.status >= 400) {
+          throw new Error(`Failed to fetch file from URL: HTTP ${response.status} ${response.statusText}`);
+        }
+        let fileNameWithExtension = fileName;
+        if (!fileName.includes(".")) {
+          const urlPath = new URL(fileUrl).pathname;
+          const urlExtension = path.extname(urlPath);
+          if (urlExtension) {
+            fileNameWithExtension = `${fileName}${urlExtension}`;
+          } else {
+            const contentType = response.headers["content-type"];
+            const extensionFromMime = getExtensionFromMimeType(contentType);
+            if (extensionFromMime) {
+              fileNameWithExtension = `${fileName}${extensionFromMime}`;
+            } else {
+              fileNameWithExtension = `${fileName}.bin`;
+            }
+          }
+        }
+        tempFilePath = path.join(os.tmpdir(), fileNameWithExtension);
+        fs.writeFileSync(tempFilePath, response.data);
+        readStream = fs.createReadStream(tempFilePath);
+      } catch (error) {
+        const axiosError = error;
+        if (axiosError.response) {
+          throw new Error(`Failed to fetch URL: HTTP ${axiosError.response.status} - ${axiosError.response.statusText} (${fileUrl})`);
+        } else if (axiosError.code === "ECONNABORTED") {
+          throw new Error(`Request timeout after 30s fetching URL: ${fileUrl}`);
+        } else if (axiosError.code) {
+          throw new Error(`Network error (${axiosError.code}) fetching URL: ${fileUrl} - ${axiosError.message}`);
+        }
+        throw new Error(`Failed to fetch URL: ${fileUrl} - ${error.message}`);
+      }
+      break;
+    case "base64":
+      if (!fileAsBase64) {
+        throw new Error("fileAsBase64 is required when sourceType is 'base64'");
+      }
+      const fileContent = Buffer.from(fileAsBase64, "base64");
+      tempFilePath = path.join(os.tmpdir(), fileName);
+      fs.writeFileSync(tempFilePath, fileContent);
+      readStream = fs.createReadStream(tempFilePath);
+      break;
+  }
+  return { readStream, tempFilePath };
+}
+function cleanupTempFile(tempFilePath) {
+  if (tempFilePath && fs.existsSync(tempFilePath)) {
+    try {
+      fs.unlinkSync(tempFilePath);
+    } catch (e) {
+      console.error("Failed to cleanup temp file:", e);
+    }
+  }
+}
+async function uploadMediaFile(client, params) {
+  let tempFilePath = null;
+  try {
+    const validatedMediaTypeName = validateMediaTypeForSvg(
+      params.filePath,
+      params.fileUrl,
+      params.name,
+      params.mediaTypeName
+    );
+    const mediaTypeId = await fetchMediaTypeId(client, validatedMediaTypeName);
+    const { readStream, tempFilePath: createdTempPath } = await createFileStream(
+      params.sourceType,
+      params.filePath,
+      params.fileUrl,
+      params.fileAsBase64,
+      params.name,
+      params.temporaryFileId
+    );
+    tempFilePath = createdTempPath;
+    try {
+      await client.postTemporaryFile({
+        Id: params.temporaryFileId,
+        File: readStream
+      });
+    } catch (error) {
+      const err = error;
+      const errorData = _optionalChain([err, 'access', _58 => _58.response, 'optionalAccess', _59 => _59.data]) ? typeof err.response.data === "string" ? err.response.data : JSON.stringify(err.response.data) : err.message;
+      throw new Error(`Failed to upload temporary file: ${_optionalChain([err, 'access', _60 => _60.response, 'optionalAccess', _61 => _61.status]) || "Unknown error"} - ${errorData}`);
+    }
+    const valueStructure = buildValueStructure(validatedMediaTypeName, params.temporaryFileId);
+    try {
+      await client.postMedia({
+        mediaType: { id: mediaTypeId },
+        variants: [
+          {
+            culture: null,
+            segment: null,
+            name: params.name
+            // Use original name provided by user
+          }
+        ],
+        values: [valueStructure],
+        parent: params.parentId ? { id: params.parentId } : null
+      });
+    } catch (error) {
+      const err = error;
+      throw new Error(`Failed to create media item: ${_optionalChain([err, 'access', _62 => _62.response, 'optionalAccess', _63 => _63.status]) || "Unknown error"} - ${JSON.stringify(_optionalChain([err, 'access', _64 => _64.response, 'optionalAccess', _65 => _65.data])) || err.message}`);
+    }
+    return params.name;
+  } finally {
+    cleanupTempFile(tempFilePath);
+  }
+}
+
+// src/umb-management-api/tools/media/post/create-media.ts
+var createMediaSchema = _zod.z.object({
+  sourceType: _zod.z.enum(["filePath", "url", "base64"]).describe("Media source type: 'filePath' for local files (most efficient), 'url' for web files, 'base64' for embedded data (small files only)"),
+  name: _zod.z.string().describe("The name of the media item"),
+  mediaTypeName: _zod.z.string().describe("Media type: 'Image', 'Article', 'Audio', 'Video', 'Vector Graphic (SVG)', 'File', or custom media type name"),
+  filePath: _zod.z.string().optional().describe("Absolute path to the file (required if sourceType is 'filePath')"),
+  fileUrl: _zod.z.string().url().optional().describe("URL to fetch the file from (required if sourceType is 'url')"),
+  fileAsBase64: _zod.z.string().optional().describe("Base64 encoded file data (required if sourceType is 'base64')"),
+  parentId: _zod.z.string().uuid().optional().describe("Parent folder ID (defaults to root)")
+});
 var CreateMediaTool = CreateUmbracoTool(
   "create-media",
-  `Creates a media item.
-  Use this endpoint to create media items like images, files, or folders.
-  The process is as follows:
-  - Create a temporary file using the temporary file endpoint
-  - Use the temporary file id when creating a media item using this endpoint`,
-  postMediaBody.shape,
+  `Upload any media file to Umbraco (images, documents, audio, video, SVG, or custom types).
+
+  Media Types:
+  - Image: jpg, png, gif, webp, etc. (supports cropping)
+  - Article: pdf, docx, doc (documents)
+  - Audio: mp3, wav, etc.
+  - Video: mp4, webm, etc.
+  - Vector Graphic (SVG): svg files only
+  - File: any other file type
+  - Custom: any custom media type created in Umbraco
+
+  Source Types:
+  1. filePath - Most efficient for local files, works with any size
+  2. url - Fetch from web URL
+  3. base64 - Only for small files (<10KB) due to token usage
+
+  The tool automatically:
+  - Creates temporary files
+  - Detects and validates media types (auto-corrects SVG vs Image)
+  - Configures correct property editors (ImageCropper vs UploadField)
+  - Cleans up temporary files`,
+  createMediaSchema.shape,
+  async (model) => {
+    try {
+      const client = UmbracoManagementClient2.getClient();
+      const temporaryFileId = _uuid.v4.call(void 0, );
+      const actualName = await uploadMediaFile(client, {
+        sourceType: model.sourceType,
+        name: model.name,
+        mediaTypeName: model.mediaTypeName,
+        filePath: model.filePath,
+        fileUrl: model.fileUrl,
+        fileAsBase64: model.fileAsBase64,
+        parentId: model.parentId,
+        temporaryFileId
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Media "${actualName}" created successfully`
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error creating media: ${error.message}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+var create_media_default = CreateMediaTool;
+
+// src/umb-management-api/tools/media/post/create-media-multiple.ts
+
+
+var createMediaMultipleSchema = _zod.z.object({
+  sourceType: _zod.z.enum(["filePath", "url"]).describe("Media source type: 'filePath' for local files (most efficient), 'url' for web files. Base64 not supported for batch uploads due to token usage."),
+  files: _zod.z.array(_zod.z.object({
+    name: _zod.z.string().describe("The name of the media item"),
+    filePath: _zod.z.string().optional().describe("Absolute path to the file (required if sourceType is 'filePath')"),
+    fileUrl: _zod.z.string().url().optional().describe("URL to fetch the file from (required if sourceType is 'url')"),
+    mediaTypeName: _zod.z.string().optional().describe("Optional override: 'Image', 'Article', 'Audio', 'Video', 'Vector Graphic (SVG)', 'File', or custom media type name. If not specified, defaults to 'File'")
+  })).describe("Array of files to upload (maximum 20 files per batch)"),
+  parentId: _zod.z.string().uuid().optional().describe("Parent folder ID (defaults to root)")
+});
+var CreateMediaMultipleTool = CreateUmbracoTool(
+  "create-media-multiple",
+  `Batch upload multiple media files to Umbraco (maximum 20 files per batch).
+
+  Supports any file type: images, documents, audio, video, SVG, or custom types.
+
+  Source Types:
+  1. filePath - Most efficient for local files, works with any size
+  2. url - Fetch from web URL
+
+  Note: base64 is not supported for batch uploads due to token usage.
+
+  The tool processes files sequentially and returns detailed results for each file.
+  If some files fail, others will continue processing (continue-on-error strategy).`,
+  createMediaMultipleSchema.shape,
   async (model) => {
+    if (model.files.length > 20) {
+      return {
+        content: [{
+          type: "text",
+          text: `Batch upload limited to 20 files per call. You provided ${model.files.length} files. Please split into multiple batches.`
+        }],
+        isError: true
+      };
+    }
+    const results = [];
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.postMedia(model);
+    for (const file of model.files) {
+      try {
+        const temporaryFileId = _uuid.v4.call(void 0, );
+        const defaultMediaType = file.mediaTypeName || "File";
+        const actualName = await uploadMediaFile(client, {
+          sourceType: model.sourceType,
+          name: file.name,
+          mediaTypeName: defaultMediaType,
+          filePath: file.filePath,
+          fileUrl: file.fileUrl,
+          fileAsBase64: void 0,
+          parentId: model.parentId,
+          temporaryFileId
+        });
+        results.push({
+          success: true,
+          name: actualName
+        });
+      } catch (error) {
+        results.push({
+          success: false,
+          name: file.name,
+          error: error.message
+        });
+      }
+    }
+    const successCount = results.filter((r) => r.success).length;
+    const failureCount = results.filter((r) => !r.success).length;
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify(response)
+          text: JSON.stringify({
+            summary: `Processed ${model.files.length} files: ${successCount} succeeded, ${failureCount} failed`,
+            results
+          }, null, 2)
         }
       ]
     };
   }
 );
-var create_media_default = CreateMediaTool;
+var create_media_multiple_default = CreateMediaMultipleTool;
 
 // src/umb-management-api/tools/media/delete/delete-media.ts
 var DeleteMediaTool = CreateUmbracoTool(
@@ -17894,7 +18452,154 @@ var DeleteFromRecycleBinTool2 = CreateUmbracoTool(
 );
 var delete_from_recycle_bin_default2 = DeleteFromRecycleBinTool2;
 
-// src/umb-management-api/tools/media/index.ts
+// src/umb-management-api/tools/media/get/get-media-are-referenced.ts
+var GetMediaAreReferencedTool = CreateUmbracoTool(
+  "get-media-are-referenced",
+  `Check if media items are referenced
+  Use this to verify if specific media items are being referenced by other content before deletion or modification.`,
+  getMediaAreReferencedQueryParams.shape,
+  async ({ id, skip, take }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getMediaAreReferenced({ id, skip, take });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_media_are_referenced_default = GetMediaAreReferencedTool;
+
+// src/umb-management-api/tools/media/get/get-media-by-id-referenced-by.ts
+
+var GetMediaByIdReferencedByTool = CreateUmbracoTool(
+  "get-media-by-id-referenced-by",
+  `Get items that reference a specific media item
+  Use this to find all content, documents, or other items that are currently referencing a specific media item.`,
+  _zod.z.object({
+    ...getMediaByIdReferencedByParams.shape,
+    ...getMediaByIdReferencedByQueryParams.shape
+  }).shape,
+  async ({ id, skip, take }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getMediaByIdReferencedBy(id, { skip, take });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_media_by_id_referenced_by_default = GetMediaByIdReferencedByTool;
+
+// src/umb-management-api/tools/media/get/get-media-by-id-referenced-descendants.ts
+
+var GetMediaByIdReferencedDescendantsTool = CreateUmbracoTool(
+  "get-media-by-id-referenced-descendants",
+  `Get descendant references for a media item
+  Use this to find all descendant references (child items) that are being referenced for a specific media item.
+
+  Useful for:
+  \u2022 Impact analysis: Before deleting a media folder, see what content would be affected
+  \u2022 Dependency tracking: Find all content using media from a specific folder hierarchy
+  \u2022 Content auditing: Identify which descendant media items are actually being used`,
+  _zod.z.object({
+    ...getMediaByIdReferencedDescendantsParams.shape,
+    ...getMediaByIdReferencedDescendantsQueryParams.shape
+  }).shape,
+  async ({ id, skip, take }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getMediaByIdReferencedDescendants(id, { skip, take });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_media_by_id_referenced_descendants_default = GetMediaByIdReferencedDescendantsTool;
+
+// src/umb-management-api/tools/media/get/get-collection-media.ts
+var GetCollectionMediaTool = CreateUmbracoTool(
+  "get-collection-media",
+  `Get a collection of media items
+  Use this to retrieve a filtered and paginated collection of media items based on various criteria like data type, ordering, and filtering.`,
+  getCollectionMediaQueryParams.shape,
+  async ({ id, dataTypeId, orderBy, orderDirection, filter, skip, take }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getCollectionMedia({
+      id,
+      dataTypeId,
+      orderBy,
+      orderDirection,
+      filter,
+      skip,
+      take
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_collection_media_default = GetCollectionMediaTool;
+
+// src/umb-management-api/tools/media/get/get-recycle-bin-media-referenced-by.ts
+var GetRecycleBinMediaReferencedByTool = CreateUmbracoTool(
+  "get-recycle-bin-media-referenced-by",
+  `Get references to deleted media items in the recycle bin
+  Use this to find content that still references deleted media items before permanently deleting them.`,
+  getRecycleBinMediaReferencedByQueryParams.shape,
+  async ({ skip, take }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getRecycleBinMediaReferencedBy({ skip, take });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_recycle_bin_media_referenced_by_default = GetRecycleBinMediaReferencedByTool;
+
+// src/umb-management-api/tools/media/get/get-recycle-bin-media-original-parent.ts
+var GetRecycleBinMediaOriginalParentTool = CreateUmbracoTool(
+  "get-recycle-bin-media-original-parent",
+  `Get the original parent location of a media item in the recycle bin
+  Returns information about where the media item was located before deletion.`,
+  getRecycleBinMediaByIdOriginalParentParams.shape,
+  async ({ id }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getRecycleBinMediaByIdOriginalParent(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_recycle_bin_media_original_parent_default = GetRecycleBinMediaOriginalParentTool;
+
+// src/umb-management-api/tools/media/index.ts
 var MediaCollection = {
   metadata: {
     name: "media",
@@ -17912,6 +18617,7 @@ var MediaCollection = {
     }
     if (AuthorizationPolicies.SectionAccessMedia(user)) {
       tools.push(create_media_default());
+      tools.push(create_media_multiple_default());
       tools.push(delete_media_default());
       tools.push(update_media_default());
       tools.push(get_media_configuration_default());
@@ -17927,6 +18633,12 @@ var MediaCollection = {
       tools.push(restore_from_recycle_bin_default());
       tools.push(move_to_recycle_bin_default2());
       tools.push(delete_from_recycle_bin_default2());
+      tools.push(get_media_are_referenced_default());
+      tools.push(get_media_by_id_referenced_by_default());
+      tools.push(get_media_by_id_referenced_descendants_default());
+      tools.push(get_collection_media_default());
+      tools.push(get_recycle_bin_media_referenced_by_default());
+      tools.push(get_recycle_bin_media_original_parent_default());
     }
     return tools;
   }
@@ -18143,6 +18855,26 @@ var GetMediaTypeAncestorsTool = CreateUmbracoTool(
 );
 var get_ancestors_default7 = GetMediaTypeAncestorsTool;
 
+// src/umb-management-api/tools/media-type/items/get/get-media-type-folders.ts
+var GetMediaTypeFoldersTool = CreateUmbracoTool(
+  "get-media-type-folders",
+  "Lists media type folders with pagination support",
+  getItemMediaTypeFoldersQueryParams.shape,
+  async (params) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getItemMediaTypeFolders(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_media_type_folders_default = GetMediaTypeFoldersTool;
+
 // src/umb-management-api/tools/media-type/folders/get/get-folder.ts
 var GetMediaTypeFolderTool = CreateUmbracoTool(
   "get-media-type-folder",
@@ -18383,6 +19115,7 @@ var MediaTypeCollection = {
       tools.push(get_root_default7());
       tools.push(get_children_default7());
       tools.push(get_ancestors_default7());
+      tools.push(get_media_type_folders_default());
     }
     if (AuthorizationPolicies.TreeAccessMediaOrMediaTypes(user)) {
       tools.push(get_media_type_by_id_default());
@@ -18438,6 +19171,27 @@ var CreateMemberTool = CreateUmbracoTool(
 );
 var create_member_default = CreateMemberTool;
 
+// src/umb-management-api/tools/member/post/validate-member.ts
+var ValidateMemberTool = CreateUmbracoTool(
+  "validate-member",
+  `Validates member data before creation using the Umbraco API.
+  Use this endpoint to validate member data structure, properties, and business rules before attempting to create a new member.`,
+  postMemberValidateBody.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.postMemberValidate(model);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var validate_member_default = ValidateMemberTool;
+
 // src/umb-management-api/tools/member/delete/delete-member.ts
 var DeleteMemberTool = CreateUmbracoTool(
   "delete-member",
@@ -18482,6 +19236,31 @@ var UpdateMemberTool = CreateUmbracoTool(
 );
 var update_member_default = UpdateMemberTool;
 
+// src/umb-management-api/tools/member/put/validate-member-update.ts
+
+var ValidateMemberUpdateTool = CreateUmbracoTool(
+  "validate-member-update",
+  `Validates member data before updating using the Umbraco API.
+  Use this endpoint to validate member data structure, properties, and business rules before attempting to update an existing member.`,
+  {
+    id: putMemberByIdValidateParams.shape.id,
+    data: _zod.z.object(putMemberByIdValidateBody.shape)
+  },
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.putMemberByIdValidate(model.id, model.data);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var validate_member_update_default = ValidateMemberUpdateTool;
+
 // src/umb-management-api/tools/member/get/find-member.ts
 var FindMemberTool = CreateUmbracoTool(
   "find-member",
@@ -18502,6 +19281,77 @@ var FindMemberTool = CreateUmbracoTool(
 );
 var find_member_default = FindMemberTool;
 
+// src/umb-management-api/tools/member/get/get-member-are-referenced.ts
+var GetMemberAreReferencedTool = CreateUmbracoTool(
+  "get-member-are-referenced",
+  `Check if member accounts are referenced
+  Use this to verify if specific member accounts are being referenced by content.`,
+  getMemberAreReferencedQueryParams.shape,
+  async ({ id, skip, take }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getMemberAreReferenced({ id, skip, take });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_member_are_referenced_default = GetMemberAreReferencedTool;
+
+// src/umb-management-api/tools/member/get/get-member-by-id-referenced-by.ts
+
+var GetMemberByIdReferencedByTool = CreateUmbracoTool(
+  "get-member-by-id-referenced-by",
+  `Get items that reference a specific member
+  Use this to find all content, documents, or other items that are currently referencing a specific member account.`,
+  _zod.z.object({
+    ...getMemberByIdReferencedByParams.shape,
+    ...getMemberByIdReferencedByQueryParams.shape
+  }).shape,
+  async ({ id, skip, take }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getMemberByIdReferencedBy(id, { skip, take });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_member_by_id_referenced_by_default = GetMemberByIdReferencedByTool;
+
+// src/umb-management-api/tools/member/get/get-member-by-id-referenced-descendants.ts
+
+var GetMemberByIdReferencedDescendantsTool = CreateUmbracoTool(
+  "get-member-by-id-referenced-descendants",
+  `Get descendant references for a member
+  Use this to find all descendant references that are being referenced for a specific member account.`,
+  _zod.z.object({
+    ...getMemberByIdReferencedDescendantsParams.shape,
+    ...getMemberByIdReferencedDescendantsQueryParams.shape
+  }).shape,
+  async ({ id, skip, take }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getMemberByIdReferencedDescendants(id, { skip, take });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_member_by_id_referenced_descendants_default = GetMemberByIdReferencedDescendantsTool;
+
 // src/umb-management-api/tools/member/index.ts
 var MemberCollection = {
   metadata: {
@@ -18515,8 +19365,13 @@ var MemberCollection = {
     if (AuthorizationPolicies.SectionAccessMembers(user)) {
       tools.push(get_member_default());
       tools.push(create_member_default());
+      tools.push(validate_member_default());
       tools.push(delete_member_default());
       tools.push(update_member_default());
+      tools.push(validate_member_update_default());
+      tools.push(get_member_are_referenced_default());
+      tools.push(get_member_by_id_referenced_by_default());
+      tools.push(get_member_by_id_referenced_descendants_default());
     }
     tools.push(find_member_default());
     return tools;
@@ -19215,8 +20070,8 @@ var UpdatePartialViewTool = CreateUmbracoTool(
   }).shape,
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    const { path, ...updateModel } = model;
-    var response = await client.putPartialViewByPath(path, updateModel);
+    const { path: path3, ...updateModel } = model;
+    var response = await client.putPartialViewByPath(path3, updateModel);
     return {
       content: [
         {
@@ -19240,8 +20095,8 @@ var RenamePartialViewTool = CreateUmbracoTool(
   }).shape,
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    const { path, ...renameModel } = model;
-    const normalizedPath = encodeURIComponent(path);
+    const { path: path3, ...renameModel } = model;
+    const normalizedPath = encodeURIComponent(path3);
     var response = await client.putPartialViewByPathRename(normalizedPath, renameModel);
     return {
       content: [
@@ -19424,7 +20279,7 @@ var PartialViewCollection = {
     dependencies: []
   },
   tools: (user) => {
-    const tools = [get_search_default2()];
+    const tools = [];
     if (AuthorizationPolicies.TreeAccessPartialViews(user)) {
       tools.push(create_partial_view_default());
       tools.push(create_partial_view_folder_default());
@@ -19439,6 +20294,7 @@ var PartialViewCollection = {
       tools.push(get_ancestors_default8());
       tools.push(get_children_default8());
       tools.push(get_root_default10());
+      tools.push(get_search_default2());
     }
     return tools;
   }
@@ -19521,6 +20377,26 @@ var GetTemplateTool = CreateUmbracoTool(
 );
 var get_template_default = GetTemplateTool;
 
+// src/umb-management-api/tools/template/get/get-template-configuration.ts
+var GetTemplateConfigurationTool = CreateUmbracoTool(
+  "get-template-configuration",
+  "Gets template configuration settings including whether templates are disabled system-wide",
+  {},
+  async () => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getTemplateConfiguration();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response, null, 2)
+        }
+      ]
+    };
+  }
+);
+var get_template_configuration_default = GetTemplateConfigurationTool;
+
 // src/umb-management-api/tools/template/get/get-template-by-id-array.ts
 var GetTemplatesByIdArrayTool = CreateUmbracoTool(
   "get-templates-by-id-array",
@@ -19723,9 +20599,10 @@ var TemplateCollection = {
     dependencies: []
   },
   tools: (user) => {
-    const tools = [get_search_default3()];
+    const tools = [];
     if (AuthorizationPolicies.TreeAccessTemplates(user)) {
       tools.push(get_template_default());
+      tools.push(get_template_configuration_default());
       tools.push(get_template_by_id_array_default());
       tools.push(create_template_default());
       tools.push(update_template_default());
@@ -19735,6 +20612,7 @@ var TemplateCollection = {
       tools.push(get_ancestors_default9());
       tools.push(get_children_default9());
       tools.push(get_root_default11());
+      tools.push(get_search_default3());
     }
     return tools;
   }
@@ -19780,6 +20658,26 @@ var GetWebhookItemTool = CreateUmbracoTool(
 );
 var get_webhook_by_id_array_default = GetWebhookItemTool;
 
+// src/umb-management-api/tools/webhook/get/get-webhook.ts
+var GetWebhookTool = CreateUmbracoTool(
+  "get-webhook",
+  "Gets a paged list of webhooks",
+  getWebhookQueryParams.shape,
+  async (params) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getWebhook(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_webhook_default = GetWebhookTool;
+
 // src/umb-management-api/tools/webhook/delete/delete-webhook.ts
 var DeleteWebhookTool = CreateUmbracoTool(
   "delete-webhook",
@@ -19899,6 +20797,7 @@ var WebhookCollection = {
     if (AuthorizationPolicies.TreeAccessWebhooks(user)) {
       tools.push(get_webhook_by_id_array_default());
       tools.push(create_webhook_default());
+      tools.push(get_webhook_default());
       tools.push(get_webhook_by_id_default());
       tools.push(delete_webhook_default());
       tools.push(update_webhook_default());
@@ -20122,13 +21021,15 @@ var ServerCollection = {
     dependencies: []
   },
   tools: (user) => {
-    return [
-      get_server_information_default(),
-      get_server_status_default(),
-      get_server_configuration_default(),
-      get_server_troubleshooting_default(),
-      get_server_upgrade_check_default()
-    ];
+    const tools = [];
+    tools.push(get_server_status_default());
+    tools.push(get_server_configuration_default());
+    tools.push(get_server_information_default());
+    tools.push(get_server_troubleshooting_default());
+    if (AuthorizationPolicies.RequireAdminAccess(user)) {
+      tools.push(get_server_upgrade_check_default());
+    }
+    return tools;
   }
 };
 
@@ -20491,8 +21392,71 @@ var UserGroupCollection = {
   }
 };
 
+// src/umb-management-api/tools/temporary-file/post/create-temporary-file.ts
+
+
+
+
+var createTemporaryFileSchema = _zod.z.object({
+  id: _zod.z.string().uuid().describe("Unique identifier for the temporary file"),
+  fileName: _zod.z.string().describe("Name of the file"),
+  fileAsBase64: _zod.z.string().describe("File content encoded as base64 string")
+});
+var CreateTemporaryFileTool = CreateUmbracoTool(
+  "create-temporary-file",
+  `Creates a new temporary file. The file will be deleted after 10 minutes.
+  The temporary file id is used when uploading media files to Umbraco.
+  The process is as follows:
+  - Create a temporary file using this endpoint
+  - Use the temporary file id when creating a media item using the media post endpoint
+
+  Provide the file content as a base64 encoded string.`,
+  createTemporaryFileSchema.shape,
+  async (model) => {
+    let tempFilePath = null;
+    try {
+      const fileContent = Buffer.from(model.fileAsBase64, "base64");
+      tempFilePath = path2.join(os2.tmpdir(), `umbraco-upload-${model.id}-${model.fileName}`);
+      fs2.writeFileSync(tempFilePath, fileContent);
+      const readStream = fs2.createReadStream(tempFilePath);
+      const client = UmbracoManagementClient2.getClient();
+      await client.postTemporaryFile({
+        Id: model.id,
+        File: readStream
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ id: model.id })
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error creating temporary file: ${error.message}`
+          }
+        ],
+        isError: true
+      };
+    } finally {
+      if (tempFilePath && fs2.existsSync(tempFilePath)) {
+        try {
+          fs2.unlinkSync(tempFilePath);
+        } catch (e) {
+          console.error("Failed to cleanup temp file:", e);
+        }
+      }
+    }
+  }
+);
+var create_temporary_file_default = CreateTemporaryFileTool;
+
 // src/umb-management-api/api/temporary-file/types.zod.ts
-var _fs = require('fs');
+
 
 var postTemporaryFileBody = _zod.z.object({
   Id: _zod.z.string().uuid(),
@@ -20516,45 +21480,19 @@ var getTemporaryFileConfigurationResponse = _zod.z.object({
   maxFileSize: _zod.z.number().nullish()
 });
 
-// src/umb-management-api/tools/temporary-file/post/create-temporary-file.ts
-var CreateTemporaryFileTool = CreateUmbracoTool(
-  "create-temporary-file",
-  `Creates a new temporary file. The file will be deleted after 10 minutes. 
-  The file must be updated as a stream.
-  The temporary file id is used when uploading media files to Umbraco.
-  The process is as follows:
-  - Create a temporary fileusing this endpoint
-  - Use the temporary file id when creating a media item using the media post endpoint
-  `,
-  postTemporaryFileBody.shape,
-  async (model) => {
+// src/umb-management-api/tools/temporary-file/get/get-temporary-file.ts
+var GetTemporaryFileTool = CreateUmbracoTool(
+  "get-temporary-file",
+  "Gets a temporary file by id",
+  getTemporaryFileByIdParams.shape,
+  async (params) => {
     const client = UmbracoManagementClient2.getClient();
-    await client.postTemporaryFile(model);
+    const response = await client.getTemporaryFileById(params.id);
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify({ id: model.Id })
-        }
-      ]
-    };
-  }
-);
-var create_temporary_file_default = CreateTemporaryFileTool;
-
-// src/umb-management-api/tools/temporary-file/get/get-temporary-file.ts
-var GetTemporaryFileTool = CreateUmbracoTool(
-  "get-temporary-file",
-  "Gets a temporary file by id",
-  getTemporaryFileByIdParams.shape,
-  async (params) => {
-    const client = UmbracoManagementClient2.getClient();
-    const response = await client.getTemporaryFileById(params.id);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(response)
+          text: JSON.stringify(response)
         }
       ]
     };
@@ -20631,9 +21569,9 @@ var GetScriptByPathTool = CreateUmbracoTool(
   "get-script-by-path",
   "Gets a script by path",
   getScriptByPathParams.shape,
-  async ({ path }) => {
+  async ({ path: path3 }) => {
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.getScriptByPath(path);
+    const response = await client.getScriptByPath(path3);
     return {
       content: [
         {
@@ -20651,9 +21589,9 @@ var GetScriptFolderByPathTool = CreateUmbracoTool(
   "get-script-folder-by-path",
   "Gets a script folder by path",
   getScriptFolderByPathParams.shape,
-  async ({ path }) => {
+  async ({ path: path3 }) => {
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.getScriptFolderByPath(path);
+    const response = await client.getScriptFolderByPath(path3);
     return {
       content: [
         {
@@ -20810,7 +21748,1158 @@ var UpdateScriptTool = CreateUmbracoTool(
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.putScriptByPath(model.path, model.data);
+    const response = await client.putScriptByPath(model.path, model.data);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var update_script_default = UpdateScriptTool;
+
+// src/umb-management-api/tools/script/put/rename-script.ts
+
+var renameScriptSchema = _zod.z.object({
+  name: _zod.z.string().min(1, "Current script name is required"),
+  folderPath: _zod.z.string().optional().describe("Path to the folder containing the script (optional, leave empty for root)"),
+  newName: _zod.z.string().min(1, "New script name is required")
+});
+var RenameScriptTool = CreateUmbracoTool(
+  "rename-script",
+  "Renames a script by name and folder path",
+  renameScriptSchema.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const currentName = model.name.endsWith(".js") ? model.name : `${model.name}.js`;
+    const newName = model.newName.endsWith(".js") ? model.newName : `${model.newName}.js`;
+    const normalizedFolderPath = model.folderPath && !model.folderPath.startsWith("/") ? `/${model.folderPath}` : model.folderPath;
+    const fullPath = normalizedFolderPath ? `${normalizedFolderPath}/${currentName}` : `/${currentName}`;
+    const encodedPath = encodeURIComponent(fullPath);
+    const renameModel = {
+      name: newName
+    };
+    const response = await client.putScriptByPathRename(encodedPath, renameModel);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var rename_script_default = RenameScriptTool;
+
+// src/umb-management-api/tools/script/delete/delete-script.ts
+var DeleteScriptTool = CreateUmbracoTool(
+  "delete-script",
+  "Deletes a script by path",
+  deleteScriptByPathParams.shape,
+  async ({ path: path3 }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.deleteScriptByPath(path3);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var delete_script_default = DeleteScriptTool;
+
+// src/umb-management-api/tools/script/delete/delete-script-folder.ts
+var DeleteScriptFolderTool = CreateUmbracoTool(
+  "delete-script-folder",
+  "Deletes a script folder by path",
+  deleteScriptFolderByPathParams.shape,
+  async ({ path: path3 }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.deleteScriptFolderByPath(path3);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var delete_script_folder_default = DeleteScriptFolderTool;
+
+// src/umb-management-api/tools/script/index.ts
+var ScriptCollection = {
+  metadata: {
+    name: "script",
+    displayName: "Scripts",
+    description: "JavaScript file management and scripting",
+    dependencies: []
+  },
+  tools: (user) => {
+    const tools = [];
+    if (AuthorizationPolicies.TreeAccessScripts(user)) {
+      tools.push(get_script_by_path_default());
+      tools.push(get_script_folder_by_path_default());
+      tools.push(get_script_items_default());
+      tools.push(get_script_tree_ancestors_default());
+      tools.push(get_script_tree_children_default());
+      tools.push(get_script_tree_root_default());
+      tools.push(create_script_default());
+      tools.push(create_script_folder_default());
+      tools.push(update_script_default());
+      tools.push(rename_script_default());
+      tools.push(delete_script_default());
+      tools.push(delete_script_folder_default());
+    }
+    return tools;
+  }
+};
+
+// src/umb-management-api/tools/stylesheet/post/create-stylesheet.ts
+var CreateStylesheetTool = CreateUmbracoTool(
+  "create-stylesheet",
+  "Creates a new stylesheet",
+  postStylesheetBody.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.postStylesheet(model);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var create_stylesheet_default = CreateStylesheetTool;
+
+// src/umb-management-api/tools/stylesheet/post/create-stylesheet-folder.ts
+var CreateStylesheetFolderTool = CreateUmbracoTool(
+  "create-stylesheet-folder",
+  "Creates a new stylesheet folder",
+  postStylesheetFolderBody.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.postStylesheetFolder(model);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var create_stylesheet_folder_default = CreateStylesheetFolderTool;
+
+// src/umb-management-api/tools/stylesheet/get/get-stylesheet-by-path.ts
+var GetStylesheetByPathTool = CreateUmbracoTool(
+  "get-stylesheet-by-path",
+  "Gets a stylesheet by its path",
+  getStylesheetByPathParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.getStylesheetByPath(model.path);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_stylesheet_by_path_default = GetStylesheetByPathTool;
+
+// src/umb-management-api/tools/stylesheet/get/get-stylesheet-folder-by-path.ts
+var GetStylesheetFolderByPathTool = CreateUmbracoTool(
+  "get-stylesheet-folder-by-path",
+  "Gets a stylesheet folder by its path",
+  getStylesheetFolderByPathParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.getStylesheetFolderByPath(model.path);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_stylesheet_folder_by_path_default = GetStylesheetFolderByPathTool;
+
+// src/umb-management-api/tools/stylesheet/put/update-stylesheet.ts
+
+var UpdateStylesheetTool = CreateUmbracoTool(
+  "update-stylesheet",
+  "Updates a stylesheet by path",
+  _zod.z.object({
+    ...putStylesheetByPathParams.shape,
+    ...putStylesheetByPathBody.shape
+  }).shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const { path: path3, ...updateModel } = model;
+    var response = await client.putStylesheetByPath(path3, updateModel);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var update_stylesheet_default = UpdateStylesheetTool;
+
+// src/umb-management-api/tools/stylesheet/put/rename-stylesheet.ts
+
+var RenameStylesheetTool = CreateUmbracoTool(
+  "rename-stylesheet",
+  `Renames a stylesheet`,
+  _zod.z.object({
+    ...putStylesheetByPathRenameParams.shape,
+    ...putStylesheetByPathRenameBody.shape
+  }).shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const { path: path3, ...renameModel } = model;
+    const normalizedPath = encodeURIComponent(path3);
+    var response = await client.putStylesheetByPathRename(normalizedPath, renameModel);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var rename_stylesheet_default = RenameStylesheetTool;
+
+// src/umb-management-api/tools/stylesheet/delete/delete-stylesheet.ts
+var DeleteStylesheetTool = CreateUmbracoTool(
+  "delete-stylesheet",
+  "Deletes a stylesheet by its path",
+  deleteStylesheetByPathParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.deleteStylesheetByPath(model.path);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var delete_stylesheet_default = DeleteStylesheetTool;
+
+// src/umb-management-api/tools/stylesheet/delete/delete-stylesheet-folder.ts
+var DeleteStylesheetFolderTool = CreateUmbracoTool(
+  "delete-stylesheet-folder",
+  "Deletes a stylesheet folder by its path",
+  deleteStylesheetFolderByPathParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.deleteStylesheetFolderByPath(model.path);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var delete_stylesheet_folder_default = DeleteStylesheetFolderTool;
+
+// src/umb-management-api/tools/stylesheet/items/get/get-ancestors.ts
+var GetStylesheetAncestorsTool = CreateUmbracoTool(
+  "get-stylesheet-ancestors",
+  "Gets the ancestors of a stylesheet in the tree structure",
+  getTreeStylesheetAncestorsQueryParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.getTreeStylesheetAncestors(model);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_ancestors_default10 = GetStylesheetAncestorsTool;
+
+// src/umb-management-api/tools/stylesheet/items/get/get-children.ts
+var GetStylesheetChildrenTool = CreateUmbracoTool(
+  "get-stylesheet-children",
+  "Gets the children of a stylesheet in the tree structure",
+  getTreeStylesheetChildrenQueryParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.getTreeStylesheetChildren(model);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_children_default10 = GetStylesheetChildrenTool;
+
+// src/umb-management-api/tools/stylesheet/items/get/get-root.ts
+var GetStylesheetRootTool = CreateUmbracoTool(
+  "get-stylesheet-root",
+  "Gets the root stylesheets in the tree structure",
+  getTreeStylesheetRootQueryParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.getTreeStylesheetRoot(model);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_root_default12 = GetStylesheetRootTool;
+
+// src/umb-management-api/tools/stylesheet/items/get/get-search.ts
+var GetStylesheetSearchTool = CreateUmbracoTool(
+  "get-stylesheet-search",
+  "Searches for stylesheets by name or path",
+  getItemStylesheetQueryParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.getItemStylesheet(model);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_search_default4 = GetStylesheetSearchTool;
+
+// src/umb-management-api/tools/stylesheet/index.ts
+var StylesheetCollection = {
+  metadata: {
+    name: "stylesheet",
+    displayName: "Stylesheets",
+    description: "CSS stylesheet file management",
+    dependencies: []
+  },
+  tools: (user) => {
+    const tools = [];
+    if (AuthorizationPolicies.TreeAccessStylesheets(user)) {
+      tools.push(create_stylesheet_default());
+      tools.push(create_stylesheet_folder_default());
+      tools.push(get_stylesheet_by_path_default());
+      tools.push(get_stylesheet_folder_by_path_default());
+      tools.push(update_stylesheet_default());
+      tools.push(rename_stylesheet_default());
+      tools.push(delete_stylesheet_default());
+      tools.push(delete_stylesheet_folder_default());
+      tools.push(get_ancestors_default10());
+      tools.push(get_children_default10());
+      tools.push(get_root_default12());
+      tools.push(get_search_default4());
+    }
+    return tools;
+  }
+};
+
+// src/umb-management-api/tools/health/get/get-health-check-groups.ts
+var GetHealthCheckGroupsTool = CreateUmbracoTool(
+  "get-health-check-groups",
+  "Gets a paged list of health check groups for system monitoring",
+  getHealthCheckGroupQueryParams.shape,
+  async (params) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getHealthCheckGroup(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_health_check_groups_default = GetHealthCheckGroupsTool;
+
+// src/umb-management-api/tools/health/get/get-health-check-group-by-name.ts
+var GetHealthCheckGroupByNameTool = CreateUmbracoTool(
+  "get-health-check-group-by-name",
+  "Gets specific health check group details by name for system monitoring",
+  getHealthCheckGroupByNameParams.shape,
+  async (params) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getHealthCheckGroupByName(params.name);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_health_check_group_by_name_default = GetHealthCheckGroupByNameTool;
+
+// src/umb-management-api/tools/health/post/run-health-check-group.ts
+var RunHealthCheckGroupTool = CreateUmbracoTool(
+  "run-health-check-group",
+  "Executes health checks for a specific group. WARNING: This will run system diagnostics which may take time and could temporarily affect system performance.",
+  postHealthCheckGroupByNameCheckParams.shape,
+  async (params) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.postHealthCheckGroupByNameCheck(params.name);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var run_health_check_group_default = RunHealthCheckGroupTool;
+
+// src/umb-management-api/tools/health/post/execute-health-check-action.ts
+var ExecuteHealthCheckActionTool = CreateUmbracoTool(
+  "execute-health-check-action",
+  "Executes remedial actions for health issues. WARNING: This performs system remedial actions that may modify system configuration, files, or database content. Use with caution.",
+  postHealthCheckExecuteActionBody.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.postHealthCheckExecuteAction(model);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var execute_health_check_action_default = ExecuteHealthCheckActionTool;
+
+// src/umb-management-api/tools/health/index.ts
+var HealthCollection = {
+  metadata: {
+    name: "health",
+    displayName: "Health Checks",
+    description: "System health monitoring and diagnostic capabilities",
+    dependencies: []
+  },
+  tools: (user) => {
+    const tools = [];
+    if (AuthorizationPolicies.SectionAccessSettings(user)) {
+      tools.push(get_health_check_groups_default());
+      tools.push(get_health_check_group_by_name_default());
+      tools.push(run_health_check_group_default());
+      tools.push(execute_health_check_action_default());
+    }
+    return tools;
+  }
+};
+
+// src/umb-management-api/tools/manifest/get/get-manifest-manifest.ts
+var GetManifestManifestTool = CreateUmbracoTool(
+  "get-manifest-manifest",
+  "Gets all manifests (both public and private) from the Umbraco installation. Each manifest contains an extensions property showing what the package exposes to Umbraco. Use to see which packages are installed, troubleshoot package issues, or list available extensions.",
+  {},
+  async () => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getManifestManifest();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_manifest_manifest_default = GetManifestManifestTool;
+
+// src/umb-management-api/tools/manifest/get/get-manifest-manifest-private.ts
+var GetManifestManifestPrivateTool = CreateUmbracoTool(
+  "get-manifest-manifest-private",
+  "Gets private manifests from the Umbraco installation. Private manifests require authentication and contain administrative/sensitive extensions.",
+  {},
+  async () => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getManifestManifestPrivate();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_manifest_manifest_private_default = GetManifestManifestPrivateTool;
+
+// src/umb-management-api/tools/manifest/get/get-manifest-manifest-public.ts
+var GetManifestManifestPublicTool = CreateUmbracoTool(
+  "get-manifest-manifest-public",
+  "Gets public manifests from the Umbraco installation. Public manifests can be accessed without authentication and contain public-facing extensions.",
+  {},
+  async () => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getManifestManifestPublic();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_manifest_manifest_public_default = GetManifestManifestPublicTool;
+
+// src/umb-management-api/tools/manifest/index.ts
+var ManifestCollection = {
+  metadata: {
+    name: "manifest",
+    displayName: "Manifest",
+    description: "System manifests and extension definitions",
+    dependencies: []
+  },
+  tools: (user) => {
+    const tools = [];
+    if (AuthorizationPolicies.SectionAccessSettings(user)) {
+      tools.push(get_manifest_manifest_default());
+      tools.push(get_manifest_manifest_private_default());
+      tools.push(get_manifest_manifest_public_default());
+    }
+    return tools;
+  }
+};
+
+// src/umb-management-api/tools/tag/get/get-tags.ts
+var GetTagsTool = CreateUmbracoTool(
+  "get-tags",
+  "Retrieves a paginated list of tags used in the Umbraco instance",
+  getTagQueryParams.shape,
+  async (params) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.getTag(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_tags_default = GetTagsTool;
+
+// src/umb-management-api/tools/tag/index.ts
+var TagCollection = {
+  metadata: {
+    name: "tag",
+    displayName: "Tag Management",
+    description: "Tag management and retrieval",
+    dependencies: []
+  },
+  tools: (user) => {
+    const tools = [get_tags_default()];
+    return tools;
+  }
+};
+
+// src/umb-management-api/tools/models-builder/get/get-models-builder-dashboard.ts
+var GetModelsBuilderDashboardTool = CreateUmbracoTool(
+  "get-models-builder-dashboard",
+  `Gets Models Builder dashboard information and current status.
+  Returns an object containing:
+  - mode: The Models Builder mode, one of: 'Nothing', 'InMemoryAuto', 'SourceCodeManual', 'SourceCodeAuto' (string)
+  - canGenerate: Whether models can be generated (boolean)
+  - outOfDateModels: Whether models are out of date (boolean)
+  - lastError: Last error message if any (string | null)
+  - version: Version information (string | null)
+  - modelsNamespace: Namespace for generated models (string | null)
+  - trackingOutOfDateModels: Whether tracking is enabled (boolean)`,
+  {},
+  async () => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getModelsBuilderDashboard();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_models_builder_dashboard_default = GetModelsBuilderDashboardTool;
+
+// src/umb-management-api/tools/models-builder/get/get-models-builder-status.ts
+var GetModelsBuilderStatusTool = CreateUmbracoTool(
+  "get-models-builder-status",
+  `Gets the out-of-date status of Models Builder models.
+  Returns an object containing:
+  - status: The out-of-date status, one of: 'OutOfDate', 'Current', 'Unknown' (string)`,
+  {},
+  async () => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getModelsBuilderStatus();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_models_builder_status_default = GetModelsBuilderStatusTool;
+
+// src/umb-management-api/tools/models-builder/post/post-models-builder-build.ts
+var PostModelsBuilderBuildTool = CreateUmbracoTool(
+  "post-models-builder-build",
+  `Triggers the generation/build of Models Builder models.
+  This endpoint initiates the process of generating strongly-typed models from Umbraco content types.
+  The operation runs asynchronously and does not return any response data.
+
+  Use this tool to:
+  - Generate models after making changes to document types, media types, or member types
+  - Refresh models when they become out of date
+  - Ensure the latest content type definitions are reflected in generated models
+
+  Note: This operation may take some time to complete depending on the number of content types.
+  Use get-models-builder-dashboard or get-models-builder-status to check the current state and if new models need to be generated.`,
+  {},
+  async () => {
+    const client = UmbracoManagementClient2.getClient();
+    await client.postModelsBuilderBuild();
+    return {
+      content: [
+        {
+          type: "text",
+          text: "Models Builder build process initiated successfully."
+        }
+      ]
+    };
+  }
+);
+var post_models_builder_build_default = PostModelsBuilderBuildTool;
+
+// src/umb-management-api/tools/models-builder/index.ts
+var ModelsBuilderCollection = {
+  metadata: {
+    name: "models-builder",
+    displayName: "Models Builder",
+    description: "Models Builder management and code generation",
+    dependencies: []
+  },
+  tools: (user) => {
+    const tools = [];
+    if (AuthorizationPolicies.SectionAccessSettings(user)) {
+      tools.push(get_models_builder_dashboard_default());
+      tools.push(get_models_builder_status_default());
+      tools.push(post_models_builder_build_default());
+    }
+    return tools;
+  }
+};
+
+// src/umb-management-api/tools/searcher/get/get-searcher.ts
+var GetSearcherTool = CreateUmbracoTool(
+  "get-searcher",
+  `Lists all searchers with pagination support.
+  Returns an object containing:
+  - total: Total number of searchers (number)
+  - items: Array of searcher objects with name and isEnabled properties`,
+  getSearcherQueryParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getSearcher(model);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_searcher_default = GetSearcherTool;
+
+// src/umb-management-api/tools/searcher/get/get-searcher-by-searcher-name-query.ts
+var combinedSchema = getSearcherBySearcherNameQueryParams.merge(getSearcherBySearcherNameQueryQueryParams);
+var GetSearcherBySearcherNameQueryTool = CreateUmbracoTool(
+  "get-searcher-by-searcher-name-query",
+  `Gets search results from a specific searcher by name with query parameters.
+  Returns search results from the specified searcher with pagination support.`,
+  combinedSchema.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const { searcherName, ...queryParams } = model;
+    const response = await client.getSearcherBySearcherNameQuery(searcherName, queryParams);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_searcher_by_searcher_name_query_default = GetSearcherBySearcherNameQueryTool;
+
+// src/umb-management-api/tools/searcher/index.ts
+var SearcherCollection = {
+  metadata: {
+    name: "searcher",
+    displayName: "Searcher",
+    description: "Searcher management and query operations",
+    dependencies: []
+  },
+  tools: (user) => {
+    const tools = [];
+    if (AuthorizationPolicies.SectionAccessSettings(user)) {
+      tools.push(get_searcher_default());
+      tools.push(get_searcher_by_searcher_name_query_default());
+    }
+    return tools;
+  }
+};
+
+// src/umb-management-api/tools/indexer/get/get-indexer.ts
+var GetIndexerTool = CreateUmbracoTool(
+  "get-indexer",
+  `Lists all indexes with pagination support.
+  Returns an object containing:
+  - total: Total number of indexes (number)
+  - items: Array of index objects with name, searcherName, and other properties`,
+  getIndexerQueryParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getIndexer(model);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_indexer_default = GetIndexerTool;
+
+// src/umb-management-api/tools/indexer/get/get-indexer-by-index-name.ts
+var GetIndexerByIndexNameTool = CreateUmbracoTool(
+  "get-indexer-by-index-name",
+  `Gets a specific index by its name.
+  Returns detailed information about the index including its configuration and status.`,
+  getIndexerByIndexNameParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getIndexerByIndexName(model.indexName);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_indexer_by_index_name_default = GetIndexerByIndexNameTool;
+
+// src/umb-management-api/tools/indexer/post/post-indexer-by-index-name-rebuild.ts
+var PostIndexerByIndexNameRebuildTool = CreateUmbracoTool(
+  "post-indexer-by-index-name-rebuild",
+  `Rebuilds a specific index by name.
+  This operation will trigger a full rebuild of the index, which may take some time depending on the amount of content.
+  Use this only when asked to by the user.`,
+  postIndexerByIndexNameRebuildParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    await client.postIndexerByIndexNameRebuild(model.indexName);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Index rebuild initiated for: ${model.indexName}`
+        }
+      ]
+    };
+  }
+);
+var post_indexer_by_index_name_rebuild_default = PostIndexerByIndexNameRebuildTool;
+
+// src/umb-management-api/tools/indexer/index.ts
+var IndexerCollection = {
+  metadata: {
+    name: "indexer",
+    displayName: "Indexer",
+    description: "Index management and configuration operations",
+    dependencies: []
+  },
+  tools: (user) => {
+    const tools = [];
+    if (AuthorizationPolicies.SectionAccessSettings(user)) {
+      tools.push(get_indexer_default());
+      tools.push(get_indexer_by_index_name_default());
+      tools.push(post_indexer_by_index_name_rebuild_default());
+    }
+    return tools;
+  }
+};
+
+// src/umb-management-api/tools/imaging/get/get-imaging-resize-urls.ts
+var GetImagingResizeUrlsTool = CreateUmbracoTool(
+  "get-imaging-resize-urls",
+  `Generates resized image URLs for media items.
+  Takes media item IDs and resize parameters to generate optimized image URLs.
+  Returns an object containing:
+  - Array of media items with their resize URL information
+  - Each item includes the media ID and URL info with culture and resized URLs
+
+  Parameters:
+  - id: Array of media item UUIDs
+  - height: Target height in pixels (default: 200)
+  - width: Target width in pixels (default: 200)
+  - mode: Resize mode (Crop, Max, Stretch, Pad, BoxPad, Min)`,
+  getImagingResizeUrlsQueryParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getImagingResizeUrls(model);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_imaging_resize_urls_default = GetImagingResizeUrlsTool;
+
+// src/umb-management-api/tools/imaging/index.ts
+var ImagingCollection = {
+  metadata: {
+    name: "imaging",
+    displayName: "Imaging",
+    description: "Image processing and URL generation utilities",
+    dependencies: ["media"]
+  },
+  tools: (user) => {
+    const tools = [];
+    if (AuthorizationPolicies.SectionAccessContentOrMedia(user)) {
+      tools.push(get_imaging_resize_urls_default());
+    }
+    return tools;
+  }
+};
+
+// src/umb-management-api/tools/relation-type/get/get-relation-type.ts
+var GetRelationTypeTool = CreateUmbracoTool(
+  "get-relation-type",
+  "Gets all relation types with pagination",
+  getRelationTypeQueryParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getRelationType(model);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_relation_type_default = GetRelationTypeTool;
+
+// src/umb-management-api/tools/relation-type/get/get-relation-type-by-id.ts
+var GetRelationTypeByIdTool = CreateUmbracoTool(
+  "get-relation-type-by-id",
+  "Gets a relation type by Id",
+  getRelationTypeByIdParams.shape,
+  async ({ id }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getRelationTypeById(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_relation_type_by_id_default = GetRelationTypeByIdTool;
+
+// src/umb-management-api/tools/relation-type/index.ts
+var RelationTypeCollection = {
+  metadata: {
+    name: "relation-type",
+    displayName: "Relation Type",
+    description: "Relation type management and configuration"
+  },
+  tools: (user) => {
+    const tools = [];
+    if (AuthorizationPolicies.TreeAccessRelationTypes(user)) {
+      tools.push(get_relation_type_default());
+      tools.push(get_relation_type_by_id_default());
+    }
+    return tools;
+  }
+};
+
+// src/umb-management-api/tools/relation/get/get-relation-by-relation-type-id.ts
+
+var GetRelationByRelationTypeIdTool = CreateUmbracoTool(
+  "get-relation-by-relation-type-id",
+  "Gets relations by relation type ID",
+  _zod.z.object({
+    ...getRelationByRelationTypeIdParams.shape,
+    ...getRelationByRelationTypeIdQueryParams.shape
+  }).shape,
+  async ({ id, skip, take }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getRelationByRelationTypeId(id, {
+      skip,
+      take
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_relation_by_relation_type_id_default = GetRelationByRelationTypeIdTool;
+
+// src/umb-management-api/tools/relation/index.ts
+var RelationCollection = {
+  metadata: {
+    name: "relation",
+    displayName: "Relation",
+    description: "Relation management and querying"
+  },
+  tools: (user) => {
+    const tools = [];
+    if (AuthorizationPolicies.TreeAccessRelationTypes(user)) {
+      tools.push(get_relation_by_relation_type_id_default());
+    }
+    return tools;
+  }
+};
+
+// src/umb-management-api/tools/user/get/get-user.ts
+var GetUserTool = CreateUmbracoTool(
+  "get-user",
+  "Lists users with pagination and filtering options",
+  getUserQueryParams.shape,
+  async (params) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getUser(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_user_default = GetUserTool;
+
+// src/umb-management-api/tools/user/get/get-user-by-id.ts
+var GetUserByIdTool = CreateUmbracoTool(
+  "get-user-by-id",
+  "Gets a user by their unique identifier",
+  getUserByIdParams.shape,
+  async ({ id }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getUserById(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_user_by_id_default = GetUserByIdTool;
+
+// src/umb-management-api/tools/user/get/find-user.ts
+var FindUserTool = CreateUmbracoTool(
+  "find-user",
+  "Finds users by filtering with name, email, or other criteria",
+  getFilterUserQueryParams.shape,
+  async (params) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getFilterUser(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var find_user_default = FindUserTool;
+
+// src/umb-management-api/tools/user/get/get-item-user.ts
+var GetItemUserTool = CreateUmbracoTool(
+  "get-item-user",
+  "Gets user items for selection lists and pickers",
+  getItemUserQueryParams.shape,
+  async (params) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getItemUser(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_item_user_default = GetItemUserTool;
+
+// src/umb-management-api/tools/user/get/get-user-current.ts
+var GetUserCurrentTool = CreateUmbracoTool(
+  "get-user-current",
+  "Gets the current authenticated user's information",
+  {},
+  // No parameters required
+  async () => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getUserCurrent();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_user_current_default = GetUserCurrentTool;
+
+// src/umb-management-api/tools/user/get/get-user-configuration.ts
+var GetUserConfigurationTool = CreateUmbracoTool(
+  "get-user-configuration",
+  "Gets user configuration settings including user invitation settings and password requirements",
+  {},
+  async () => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getUserConfiguration();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response, null, 2)
+        }
+      ]
+    };
+  }
+);
+var get_user_configuration_default = GetUserConfigurationTool;
+
+// src/umb-management-api/tools/user/get/get-user-current-configuration.ts
+var GetUserCurrentConfigurationTool = CreateUmbracoTool(
+  "get-user-current-configuration",
+  "Gets current user configuration settings including login preferences and password requirements",
+  {},
+  async () => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getUserCurrentConfiguration();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response, null, 2)
+        }
+      ]
+    };
+  }
+);
+var get_user_current_configuration_default = GetUserCurrentConfigurationTool;
+
+// src/umb-management-api/tools/user/get/get-user-current-login-providers.ts
+var GetUserCurrentLoginProvidersTool = CreateUmbracoTool(
+  "get-user-current-login-providers",
+  "Gets the current user's available login providers",
+  {},
+  // No parameters required
+  async () => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.getUserCurrentLoginProviders();
     return {
       content: [
         {
@@ -20821,30 +22910,16 @@ var UpdateScriptTool = CreateUmbracoTool(
     };
   }
 );
-var update_script_default = UpdateScriptTool;
+var get_user_current_login_providers_default = GetUserCurrentLoginProvidersTool;
 
-// src/umb-management-api/tools/script/put/rename-script.ts
-
-var renameScriptSchema = _zod.z.object({
-  name: _zod.z.string().min(1, "Current script name is required"),
-  folderPath: _zod.z.string().optional().describe("Path to the folder containing the script (optional, leave empty for root)"),
-  newName: _zod.z.string().min(1, "New script name is required")
-});
-var RenameScriptTool = CreateUmbracoTool(
-  "rename-script",
-  "Renames a script by name and folder path",
-  renameScriptSchema.shape,
-  async (model) => {
+// src/umb-management-api/tools/user/get/get-user-current-permissions.ts
+var GetUserCurrentPermissionsTool = CreateUmbracoTool(
+  "get-user-current-permissions",
+  "Gets the current user's permissions for the specified entity",
+  getUserCurrentPermissionsQueryParams.shape,
+  async (params) => {
     const client = UmbracoManagementClient2.getClient();
-    const currentName = model.name.endsWith(".js") ? model.name : `${model.name}.js`;
-    const newName = model.newName.endsWith(".js") ? model.newName : `${model.newName}.js`;
-    const normalizedFolderPath = model.folderPath && !model.folderPath.startsWith("/") ? `/${model.folderPath}` : model.folderPath;
-    const fullPath = normalizedFolderPath ? `${normalizedFolderPath}/${currentName}` : `/${currentName}`;
-    const encodedPath = encodeURIComponent(fullPath);
-    const renameModel = {
-      name: newName
-    };
-    const response = await client.putScriptByPathRename(encodedPath, renameModel);
+    const response = await client.getUserCurrentPermissions(params);
     return {
       content: [
         {
@@ -20855,16 +22930,16 @@ var RenameScriptTool = CreateUmbracoTool(
     };
   }
 );
-var rename_script_default = RenameScriptTool;
+var get_user_current_permissions_default = GetUserCurrentPermissionsTool;
 
-// src/umb-management-api/tools/script/delete/delete-script.ts
-var DeleteScriptTool = CreateUmbracoTool(
-  "delete-script",
-  "Deletes a script by path",
-  deleteScriptByPathParams.shape,
-  async ({ path }) => {
+// src/umb-management-api/tools/user/get/get-user-current-permissions-document.ts
+var GetUserCurrentPermissionsDocumentTool = CreateUmbracoTool(
+  "get-user-current-permissions-document",
+  "Gets the current user's document permissions for specific documents",
+  getUserCurrentPermissionsDocumentQueryParams.shape,
+  async (params) => {
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.deleteScriptByPath(path);
+    const response = await client.getUserCurrentPermissionsDocument(params);
     return {
       content: [
         {
@@ -20875,16 +22950,16 @@ var DeleteScriptTool = CreateUmbracoTool(
     };
   }
 );
-var delete_script_default = DeleteScriptTool;
+var get_user_current_permissions_document_default = GetUserCurrentPermissionsDocumentTool;
 
-// src/umb-management-api/tools/script/delete/delete-script-folder.ts
-var DeleteScriptFolderTool = CreateUmbracoTool(
-  "delete-script-folder",
-  "Deletes a script folder by path",
-  deleteScriptFolderByPathParams.shape,
-  async ({ path }) => {
+// src/umb-management-api/tools/user/get/get-user-current-permissions-media.ts
+var GetUserCurrentPermissionsMediaTool = CreateUmbracoTool(
+  "get-user-current-permissions-media",
+  "Gets the current user's media permissions for specific media items",
+  getUserCurrentPermissionsMediaQueryParams.shape,
+  async (params) => {
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.deleteScriptFolderByPath(path);
+    const response = await client.getUserCurrentPermissionsMedia(params);
     return {
       content: [
         {
@@ -20895,44 +22970,16 @@ var DeleteScriptFolderTool = CreateUmbracoTool(
     };
   }
 );
-var delete_script_folder_default = DeleteScriptFolderTool;
-
-// src/umb-management-api/tools/script/index.ts
-var ScriptCollection = {
-  metadata: {
-    name: "script",
-    displayName: "Scripts",
-    description: "JavaScript file management and scripting",
-    dependencies: []
-  },
-  tools: (user) => {
-    const tools = [];
-    if (AuthorizationPolicies.TreeAccessScripts(user)) {
-      tools.push(get_script_by_path_default());
-      tools.push(get_script_folder_by_path_default());
-      tools.push(get_script_items_default());
-      tools.push(get_script_tree_ancestors_default());
-      tools.push(get_script_tree_children_default());
-      tools.push(get_script_tree_root_default());
-      tools.push(create_script_default());
-      tools.push(create_script_folder_default());
-      tools.push(update_script_default());
-      tools.push(rename_script_default());
-      tools.push(delete_script_default());
-      tools.push(delete_script_folder_default());
-    }
-    return tools;
-  }
-};
+var get_user_current_permissions_media_default = GetUserCurrentPermissionsMediaTool;
 
-// src/umb-management-api/tools/stylesheet/post/create-stylesheet.ts
-var CreateStylesheetTool = CreateUmbracoTool(
-  "create-stylesheet",
-  "Creates a new stylesheet",
-  postStylesheetBody.shape,
-  async (model) => {
+// src/umb-management-api/tools/user/get/get-user-by-id-calculate-start-nodes.ts
+var GetUserByIdCalculateStartNodesTool = CreateUmbracoTool(
+  "get-user-by-id-calculate-start-nodes",
+  "Calculates start nodes for a user by their ID based on permissions",
+  getUserByIdCalculateStartNodesParams.shape,
+  async ({ id }) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.postStylesheet(model);
+    const response = await client.getUserByIdCalculateStartNodes(id);
     return {
       content: [
         {
@@ -20943,16 +22990,19 @@ var CreateStylesheetTool = CreateUmbracoTool(
     };
   }
 );
-var create_stylesheet_default = CreateStylesheetTool;
+var get_user_by_id_calculate_start_nodes_default = GetUserByIdCalculateStartNodesTool;
 
-// src/umb-management-api/tools/stylesheet/post/create-stylesheet-folder.ts
-var CreateStylesheetFolderTool = CreateUmbracoTool(
-  "create-stylesheet-folder",
-  "Creates a new stylesheet folder",
-  postStylesheetFolderBody.shape,
-  async (model) => {
+// src/umb-management-api/tools/user/post/upload-user-avatar-by-id.ts
+var UploadUserAvatarByIdTool = CreateUmbracoTool(
+  "upload-user-avatar-by-id",
+  "Uploads an avatar for a specific user by ID (admin only or self-service)",
+  {
+    ...postUserAvatarByIdParams.shape,
+    ...postUserAvatarByIdBody.shape
+  },
+  async ({ id, file }) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.postStylesheetFolder(model);
+    const response = await client.postUserAvatarById(id, { file });
     return {
       content: [
         {
@@ -20963,16 +23013,16 @@ var CreateStylesheetFolderTool = CreateUmbracoTool(
     };
   }
 );
-var create_stylesheet_folder_default = CreateStylesheetFolderTool;
+var upload_user_avatar_by_id_default = UploadUserAvatarByIdTool;
 
-// src/umb-management-api/tools/stylesheet/get/get-stylesheet-by-path.ts
-var GetStylesheetByPathTool = CreateUmbracoTool(
-  "get-stylesheet-by-path",
-  "Gets a stylesheet by its path",
-  getStylesheetByPathParams.shape,
-  async (model) => {
+// src/umb-management-api/tools/user/post/upload-user-current-avatar.ts
+var UploadUserCurrentAvatarTool = CreateUmbracoTool(
+  "upload-user-current-avatar",
+  "Uploads an avatar for the current authenticated user",
+  postUserCurrentAvatarBody.shape,
+  async ({ file }) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.getStylesheetByPath(model.path);
+    const response = await client.postUserCurrentAvatar({ file });
     return {
       content: [
         {
@@ -20983,16 +23033,16 @@ var GetStylesheetByPathTool = CreateUmbracoTool(
     };
   }
 );
-var get_stylesheet_by_path_default = GetStylesheetByPathTool;
+var upload_user_current_avatar_default = UploadUserCurrentAvatarTool;
 
-// src/umb-management-api/tools/stylesheet/get/get-stylesheet-folder-by-path.ts
-var GetStylesheetFolderByPathTool = CreateUmbracoTool(
-  "get-stylesheet-folder-by-path",
-  "Gets a stylesheet folder by its path",
-  getStylesheetFolderByPathParams.shape,
-  async (model) => {
+// src/umb-management-api/tools/user/delete/delete-user-avatar-by-id.ts
+var DeleteUserAvatarByIdTool = CreateUmbracoTool(
+  "delete-user-avatar-by-id",
+  "Deletes an avatar for a specific user by ID (admin only or self-service)",
+  deleteUserAvatarByIdParams.shape,
+  async ({ id }) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.getStylesheetFolderByPath(model.path);
+    const response = await client.deleteUserAvatarById(id);
     return {
       content: [
         {
@@ -21003,21 +23053,47 @@ var GetStylesheetFolderByPathTool = CreateUmbracoTool(
     };
   }
 );
-var get_stylesheet_folder_by_path_default = GetStylesheetFolderByPathTool;
+var delete_user_avatar_by_id_default = DeleteUserAvatarByIdTool;
 
-// src/umb-management-api/tools/stylesheet/put/update-stylesheet.ts
+// src/umb-management-api/tools/user/index.ts
+var UserCollection = {
+  metadata: {
+    name: "user",
+    displayName: "Users",
+    description: "User account management and administration",
+    dependencies: []
+  },
+  tools: (user) => {
+    const tools = [];
+    tools.push(get_user_current_default());
+    tools.push(get_user_current_configuration_default());
+    tools.push(get_user_current_login_providers_default());
+    tools.push(get_user_current_permissions_default());
+    tools.push(get_user_current_permissions_document_default());
+    tools.push(get_user_current_permissions_media_default());
+    tools.push(upload_user_current_avatar_default());
+    if (AuthorizationPolicies.SectionAccessUsers(user)) {
+      tools.push(get_user_default());
+      tools.push(get_user_by_id_default());
+      tools.push(find_user_default());
+      tools.push(get_item_user_default());
+      tools.push(get_user_configuration_default());
+      tools.push(get_user_by_id_calculate_start_nodes_default());
+      tools.push(upload_user_avatar_by_id_default());
+      tools.push(delete_user_avatar_by_id_default());
+    }
+    return tools;
+  }
+};
 
-var UpdateStylesheetTool = CreateUmbracoTool(
-  "update-stylesheet",
-  "Updates a stylesheet by path",
-  _zod.z.object({
-    ...putStylesheetByPathParams.shape,
-    ...putStylesheetByPathBody.shape
-  }).shape,
-  async (model) => {
+// src/umb-management-api/tools/user-data/post/create-user-data.ts
+var CreateUserDataTool = CreateUmbracoTool(
+  "create-user-data",
+  "Creates a new user data record",
+  postUserDataBody.shape,
+  async (body) => {
     const client = UmbracoManagementClient2.getClient();
-    const { path, ...updateModel } = model;
-    var response = await client.putStylesheetByPath(path, updateModel);
+    const response = await client.postUserData(body);
     return {
       content: [
         {
@@ -21028,22 +23104,16 @@ var UpdateStylesheetTool = CreateUmbracoTool(
     };
   }
 );
-var update_stylesheet_default = UpdateStylesheetTool;
-
-// src/umb-management-api/tools/stylesheet/put/rename-stylesheet.ts
+var create_user_data_default = CreateUserDataTool;
 
-var RenameStylesheetTool = CreateUmbracoTool(
-  "rename-stylesheet",
-  `Renames a stylesheet`,
-  _zod.z.object({
-    ...putStylesheetByPathRenameParams.shape,
-    ...putStylesheetByPathRenameBody.shape
-  }).shape,
-  async (model) => {
+// src/umb-management-api/tools/user-data/put/update-user-data.ts
+var UpdateUserDataTool = CreateUmbracoTool(
+  "update-user-data",
+  "Updates an existing user data record",
+  putUserDataBody.shape,
+  async (body) => {
     const client = UmbracoManagementClient2.getClient();
-    const { path, ...renameModel } = model;
-    const normalizedPath = encodeURIComponent(path);
-    var response = await client.putStylesheetByPathRename(normalizedPath, renameModel);
+    const response = await client.putUserData(body);
     return {
       content: [
         {
@@ -21054,16 +23124,16 @@ var RenameStylesheetTool = CreateUmbracoTool(
     };
   }
 );
-var rename_stylesheet_default = RenameStylesheetTool;
+var update_user_data_default = UpdateUserDataTool;
 
-// src/umb-management-api/tools/stylesheet/delete/delete-stylesheet.ts
-var DeleteStylesheetTool = CreateUmbracoTool(
-  "delete-stylesheet",
-  "Deletes a stylesheet by its path",
-  deleteStylesheetByPathParams.shape,
-  async (model) => {
+// src/umb-management-api/tools/user-data/get/get-user-data.ts
+var GetUserDataTool = CreateUmbracoTool(
+  "get-user-data",
+  "Retrieves user data records with pagination and filtering",
+  getUserDataQueryParams.shape,
+  async (params) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.deleteStylesheetByPath(model.path);
+    const response = await client.getUserData(params);
     return {
       content: [
         {
@@ -21074,16 +23144,16 @@ var DeleteStylesheetTool = CreateUmbracoTool(
     };
   }
 );
-var delete_stylesheet_default = DeleteStylesheetTool;
+var get_user_data_default = GetUserDataTool;
 
-// src/umb-management-api/tools/stylesheet/delete/delete-stylesheet-folder.ts
-var DeleteStylesheetFolderTool = CreateUmbracoTool(
-  "delete-stylesheet-folder",
-  "Deletes a stylesheet folder by its path",
-  deleteStylesheetFolderByPathParams.shape,
-  async (model) => {
+// src/umb-management-api/tools/user-data/get/get-user-data-by-id.ts
+var GetUserDataByIdTool = CreateUmbracoTool(
+  "get-user-data-by-id",
+  "Retrieves a specific personal key-value storage record by its unique identifier for the authenticated user. User data stores user preferences, settings, and configuration values that persist permanently and are organized by group (category) and identifier (key).",
+  getUserDataByIdParams.shape,
+  async ({ id }) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.deleteStylesheetFolderByPath(model.path);
+    const response = await client.getUserDataById(id);
     return {
       content: [
         {
@@ -21094,16 +23164,34 @@ var DeleteStylesheetFolderTool = CreateUmbracoTool(
     };
   }
 );
-var delete_stylesheet_folder_default = DeleteStylesheetFolderTool;
+var get_user_data_by_id_default = GetUserDataByIdTool;
 
-// src/umb-management-api/tools/stylesheet/items/get/get-ancestors.ts
-var GetStylesheetAncestorsTool = CreateUmbracoTool(
-  "get-stylesheet-ancestors",
-  "Gets the ancestors of a stylesheet in the tree structure",
-  getTreeStylesheetAncestorsQueryParams.shape,
-  async (model) => {
+// src/umb-management-api/tools/user-data/index.ts
+var UserDataCollection = {
+  metadata: {
+    name: "user-data",
+    displayName: "User Data",
+    description: "Personal key-value storage for authenticated users - manage preferences, settings, and application state",
+    dependencies: []
+  },
+  tools: (user) => {
+    const tools = [];
+    tools.push(create_user_data_default());
+    tools.push(update_user_data_default());
+    tools.push(get_user_data_default());
+    tools.push(get_user_data_by_id_default());
+    return tools;
+  }
+};
+
+// src/umb-management-api/tools/static-file/items/get/get-static-files.ts
+var GetStaticFilesTool = CreateUmbracoTool(
+  "get-static-files",
+  "Lists static files with optional path filtering for browsing the file system",
+  getItemStaticFileQueryParams.shape,
+  async (params) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.getTreeStylesheetAncestors(model);
+    const response = await client.getItemStaticFile(params);
     return {
       content: [
         {
@@ -21114,16 +23202,16 @@ var GetStylesheetAncestorsTool = CreateUmbracoTool(
     };
   }
 );
-var get_ancestors_default10 = GetStylesheetAncestorsTool;
+var get_static_files_default = GetStaticFilesTool;
 
-// src/umb-management-api/tools/stylesheet/items/get/get-children.ts
-var GetStylesheetChildrenTool = CreateUmbracoTool(
-  "get-stylesheet-children",
-  "Gets the children of a stylesheet in the tree structure",
-  getTreeStylesheetChildrenQueryParams.shape,
-  async (model) => {
+// src/umb-management-api/tools/static-file/items/get/get-root.ts
+var GetStaticFileRootTool = CreateUmbracoTool(
+  "get-static-file-root",
+  "Gets root-level static files and folders in the Umbraco file system",
+  getTreeStaticFileRootQueryParams.shape,
+  async (params) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.getTreeStylesheetChildren(model);
+    const response = await client.getTreeStaticFileRoot(params);
     return {
       content: [
         {
@@ -21134,16 +23222,16 @@ var GetStylesheetChildrenTool = CreateUmbracoTool(
     };
   }
 );
-var get_children_default10 = GetStylesheetChildrenTool;
+var get_root_default13 = GetStaticFileRootTool;
 
-// src/umb-management-api/tools/stylesheet/items/get/get-root.ts
-var GetStylesheetRootTool = CreateUmbracoTool(
-  "get-stylesheet-root",
-  "Gets the root stylesheets in the tree structure",
-  getTreeStylesheetRootQueryParams.shape,
-  async (model) => {
+// src/umb-management-api/tools/static-file/items/get/get-children.ts
+var GetStaticFileChildrenTool = CreateUmbracoTool(
+  "get-static-file-children",
+  "Lists child files and folders in a static file directory by parent path",
+  getTreeStaticFileChildrenQueryParams.shape,
+  async (params) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.getTreeStylesheetRoot(model);
+    const response = await client.getTreeStaticFileChildren(params);
     return {
       content: [
         {
@@ -21154,16 +23242,16 @@ var GetStylesheetRootTool = CreateUmbracoTool(
     };
   }
 );
-var get_root_default12 = GetStylesheetRootTool;
+var get_children_default11 = GetStaticFileChildrenTool;
 
-// src/umb-management-api/tools/stylesheet/items/get/get-search.ts
-var GetStylesheetSearchTool = CreateUmbracoTool(
-  "get-stylesheet-search",
-  "Searches for stylesheets by name or path",
-  getItemStylesheetQueryParams.shape,
-  async (model) => {
+// src/umb-management-api/tools/static-file/items/get/get-ancestors.ts
+var GetStaticFileAncestorsTool = CreateUmbracoTool(
+  "get-static-file-ancestors",
+  "Gets ancestor folders for navigation breadcrumbs by descendant path",
+  getTreeStaticFileAncestorsQueryParams.shape,
+  async (params) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.getItemStylesheet(model);
+    const response = await client.getTreeStaticFileAncestors(params);
     return {
       content: [
         {
@@ -21174,31 +23262,22 @@ var GetStylesheetSearchTool = CreateUmbracoTool(
     };
   }
 );
-var get_search_default4 = GetStylesheetSearchTool;
+var get_ancestors_default11 = GetStaticFileAncestorsTool;
 
-// src/umb-management-api/tools/stylesheet/index.ts
-var StylesheetCollection = {
+// src/umb-management-api/tools/static-file/index.ts
+var StaticFileCollection = {
   metadata: {
-    name: "stylesheet",
-    displayName: "Stylesheets",
-    description: "CSS stylesheet file management",
+    name: "static-file",
+    displayName: "Static Files",
+    description: "Read-only access to static files and folders in the Umbraco file system",
     dependencies: []
   },
   tools: (user) => {
-    const tools = [get_search_default4()];
-    if (AuthorizationPolicies.TreeAccessStylesheets(user)) {
-      tools.push(create_stylesheet_default());
-      tools.push(create_stylesheet_folder_default());
-      tools.push(get_stylesheet_by_path_default());
-      tools.push(get_stylesheet_folder_by_path_default());
-      tools.push(update_stylesheet_default());
-      tools.push(rename_stylesheet_default());
-      tools.push(delete_stylesheet_default());
-      tools.push(delete_stylesheet_folder_default());
-      tools.push(get_ancestors_default10());
-      tools.push(get_children_default10());
-      tools.push(get_root_default12());
-    }
+    const tools = [];
+    tools.push(get_static_files_default());
+    tools.push(get_root_default13());
+    tools.push(get_children_default11());
+    tools.push(get_ancestors_default11());
     return tools;
   }
 };
@@ -21213,12 +23292,12 @@ var DEFAULT_COLLECTION_CONFIG = {
 
 // src/helpers/config/collection-config-loader.ts
 var CollectionConfigLoader = class {
-  static loadFromEnv() {
+  static loadFromConfig(config) {
     return {
-      enabledCollections: _nullishCoalesce(env_default.UMBRACO_INCLUDE_TOOL_COLLECTIONS, () => ( DEFAULT_COLLECTION_CONFIG.enabledCollections)),
-      disabledCollections: _nullishCoalesce(env_default.UMBRACO_EXCLUDE_TOOL_COLLECTIONS, () => ( DEFAULT_COLLECTION_CONFIG.disabledCollections)),
-      enabledTools: _nullishCoalesce(env_default.UMBRACO_INCLUDE_TOOLS, () => ( DEFAULT_COLLECTION_CONFIG.enabledTools)),
-      disabledTools: _nullishCoalesce(env_default.UMBRACO_EXCLUDE_TOOLS, () => ( DEFAULT_COLLECTION_CONFIG.disabledTools))
+      enabledCollections: _nullishCoalesce(config.includeToolCollections, () => ( DEFAULT_COLLECTION_CONFIG.enabledCollections)),
+      disabledCollections: _nullishCoalesce(config.excludeToolCollections, () => ( DEFAULT_COLLECTION_CONFIG.disabledCollections)),
+      enabledTools: _nullishCoalesce(config.includeTools, () => ( DEFAULT_COLLECTION_CONFIG.enabledTools)),
+      disabledTools: _nullishCoalesce(config.excludeTools, () => ( DEFAULT_COLLECTION_CONFIG.disabledTools))
     };
   }
 };
@@ -21248,14 +23327,26 @@ var availableCollections = [
   UserGroupCollection,
   TemporaryFileCollection,
   ScriptCollection,
-  StylesheetCollection
+  StylesheetCollection,
+  HealthCollection,
+  ManifestCollection,
+  TagCollection,
+  ModelsBuilderCollection,
+  SearcherCollection,
+  IndexerCollection,
+  ImagingCollection,
+  RelationTypeCollection,
+  RelationCollection,
+  UserCollection,
+  UserDataCollection,
+  StaticFileCollection
 ];
-var mapTools = (server, user, tools) => {
+var mapTools = (server, user, tools, config) => {
   return tools.forEach((tool) => {
     const userHasPermission = tool.enabled === void 0 || tool.enabled(user);
     if (!userHasPermission) return;
-    if (_optionalChain([env_default, 'access', _72 => _72.UMBRACO_EXCLUDE_TOOLS, 'optionalAccess', _73 => _73.includes, 'call', _74 => _74(tool.name)])) return;
-    if (_optionalChain([env_default, 'access', _75 => _75.UMBRACO_INCLUDE_TOOLS, 'optionalAccess', _76 => _76.length]) && !env_default.UMBRACO_INCLUDE_TOOLS.includes(tool.name)) return;
+    if (_optionalChain([config, 'access', _66 => _66.disabledTools, 'optionalAccess', _67 => _67.includes, 'call', _68 => _68(tool.name)])) return;
+    if (_optionalChain([config, 'access', _69 => _69.enabledTools, 'optionalAccess', _70 => _70.length]) && !config.enabledTools.includes(tool.name)) return;
     server.tool(tool.name, tool.description, tool.schema, tool.handler);
   });
 };
@@ -21276,7 +23367,7 @@ function resolveDependencies(requestedNames, collections) {
   const collectionMap = new Map(collections.map((c) => [c.metadata.name, c]));
   function addDependencies(collectionName) {
     const collection = collectionMap.get(collectionName);
-    if (_optionalChain([collection, 'optionalAccess', _77 => _77.metadata, 'access', _78 => _78.dependencies])) {
+    if (_optionalChain([collection, 'optionalAccess', _71 => _71.metadata, 'access', _72 => _72.dependencies])) {
       collection.metadata.dependencies.forEach((dep) => {
         if (!result.has(dep)) {
           result.add(dep);
@@ -21302,13 +23393,13 @@ function getEnabledCollections(config) {
     (collection) => enabledWithDependencies.includes(collection.metadata.name)
   );
 }
-function UmbracoToolFactory(server, user) {
-  const config = CollectionConfigLoader.loadFromEnv();
+function UmbracoToolFactory(server, user, serverConfig) {
+  const config = CollectionConfigLoader.loadFromConfig(serverConfig);
   validateConfiguration(config, availableCollections);
   const enabledCollections = getEnabledCollections(config);
   enabledCollections.forEach((collection) => {
     const tools = collection.tools(user);
-    mapTools(server, user, tools);
+    mapTools(server, user, tools, config);
   });
 }
 
@@ -21354,7 +23445,7 @@ var GetDataTypeAncestorsResource = CreateUmbracoTemplateResource(
     }
   }
 );
-var get_ancestors_default11 = GetDataTypeAncestorsResource;
+var get_ancestors_default12 = GetDataTypeAncestorsResource;
 
 // src/umb-management-api/resources/data-types/get/get-children.ts
 var GetDataTypeChildrenResource = CreateUmbracoTemplateResource(
@@ -21405,7 +23496,7 @@ var GetDataTypeChildrenResource = CreateUmbracoTemplateResource(
     }
   }
 );
-var get_children_default11 = GetDataTypeChildrenResource;
+var get_children_default12 = GetDataTypeChildrenResource;
 
 // src/umb-management-api/resources/data-types/get/get-folder.ts
 var GetDataTypeFolderResource = CreateUmbracoTemplateResource(
@@ -21607,7 +23698,7 @@ var GetDataTypeRootResource = CreateUmbracoTemplateResource(
     }
   }
 );
-var get_root_default13 = GetDataTypeRootResource;
+var get_root_default14 = GetDataTypeRootResource;
 
 // src/umb-management-api/resources/data-types/get/get-search.ts
 var GetDataTypeSearchResource = CreateUmbracoTemplateResource(
@@ -21661,13 +23752,13 @@ var get_search_default5 = GetDataTypeSearchResource;
 
 // src/umb-management-api/resources/data-types/index.ts
 var DataTypeTemplateResources = [
-  get_ancestors_default11,
-  get_children_default11,
+  get_ancestors_default12,
+  get_children_default12,
   get_folder_default4,
   get_is_used_default,
   get_query_default,
   get_references_default,
-  get_root_default13,
+  get_root_default14,
   get_search_default5
 ];
 
@@ -21720,13 +23811,197 @@ function ResourceFactory(server) {
   );
 }
 
+// src/config.ts
+var _dotenv = require('dotenv');
+var _yargs = require('yargs'); var _yargs2 = _interopRequireDefault(_yargs);
+var _helpers = require('yargs/helpers');
+
+function maskSecret(secret) {
+  if (!secret || secret.length <= 4) return "****";
+  return `****${secret.slice(-4)}`;
+}
+function getServerConfig(isStdioMode) {
+  const argv = _yargs2.default.call(void 0, _helpers.hideBin.call(void 0, process.argv)).options({
+    "umbraco-client-id": {
+      type: "string",
+      description: "Umbraco API client ID"
+    },
+    "umbraco-client-secret": {
+      type: "string",
+      description: "Umbraco API client secret"
+    },
+    "umbraco-base-url": {
+      type: "string",
+      description: "Umbraco base URL (e.g., https://localhost:44391)"
+    },
+    "umbraco-include-tool-collections": {
+      type: "string",
+      description: "Comma-separated list of tool collections to include"
+    },
+    "umbraco-exclude-tool-collections": {
+      type: "string",
+      description: "Comma-separated list of tool collections to exclude"
+    },
+    "umbraco-include-tools": {
+      type: "string",
+      description: "Comma-separated list of tools to include"
+    },
+    "umbraco-exclude-tools": {
+      type: "string",
+      description: "Comma-separated list of tools to exclude"
+    },
+    env: {
+      type: "string",
+      description: "Path to custom .env file to load environment variables from"
+    }
+  }).help().version(_nullishCoalesce(process.env.NPM_PACKAGE_VERSION, () => ( "unknown"))).parseSync();
+  let envFilePath;
+  let envFileSource;
+  if (argv["env"]) {
+    envFilePath = _path.resolve.call(void 0, argv["env"]);
+    envFileSource = "cli";
+  } else {
+    envFilePath = _path.resolve.call(void 0, process.cwd(), ".env");
+    envFileSource = "default";
+  }
+  _dotenv.config.call(void 0, { path: envFilePath, override: true });
+  const auth = {
+    clientId: "",
+    clientSecret: "",
+    baseUrl: ""
+  };
+  const config = {
+    includeToolCollections: void 0,
+    excludeToolCollections: void 0,
+    includeTools: void 0,
+    excludeTools: void 0,
+    configSources: {
+      clientId: "env",
+      clientSecret: "env",
+      baseUrl: "env",
+      includeToolCollections: "none",
+      excludeToolCollections: "none",
+      includeTools: "none",
+      excludeTools: "none",
+      envFile: envFileSource
+    }
+  };
+  if (argv["umbraco-client-id"]) {
+    auth.clientId = argv["umbraco-client-id"];
+    config.configSources.clientId = "cli";
+  } else if (process.env.UMBRACO_CLIENT_ID) {
+    auth.clientId = process.env.UMBRACO_CLIENT_ID;
+    config.configSources.clientId = "env";
+  }
+  if (argv["umbraco-client-secret"]) {
+    auth.clientSecret = argv["umbraco-client-secret"];
+    config.configSources.clientSecret = "cli";
+  } else if (process.env.UMBRACO_CLIENT_SECRET) {
+    auth.clientSecret = process.env.UMBRACO_CLIENT_SECRET;
+    config.configSources.clientSecret = "env";
+  }
+  if (argv["umbraco-base-url"]) {
+    auth.baseUrl = argv["umbraco-base-url"];
+    config.configSources.baseUrl = "cli";
+  } else if (process.env.UMBRACO_BASE_URL) {
+    auth.baseUrl = process.env.UMBRACO_BASE_URL;
+    config.configSources.baseUrl = "env";
+  }
+  if (argv["umbraco-include-tool-collections"]) {
+    config.includeToolCollections = argv["umbraco-include-tool-collections"].split(",").map((c) => c.trim()).filter(Boolean);
+    config.configSources.includeToolCollections = "cli";
+  } else if (process.env.UMBRACO_INCLUDE_TOOL_COLLECTIONS) {
+    config.includeToolCollections = process.env.UMBRACO_INCLUDE_TOOL_COLLECTIONS.split(",").map((c) => c.trim()).filter(Boolean);
+    config.configSources.includeToolCollections = "env";
+  }
+  if (argv["umbraco-exclude-tool-collections"]) {
+    config.excludeToolCollections = argv["umbraco-exclude-tool-collections"].split(",").map((c) => c.trim()).filter(Boolean);
+    config.configSources.excludeToolCollections = "cli";
+  } else if (process.env.UMBRACO_EXCLUDE_TOOL_COLLECTIONS) {
+    config.excludeToolCollections = process.env.UMBRACO_EXCLUDE_TOOL_COLLECTIONS.split(",").map((c) => c.trim()).filter(Boolean);
+    config.configSources.excludeToolCollections = "env";
+  }
+  if (argv["umbraco-include-tools"]) {
+    config.includeTools = argv["umbraco-include-tools"].split(",").map((t) => t.trim()).filter(Boolean);
+    config.configSources.includeTools = "cli";
+  } else if (process.env.UMBRACO_INCLUDE_TOOLS) {
+    config.includeTools = process.env.UMBRACO_INCLUDE_TOOLS.split(",").map((t) => t.trim()).filter(Boolean);
+    config.configSources.includeTools = "env";
+  }
+  if (argv["umbraco-exclude-tools"]) {
+    config.excludeTools = argv["umbraco-exclude-tools"].split(",").map((t) => t.trim()).filter(Boolean);
+    config.configSources.excludeTools = "cli";
+  } else if (process.env.UMBRACO_EXCLUDE_TOOLS) {
+    config.excludeTools = process.env.UMBRACO_EXCLUDE_TOOLS.split(",").map((t) => t.trim()).filter(Boolean);
+    config.configSources.excludeTools = "env";
+  }
+  if (!auth.clientId) {
+    console.error(
+      "UMBRACO_CLIENT_ID is required (via CLI argument --umbraco-client-id or .env file)"
+    );
+    process.exit(1);
+  }
+  if (!auth.clientSecret) {
+    console.error(
+      "UMBRACO_CLIENT_SECRET is required (via CLI argument --umbraco-client-secret or .env file)"
+    );
+    process.exit(1);
+  }
+  if (!auth.baseUrl) {
+    console.error(
+      "UMBRACO_BASE_URL is required (via CLI argument --umbraco-base-url or .env file)"
+    );
+    process.exit(1);
+  }
+  if (!isStdioMode) {
+    console.log("\nUmbraco MCP Configuration:");
+    console.log(`- ENV_FILE: ${envFilePath} (source: ${config.configSources.envFile})`);
+    console.log(
+      `- UMBRACO_CLIENT_ID: ${auth.clientId} (source: ${config.configSources.clientId})`
+    );
+    console.log(
+      `- UMBRACO_CLIENT_SECRET: ${maskSecret(auth.clientSecret)} (source: ${config.configSources.clientSecret})`
+    );
+    console.log(
+      `- UMBRACO_BASE_URL: ${auth.baseUrl} (source: ${config.configSources.baseUrl})`
+    );
+    if (config.includeToolCollections) {
+      console.log(
+        `- UMBRACO_INCLUDE_TOOL_COLLECTIONS: ${config.includeToolCollections.join(", ")} (source: ${config.configSources.includeToolCollections})`
+      );
+    }
+    if (config.excludeToolCollections) {
+      console.log(
+        `- UMBRACO_EXCLUDE_TOOL_COLLECTIONS: ${config.excludeToolCollections.join(", ")} (source: ${config.configSources.excludeToolCollections})`
+      );
+    }
+    if (config.includeTools) {
+      console.log(
+        `- UMBRACO_INCLUDE_TOOLS: ${config.includeTools.join(", ")} (source: ${config.configSources.includeTools})`
+      );
+    }
+    if (config.excludeTools) {
+      console.log(
+        `- UMBRACO_EXCLUDE_TOOLS: ${config.excludeTools.join(", ")} (source: ${config.configSources.excludeTools})`
+      );
+    }
+    console.log();
+  }
+  return {
+    ...config,
+    auth
+  };
+}
+
 // src/index.ts
 var main = async () => {
+  const config = getServerConfig(true);
+  initializeUmbracoAxios(config.auth);
   const server = UmbracoMcpServer.GetServer();
   const client = UmbracoManagementClient2.getClient();
   const user = await client.getUserCurrent();
   ResourceFactory(server);
-  UmbracoToolFactory(server, user);
+  UmbracoToolFactory(server, user, config);
   const transport = new StdioServerTransport();
   await server.connect(transport);
 };