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

package/dist/index.js

@@ -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);
         }
@@ -3238,44 +3238,32 @@ import Axios2 from "axios";
 // src/orval/client/umbraco-axios.ts
 import qs from "qs";
 import Axios from "axios";
-
-// src/helpers/config/env.ts
-import { z as z3 } from "zod";
-var envSchema = z3.object({
-  UMBRACO_CLIENT_ID: z3.string(),
-  UMBRACO_CLIENT_SECRET: z3.string(),
-  UMBRACO_BASE_URL: z3.string().url(),
-  UMBRACO_EXCLUDE_TOOLS: z3.string().optional().transform((val) => val?.split(",").map((tool) => tool.trim())).pipe(z3.array(z3.string()).optional()),
-  UMBRACO_INCLUDE_TOOLS: z3.string().optional().transform((val) => val?.split(",").map((tool) => tool.trim()).filter(Boolean)).pipe(z3.array(z3.string()).optional()),
-  // Collection-level filtering
-  UMBRACO_INCLUDE_TOOL_COLLECTIONS: z3.string().optional().transform((val) => val?.split(",").map((collection) => collection.trim()).filter(Boolean)).pipe(z3.array(z3.string()).optional()),
-  UMBRACO_EXCLUDE_TOOL_COLLECTIONS: z3.string().optional().transform((val) => val?.split(",").map((collection) => collection.trim()).filter(Boolean)).pipe(z3.array(z3.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 = Axios.create({ baseURL });
+var UmbracoAxios = Axios.create();
 var accessToken = null;
 var tokenExpiry = null;
 var fetchAccessToken = async () => {
+  if (!authConfig) {
+    throw new Error("UmbracoAxios not initialized. Call initializeUmbracoAxios first.");
+  }
   const response = await Axios.post(
-    `${baseURL}${tokenPath}`,
+    `${authConfig.baseUrl}${tokenPath}`,
     {
-      client_id,
-      client_secret: client_secret ?? "",
+      client_id: authConfig.clientId,
+      client_secret: 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
@@ -13633,14 +13621,34 @@ 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
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 var UpdateDataTypeTool = CreateUmbracoTool(
   "update-data-type",
   "Updates a data type by Id",
   {
     id: putDataTypeByIdParams.shape.id,
-    data: z4.object(putDataTypeByIdBody.shape)
+    data: z3.object(putDataTypeByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -13658,13 +13666,13 @@ var UpdateDataTypeTool = CreateUmbracoTool(
 var update_data_type_default = UpdateDataTypeTool;
 
 // src/umb-management-api/tools/data-type/post/copy-data-type.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 var CopyDataTypeTool = CreateUmbracoTool(
   "copy-data-type",
   "Copy a data type by Id",
   {
     id: postDataTypeByIdCopyParams.shape.id,
-    body: z5.object(postDataTypeByIdCopyBody.shape)
+    body: z4.object(postDataTypeByIdCopyBody.shape)
   },
   async ({ id, body }) => {
     const client = UmbracoManagementClient2.getClient();
@@ -13702,13 +13710,13 @@ var IsUsedDataTypeTool = CreateUmbracoTool(
 var is_used_data_type_default = IsUsedDataTypeTool;
 
 // src/umb-management-api/tools/data-type/put/move-data-type.ts
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
 var MoveDataTypeTool = CreateUmbracoTool(
   "move-data-type",
   "Move a data type by Id",
   {
     id: putDataTypeByIdMoveParams.shape.id,
-    body: z6.object(putDataTypeByIdMoveBody.shape)
+    body: z5.object(putDataTypeByIdMoveBody.shape)
   },
   async ({ id, body }) => {
     const client = UmbracoManagementClient2.getClient();
@@ -13837,13 +13845,13 @@ var GetDataTypeSearchTool = CreateUmbracoTool(
 var get_search_default = GetDataTypeSearchTool;
 
 // src/umb-management-api/tools/data-type/folders/put/update-folder.ts
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 var UpdateDataTypeFolderTool = CreateUmbracoTool(
   "update-data-type-folder",
   "Updates a data type folder by Id",
   {
     id: putDataTypeFolderByIdParams.shape.id,
-    data: z7.object(putDataTypeFolderByIdBody.shape)
+    data: z6.object(putDataTypeFolderByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -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());
@@ -14130,13 +14139,13 @@ var CreateDictionaryItemTool = CreateUmbracoTool(
 var create_dictionary_item_default = CreateDictionaryItemTool;
 
 // src/umb-management-api/tools/dictionary/put/update-dictionary-item.ts
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 var UpdateDictionaryItemTool = CreateUmbracoTool(
   "update-dictionary-item",
   "Updates a dictionary item by Id",
   {
     id: putDictionaryByIdParams.shape.id,
-    data: z8.object(putDictionaryByIdBody.shape)
+    data: z7.object(putDictionaryByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -14154,13 +14163,13 @@ var UpdateDictionaryItemTool = CreateUmbracoTool(
 var update_dictionary_item_default = UpdateDictionaryItemTool;
 
 // src/umb-management-api/tools/dictionary/put/move-dictionary-item.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 var MoveDictionaryItemTool = CreateUmbracoTool(
   "move-dictionary-item",
   "Moves a dictionary item by Id",
   {
     id: putDictionaryByIdMoveParams.shape.id,
-    data: z9.object(putDictionaryByIdMoveBody.shape)
+    data: z8.object(putDictionaryByIdMoveBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -14265,18 +14274,18 @@ var DictionaryCollection = {
 };
 
 // src/umb-management-api/tools/document-type/post/create-document-type.ts
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 import { v4 as uuidv42 } from "uuid";
 
 // src/umb-management-api/tools/document-type/post/helpers/create-container-hierarchy.ts
 import { v4 as uuidv4 } from "uuid";
-import { z as z10 } from "zod";
-var propertySchema = z10.object({
-  name: z10.string().min(1, "Property name is required"),
-  alias: z10.string().min(1, "Property alias is required"),
-  dataTypeId: z10.string().uuid("Must be a valid UUID"),
-  tab: z10.string().optional(),
-  group: z10.string().optional()
+import { z as z9 } from "zod";
+var propertySchema = z9.object({
+  name: z9.string().min(1, "Property name is required"),
+  alias: z9.string().min(1, "Property alias is required"),
+  dataTypeId: z9.string().uuid("Must be a valid UUID"),
+  tab: z9.string().optional(),
+  group: z9.string().optional()
 });
 function createContainerHierarchy(properties) {
   const containerIds = /* @__PURE__ */ new Map();
@@ -14317,22 +14326,22 @@ function createContainerHierarchy(properties) {
 }
 
 // src/umb-management-api/tools/document-type/post/create-document-type.ts
-var createDocumentTypeSchema = z11.object({
-  name: z11.string().min(1, "Name is required"),
-  alias: z11.string().min(1, "Alias is required"),
-  description: z11.string().optional(),
-  icon: z11.string().min(1, "Icon is required"),
-  allowedAsRoot: z11.boolean().default(false),
-  compositions: z11.array(z11.string().uuid("Must be a valid document type UUID")).default([]),
-  allowedDocumentTypes: z11.array(z11.string().uuid("Must be a valid document type UUID")).default([]),
-  collection: z11.string().uuid("Must be a valid collection data type UUID").optional(),
-  properties: z11.array(
-    z11.object({
-      name: z11.string().min(1, "Property name is required"),
-      alias: z11.string().min(1, "Property alias is required"),
-      dataTypeId: z11.string().uuid("Must be a valid data type UUID"),
-      tab: z11.string().optional(),
-      group: z11.string().optional()
+var createDocumentTypeSchema = z10.object({
+  name: z10.string().min(1, "Name is required"),
+  alias: z10.string().min(1, "Alias is required"),
+  description: z10.string().optional(),
+  icon: z10.string().min(1, "Icon is required"),
+  allowedAsRoot: z10.boolean().default(false),
+  compositions: z10.array(z10.string().uuid("Must be a valid document type UUID")).default([]),
+  allowedDocumentTypes: z10.array(z10.string().uuid("Must be a valid document type UUID")).default([]),
+  collection: z10.string().uuid("Must be a valid collection data type UUID").optional(),
+  properties: z10.array(
+    z10.object({
+      name: z10.string().min(1, "Property name is required"),
+      alias: z10.string().min(1, "Property alias is required"),
+      dataTypeId: z10.string().uuid("Must be a valid data type UUID"),
+      tab: z10.string().optional(),
+      group: z10.string().optional()
     })
   ).default([])
 });
@@ -14469,13 +14478,13 @@ var GetDocumentTypeByIdTool = CreateUmbracoTool(
 var get_document_type_by_ids_default = GetDocumentTypeByIdTool;
 
 // src/umb-management-api/tools/document-type/put/update-document-type.ts
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 var UpdateDocumentTypeTool = CreateUmbracoTool(
   "update-document-type",
   "Updates a document type by Id",
   {
     id: putDocumentTypeByIdParams.shape.id,
-    data: z12.object(putDocumentTypeByIdBody.shape)
+    data: z11.object(putDocumentTypeByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -14493,13 +14502,13 @@ var UpdateDocumentTypeTool = CreateUmbracoTool(
 var update_document_type_default = UpdateDocumentTypeTool;
 
 // src/umb-management-api/tools/document-type/post/copy-document-type.ts
-import { z as z13 } from "zod";
+import { z as z12 } from "zod";
 var CopyDocumentTypeTool = CreateUmbracoTool(
   "copy-document-type",
   "Copy a document type to a new location",
   {
-    id: z13.string().uuid(),
-    data: z13.object(postDocumentTypeByIdCopyBody.shape)
+    id: z12.string().uuid(),
+    data: z12.object(postDocumentTypeByIdCopyBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -14520,13 +14529,13 @@ var CopyDocumentTypeTool = CreateUmbracoTool(
 var copy_document_type_default = CopyDocumentTypeTool;
 
 // src/umb-management-api/tools/document-type/put/move-document-type.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 var MoveDocumentTypeTool = CreateUmbracoTool(
   "move-document-type",
   "Move a document type to a new location",
   {
-    id: z14.string().uuid(),
-    data: z14.object(putDocumentTypeByIdMoveBody.shape)
+    id: z13.string().uuid(),
+    data: z13.object(putDocumentTypeByIdMoveBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -14664,13 +14673,13 @@ var GetDocumentTypeFolderTool = CreateUmbracoTool(
 var get_folder_default2 = GetDocumentTypeFolderTool;
 
 // src/umb-management-api/tools/document-type/folders/put/update-folder.ts
-import { z as z15 } from "zod";
+import { z as z14 } from "zod";
 var UpdateDocumentTypeFolderTool = CreateUmbracoTool(
   "update-document-type-folder",
   "Updates a document type folder by Id",
   {
     id: putDocumentTypeFolderByIdParams.shape.id,
-    data: z15.object(putDocumentTypeFolderByIdBody.shape)
+    data: z14.object(putDocumentTypeFolderByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -15343,21 +15352,21 @@ var GetIconsTool = CreateUmbracoTool(
 var get_icons_default = GetIconsTool;
 
 // src/umb-management-api/tools/document-type/post/create-element-type.ts
-import { z as z16 } from "zod";
+import { z as z15 } from "zod";
 import { v4 as uuidv43 } from "uuid";
-var createElementTypeSchema = z16.object({
-  name: z16.string().min(1, "Name is required"),
-  alias: z16.string().min(1, "Alias is required"),
-  description: z16.string().optional(),
-  icon: z16.string().min(1, "Icon is required"),
-  compositions: z16.array(z16.string().uuid("Must be a valid document type UUID")).default([]),
-  properties: z16.array(
-    z16.object({
-      name: z16.string().min(1, "Property name is required"),
-      alias: z16.string().min(1, "Property alias is required"),
-      dataTypeId: z16.string().uuid("Must be a valid data type UUID"),
-      tab: z16.string().optional(),
-      group: z16.string().optional()
+var createElementTypeSchema = z15.object({
+  name: z15.string().min(1, "Name is required"),
+  alias: z15.string().min(1, "Alias is required"),
+  description: z15.string().optional(),
+  icon: z15.string().min(1, "Icon is required"),
+  compositions: z15.array(z15.string().uuid("Must be a valid document type UUID")).default([]),
+  properties: z15.array(
+    z15.object({
+      name: z15.string().min(1, "Property name is required"),
+      alias: z15.string().min(1, "Property alias is required"),
+      dataTypeId: z15.string().uuid("Must be a valid data type UUID"),
+      tab: z15.string().optional(),
+      group: z15.string().optional()
     })
   ).default([])
 });
@@ -15622,13 +15631,13 @@ var CreateLanguageTool = CreateUmbracoTool(
 var create_language_default = CreateLanguageTool;
 
 // src/umb-management-api/tools/language/put/update-language.ts
-import { z as z17 } from "zod";
+import { z as z16 } from "zod";
 var UpdateLanguageTool = CreateUmbracoTool(
   "update-language",
   "Updates an existing language by ISO code",
   {
     isoCode: putLanguageByIsoCodeParams.shape.isoCode,
-    data: z17.object(putLanguageByIsoCodeBody.shape)
+    data: z16.object(putLanguageByIsoCodeBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -15734,13 +15743,13 @@ var DeleteDocumentBlueprintTool = CreateUmbracoTool(
 var delete_blueprint_default = DeleteDocumentBlueprintTool;
 
 // src/umb-management-api/tools/document-blueprint/put/update-blueprint.ts
-import { z as z18 } from "zod";
+import { z as z17 } from "zod";
 var UpdateDocumentBlueprintTool = CreateUmbracoTool(
   "update-document-blueprint",
   "Updates a document blueprint by Id",
   {
     id: putDocumentBlueprintByIdParams.shape.id,
-    data: z18.object(putDocumentBlueprintByIdBody.shape)
+    data: z17.object(putDocumentBlueprintByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -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;
   }
@@ -16025,13 +16079,13 @@ var GetDocumentPublicAccessTool = CreateUmbracoTool(
 var get_document_public_access_default = GetDocumentPublicAccessTool;
 
 // src/umb-management-api/tools/document/get/get-document-audit-log.ts
-import { z as z19 } from "zod";
+import { z as z18 } from "zod";
 var GetDocumentAuditLogTool = CreateUmbracoTool(
   "get-document-audit-log",
   "Fetches the audit log for a document by Id.",
   {
     id: getDocumentByIdAuditLogParams.shape.id,
-    data: z19.object(getDocumentByIdAuditLogQueryParams.shape)
+    data: z18.object(getDocumentByIdAuditLogQueryParams.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -16131,14 +16185,164 @@ var SearchDocumentTool = CreateUmbracoTool(
 );
 var search_document_default = SearchDocumentTool;
 
-// src/umb-management-api/tools/document/post/post-document-public-access.ts
+// src/umb-management-api/tools/document/get/get-collection-document-by-id.ts
+import { z as z19 } from "zod";
+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.`,
+  z19.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
 import { z as z20 } from "zod";
+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.`,
+  z20.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
+import { z as z21 } from "zod";
+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`,
+  z21.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
+import { z as z22 } from "zod";
 var PostDocumentPublicAccessTool = CreateUmbracoTool(
   "post-document-public-access",
   "Adds public access settings to a document by Id.",
   {
     id: postDocumentByIdPublicAccessParams.shape.id,
-    data: z20.object(postDocumentByIdPublicAccessBody.shape)
+    data: z22.object(postDocumentByIdPublicAccessBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -16181,7 +16385,13 @@ var ValidateDocumentTool = CreateUmbracoTool(
 var validate_document_default = ValidateDocumentTool;
 
 // src/umb-management-api/tools/document/post/copy-document.ts
-import { z as z21 } from "zod";
+import { z as z23 } from "zod";
+var copyDocumentSchema = z23.object({
+  parentId: z23.string().uuid("Must be a valid document UUID of the parent node").optional(),
+  idToCopy: z23.string().uuid("Must be a valid document UUID that belongs to the parent document's children"),
+  relateToOriginal: z23.boolean().describe("Relate the copy to the original document. This is usually set to false unless specified."),
+  includeDescendants: z23.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: z21.string().uuid(),
-    data: z21.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: [
         {
@@ -16224,24 +16438,28 @@ var copy_document_default = CopyDocumentTool;
 
 // src/umb-management-api/tools/document/post/create-document.ts
 import { v4 as uuidv44 } from "uuid";
-import { z as z22 } from "zod";
-var createDocumentSchema = z22.object({
-  documentTypeId: z22.string().uuid("Must be a valid document type type UUID"),
-  parentId: z22.string().uuid("Must be a valid document UUID").optional(),
-  name: z22.string(),
-  values: z22.array(
-    z22.object({
-      editorAlias: z22.string(),
-      culture: z22.string().nullable(),
-      segment: z22.string().nullable(),
-      alias: z22.string(),
-      value: z22.any()
+import { z as z24 } from "zod";
+var createDocumentSchema = z24.object({
+  documentTypeId: z24.string().uuid("Must be a valid document type type UUID"),
+  parentId: z24.string().uuid("Must be a valid document UUID").optional(),
+  name: z24.string(),
+  cultures: z24.array(z24.string()).optional().describe("Array of culture codes. If not provided or empty array, will create single variant with null culture."),
+  values: z24.array(
+    z24.object({
+      editorAlias: z24.string(),
+      culture: z24.string().nullable(),
+      segment: z24.string().nullable(),
+      alias: z24.string(),
+      value: z24.any()
     })
   ).default([])
 });
 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 = uuidv44();
+    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 {
@@ -16880,13 +17103,13 @@ var CreateDocumentTool = CreateUmbracoTool(
 var create_document_default = CreateDocumentTool;
 
 // src/umb-management-api/tools/document/put/put-document-public-access.ts
-import { z as z23 } from "zod";
+import { z as z25 } from "zod";
 var PutDocumentPublicAccessTool = CreateUmbracoTool(
   "put-document-public-access",
   "Updates public access settings for a document by Id.",
   {
     id: putDocumentByIdPublicAccessParams.shape.id,
-    data: z23.object(putDocumentByIdPublicAccessBody.shape)
+    data: z25.object(putDocumentByIdPublicAccessBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -16908,14 +17131,14 @@ var PutDocumentPublicAccessTool = CreateUmbracoTool(
 var put_document_public_access_default = PutDocumentPublicAccessTool;
 
 // src/umb-management-api/tools/document/put/put-document-domains.ts
-import { z as z24 } from "zod";
+import { z as z26 } from "zod";
 var PutDocumentDomainsTool = CreateUmbracoTool(
   "put-document-domains",
   `Updates the domains assigned to a document by Id. Default value of the defaultIsoCode is null. 
   Domain isoCode in the domains array should be in the format of 'en-US' amd be a valid domain name from the Umbraco instance.`,
   {
     id: putDocumentByIdDomainsParams.shape.id,
-    data: z24.object(putDocumentByIdDomainsBody.shape)
+    data: z26.object(putDocumentByIdDomainsBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -16934,13 +17157,13 @@ var PutDocumentDomainsTool = CreateUmbracoTool(
 var put_document_domains_default = PutDocumentDomainsTool;
 
 // src/umb-management-api/tools/document/put/put-document-notifications.ts
-import { z as z25 } from "zod";
+import { z as z27 } from "zod";
 var PutDocumentNotificationsTool = CreateUmbracoTool(
   "put-document-notifications",
   "Updates the notifications for a document by Id.",
   {
     id: putDocumentByIdNotificationsParams.shape.id,
-    data: z25.object(putDocumentByIdNotificationsBody.shape)
+    data: z27.object(putDocumentByIdNotificationsBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -16961,14 +17184,14 @@ var PutDocumentNotificationsTool = CreateUmbracoTool(
 var put_document_notifications_default = PutDocumentNotificationsTool;
 
 // src/umb-management-api/tools/document/put/publish-document-with-descendants.ts
-import { z as z26 } from "zod";
+import { z as z28 } from "zod";
 var PublishDocumentWithDescendantsTool = CreateUmbracoTool(
   "publish-document-with-descendants",
   `Publishes a document and its descendants by Id. This is an asynchronous operation that may take time for large document trees. 
   The tool will poll for completion and return the final result when finished.`,
   {
-    id: z26.string().uuid(),
-    data: z26.object(putDocumentByIdPublishWithDescendantsBody.shape)
+    id: z28.string().uuid(),
+    data: z28.object(putDocumentByIdPublishWithDescendantsBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -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,
@@ -17040,13 +17263,13 @@ var PublishDocumentWithDescendantsTool = CreateUmbracoTool(
 var publish_document_with_descendants_default = PublishDocumentWithDescendantsTool;
 
 // src/umb-management-api/tools/document/put/unpublish-document.ts
-import { z as z27 } from "zod";
+import { z as z29 } from "zod";
 var UnpublishDocumentTool = CreateUmbracoTool(
   "unpublish-document",
   "Unpublishes a document by Id.",
   {
-    id: z27.string().uuid(),
-    data: z27.object(putDocumentByIdUnpublishBody.shape)
+    id: z29.string().uuid(),
+    data: z29.object(putDocumentByIdUnpublishBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -17090,13 +17313,13 @@ var SortDocumentTool = CreateUmbracoTool(
 var sort_document_default = SortDocumentTool;
 
 // src/umb-management-api/tools/document/put/move-document.ts
-import { z as z28 } from "zod";
+import { z as z30 } from "zod";
 var MoveDocumentTool = CreateUmbracoTool(
   "move-document",
   "Move a document to a new location",
   {
-    id: z28.string().uuid(),
-    data: z28.object(putDocumentByIdMoveBody.shape)
+    id: z30.string().uuid(),
+    data: z30.object(putDocumentByIdMoveBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -17115,7 +17338,7 @@ var MoveDocumentTool = CreateUmbracoTool(
 var move_document_default = MoveDocumentTool;
 
 // src/umb-management-api/tools/document/put/publish-document.ts
-import { z as z29 } from "zod";
+import { z as z31 } from "zod";
 var PublishDocumentTool = CreateUmbracoTool(
   "publish-document",
   `Publishes a document by Id. IMPORTANT: If workflow approval is required, use the initiate-workflow-action function instead. 
@@ -17123,8 +17346,8 @@ var PublishDocumentTool = CreateUmbracoTool(
   When the culture is not provided, the default culture is null.
   When the schedule is not provided, the default schedule is null.`,
   {
-    id: z29.string().uuid(),
-    data: z29.object(putDocumentByIdPublishBody.shape)
+    id: z31.string().uuid(),
+    data: z31.object(putDocumentByIdPublishBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -17188,7 +17411,7 @@ var MoveDocumentToRecycleBinTool = CreateUmbracoTool(
 var move_to_recycle_bin_default = MoveDocumentToRecycleBinTool;
 
 // src/umb-management-api/tools/document/put/update-document.ts
-import { z as z30 } from "zod";
+import { z as z32 } from "zod";
 var UpdateDocumentTool = CreateUmbracoTool(
   "update-document",
   `Updates a document by Id
@@ -17196,7 +17419,7 @@ var UpdateDocumentTool = CreateUmbracoTool(
   Don't miss any properties from the original document that you are updating`,
   {
     id: putDocumentByIdParams.shape.id,
-    data: z30.object(putDocumentByIdBody.shape)
+    data: z32.object(putDocumentByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -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,57 +17700,386 @@ var DocumentVersionCollection = {
 };
 
 // src/umb-management-api/tools/media/post/create-media.ts
-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,
-  async (model) => {
-    const client = UmbracoManagementClient2.getClient();
-    const response = await client.postMedia(model);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(response)
-        }
-      ]
-    };
+import { z as z33 } from "zod";
+import { v4 as uuidv45 } from "uuid";
+
+// src/umb-management-api/tools/media/post/helpers/media-upload-helpers.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import axios from "axios";
+import mime from "mime-types";
+function getExtensionFromMimeType(mimeType) {
+  if (!mimeType) return void 0;
+  const baseMimeType = mimeType.split(";")[0].trim();
+  const extension = mime.extension(baseMimeType);
+  return extension ? `.${extension}` : void 0;
+}
+function validateMediaTypeForSvg(filePath, fileUrl, fileName, mediaTypeName) {
+  const isSvg = filePath?.toLowerCase().endsWith(".svg") || fileUrl?.toLowerCase().endsWith(".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)";
   }
-);
-var create_media_default = CreateMediaTool;
-
-// src/umb-management-api/tools/media/delete/delete-media.ts
-var DeleteMediaTool = CreateUmbracoTool(
-  "delete-media",
-  "Deletes a media item by Id",
-  deleteMediaByIdParams.shape,
-  async ({ id }) => {
-    const client = UmbracoManagementClient2.getClient();
-    const response = await client.deleteMediaById(id);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(response)
-        }
-      ]
+  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
+      }
     };
   }
-);
-var delete_media_default = DeleteMediaTool;
-
-// src/umb-management-api/tools/media/get/get-media-by-id.ts
-var GetMediaByIdTool = CreateUmbracoTool(
-  "get-media-by-id",
-  `Gets a media item by id
-  Use this to retrieve existing media items.`,
-  getMediaByIdParams.shape,
-  async ({ id }) => {
-    const client = UmbracoManagementClient2.getClient();
+  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 axios.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 = err.response?.data ? typeof err.response.data === "string" ? err.response.data : JSON.stringify(err.response.data) : err.message;
+      throw new Error(`Failed to upload temporary file: ${err.response?.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: ${err.response?.status || "Unknown error"} - ${JSON.stringify(err.response?.data) || err.message}`);
+    }
+    return params.name;
+  } finally {
+    cleanupTempFile(tempFilePath);
+  }
+}
+
+// src/umb-management-api/tools/media/post/create-media.ts
+var createMediaSchema = z33.object({
+  sourceType: z33.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: z33.string().describe("The name of the media item"),
+  mediaTypeName: z33.string().describe("Media type: 'Image', 'Article', 'Audio', 'Video', 'Vector Graphic (SVG)', 'File', or custom media type name"),
+  filePath: z33.string().optional().describe("Absolute path to the file (required if sourceType is 'filePath')"),
+  fileUrl: z33.string().url().optional().describe("URL to fetch the file from (required if sourceType is 'url')"),
+  fileAsBase64: z33.string().optional().describe("Base64 encoded file data (required if sourceType is 'base64')"),
+  parentId: z33.string().uuid().optional().describe("Parent folder ID (defaults to root)")
+});
+var CreateMediaTool = CreateUmbracoTool(
+  "create-media",
+  `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 = uuidv45();
+      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
+import { z as z34 } from "zod";
+import { v4 as uuidv46 } from "uuid";
+var createMediaMultipleSchema = z34.object({
+  sourceType: z34.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: z34.array(z34.object({
+    name: z34.string().describe("The name of the media item"),
+    filePath: z34.string().optional().describe("Absolute path to the file (required if sourceType is 'filePath')"),
+    fileUrl: z34.string().url().optional().describe("URL to fetch the file from (required if sourceType is 'url')"),
+    mediaTypeName: z34.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: z34.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();
+    for (const file of model.files) {
+      try {
+        const temporaryFileId = uuidv46();
+        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({
+            summary: `Processed ${model.files.length} files: ${successCount} succeeded, ${failureCount} failed`,
+            results
+          }, null, 2)
+        }
+      ]
+    };
+  }
+);
+var create_media_multiple_default = CreateMediaMultipleTool;
+
+// src/umb-management-api/tools/media/delete/delete-media.ts
+var DeleteMediaTool = CreateUmbracoTool(
+  "delete-media",
+  "Deletes a media item by Id",
+  deleteMediaByIdParams.shape,
+  async ({ id }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.deleteMediaById(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var delete_media_default = DeleteMediaTool;
+
+// src/umb-management-api/tools/media/get/get-media-by-id.ts
+var GetMediaByIdTool = CreateUmbracoTool(
+  "get-media-by-id",
+  `Gets a media item by id
+  Use this to retrieve existing media items.`,
+  getMediaByIdParams.shape,
+  async ({ id }) => {
+    const client = UmbracoManagementClient2.getClient();
     const response = await client.getMediaById(id);
     return {
       content: [
@@ -17536,7 +18094,7 @@ var GetMediaByIdTool = CreateUmbracoTool(
 var get_media_by_id_default = GetMediaByIdTool;
 
 // src/umb-management-api/tools/media/put/update-media.ts
-import { z as z31 } from "zod";
+import { z as z35 } from "zod";
 var UpdateMediaTool = CreateUmbracoTool(
   "update-media",
   `Updates a media item by Id
@@ -17545,7 +18103,7 @@ var UpdateMediaTool = CreateUmbracoTool(
   This cannot be used for moving media to a new folder. Use the move endpoint to do that`,
   {
     id: putMediaByIdParams.shape.id,
-    data: z31.object(putMediaByIdBody.shape)
+    data: z35.object(putMediaByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -17665,13 +18223,13 @@ var GetMediaByIdArrayTool = CreateUmbracoTool(
 var get_media_by_id_array_default = GetMediaByIdArrayTool;
 
 // src/umb-management-api/tools/media/put/move-media.ts
-import { z as z32 } from "zod";
+import { z as z36 } from "zod";
 var MoveMediaTool = CreateUmbracoTool(
   "move-media",
   "Move a media item to a new location",
   {
-    id: z32.string().uuid(),
-    data: z32.object(putMediaByIdMoveBody.shape)
+    id: z36.string().uuid(),
+    data: z36.object(putMediaByIdMoveBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -17749,13 +18307,13 @@ var GetMediaRootTool = CreateUmbracoTool(
 var get_root_default6 = GetMediaRootTool;
 
 // src/umb-management-api/tools/media/get/get-media-audit-log.ts
-import { z as z33 } from "zod";
+import { z as z37 } from "zod";
 var GetMediaAuditLogTool = CreateUmbracoTool(
   "get-media-audit-log",
   "Fetches the audit log for a media item by Id.",
   {
     id: getMediaByIdAuditLogParams.shape.id,
-    data: z33.object(getMediaByIdAuditLogQueryParams.shape)
+    data: z37.object(getMediaByIdAuditLogQueryParams.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -17894,6 +18452,153 @@ var DeleteFromRecycleBinTool2 = CreateUmbracoTool(
 );
 var delete_from_recycle_bin_default2 = DeleteFromRecycleBinTool2;
 
+// 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
+import { z as z38 } from "zod";
+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.`,
+  z38.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
+import { z as z39 } from "zod";
+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`,
+  z39.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: {
@@ -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;
   }
@@ -17973,12 +18685,12 @@ var GetMediaTypeByIdTool = CreateUmbracoTool(
 var get_media_type_by_id_default = GetMediaTypeByIdTool;
 
 // src/umb-management-api/tools/media-type/get/get-media-type-by-ids.ts
-import { z as z34 } from "zod";
+import { z as z40 } from "zod";
 var GetMediaTypeByIdsTool = CreateUmbracoTool(
   "get-media-type-by-ids",
   "Gets media types by ids",
   {
-    ids: z34.array(z34.string())
+    ids: z40.array(z40.string())
   },
   async ({ ids }) => {
     const client = UmbracoManagementClient2.getClient();
@@ -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",
@@ -18204,13 +18936,13 @@ var DeleteMediaTypeFolderTool = CreateUmbracoTool(
 var delete_folder_default3 = DeleteMediaTypeFolderTool;
 
 // src/umb-management-api/tools/media-type/folders/put/update-folder.ts
-import { z as z35 } from "zod";
+import { z as z41 } from "zod";
 var UpdateMediaTypeFolderTool = CreateUmbracoTool(
   "update-media-type-folder",
   "Updates a media type folder by Id",
   {
     id: putMediaTypeFolderByIdParams.shape.id,
-    data: z35.object(putMediaTypeFolderByIdBody.shape)
+    data: z41.object(putMediaTypeFolderByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -18248,13 +18980,13 @@ var CreateMediaTypeTool = CreateUmbracoTool(
 var create_media_type_default = CreateMediaTypeTool;
 
 // src/umb-management-api/tools/media-type/post/copy-media-type.ts
-import { z as z36 } from "zod";
+import { z as z42 } from "zod";
 var CopyMediaTypeTool = CreateUmbracoTool(
   "copy-media-type",
   "Copy a media type to a new location",
   {
-    id: z36.string().uuid(),
-    data: z36.object(postMediaTypeByIdCopyBody.shape)
+    id: z42.string().uuid(),
+    data: z42.object(postMediaTypeByIdCopyBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -18292,13 +19024,13 @@ var GetMediaTypeAvailableCompositionsTool = CreateUmbracoTool(
 var get_media_type_available_compositions_default = GetMediaTypeAvailableCompositionsTool;
 
 // src/umb-management-api/tools/media-type/put/update-media-type.ts
-import { z as z37 } from "zod";
+import { z as z43 } from "zod";
 var UpdateMediaTypeTool = CreateUmbracoTool(
   "update-media-type",
   "Updates a media type by Id",
   {
     id: putMediaTypeByIdParams.shape.id,
-    data: z37.object(putMediaTypeByIdBody.shape)
+    data: z43.object(putMediaTypeByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -18316,13 +19048,13 @@ var UpdateMediaTypeTool = CreateUmbracoTool(
 var update_media_type_default = UpdateMediaTypeTool;
 
 // src/umb-management-api/tools/media-type/put/move-media-type.ts
-import { z as z38 } from "zod";
+import { z as z44 } from "zod";
 var MoveMediaTypeTool = CreateUmbracoTool(
   "move-media-type",
   "Move a media type to a new location",
   {
-    id: z38.string().uuid(),
-    data: z38.object(putMediaTypeByIdMoveBody.shape)
+    id: z44.string().uuid(),
+    data: z44.object(putMediaTypeByIdMoveBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -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",
@@ -18459,13 +19213,13 @@ var DeleteMemberTool = CreateUmbracoTool(
 var delete_member_default = DeleteMemberTool;
 
 // src/umb-management-api/tools/member/put/update-member.ts
-import { z as z39 } from "zod";
+import { z as z45 } from "zod";
 var UpdateMemberTool = CreateUmbracoTool(
   "update-member",
   "Updates a member by Id",
   {
     id: putMemberByIdParams.shape.id,
-    data: z39.object(putMemberByIdBody.shape)
+    data: z45.object(putMemberByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -18482,14 +19236,19 @@ var UpdateMemberTool = CreateUmbracoTool(
 );
 var update_member_default = UpdateMemberTool;
 
-// src/umb-management-api/tools/member/get/find-member.ts
-var FindMemberTool = CreateUmbracoTool(
-  "find-member",
-  `Finds members by various filter criteria`,
-  getFilterMemberQueryParams.shape,
+// src/umb-management-api/tools/member/put/validate-member-update.ts
+import { z as z46 } from "zod";
+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: z46.object(putMemberByIdValidateBody.shape)
+  },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.getFilterMember(model);
+    const response = await client.putMemberByIdValidate(model.id, model.data);
     return {
       content: [
         {
@@ -18500,10 +19259,101 @@ var FindMemberTool = CreateUmbracoTool(
     };
   }
 );
-var find_member_default = FindMemberTool;
+var validate_member_update_default = ValidateMemberUpdateTool;
 
-// src/umb-management-api/tools/member/index.ts
-var MemberCollection = {
+// src/umb-management-api/tools/member/get/find-member.ts
+var FindMemberTool = CreateUmbracoTool(
+  "find-member",
+  `Finds members by various filter criteria`,
+  getFilterMemberQueryParams.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.getFilterMember(model);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+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
+import { z as z47 } from "zod";
+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.`,
+  z47.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
+import { z as z48 } from "zod";
+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.`,
+  z48.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: {
     name: "member",
     displayName: "Members",
@@ -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;
@@ -18605,13 +19460,13 @@ var CreateMemberGroupTool = CreateUmbracoTool(
 var create_member_group_default = CreateMemberGroupTool;
 
 // src/umb-management-api/tools/member-group/put/update-member-group.ts
-import { z as z40 } from "zod";
+import { z as z49 } from "zod";
 var UpdateMemberGroupTool = CreateUmbracoTool(
   "update-member-group",
   "Updates a member group by Id",
   {
     id: putMemberGroupByIdParams.shape.id,
-    data: z40.object(putMemberGroupByIdBody.shape)
+    data: z49.object(putMemberGroupByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -18753,13 +19608,13 @@ var DeleteMemberTypeTool = CreateUmbracoTool(
 var delete_member_type_default = DeleteMemberTypeTool;
 
 // src/umb-management-api/tools/member-type/put/update-member-type.ts
-import { z as z41 } from "zod";
+import { z as z50 } from "zod";
 var UpdateMemberTypeTool = CreateUmbracoTool(
   "update-member-type",
   "Updates a member type by id",
   {
     id: putMemberTypeByIdParams.shape.id,
-    data: z41.object(putMemberTypeByIdBody.shape)
+    data: z50.object(putMemberTypeByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -18777,12 +19632,12 @@ var UpdateMemberTypeTool = CreateUmbracoTool(
 var update_member_type_default = UpdateMemberTypeTool;
 
 // src/umb-management-api/tools/member-type/post/copy-member-type.ts
-import { z as z42 } from "zod";
+import { z as z51 } from "zod";
 var CopyMemberTypeTool = CreateUmbracoTool(
   "copy-member-type",
   "Copy a member type to a new location",
   {
-    id: z42.string().uuid()
+    id: z51.string().uuid()
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -19111,11 +19966,11 @@ var LogViewerCollection = {
 };
 
 // src/umb-management-api/tools/partial-view/post/create-partial-view.ts
-import z43 from "zod";
-var createPartialViewSchema = z43.object({
-  name: z43.string().min(1, "Name is required"),
-  path: z43.string().optional(),
-  content: z43.string().min(1, "Content is required")
+import z52 from "zod";
+var createPartialViewSchema = z52.object({
+  name: z52.string().min(1, "Name is required"),
+  path: z52.string().optional(),
+  content: z52.string().min(1, "Content is required")
 });
 var CreatePartialViewTool = CreateUmbracoTool(
   "create-partial-view",
@@ -19205,18 +20060,18 @@ var GetPartialViewFolderByPathTool = CreateUmbracoTool(
 var get_partial_view_folder_by_path_default = GetPartialViewFolderByPathTool;
 
 // src/umb-management-api/tools/partial-view/put/update-partial-view.ts
-import { z as z44 } from "zod";
+import { z as z53 } from "zod";
 var UpdatePartialViewTool = CreateUmbracoTool(
   "update-partial-view",
   "Updates a partial view",
-  z44.object({
+  z53.object({
     ...putPartialViewByPathParams.shape,
     ...putPartialViewByPathBody.shape
   }).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: [
         {
@@ -19230,18 +20085,18 @@ var UpdatePartialViewTool = CreateUmbracoTool(
 var update_partial_view_default = UpdatePartialViewTool;
 
 // src/umb-management-api/tools/partial-view/put/rename-partial-view.ts
-import { z as z45 } from "zod";
+import { z as z54 } from "zod";
 var RenamePartialViewTool = CreateUmbracoTool(
   "rename-partial-view",
   `Renames a partial view`,
-  z45.object({
+  z54.object({
     ...putPartialViewByPathRenameParams.shape,
     ...putPartialViewByPathRenameBody.shape
   }).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",
@@ -19542,13 +20418,13 @@ var GetTemplatesByIdArrayTool = CreateUmbracoTool(
 var get_template_by_id_array_default = GetTemplatesByIdArrayTool;
 
 // src/umb-management-api/tools/template/put/update-template.ts
-import { z as z46 } from "zod";
+import { z as z55 } from "zod";
 var UpdateTemplateTool = CreateUmbracoTool(
   "update-template",
   "Updates a template by Id",
   {
     id: putTemplateByIdParams.shape.id,
-    data: z46.object(putTemplateByIdBody.shape)
+    data: z55.object(putTemplateByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -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",
@@ -19801,13 +20699,13 @@ var DeleteWebhookTool = CreateUmbracoTool(
 var delete_webhook_default = DeleteWebhookTool;
 
 // src/umb-management-api/tools/webhook/put/update-webhook.ts
-import { z as z47 } from "zod";
+import { z as z56 } from "zod";
 var UpdateWebhookTool = CreateUmbracoTool(
   "update-webhook",
   "Updates a webhook by id",
   {
     id: putWebhookByIdParams.shape.id,
-    data: z47.object(putWebhookByIdBody.shape)
+    data: z56.object(putWebhookByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -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;
   }
 };
 
@@ -20404,13 +21305,13 @@ var CreateUserGroupTool = CreateUmbracoTool(
 var create_user_group_default = CreateUserGroupTool;
 
 // src/umb-management-api/tools/user-group/put/update-user-group.ts
-import { z as z48 } from "zod";
+import { z as z57 } from "zod";
 var UpdateUserGroupTool = CreateUmbracoTool(
   "update-user-group",
   "Updates a user group by Id",
   {
     id: putUserGroupByIdParams.shape.id,
-    data: z48.object(putUserGroupByIdBody.shape)
+    data: z57.object(putUserGroupByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -20491,6 +21392,69 @@ var UserGroupCollection = {
   }
 };
 
+// src/umb-management-api/tools/temporary-file/post/create-temporary-file.ts
+import { z as z58 } from "zod";
+import * as fs2 from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+var createTemporaryFileSchema = z58.object({
+  id: z58.string().uuid().describe("Unique identifier for the temporary file"),
+  fileName: z58.string().describe("Name of the file"),
+  fileAsBase64: z58.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
 import { ReadStream } from "fs";
 import { z as zod2 } from "zod";
@@ -20516,32 +21480,6 @@ var getTemporaryFileConfigurationResponse = zod2.object({
   maxFileSize: zod2.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) => {
-    const client = UmbracoManagementClient2.getClient();
-    await client.postTemporaryFile(model);
-    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",
@@ -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: [
         {
@@ -20747,11 +21685,11 @@ var GetScriptTreeRootTool = CreateUmbracoTool(
 var get_script_tree_root_default = GetScriptTreeRootTool;
 
 // src/umb-management-api/tools/script/post/create-script.ts
-import z49 from "zod";
-var createScriptSchema = z49.object({
-  name: z49.string().min(1, "Name is required"),
-  path: z49.string().optional(),
-  content: z49.string().min(1, "Content is required")
+import z59 from "zod";
+var createScriptSchema = z59.object({
+  name: z59.string().min(1, "Name is required"),
+  path: z59.string().optional(),
+  content: z59.string().min(1, "Content is required")
 });
 var CreateScriptTool = CreateUmbracoTool(
   "create-script",
@@ -20800,13 +21738,13 @@ var CreateScriptFolderTool = CreateUmbracoTool(
 var create_script_folder_default = CreateScriptFolderTool;
 
 // src/umb-management-api/tools/script/put/update-script.ts
-import { z as z50 } from "zod";
+import { z as z60 } from "zod";
 var UpdateScriptTool = CreateUmbracoTool(
   "update-script",
   "Updates a script by path",
   {
     path: putScriptByPathParams.shape.path,
-    data: z50.object(putScriptByPathBody.shape)
+    data: z60.object(putScriptByPathBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -20824,11 +21762,11 @@ var UpdateScriptTool = CreateUmbracoTool(
 var update_script_default = UpdateScriptTool;
 
 // src/umb-management-api/tools/script/put/rename-script.ts
-import { z as z51 } from "zod";
-var renameScriptSchema = z51.object({
-  name: z51.string().min(1, "Current script name is required"),
-  folderPath: z51.string().optional().describe("Path to the folder containing the script (optional, leave empty for root)"),
-  newName: z51.string().min(1, "New script name is required")
+import { z as z61 } from "zod";
+var renameScriptSchema = z61.object({
+  name: z61.string().min(1, "Current script name is required"),
+  folderPath: z61.string().optional().describe("Path to the folder containing the script (optional, leave empty for root)"),
+  newName: z61.string().min(1, "New script name is required")
 });
 var RenameScriptTool = CreateUmbracoTool(
   "rename-script",
@@ -20862,9 +21800,9 @@ var DeleteScriptTool = CreateUmbracoTool(
   "delete-script",
   "Deletes a script by path",
   deleteScriptByPathParams.shape,
-  async ({ path }) => {
+  async ({ path: path3 }) => {
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.deleteScriptByPath(path);
+    const response = await client.deleteScriptByPath(path3);
     return {
       content: [
         {
@@ -20882,9 +21820,9 @@ var DeleteScriptFolderTool = CreateUmbracoTool(
   "delete-script-folder",
   "Deletes a script folder by path",
   deleteScriptFolderByPathParams.shape,
-  async ({ path }) => {
+  async ({ path: path3 }) => {
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.deleteScriptFolderByPath(path);
+    const response = await client.deleteScriptFolderByPath(path3);
     return {
       content: [
         {
@@ -21006,18 +21944,18 @@ var GetStylesheetFolderByPathTool = CreateUmbracoTool(
 var get_stylesheet_folder_by_path_default = GetStylesheetFolderByPathTool;
 
 // src/umb-management-api/tools/stylesheet/put/update-stylesheet.ts
-import { z as z52 } from "zod";
+import { z as z62 } from "zod";
 var UpdateStylesheetTool = CreateUmbracoTool(
   "update-stylesheet",
   "Updates a stylesheet by path",
-  z52.object({
+  z62.object({
     ...putStylesheetByPathParams.shape,
     ...putStylesheetByPathBody.shape
   }).shape,
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    const { path, ...updateModel } = model;
-    var response = await client.putStylesheetByPath(path, updateModel);
+    const { path: path3, ...updateModel } = model;
+    var response = await client.putStylesheetByPath(path3, updateModel);
     return {
       content: [
         {
@@ -21031,18 +21969,18 @@ var UpdateStylesheetTool = CreateUmbracoTool(
 var update_stylesheet_default = UpdateStylesheetTool;
 
 // src/umb-management-api/tools/stylesheet/put/rename-stylesheet.ts
-import { z as z53 } from "zod";
+import { z as z63 } from "zod";
 var RenameStylesheetTool = CreateUmbracoTool(
   "rename-stylesheet",
   `Renames a stylesheet`,
-  z53.object({
+  z63.object({
     ...putStylesheetByPathRenameParams.shape,
     ...putStylesheetByPathRenameBody.shape
   }).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.putStylesheetByPathRename(normalizedPath, renameModel);
     return {
       content: [
@@ -21185,7 +22123,7 @@ var StylesheetCollection = {
     dependencies: []
   },
   tools: (user) => {
-    const tools = [get_search_default4()];
+    const tools = [];
     if (AuthorizationPolicies.TreeAccessStylesheets(user)) {
       tools.push(create_stylesheet_default());
       tools.push(create_stylesheet_folder_default());
@@ -21198,97 +22136,1250 @@ var StylesheetCollection = {
       tools.push(get_ancestors_default10());
       tools.push(get_children_default10());
       tools.push(get_root_default12());
+      tools.push(get_search_default4());
     }
     return tools;
   }
 };
 
-// src/types/collection-configuration.ts
-var DEFAULT_COLLECTION_CONFIG = {
-  enabledCollections: [],
-  disabledCollections: [],
-  enabledTools: [],
-  disabledTools: []
-};
-
-// src/helpers/config/collection-config-loader.ts
-var CollectionConfigLoader = class {
-  static loadFromEnv() {
+// 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 {
-      enabledCollections: env_default.UMBRACO_INCLUDE_TOOL_COLLECTIONS ?? DEFAULT_COLLECTION_CONFIG.enabledCollections,
-      disabledCollections: env_default.UMBRACO_EXCLUDE_TOOL_COLLECTIONS ?? DEFAULT_COLLECTION_CONFIG.disabledCollections,
-      enabledTools: env_default.UMBRACO_INCLUDE_TOOLS ?? DEFAULT_COLLECTION_CONFIG.enabledTools,
-      disabledTools: env_default.UMBRACO_EXCLUDE_TOOLS ?? DEFAULT_COLLECTION_CONFIG.disabledTools
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
     };
   }
-};
+);
+var get_health_check_groups_default = GetHealthCheckGroupsTool;
 
-// src/umb-management-api/tools/tool-factory.ts
-var availableCollections = [
-  CultureCollection,
-  DataTypeCollection,
-  DictionaryCollection,
-  DocumentTypeCollection,
-  LanguageCollection,
-  DocumentBlueprintCollection,
-  DocumentCollection,
-  DocumentVersionCollection,
-  MediaCollection,
-  MediaTypeCollection,
-  MemberCollection,
-  MemberGroupCollection,
-  MemberTypeCollection,
-  LogViewerCollection,
-  PartialViewCollection,
-  PropertyTypeCollection,
-  TemplateCollection,
-  WebhookCollection,
-  ServerCollection,
-  RedirectCollection,
-  UserGroupCollection,
-  TemporaryFileCollection,
-  ScriptCollection,
-  StylesheetCollection
-];
-var mapTools = (server, user, tools) => {
-  return tools.forEach((tool) => {
-    const userHasPermission = tool.enabled === void 0 || tool.enabled(user);
-    if (!userHasPermission) return;
-    if (env_default.UMBRACO_EXCLUDE_TOOLS?.includes(tool.name)) return;
-    if (env_default.UMBRACO_INCLUDE_TOOLS?.length && !env_default.UMBRACO_INCLUDE_TOOLS.includes(tool.name)) return;
-    server.tool(tool.name, tool.description, tool.schema, tool.handler);
-  });
-};
-function validateConfiguration(config, collections) {
-  const availableNames = new Set(collections.map((c) => c.metadata.name));
-  const referencedNames = [
-    ...config.enabledCollections,
-    ...config.disabledCollections,
-    ...collections.flatMap((c) => c.metadata.dependencies || [])
-  ];
-  const invalid = referencedNames.filter((name) => !availableNames.has(name));
-  if (invalid.length > 0) {
-    console.warn(`Referenced collections don't exist: ${[...new Set(invalid)].join(", ")}`);
-  }
-}
-function resolveDependencies(requestedNames, collections) {
-  const result = new Set(requestedNames);
-  const collectionMap = new Map(collections.map((c) => [c.metadata.name, c]));
-  function addDependencies(collectionName) {
-    const collection = collectionMap.get(collectionName);
-    if (collection?.metadata.dependencies) {
-      collection.metadata.dependencies.forEach((dep) => {
-        if (!result.has(dep)) {
-          result.add(dep);
-          addDependencies(dep);
+// 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)
         }
-      });
-    }
+      ]
+    };
   }
-  requestedNames.forEach(addDependencies);
-  return Array.from(result);
-}
-function getEnabledCollections(config) {
+);
+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
+import { z as z64 } from "zod";
+var GetRelationByRelationTypeIdTool = CreateUmbracoTool(
+  "get-relation-by-relation-type-id",
+  "Gets relations by relation type ID",
+  z64.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: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_user_current_login_providers_default = GetUserCurrentLoginProvidersTool;
+
+// 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 response = await client.getUserCurrentPermissions(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_user_current_permissions_default = GetUserCurrentPermissionsTool;
+
+// 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.getUserCurrentPermissionsDocument(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_user_current_permissions_document_default = GetUserCurrentPermissionsDocumentTool;
+
+// 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.getUserCurrentPermissionsMedia(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_user_current_permissions_media_default = GetUserCurrentPermissionsMediaTool;
+
+// 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();
+    const response = await client.getUserByIdCalculateStartNodes(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_user_by_id_calculate_start_nodes_default = GetUserByIdCalculateStartNodesTool;
+
+// 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();
+    const response = await client.postUserAvatarById(id, { file });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var upload_user_avatar_by_id_default = UploadUserAvatarByIdTool;
+
+// 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();
+    const response = await client.postUserCurrentAvatar({ file });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var upload_user_current_avatar_default = UploadUserCurrentAvatarTool;
+
+// 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();
+    const response = await client.deleteUserAvatarById(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var delete_user_avatar_by_id_default = DeleteUserAvatarByIdTool;
+
+// 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;
+  }
+};
+
+// 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 response = await client.postUserData(body);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var create_user_data_default = CreateUserDataTool;
+
+// 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 response = await client.putUserData(body);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var update_user_data_default = UpdateUserDataTool;
+
+// 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();
+    const response = await client.getUserData(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_user_data_default = GetUserDataTool;
+
+// 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();
+    const response = await client.getUserDataById(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_user_data_by_id_default = GetUserDataByIdTool;
+
+// 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();
+    const response = await client.getItemStaticFile(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_static_files_default = GetStaticFilesTool;
+
+// 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();
+    const response = await client.getTreeStaticFileRoot(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_root_default13 = GetStaticFileRootTool;
+
+// 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();
+    const response = await client.getTreeStaticFileChildren(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_children_default11 = GetStaticFileChildrenTool;
+
+// 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();
+    const response = await client.getTreeStaticFileAncestors(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_ancestors_default11 = GetStaticFileAncestorsTool;
+
+// src/umb-management-api/tools/static-file/index.ts
+var StaticFileCollection = {
+  metadata: {
+    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 = [];
+    tools.push(get_static_files_default());
+    tools.push(get_root_default13());
+    tools.push(get_children_default11());
+    tools.push(get_ancestors_default11());
+    return tools;
+  }
+};
+
+// src/types/collection-configuration.ts
+var DEFAULT_COLLECTION_CONFIG = {
+  enabledCollections: [],
+  disabledCollections: [],
+  enabledTools: [],
+  disabledTools: []
+};
+
+// src/helpers/config/collection-config-loader.ts
+var CollectionConfigLoader = class {
+  static loadFromConfig(config) {
+    return {
+      enabledCollections: config.includeToolCollections ?? DEFAULT_COLLECTION_CONFIG.enabledCollections,
+      disabledCollections: config.excludeToolCollections ?? DEFAULT_COLLECTION_CONFIG.disabledCollections,
+      enabledTools: config.includeTools ?? DEFAULT_COLLECTION_CONFIG.enabledTools,
+      disabledTools: config.excludeTools ?? DEFAULT_COLLECTION_CONFIG.disabledTools
+    };
+  }
+};
+
+// src/umb-management-api/tools/tool-factory.ts
+var availableCollections = [
+  CultureCollection,
+  DataTypeCollection,
+  DictionaryCollection,
+  DocumentTypeCollection,
+  LanguageCollection,
+  DocumentBlueprintCollection,
+  DocumentCollection,
+  DocumentVersionCollection,
+  MediaCollection,
+  MediaTypeCollection,
+  MemberCollection,
+  MemberGroupCollection,
+  MemberTypeCollection,
+  LogViewerCollection,
+  PartialViewCollection,
+  PropertyTypeCollection,
+  TemplateCollection,
+  WebhookCollection,
+  ServerCollection,
+  RedirectCollection,
+  UserGroupCollection,
+  TemporaryFileCollection,
+  ScriptCollection,
+  StylesheetCollection,
+  HealthCollection,
+  ManifestCollection,
+  TagCollection,
+  ModelsBuilderCollection,
+  SearcherCollection,
+  IndexerCollection,
+  ImagingCollection,
+  RelationTypeCollection,
+  RelationCollection,
+  UserCollection,
+  UserDataCollection,
+  StaticFileCollection
+];
+var mapTools = (server, user, tools, config) => {
+  return tools.forEach((tool) => {
+    const userHasPermission = tool.enabled === void 0 || tool.enabled(user);
+    if (!userHasPermission) return;
+    if (config.disabledTools?.includes(tool.name)) return;
+    if (config.enabledTools?.length && !config.enabledTools.includes(tool.name)) return;
+    server.tool(tool.name, tool.description, tool.schema, tool.handler);
+  });
+};
+function validateConfiguration(config, collections) {
+  const availableNames = new Set(collections.map((c) => c.metadata.name));
+  const referencedNames = [
+    ...config.enabledCollections,
+    ...config.disabledCollections,
+    ...collections.flatMap((c) => c.metadata.dependencies || [])
+  ];
+  const invalid = referencedNames.filter((name) => !availableNames.has(name));
+  if (invalid.length > 0) {
+    console.warn(`Referenced collections don't exist: ${[...new Set(invalid)].join(", ")}`);
+  }
+}
+function resolveDependencies(requestedNames, collections) {
+  const result = new Set(requestedNames);
+  const collectionMap = new Map(collections.map((c) => [c.metadata.name, c]));
+  function addDependencies(collectionName) {
+    const collection = collectionMap.get(collectionName);
+    if (collection?.metadata.dependencies) {
+      collection.metadata.dependencies.forEach((dep) => {
+        if (!result.has(dep)) {
+          result.add(dep);
+          addDependencies(dep);
+        }
+      });
+    }
+  }
+  requestedNames.forEach(addDependencies);
+  return Array.from(result);
+}
+function getEnabledCollections(config) {
   const allCollectionNames = availableCollections.map((c) => c.metadata.name);
   let enabledNames = allCollectionNames.filter((name) => {
     if (config.disabledCollections.includes(name)) return false;
@@ -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
+import { config as loadEnv } from "dotenv";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { resolve } from "path";
+function maskSecret(secret) {
+  if (!secret || secret.length <= 4) return "****";
+  return `****${secret.slice(-4)}`;
+}
+function getServerConfig(isStdioMode) {
+  const argv = yargs(hideBin(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(process.env.NPM_PACKAGE_VERSION ?? "unknown").parseSync();
+  let envFilePath;
+  let envFileSource;
+  if (argv["env"]) {
+    envFilePath = resolve(argv["env"]);
+    envFileSource = "cli";
+  } else {
+    envFilePath = resolve(process.cwd(), ".env");
+    envFileSource = "default";
+  }
+  loadEnv({ 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);
 };