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

package/dist/index.cjs

@@ -815,12 +815,12 @@ var StdioServerTransport = class {
     (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
   }
   send(message) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve2();
+        resolve3();
       } else {
-        this._stdout.once("drain", resolve2);
+        this._stdout.once("drain", resolve3);
       }
     });
   }
@@ -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((resolve2, reject) => {
+    return new Promise((resolve3, 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);
-          resolve2(result);
+          resolve3(result);
         } catch (error) {
           reject(error);
         }
@@ -3308,11 +3308,14 @@ UmbracoAxios.interceptors.response.use(
 // src/orval/client/mutators/umbraco-management.ts
 var UmbracoManagementClient = (config, options) => {
   const source = _axios2.default.CancelToken.source();
+  const returnFullResponse = _optionalChain([options, 'optionalAccess', _46 => _46.returnFullResponse]);
   const promise = UmbracoAxios({
     ...config,
     ...options,
     cancelToken: source.token
-  }).then(({ data }) => data);
+  }).then((response) => {
+    return returnFullResponse ? response : response.data;
+  });
   promise.cancel = () => {
     source.cancel("Query was cancelled");
   };
@@ -5839,28 +5842,28 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const getPartialViewByPath = (path3, options) => {
+  const getPartialViewByPath = (path4, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/partial-view/${path3}`,
+        url: `/umbraco/management/api/v1/partial-view/${path4}`,
         method: "GET"
       },
       options
     );
   };
-  const deletePartialViewByPath = (path3, options) => {
+  const deletePartialViewByPath = (path4, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/partial-view/${path3}`,
+        url: `/umbraco/management/api/v1/partial-view/${path4}`,
         method: "DELETE"
       },
       options
     );
   };
-  const putPartialViewByPath = (path3, updatePartialViewRequestModel, options) => {
+  const putPartialViewByPath = (path4, updatePartialViewRequestModel, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/partial-view/${path3}`,
+        url: `/umbraco/management/api/v1/partial-view/${path4}`,
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         data: updatePartialViewRequestModel
@@ -5868,10 +5871,10 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const putPartialViewByPathRename = (path3, renamePartialViewRequestModel, options) => {
+  const putPartialViewByPathRename = (path4, renamePartialViewRequestModel, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/partial-view/${path3}/rename`,
+        url: `/umbraco/management/api/v1/partial-view/${path4}/rename`,
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         data: renamePartialViewRequestModel
@@ -5890,19 +5893,19 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const getPartialViewFolderByPath = (path3, options) => {
+  const getPartialViewFolderByPath = (path4, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/partial-view/folder/${path3}`,
+        url: `/umbraco/management/api/v1/partial-view/folder/${path4}`,
         method: "GET"
       },
       options
     );
   };
-  const deletePartialViewFolderByPath = (path3, options) => {
+  const deletePartialViewFolderByPath = (path4, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/partial-view/folder/${path3}`,
+        url: `/umbraco/management/api/v1/partial-view/folder/${path4}`,
         method: "DELETE"
       },
       options
@@ -6140,28 +6143,28 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const getScriptByPath = (path3, options) => {
+  const getScriptByPath = (path4, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/script/${path3}`,
+        url: `/umbraco/management/api/v1/script/${path4}`,
         method: "GET"
       },
       options
     );
   };
-  const deleteScriptByPath = (path3, options) => {
+  const deleteScriptByPath = (path4, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/script/${path3}`,
+        url: `/umbraco/management/api/v1/script/${path4}`,
         method: "DELETE"
       },
       options
     );
   };
-  const putScriptByPath = (path3, updateScriptRequestModel, options) => {
+  const putScriptByPath = (path4, updateScriptRequestModel, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/script/${path3}`,
+        url: `/umbraco/management/api/v1/script/${path4}`,
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         data: updateScriptRequestModel
@@ -6169,10 +6172,10 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const putScriptByPathRename = (path3, renameScriptRequestModel, options) => {
+  const putScriptByPathRename = (path4, renameScriptRequestModel, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/script/${path3}/rename`,
+        url: `/umbraco/management/api/v1/script/${path4}/rename`,
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         data: renameScriptRequestModel
@@ -6191,19 +6194,19 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const getScriptFolderByPath = (path3, options) => {
+  const getScriptFolderByPath = (path4, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/script/folder/${path3}`,
+        url: `/umbraco/management/api/v1/script/folder/${path4}`,
         method: "GET"
       },
       options
     );
   };
-  const deleteScriptFolderByPath = (path3, options) => {
+  const deleteScriptFolderByPath = (path4, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/script/folder/${path3}`,
+        url: `/umbraco/management/api/v1/script/folder/${path4}`,
         method: "DELETE"
       },
       options
@@ -6417,28 +6420,28 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const getStylesheetByPath = (path3, options) => {
+  const getStylesheetByPath = (path4, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/stylesheet/${path3}`,
+        url: `/umbraco/management/api/v1/stylesheet/${path4}`,
         method: "GET"
       },
       options
     );
   };
-  const deleteStylesheetByPath = (path3, options) => {
+  const deleteStylesheetByPath = (path4, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/stylesheet/${path3}`,
+        url: `/umbraco/management/api/v1/stylesheet/${path4}`,
         method: "DELETE"
       },
       options
     );
   };
-  const putStylesheetByPath = (path3, updateStylesheetRequestModel, options) => {
+  const putStylesheetByPath = (path4, updateStylesheetRequestModel, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/stylesheet/${path3}`,
+        url: `/umbraco/management/api/v1/stylesheet/${path4}`,
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         data: updateStylesheetRequestModel
@@ -6446,10 +6449,10 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const putStylesheetByPathRename = (path3, renameStylesheetRequestModel, options) => {
+  const putStylesheetByPathRename = (path4, renameStylesheetRequestModel, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/stylesheet/${path3}/rename`,
+        url: `/umbraco/management/api/v1/stylesheet/${path4}/rename`,
         method: "PUT",
         headers: { "Content-Type": "application/json" },
         data: renameStylesheetRequestModel
@@ -6468,19 +6471,19 @@ var getUmbracoManagementAPI = () => {
       options
     );
   };
-  const getStylesheetFolderByPath = (path3, options) => {
+  const getStylesheetFolderByPath = (path4, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/stylesheet/folder/${path3}`,
+        url: `/umbraco/management/api/v1/stylesheet/folder/${path4}`,
         method: "GET"
       },
       options
     );
   };
-  const deleteStylesheetFolderByPath = (path3, options) => {
+  const deleteStylesheetFolderByPath = (path4, options) => {
     return UmbracoManagementClient(
       {
-        url: `/umbraco/management/api/v1/stylesheet/folder/${path3}`,
+        url: `/umbraco/management/api/v1/stylesheet/folder/${path4}`,
         method: "DELETE"
       },
       options
@@ -7331,7 +7334,7 @@ var getTemporaryFileAPI = () => ({
     formData.append("File", postTemporaryFileBody2.File);
     const headers = {
       ...formData.getHeaders(),
-      ..._optionalChain([options, 'optionalAccess', _46 => _46.headers])
+      ..._optionalChain([options, 'optionalAccess', _47 => _47.headers])
     };
     return UmbracoManagementClient(
       {
@@ -7385,6 +7388,125 @@ var UmbracoManagementClient2 = (_class2 = class {
   }
 }, _class2.__initStatic2(), _class2);
 
+// package.json
+var package_default = {
+  name: "@umbraco-cms/mcp-dev",
+  version: "16.0.1",
+  type: "module",
+  description: "A model context protocol (MCP) server for Umbraco CMS",
+  main: "index.js",
+  mcpName: "io.github.umbraco/Umbraco-CMS-MCP-Dev",
+  bin: {
+    umbraco: "dist/index.js"
+  },
+  scripts: {
+    clean: "rimraf dist",
+    build: "tsup --config tsup.config.ts",
+    compile: "tsc --noEmit",
+    watch: "tsup --config tsup.config.ts --watch",
+    generate: "orval --config orval.config.ts",
+    inspect: "npx @modelcontextprotocol/inspector node dist/index.js",
+    test: "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "patch-publish-alpha": "npm version prerelease --preid=alpha && npm publish --tag alpha --access public",
+    "eval-mcp:basic": "npx mcp-server-tester@1.4.0 evals tests/e2e/basic/basic-tests.yaml --server-config tests/e2e/basic/basic-tests-config.json",
+    "eval-mcp:create-data-type-text-box": "npx mcp-server-tester@1.4.0 evals tests/e2e/create-data-type/create-data-type-text-box.yaml --server-config tests/e2e/create-data-type/create-data-type-config.json",
+    "eval-mcp:create-data-type-block-list": "npx mcp-server-tester@1.4.0 evals tests/e2e/create-data-type/create-data-type-block-list.yaml --server-config tests/e2e/create-data-type/create-data-type-config.json --debug",
+    "eval-mcp:create-document-type": "npx mcp-server-tester@1.4.0 evals tests/e2e/create-document-type/create-document-type.yaml --server-config tests/e2e/create-document-type/create-document-type-config.json",
+    "eval-mcp:create-document-copy": "npx mcp-server-tester@1.4.0 evals tests/e2e/create-document-copy/create-document-copy.yaml --server-config tests/e2e/create-document-copy/create-document-copy-config.json",
+    "eval-mcp:create-document-with-template": "npx mcp-server-tester@1.4.0 evals tests/e2e/create-document-with-template/create-document-with-template.yaml --server-config tests/e2e/create-document-with-template/create-document-with-template-config.json",
+    "eval-mcp:all": "npm run eval-mcp:basic && npm run eval-mcp:create-data-type && npm run eval-mcp:create-document-type && npm run eval-mcp:create-blog-post"
+  },
+  engines: {
+    node: ">=22.0.0"
+  },
+  files: [
+    "dist"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/umbraco/Umbraco-CMS-MCP-Dev"
+  },
+  keywords: [
+    "Umbraco",
+    "MCP",
+    "Model Context Protocol",
+    "CMS",
+    "MCP-Server",
+    "AI"
+  ],
+  author: "",
+  license: "MIT",
+  bugs: {
+    url: "https://github.com/umbraco/Umbraco-CMS-MCP-Dev/issues"
+  },
+  homepage: "https://github.com/umbraco/Umbraco-CMS-MCP-Dev#readme",
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.9.0",
+    "@types/uuid": "^10.0.0",
+    "@types/yargs": "^17.0.33",
+    axios: "^1.8.4",
+    dotenv: "^16.5.0",
+    "form-data": "^4.0.4",
+    "mime-types": "^3.0.1",
+    qs: "^6.14.0",
+    uuid: "^11.1.0",
+    yargs: "^18.0.0",
+    zod: "^3.24.3"
+  },
+  devDependencies: {
+    "@types/dotenv": "^6.1.1",
+    "@types/jest": "^29.5.14",
+    "@types/mime-types": "^3.0.1",
+    "@types/node": "^22.14.1",
+    "@types/qs": "^6.9.18",
+    copyfiles: "^2.4.1",
+    glob: "^11.0.2",
+    jest: "^29.7.0",
+    "jest-extended": "^4.0.2",
+    orval: "^7.8.0",
+    rimraf: "^6.0.1",
+    "ts-jest": "^29.3.2",
+    "ts-node": "^10.9.2",
+    tsup: "^8.4.0",
+    typescript: "^5.8.3"
+  }
+};
+
+// src/helpers/version-check/check-umbraco-version.ts
+var versionCheckMessage = null;
+var isBlocked = false;
+async function checkUmbracoVersion(client) {
+  try {
+    const serverInfo = await client.getServerInformation();
+    const umbracoVersion = serverInfo.version;
+    const mcpVersion = package_default.version;
+    const mcpMajor = mcpVersion.split(".")[0];
+    const umbracoMajor = umbracoVersion.split(".")[0];
+    if (umbracoMajor === mcpMajor) {
+      versionCheckMessage = null;
+      isBlocked = false;
+    } else {
+      versionCheckMessage = `\u26A0\uFE0F Version Mismatch: Connected to Umbraco ${umbracoMajor}.x, but MCP server (${mcpVersion}) expects Umbraco ${mcpMajor}.x
+   This may cause compatibility issues with the Management API.`;
+      isBlocked = true;
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    versionCheckMessage = `\u26A0\uFE0F Unable to verify Umbraco version compatibility: ${errorMessage}`;
+    isBlocked = false;
+  }
+}
+function getVersionCheckMessage() {
+  return versionCheckMessage;
+}
+function clearVersionCheckMessage() {
+  versionCheckMessage = null;
+  isBlocked = false;
+}
+function isToolExecutionBlocked() {
+  return isBlocked;
+}
+
 // src/helpers/mcp/create-umbraco-tool.ts
 var CreateUmbracoTool = (name, description, schema, handler, enabled) => () => ({
   name,
@@ -7392,27 +7514,32 @@ var CreateUmbracoTool = (name, description, schema, handler, enabled) => () => (
   enabled,
   schema,
   handler: async (args, context) => {
+    if (isToolExecutionBlocked()) {
+      const versionMessage = getVersionCheckMessage();
+      clearVersionCheckMessage();
+      return {
+        content: [{
+          type: "text",
+          text: `${versionMessage}
+
+\u26A0\uFE0F Tool execution paused due to version incompatibility.
+
+If you understand the risks and want to proceed anyway, please retry your request.`
+        }],
+        isError: true
+      };
+    }
     try {
       return await handler(args, context);
     } catch (error) {
       console.error(`Error in tool ${name}:`, error);
-      const errorDetails = error instanceof Error ? {
-        message: error.message,
-        cause: error.cause,
-        response: _optionalChain([error, 'access', _47 => _47.response, 'optionalAccess', _48 => _48.data])
-      } : error;
+      const errorDetails = error instanceof Error ? { message: error.message, cause: error.cause, response: _optionalChain([error, 'access', _48 => _48.response, 'optionalAccess', _49 => _49.data]) } : error;
       return {
-        content: [
-          {
-            type: "text",
-            text: `Error using ${name}:
-${JSON.stringify(
-              errorDetails,
-              null,
-              2
-            )}`
-          }
-        ]
+        content: [{
+          type: "text",
+          text: `Error using ${name}:
+${JSON.stringify(errorDetails, null, 2)}`
+        }]
       };
     }
   }
@@ -13375,6 +13502,19 @@ var CultureCollection = {
 };
 
 // src/umb-management-api/tools/data-type/post/create-data-type.ts
+
+var _uuid = require('uuid');
+var createDataTypeSchema = _zod.z.object({
+  name: _zod.z.string().min(1),
+  editorAlias: _zod.z.string().min(1),
+  editorUiAlias: _zod.z.string(),
+  values: _zod.z.array(_zod.z.object({
+    alias: _zod.z.string(),
+    value: _zod.z.any().nullish()
+  })),
+  parentId: _zod.z.string().uuid().optional()
+  // Flattened parent ID
+});
 var CreateDataTypeTool = CreateUmbracoTool(
   "create-data-type",
   `Creates a new data type
@@ -13386,177 +13526,64 @@ var CreateDataTypeTool = CreateUmbracoTool(
   3. Only proceed with creating a new data type if no suitable option exists
   4. If a similar data type exists, inform the user and suggest using this one instead.
 
-  When creating a new data type you will need to assign a propety editor. 
-  
-  Always create new element types in the root, if you need to create a new element type in a specific folder then move the element type to the correct folder after it has been created.
-
-  Below is the list of property editor available by default in Umbraco. Each property editor is followed by an example.
-  IMPORTANT: Amend these examples to match the requirements of the data type you are creating. DO NOT STRAY FROM THE EXAMPLES BUT USE THEM AS TEMPLATES.
-  Some property editors have optional parameter, it in doubt, leave it out.
-
-  *** Common Property Editors ***
-
-  Decimal
-  {"id":"8480eacc-894f-4fbf-8f28-ec001a115c3f","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.Decimal","editorUiAlias":"Umb.PropertyEditorUi.Decimal","values":[{"alias":"step","value":"0.01"},{"alias":"min","value":3},{"alias":"max","value":10},{"alias":"placeholder","value":"Item"}]}
-
-  Email | Umb.PropertyEditorUi.EmailAddress, | Umbraco.EmailAddress
-  {"id":"38e3fdb3-2cc2-433e-9064-58edffc5456c","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.EmailAddress","editorUiAlias":"Umb.PropertyEditorUi.EmailAddress","values":[{"alias":"inputType","value":"email"}]}
-
-  Label | Umb.PropertyEditorUi.Label, | Umbraco.Label
-  {"id":"05c199b8-d134-4890-803f-053476633686","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.Label","editorUiAlias":"Umb.PropertyEditorUi.Label","values":[{"alias":"umbracoDataValueType","value":"DECIMAL"}]}
-  label options : STRING, DECIMAL, DATETIME, TIME, INTEGER, BIGINT, TEXT   
-
-  Numeric 
-  {"id":"05c199b8-d134-4890-803f-053476633686","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.Label","editorUiAlias":"Umb.PropertyEditorUi.Label","values":[{"alias":"umbracoDataValueType","value":"DECIMAL"}]}
-
-  Slider
-  {"id":"4a949427-2814-42c3-86eb-c874cf5100d6","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.Slider","editorUiAlias":"Umb.PropertyEditorUi.Slider","values":[{"alias":"minVal","value":0},{"alias":"maxVal","value":100},{"alias":"initVal1","value":0},{"alias":"initVal2","value":0},{"alias":"step","value":1}]}
-
-  Tags
-  {"id":"87a371cc-9da9-4771-ae58-6895a37b4560","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.Tags","editorUiAlias":"Umb.PropertyEditorUi.Tags","values":[{"alias":"group","value":"default"},{"alias":"storageType","value":"Json"}]}
-  Storage options : Json, CSV
-
-  Textarea
-  {"id":"5ee0462b-d8d9-45fd-a742-bb0cd4536d78","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.TextArea","editorUiAlias":"Umb.PropertyEditorUi.TextArea","values":[{"alias":"rows","value":10},{"alias":"maxChars","value":100},{"alias":"minHeight","value":200},{"alias":"maxHeight","value":100}]}
-
-  Textbox 
-  {"id":"21732e7d-14b9-4413-bf39-86e73beb96c9","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.TextBox","editorUiAlias":"Umb.PropertyEditorUi.TextBox","values":[{"alias":"maxChars","value":512},{"alias":"inputType","value":"text"}]}
-
-  Toggle
-  {"id":"b5889bfd-2f39-4214-bc4c-31de062cca73","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.TrueFalse","editorUiAlias":"Umb.PropertyEditorUi.Toggle","values":[{"alias":"default","value":true},{"alias":"showLabels","value":true},{"alias":"labelOn","value":"On"},{"alias":"labelOff","value":"Off"},{"alias":"ariaLabel","value":"Reader"}]}
-
-
-  *** Lists Property Editors ***
-
-  BlockList 
-
-  IMPORTANT - when creating new block list data types always create the reuired element types first before creating the data type
-
-  {"id":"aff61371-d3d3-4dde-9c85-7c01ff330ede","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.BlockList","editorUiAlias":"Umb.PropertyEditorUi.BlockList","values":[{"alias":"blocks","value":[{"contentElementTypeKey":"c80027e5-7e87-49c1-9b4f-1b9d3fbc2e90","settingsElementTypeKey":"2e1a4fd4-b695-4033-8626-1a45b54e04cb","backgroundColor":"#c05454","iconColor":"#00ff6f"}]},{"alias":"validationLimit","value":{"max":3}},{"alias":"useLiveEditing","value":true},{"alias":"useInlineEditingAsDefault","value":true},{"alias":"maxPropertyWidth","value":"100px"}]}
-
-  CheckBoxList 
-  {"id":"aff61371-d3d3-4dde-9c85-7c01ff330ede","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.BlockList","editorUiAlias":"Umb.PropertyEditorUi.BlockList","values":[{"alias":"blocks","value":[{"contentElementTypeKey":"c80027e5-7e87-49c1-9b4f-1b9d3fbc2e90","settingsElementTypeKey":"2e1a4fd4-b695-4033-8626-1a45b54e04cb","backgroundColor":"#c05454","iconColor":"#00ff6f"}]},{"alias":"validationLimit","value":{"max":3}},{"alias":"useLiveEditing","value":true},{"alias":"useInlineEditingAsDefault","value":true},{"alias":"maxPropertyWidth","value":"100px"}]}
-
-  Collection
-  {"id":"aff61371-d3d3-4dde-9c85-7c01ff330ede","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.BlockList","editorUiAlias":"Umb.PropertyEditorUi.BlockList","values":[{"alias":"blocks","value":[{"contentElementTypeKey":"c80027e5-7e87-49c1-9b4f-1b9d3fbc2e90","settingsElementTypeKey":"2e1a4fd4-b695-4033-8626-1a45b54e04cb","backgroundColor":"#c05454","iconColor":"#00ff6f"}]},{"alias":"validationLimit","value":{"max":3}},{"alias":"useLiveEditing","value":true},{"alias":"useInlineEditingAsDefault","value":true},{"alias":"maxPropertyWidth","value":"100px"}]}
-
-  Dropdown
-  {"id":"0aa7b755-d24a-44fd-917a-1d6a7fa07c1e","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.DropDown.Flexible","editorUiAlias":"Umb.PropertyEditorUi.Dropdown","values":[{"alias":"items","value":["Item 1","Item 2"]},{"alias":"multiple","value":true}]}
-
-  MultipleTestString
-  {"id":"aaa23533-275e-4ba2-9a06-fc2bf0ea053a","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.MultipleTextstring","editorUiAlias":"Umb.PropertyEditorUi.MultipleTextString","values":[{"alias":"min","value":3},{"alias":"max","value":10}]}
-
-  RadioButtonList
-  {"id":"99f20003-8b65-4db9-ac0b-932c2fd5abaa","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.RadioButtonList","editorUiAlias":"Umb.PropertyEditorUi.RadioButtonList","values":[{"alias":"items","value":["Item 1","Item 2"]}]}
-
-
-  *** Media Property Editors ***
-
-  ImageCropper 
-  Doesn't work
+  *** PROPERTY EDITOR CONFIGURATION ***
+  When creating a new data type you will need to assign a property editor with the correct configuration.
 
-  MediaPicker
-  {"id":"57d1162b-264f-4627-ac86-e0692de5ae39","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.MediaPicker3","editorUiAlias":"Umb.PropertyEditorUi.MediaPicker","values":[{"alias":"filter","value":"cc07b313-0843-4aa8-bbda-871c8da728c8"},{"alias":"multiple","value":true},{"alias":"validationLimit","value":{"max":10}},{"alias":"startNodeId"},{"alias":"enableLocalFocalPoint","value":true},{"alias":"ignoreUserStartNodes","value":true}]}
+  IMPORTANT: Use the get-data-type-property-editor-template tool to:
+  - View all available property editors (call without parameters)
+  - Get the correct configuration template for a specific property editor (call with editorName parameter)
+  - Each template shows the required editorAlias, editorUiAlias, and values configuration
+  - Customize the template values to match your specific requirements
 
-  UploadField
-  {"id":"2d574e0b-a7ab-47f2-92c7-acb460fea5dc","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.UploadField","editorUiAlias":"Umb.PropertyEditorUi.UploadField","values":[{"alias":"fileExtensions","value":["pdf"]}]}
-
-  *** Peeople Property Editors ***
-
-  MemberGroupPicker
-  {"id":"44802c76-ef67-4bf9-90dd-1e2d431a29d9","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.MemberGroupPicker","editorUiAlias":"Umb.PropertyEditorUi.MemberGroupPicker","values":[]}
-
-  MemberPicker
-  {"id":"79f86b6f-f01a-4ba2-8e6d-a7204f8e04b3","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.MemberPicker","editorUiAlias":"Umb.PropertyEditorUi.MemberPicker","values":[]}
-
-  UserPicker
-  {"id":"c6f83e2d-3863-4577-9cd6-544e6906bfaa","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.UserPicker","editorUiAlias":"Umb.PropertyEditorUi.UserPicker","values":[]}
-
-  *** Picker Property Editors ***
-
-  ColorPicker
-  {"id":"93f22ab5-1cf3-4b4f-b1b1-98d60205929f","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.ColorPicker","editorUiAlias":"Umb.PropertyEditorUi.ColorPicker","values":[{"alias":"useLabel","value":true},{"alias":"items","value":[{"value":"F00","label":"Red"}]}]}
-
-  * ContentPicker | Umb.PropertyEditorUi.ContentPicker | Umbraco.ContentPicker
-  {"id":"4bc0e04c-cde8-4f92-a85b-f83a5860a1e8","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.MultiNodeTreePicker","editorUiAlias":"Umb.PropertyEditorUi.ContentPicker","values":[{"alias":"minNumber","value":0},{"alias":"maxNumber","value":0},{"alias":"ignoreUserStartNodes","value":true},{"alias":"startNode","value":{"type":"content","dynamicRoot":{"originAlias":"Current"}}},{"alias":"filter","value":"0fde8472-7c10-4e8a-bd4a-fffc0306d0aa"},{"alias":"showOpenButton","value":true}]}
-
-  DatePicker
-  {"id":"d022160d-9703-42f7-9e0d-3611bb26222e","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.DateTime","editorUiAlias":"Umb.PropertyEditorUi.DatePicker","values":[{"alias":"format","value":"YYYY-MM-DD HH:mm:ss"}]}
-
-  DocumentPicker
-  {"id":"ed366ea4-ed19-4d7a-bf76-66b4e225cd7f","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.ContentPicker","editorUiAlias":"Umb.PropertyEditorUi.DocumentPicker","values":[{"alias":"ignoreUserStartNodes","value":true},{"alias":"startNodeId","value":"dcf18a51-6919-4cf8-89d1-36b94ce4d963"},{"alias":"showOpenButton","value":true}]}
-
-  EyeDropper | Umb.PropertyEditorUi.EyeDropper | Umbraco.ColorPicker.EyeDropper
-  {"id":"871938c0-a549-4da4-84ff-589d0237575b","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.ColorPicker.EyeDropper","editorUiAlias":"Umb.PropertyEditorUi.EyeDropper","values":[{"alias":"showAlpha","value":true},{"alias":"showPalette","value":true}]}
-
-  MultiUrlPicker | Umb.PropertyEditorUi.MultiUrlPicker | Umbraco.MultiUrlPicker
-  {"id":"a9887fb3-d2af-40eb-a566-c0907ac7bba3","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.MultiUrlPicker","editorUiAlias":"Umb.PropertyEditorUi.MultiUrlPicker","values":[{"alias":"minNumber","value":1},{"alias":"maxNumber","value":3},{"alias":"ignoreUserStartNodes","value":true},{"alias":"hideAnchor","value":false}]}
-
-  *** Rich Text Property Editors ***
-
-  BlockGrid
-
-  IMPORTANT - when creating new block grid data types always create the reuired element types first before creating the data type
-
-  {"id":"cfdd79d9-6f18-4b2b-a502-c67b0fb3929c","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.BlockGrid","editorUiAlias":"Umb.PropertyEditorUi.BlockGrid","values":[{"alias":"gridColumns","value":12},{"alias":"blocks","value":[{"contentElementTypeKey":"c80027e5-7e87-49c1-9b4f-1b9d3fbc2e90","allowAtRoot":true,"allowInAreas":true,"settingsElementTypeKey":"93638715-f76c-4a11-86b1-6a9d66504901","columnSpanOptions":[{"columnSpan":12}],"rowMinSpan":0,"rowMaxSpan":3}]}]}
-
-  CodeEditor | Umb.PropertyEditorUi.CodeEditor | Umbraco.Plain.String
-  {"id":"f845a669-c92d-4af7-9f3c-3a9717925e36","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.Plain.String","editorUiAlias":"Umb.PropertyEditorUi.CodeEditor","values":[{"alias":"language","value":"javascript"},{"alias":"height","value":400},{"alias":"lineNumbers","value":true},{"alias":"minimap","value":true},{"alias":"wordWrap","value":false}]}
-
-  MarkdownEditor
-  {"id":"18594f1e-75b7-4e04-9abf-20805556f02c","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.MarkdownEditor","editorUiAlias":"Umb.PropertyEditorUi.MarkdownEditor","values":[{"alias":"preview","value":true},{"alias":"defaultValue","value":"Default value"},{"alias":"overlaySize","value":"small"}]}
-
-  RichTextEditor
-  {"id":"29d6b5cf-80ec-4271-bdc0-d18494555b44","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.RichText","editorUiAlias":"Umb.PropertyEditorUi.TinyMCE","values":[{"alias":"toolbar","value":["styles","bold","italic","alignleft","aligncenter","alignright","bullist","numlist","outdent","indent","sourcecode","link","umbmediapicker","umbembeddialog"]},{"alias":"mode","value":"Classic"},{"alias":"maxImageSize","value":500},{"alias":"blocks","value":[{"contentElementTypeKey":"c80027e5-7e87-49c1-9b4f-1b9d3fbc2e90","settingsElementTypeKey":"93638715-f76c-4a11-86b1-6a9d66504901","label":"Appearance","displayInline":true,"editorSize":"small","backgroundColor":"#000000","iconColor":"#000000"}]},{"alias":"mediaParentId"},{"alias":"ignoreUserStartNodes","value":true}]}
-
-  RichTextEditor
-  {"id":"45a57ebf-5a20-4148-b247-cb8718059df6","parent":{"id":"6e92aaa2-89b0-48f5-9e68-abff56010e8a"},"name":"Example","editorAlias":"Umbraco.RichText","editorUiAlias":"Umb.PropertyEditorUi.Tiptap","values":[{"alias":"toolbar","value":[[["Umb.Tiptap.Toolbar.SourceEditor"],["Umb.Tiptap.Toolbar.Bold","Umb.Tiptap.Toolbar.Italic","Umb.Tiptap.Toolbar.Underline"],["Umb.Tiptap.Toolbar.TextAlignLeft","Umb.Tiptap.Toolbar.TextAlignCenter","Umb.Tiptap.Toolbar.TextAlignRight"],["Umb.Tiptap.Toolbar.BulletList","Umb.Tiptap.Toolbar.OrderedList"],["Umb.Tiptap.Toolbar.Blockquote","Umb.Tiptap.Toolbar.HorizontalRule"],["Umb.Tiptap.Toolbar.Link","Umb.Tiptap.Toolbar.Unlink"],["Umb.Tiptap.Toolbar.MediaPicker","Umb.Tiptap.Toolbar.EmbeddedMedia"]]]},{"alias":"maxImageSize","value":500},{"alias":"overlaySize","value":"medium"},{"alias":"extensions","value":["Umb.Tiptap.Embed","Umb.Tiptap.Figure","Umb.Tiptap.Image","Umb.Tiptap.Link","Umb.Tiptap.MediaUpload","Umb.Tiptap.RichTextEssentials","Umb.Tiptap.Subscript","Umb.Tiptap.Superscript","Umb.Tiptap.Table","Umb.Tiptap.TextAlign","Umb.Tiptap.TextDirection","Umb.Tiptap.Underline"]}]}
-
-  if you are not asked for a property editor then stop and ask the user to provide one. 
-
-  if you are asked to create a data type for a property that already exists, then stop and ask the user to provide a unique name. 
-
-  Each property editor is configurable. That configuration is different for each property editor. The configuration options can be found in the Umbraco Sourcecode.
-
-  IMPRTANT : Always use the correct configration for the specific property editor. Do not make assumptions. 
-
-  The Umbraco Sourcecode can be found at https://github.com/umbraco/Umbraco-CMS
-
-  The property editors are located in the Umbraco.Core.PropertyEditors namespace.
-
-
-  Here is an example of a dropdown property editor configuration:
-
-  {
-    "id": "b90cccaf-549d-4419-8543-d50aecae0819",
-    "parent": null,
-    "name": "Test",
-    "editorAlias": "Umbraco.DropDown.Flexible", // These MUST match one of the property editors listed above.
-    "editorUiAlias": "Umb.PropertyEditorUi.Dropdown", // These MUST match one of the property editors listed above.
-    "values": [
-      {
-        "alias": "items",
-        "value": [
-          "test",
-          "test 2"
-        ]
-      }
-    ]
-  }
+  *** VALIDATION ***
+  If you are not asked for a property editor then stop and ask the user to provide one.
+  If you are asked to create a data type for a property that already exists, then stop and ask the user to provide a unique name.
 
   `,
-  postDataTypeBody.shape,
+  createDataTypeSchema.shape,
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.postDataType(model);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(response)
-        }
-      ]
+    const dataTypeId = _uuid.v4.call(void 0, );
+    const payload = {
+      name: model.name,
+      editorAlias: model.editorAlias,
+      editorUiAlias: model.editorUiAlias,
+      values: model.values,
+      id: dataTypeId,
+      parent: model.parentId ? { id: model.parentId } : void 0
     };
+    const response = await client.postDataType(payload, {
+      returnFullResponse: true,
+      validateStatus: () => true
+    });
+    if (response.status === 201) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              message: "Data type created successfully",
+              id: dataTypeId
+            })
+          }
+        ]
+      };
+    } else {
+      const errorData = response.data;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              message: "Failed to create data type",
+              status: response.status,
+              error: errorData || response.statusText
+            })
+          }
+        ],
+        isError: true
+      };
+    }
   }
 );
 var create_data_type_default = CreateDataTypeTool;
@@ -13641,121 +13668,922 @@ var GetDataTypeConfigurationTool = CreateUmbracoTool(
 );
 var get_data_type_configuration_default = GetDataTypeConfigurationTool;
 
-// src/umb-management-api/tools/data-type/put/update-data-type.ts
-
-var UpdateDataTypeTool = CreateUmbracoTool(
-  "update-data-type",
-  "Updates a data type by Id",
-  {
-    id: putDataTypeByIdParams.shape.id,
-    data: _zod.z.object(putDataTypeByIdBody.shape)
-  },
-  async (model) => {
-    const client = UmbracoManagementClient2.getClient();
-    var response = await client.putDataTypeById(model.id, model.data);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(response)
-        }
-      ]
-    };
-  }
-);
-var update_data_type_default = UpdateDataTypeTool;
+// src/umb-management-api/tools/data-type/get/get-data-type-property-editor-template.ts
 
-// src/umb-management-api/tools/data-type/post/copy-data-type.ts
 
-var CopyDataTypeTool = CreateUmbracoTool(
-  "copy-data-type",
-  "Copy a data type by Id",
-  {
-    id: postDataTypeByIdCopyParams.shape.id,
-    body: _zod.z.object(postDataTypeByIdCopyBody.shape)
+// src/umb-management-api/tools/data-type/post/property-editor-templates.ts
+var propertyEditorTemplates = {
+  "Decimal": {
+    "editorAlias": "Umbraco.Decimal",
+    "editorUiAlias": "Umb.PropertyEditorUi.Decimal",
+    "values": [
+      {
+        "alias": "step",
+        "value": "0.01"
+      },
+      {
+        "alias": "min",
+        "value": 3
+      },
+      {
+        "alias": "max",
+        "value": 10
+      },
+      {
+        "alias": "placeholder",
+        "value": "Item"
+      }
+    ]
   },
-  async ({ id, body }) => {
-    const client = UmbracoManagementClient2.getClient();
-    var response = await client.postDataTypeByIdCopy(id, body);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(response)
-        }
-      ]
-    };
-  }
-);
-var copy_data_type_default = CopyDataTypeTool;
-
-// src/umb-management-api/tools/data-type/get/is-used-data-type.ts
-var IsUsedDataTypeTool = CreateUmbracoTool(
-  "is-used-data-type",
-  "Checks if a data type is used within Umbraco",
-  getDataTypeByIdIsUsedParams.shape,
-  async ({ id }) => {
-    const client = UmbracoManagementClient2.getClient();
-    var response = await client.getDataTypeByIdIsUsed(id);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(response)
-        }
-      ]
-    };
-  }
-);
-var is_used_data_type_default = IsUsedDataTypeTool;
-
-// src/umb-management-api/tools/data-type/put/move-data-type.ts
-
-var MoveDataTypeTool = CreateUmbracoTool(
-  "move-data-type",
-  "Move a data type by Id",
-  {
-    id: putDataTypeByIdMoveParams.shape.id,
-    body: _zod.z.object(putDataTypeByIdMoveBody.shape)
+  "Email": {
+    "editorAlias": "Umbraco.EmailAddress",
+    "editorUiAlias": "Umb.PropertyEditorUi.EmailAddress",
+    "values": [
+      {
+        "alias": "inputType",
+        "value": "email"
+      }
+    ]
   },
-  async ({ id, body }) => {
-    const client = UmbracoManagementClient2.getClient();
-    var response = await client.putDataTypeByIdMove(id, body);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(response)
-        }
-      ]
-    };
-  }
-);
-var move_data_type_default = MoveDataTypeTool;
-
-// src/umb-management-api/tools/data-type/get/get-references-data-type.ts
-var GetReferencesDataTypeTool = CreateUmbracoTool(
-  "get-references-data-type",
-  `Gets the document types and properties that use a specific data type.
-  
-  This is the recommended method to find all document types that reference a particular data type.
-    
-  Usage examples:
-  - Find all document types using the RichText editor data type
-  - Identify properties that reference a specific data type before modifying or deleting it
-  - Perform bulk updates to all properties using a specific data type
-    
-  Returns a detailed list with content type information (id, type, name, icon) and all properties
-  (name, alias) that use the specified data type.
-  `,
-  getDataTypeByIdReferencesParams.shape,
-  async ({ id }) => {
-    const client = UmbracoManagementClient2.getClient();
-    var response = await client.getDataTypeByIdReferences(id);
-    return {
-      content: [
-        {
-          type: "text",
+  "Label": {
+    "editorAlias": "Umbraco.Label",
+    "editorUiAlias": "Umb.PropertyEditorUi.Label",
+    "values": [
+      {
+        "alias": "umbracoDataValueType",
+        "value": "DECIMAL"
+      }
+    ],
+    "_notes": "Label options: STRING, DECIMAL, DATETIME, TIME, INTEGER, BIGINT, TEXT"
+  },
+  "Numeric": {
+    "editorAlias": "Umbraco.Label",
+    "editorUiAlias": "Umb.PropertyEditorUi.Label",
+    "values": [
+      {
+        "alias": "umbracoDataValueType",
+        "value": "DECIMAL"
+      }
+    ]
+  },
+  "Slider": {
+    "editorAlias": "Umbraco.Slider",
+    "editorUiAlias": "Umb.PropertyEditorUi.Slider",
+    "values": [
+      {
+        "alias": "minVal",
+        "value": 0
+      },
+      {
+        "alias": "maxVal",
+        "value": 100
+      },
+      {
+        "alias": "initVal1",
+        "value": 0
+      },
+      {
+        "alias": "initVal2",
+        "value": 0
+      },
+      {
+        "alias": "step",
+        "value": 1
+      }
+    ]
+  },
+  "Tags": {
+    "editorAlias": "Umbraco.Tags",
+    "editorUiAlias": "Umb.PropertyEditorUi.Tags",
+    "values": [
+      {
+        "alias": "group",
+        "value": "default"
+      },
+      {
+        "alias": "storageType",
+        "value": "Json"
+      }
+    ],
+    "_notes": "Storage options: Json, CSV"
+  },
+  "Textarea": {
+    "editorAlias": "Umbraco.TextArea",
+    "editorUiAlias": "Umb.PropertyEditorUi.TextArea",
+    "values": [
+      {
+        "alias": "rows",
+        "value": 10
+      },
+      {
+        "alias": "maxChars",
+        "value": 100
+      },
+      {
+        "alias": "minHeight",
+        "value": 200
+      },
+      {
+        "alias": "maxHeight",
+        "value": 100
+      }
+    ]
+  },
+  "Textbox": {
+    "editorAlias": "Umbraco.TextBox",
+    "editorUiAlias": "Umb.PropertyEditorUi.TextBox",
+    "values": [
+      {
+        "alias": "maxChars",
+        "value": 512
+      },
+      {
+        "alias": "inputType",
+        "value": "text"
+      }
+    ]
+  },
+  "Toggle": {
+    "editorAlias": "Umbraco.TrueFalse",
+    "editorUiAlias": "Umb.PropertyEditorUi.Toggle",
+    "values": [
+      {
+        "alias": "default",
+        "value": true
+      },
+      {
+        "alias": "showLabels",
+        "value": true
+      },
+      {
+        "alias": "labelOn",
+        "value": "On"
+      },
+      {
+        "alias": "labelOff",
+        "value": "Off"
+      },
+      {
+        "alias": "ariaLabel",
+        "value": "Reader"
+      }
+    ]
+  },
+  "BlockList": {
+    "editorAlias": "Umbraco.BlockList",
+    "editorUiAlias": "Umb.PropertyEditorUi.BlockList",
+    "values": [
+      {
+        "alias": "blocks",
+        "value": [
+          {
+            "contentElementTypeKey": "c80027e5-7e87-49c1-9b4f-1b9d3fbc2e90",
+            "settingsElementTypeKey": "2e1a4fd4-b695-4033-8626-1a45b54e04cb",
+            "backgroundColor": "#c05454",
+            "iconColor": "#00ff6f"
+          }
+        ]
+      },
+      {
+        "alias": "validationLimit",
+        "value": {
+          "max": 3
+        }
+      },
+      {
+        "alias": "useLiveEditing",
+        "value": true
+      },
+      {
+        "alias": "useInlineEditingAsDefault",
+        "value": true
+      },
+      {
+        "alias": "maxPropertyWidth",
+        "value": "100px"
+      }
+    ],
+    "_notes": "IMPORTANT - when creating new block list data types always create the required element types first before creating the data type"
+  },
+  "CheckBoxList": {
+    "editorAlias": "Umbraco.BlockList",
+    "editorUiAlias": "Umb.PropertyEditorUi.BlockList",
+    "values": [
+      {
+        "alias": "blocks",
+        "value": [
+          {
+            "contentElementTypeKey": "c80027e5-7e87-49c1-9b4f-1b9d3fbc2e90",
+            "settingsElementTypeKey": "2e1a4fd4-b695-4033-8626-1a45b54e04cb",
+            "backgroundColor": "#c05454",
+            "iconColor": "#00ff6f"
+          }
+        ]
+      },
+      {
+        "alias": "validationLimit",
+        "value": {
+          "max": 3
+        }
+      },
+      {
+        "alias": "useLiveEditing",
+        "value": true
+      },
+      {
+        "alias": "useInlineEditingAsDefault",
+        "value": true
+      },
+      {
+        "alias": "maxPropertyWidth",
+        "value": "100px"
+      }
+    ]
+  },
+  "Collection": {
+    "editorAlias": "Umbraco.BlockList",
+    "editorUiAlias": "Umb.PropertyEditorUi.BlockList",
+    "values": [
+      {
+        "alias": "blocks",
+        "value": [
+          {
+            "contentElementTypeKey": "c80027e5-7e87-49c1-9b4f-1b9d3fbc2e90",
+            "settingsElementTypeKey": "2e1a4fd4-b695-4033-8626-1a45b54e04cb",
+            "backgroundColor": "#c05454",
+            "iconColor": "#00ff6f"
+          }
+        ]
+      },
+      {
+        "alias": "validationLimit",
+        "value": {
+          "max": 3
+        }
+      },
+      {
+        "alias": "useLiveEditing",
+        "value": true
+      },
+      {
+        "alias": "useInlineEditingAsDefault",
+        "value": true
+      },
+      {
+        "alias": "maxPropertyWidth",
+        "value": "100px"
+      }
+    ]
+  },
+  "Dropdown": {
+    "editorAlias": "Umbraco.DropDown.Flexible",
+    "editorUiAlias": "Umb.PropertyEditorUi.Dropdown",
+    "values": [
+      {
+        "alias": "items",
+        "value": [
+          "Item 1",
+          "Item 2"
+        ]
+      },
+      {
+        "alias": "multiple",
+        "value": true
+      }
+    ]
+  },
+  "MultipleTextString": {
+    "editorAlias": "Umbraco.MultipleTextstring",
+    "editorUiAlias": "Umb.PropertyEditorUi.MultipleTextString",
+    "values": [
+      {
+        "alias": "min",
+        "value": 3
+      },
+      {
+        "alias": "max",
+        "value": 10
+      }
+    ]
+  },
+  "RadioButtonList": {
+    "editorAlias": "Umbraco.RadioButtonList",
+    "editorUiAlias": "Umb.PropertyEditorUi.RadioButtonList",
+    "values": [
+      {
+        "alias": "items",
+        "value": [
+          "Item 1",
+          "Item 2"
+        ]
+      }
+    ]
+  },
+  "ImageCropper": {
+    "_notes": "Doesn't work"
+  },
+  "MediaPicker": {
+    "editorAlias": "Umbraco.MediaPicker3",
+    "editorUiAlias": "Umb.PropertyEditorUi.MediaPicker",
+    "values": [
+      {
+        "alias": "filter",
+        "value": "cc07b313-0843-4aa8-bbda-871c8da728c8"
+      },
+      {
+        "alias": "multiple",
+        "value": true
+      },
+      {
+        "alias": "validationLimit",
+        "value": {
+          "max": 10
+        }
+      },
+      {
+        "alias": "startNodeId"
+      },
+      {
+        "alias": "enableLocalFocalPoint",
+        "value": true
+      },
+      {
+        "alias": "ignoreUserStartNodes",
+        "value": true
+      }
+    ]
+  },
+  "UploadField": {
+    "editorAlias": "Umbraco.UploadField",
+    "editorUiAlias": "Umb.PropertyEditorUi.UploadField",
+    "values": [
+      {
+        "alias": "fileExtensions",
+        "value": [
+          "pdf"
+        ]
+      }
+    ]
+  },
+  "MemberGroupPicker": {
+    "editorAlias": "Umbraco.MemberGroupPicker",
+    "editorUiAlias": "Umb.PropertyEditorUi.MemberGroupPicker",
+    "values": []
+  },
+  "MemberPicker": {
+    "editorAlias": "Umbraco.MemberPicker",
+    "editorUiAlias": "Umb.PropertyEditorUi.MemberPicker",
+    "values": []
+  },
+  "UserPicker": {
+    "editorAlias": "Umbraco.UserPicker",
+    "editorUiAlias": "Umb.PropertyEditorUi.UserPicker",
+    "values": []
+  },
+  "ColorPicker": {
+    "editorAlias": "Umbraco.ColorPicker",
+    "editorUiAlias": "Umb.PropertyEditorUi.ColorPicker",
+    "values": [
+      {
+        "alias": "useLabel",
+        "value": true
+      },
+      {
+        "alias": "items",
+        "value": [
+          {
+            "value": "F00",
+            "label": "Red"
+          }
+        ]
+      }
+    ]
+  },
+  "ContentPicker": {
+    "editorAlias": "Umbraco.MultiNodeTreePicker",
+    "editorUiAlias": "Umb.PropertyEditorUi.ContentPicker",
+    "values": [
+      {
+        "alias": "minNumber",
+        "value": 0
+      },
+      {
+        "alias": "maxNumber",
+        "value": 0
+      },
+      {
+        "alias": "ignoreUserStartNodes",
+        "value": true
+      },
+      {
+        "alias": "startNode",
+        "value": {
+          "type": "content",
+          "dynamicRoot": {
+            "originAlias": "Current"
+          }
+        }
+      },
+      {
+        "alias": "filter",
+        "value": "0fde8472-7c10-4e8a-bd4a-fffc0306d0aa"
+      },
+      {
+        "alias": "showOpenButton",
+        "value": true
+      }
+    ]
+  },
+  "DatePicker": {
+    "editorAlias": "Umbraco.DateTime",
+    "editorUiAlias": "Umb.PropertyEditorUi.DatePicker",
+    "values": [
+      {
+        "alias": "format",
+        "value": "YYYY-MM-DD HH:mm:ss"
+      }
+    ]
+  },
+  "DocumentPicker": {
+    "editorAlias": "Umbraco.ContentPicker",
+    "editorUiAlias": "Umb.PropertyEditorUi.DocumentPicker",
+    "values": [
+      {
+        "alias": "ignoreUserStartNodes",
+        "value": true
+      },
+      {
+        "alias": "startNodeId",
+        "value": "dcf18a51-6919-4cf8-89d1-36b94ce4d963"
+      },
+      {
+        "alias": "showOpenButton",
+        "value": true
+      }
+    ]
+  },
+  "EyeDropper": {
+    "editorAlias": "Umbraco.ColorPicker.EyeDropper",
+    "editorUiAlias": "Umb.PropertyEditorUi.EyeDropper",
+    "values": [
+      {
+        "alias": "showAlpha",
+        "value": true
+      },
+      {
+        "alias": "showPalette",
+        "value": true
+      }
+    ]
+  },
+  "MultiUrlPicker": {
+    "editorAlias": "Umbraco.MultiUrlPicker",
+    "editorUiAlias": "Umb.PropertyEditorUi.MultiUrlPicker",
+    "values": [
+      {
+        "alias": "minNumber",
+        "value": 1
+      },
+      {
+        "alias": "maxNumber",
+        "value": 3
+      },
+      {
+        "alias": "ignoreUserStartNodes",
+        "value": true
+      },
+      {
+        "alias": "hideAnchor",
+        "value": false
+      }
+    ]
+  },
+  "BlockGrid": {
+    "editorAlias": "Umbraco.BlockGrid",
+    "editorUiAlias": "Umb.PropertyEditorUi.BlockGrid",
+    "values": [
+      {
+        "alias": "gridColumns",
+        "value": 12
+      },
+      {
+        "alias": "blocks",
+        "value": [
+          {
+            "contentElementTypeKey": "c80027e5-7e87-49c1-9b4f-1b9d3fbc2e90",
+            "allowAtRoot": true,
+            "allowInAreas": true,
+            "settingsElementTypeKey": "93638715-f76c-4a11-86b1-6a9d66504901",
+            "columnSpanOptions": [
+              {
+                "columnSpan": 12
+              }
+            ],
+            "rowMinSpan": 0,
+            "rowMaxSpan": 3
+          }
+        ]
+      }
+    ],
+    "_notes": "IMPORTANT - when creating new block grid data types always create the required element types first before creating the data type"
+  },
+  "CodeEditor": {
+    "editorAlias": "Umbraco.Plain.String",
+    "editorUiAlias": "Umb.PropertyEditorUi.CodeEditor",
+    "values": [
+      {
+        "alias": "language",
+        "value": "javascript"
+      },
+      {
+        "alias": "height",
+        "value": 400
+      },
+      {
+        "alias": "lineNumbers",
+        "value": true
+      },
+      {
+        "alias": "minimap",
+        "value": true
+      },
+      {
+        "alias": "wordWrap",
+        "value": false
+      }
+    ]
+  },
+  "MarkdownEditor": {
+    "editorAlias": "Umbraco.MarkdownEditor",
+    "editorUiAlias": "Umb.PropertyEditorUi.MarkdownEditor",
+    "values": [
+      {
+        "alias": "preview",
+        "value": true
+      },
+      {
+        "alias": "defaultValue",
+        "value": "Default value"
+      },
+      {
+        "alias": "overlaySize",
+        "value": "small"
+      }
+    ]
+  },
+  "RichTextEditor_TinyMCE": {
+    "editorAlias": "Umbraco.RichText",
+    "editorUiAlias": "Umb.PropertyEditorUi.TinyMCE",
+    "values": [
+      {
+        "alias": "toolbar",
+        "value": [
+          "styles",
+          "bold",
+          "italic",
+          "alignleft",
+          "aligncenter",
+          "alignright",
+          "bullist",
+          "numlist",
+          "outdent",
+          "indent",
+          "sourcecode",
+          "link",
+          "umbmediapicker",
+          "umbembeddialog"
+        ]
+      },
+      {
+        "alias": "mode",
+        "value": "Classic"
+      },
+      {
+        "alias": "maxImageSize",
+        "value": 500
+      },
+      {
+        "alias": "blocks",
+        "value": [
+          {
+            "contentElementTypeKey": "c80027e5-7e87-49c1-9b4f-1b9d3fbc2e90",
+            "settingsElementTypeKey": "93638715-f76c-4a11-86b1-6a9d66504901",
+            "label": "Appearance",
+            "displayInline": true,
+            "editorSize": "small",
+            "backgroundColor": "#000000",
+            "iconColor": "#000000"
+          }
+        ]
+      },
+      {
+        "alias": "mediaParentId"
+      },
+      {
+        "alias": "ignoreUserStartNodes",
+        "value": true
+      }
+    ]
+  },
+  "RichTextEditor_Tiptap": {
+    "editorAlias": "Umbraco.RichText",
+    "editorUiAlias": "Umb.PropertyEditorUi.Tiptap",
+    "values": [
+      {
+        "alias": "toolbar",
+        "value": [
+          [
+            [
+              "Umb.Tiptap.Toolbar.SourceEditor"
+            ],
+            [
+              "Umb.Tiptap.Toolbar.Bold",
+              "Umb.Tiptap.Toolbar.Italic",
+              "Umb.Tiptap.Toolbar.Underline"
+            ],
+            [
+              "Umb.Tiptap.Toolbar.TextAlignLeft",
+              "Umb.Tiptap.Toolbar.TextAlignCenter",
+              "Umb.Tiptap.Toolbar.TextAlignRight"
+            ],
+            [
+              "Umb.Tiptap.Toolbar.BulletList",
+              "Umb.Tiptap.Toolbar.OrderedList"
+            ],
+            [
+              "Umb.Tiptap.Toolbar.Blockquote",
+              "Umb.Tiptap.Toolbar.HorizontalRule"
+            ],
+            [
+              "Umb.Tiptap.Toolbar.Link",
+              "Umb.Tiptap.Toolbar.Unlink"
+            ],
+            [
+              "Umb.Tiptap.Toolbar.MediaPicker",
+              "Umb.Tiptap.Toolbar.EmbeddedMedia"
+            ]
+          ]
+        ]
+      },
+      {
+        "alias": "maxImageSize",
+        "value": 500
+      },
+      {
+        "alias": "overlaySize",
+        "value": "medium"
+      },
+      {
+        "alias": "extensions",
+        "value": [
+          "Umb.Tiptap.Embed",
+          "Umb.Tiptap.Figure",
+          "Umb.Tiptap.Image",
+          "Umb.Tiptap.Link",
+          "Umb.Tiptap.MediaUpload",
+          "Umb.Tiptap.RichTextEssentials",
+          "Umb.Tiptap.Subscript",
+          "Umb.Tiptap.Superscript",
+          "Umb.Tiptap.Table",
+          "Umb.Tiptap.TextAlign",
+          "Umb.Tiptap.TextDirection",
+          "Umb.Tiptap.Underline"
+        ]
+      }
+    ]
+  }
+};
+
+// src/umb-management-api/tools/data-type/get/get-data-type-property-editor-template.ts
+var propertyEditorTemplateSchema = _zod.z.object({
+  editorName: _zod.z.string().optional().describe("The name of the property editor template to retrieve (e.g., 'Textbox', 'Toggle', 'RichTextEditor_TinyMCE'). If not provided, returns a list of all available property editor names.")
+});
+var GetDataTypePropertyEditorTemplateTool = CreateUmbracoTool(
+  "get-data-type-property-editor-template",
+  `Retrieves property editor templates for creating data types in Umbraco.
+
+IMPORTANT: This tool should be used BEFORE creating data types to understand:
+- What property editors are available
+- The required configuration structure for each property editor
+- Example values that can be customized for your needs
+
+Usage:
+1. Call without parameters to see all available property editor names
+2. Call with a specific editorName to get the full configuration template for that property editor
+3. Use the returned template as a starting point when creating new data types with create-data-type
+
+The templates include:
+- editorAlias: The internal Umbraco editor identifier (required)
+- editorUiAlias: The UI component identifier (required)
+- values: An array of configuration options with example values
+- _notes: Important information about special requirements or options
+
+Note: Some templates (like BlockList, BlockGrid) have _notes indicating you must create element types first before creating the data type.`,
+  propertyEditorTemplateSchema.shape,
+  async (model) => {
+    try {
+      if (!model.editorName) {
+        const availableEditors = Object.entries(propertyEditorTemplates).map(([name, config]) => {
+          const hasNotes = config._notes ? ` (${config._notes})` : "";
+          return `- ${name}${hasNotes}`;
+        }).sort().join("\n");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Available Property Editor Templates:
+
+${availableEditors}
+
+Use get-data-type-property-editor-template with a specific editorName to see the full configuration.`
+            }
+          ]
+        };
+      }
+      const editorKey = Object.keys(propertyEditorTemplates).find(
+        (key) => key.toLowerCase() === model.editorName.toLowerCase()
+      );
+      if (!editorKey) {
+        const availableEditors = Object.keys(propertyEditorTemplates).sort().join(", ");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Property editor template '${model.editorName}' not found.
+
+Available templates: ${availableEditors}
+
+Note: Editor names are case-insensitive.`
+            }
+          ],
+          isError: true
+        };
+      }
+      const template = propertyEditorTemplates[editorKey];
+      let response = `Property Editor Template: ${editorKey}
+
+`;
+      if (template._notes) {
+        response += `IMPORTANT NOTES:
+${template._notes}
+
+`;
+      }
+      response += `Configuration:
+${JSON.stringify(template, null, 2)}
+
+`;
+      response += `Usage with create-data-type:
+`;
+      response += `When creating a data type with this property editor, use:
+`;
+      response += `- editorAlias: "${template.editorAlias}"
+`;
+      response += `- editorUiAlias: "${template.editorUiAlias}"
+`;
+      if (template.values && template.values.length > 0) {
+        response += `- values: Customize the values array based on your requirements
+`;
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: response
+          }
+        ]
+      };
+    } catch (error) {
+      console.error("Error reading property editor templates:", error);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error reading property editor templates: ${error instanceof Error ? error.message : String(error)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+var get_data_type_property_editor_template_default = GetDataTypePropertyEditorTemplateTool;
+
+// src/umb-management-api/tools/data-type/put/update-data-type.ts
+
+var UpdateDataTypeTool = CreateUmbracoTool(
+  "update-data-type",
+  "Updates a data type by Id",
+  {
+    id: putDataTypeByIdParams.shape.id,
+    data: _zod.z.object(putDataTypeByIdBody.shape)
+  },
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.putDataTypeById(model.id, model.data);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var update_data_type_default = UpdateDataTypeTool;
+
+// src/umb-management-api/tools/data-type/post/copy-data-type.ts
+
+var CopyDataTypeTool = CreateUmbracoTool(
+  "copy-data-type",
+  "Copy a data type by Id",
+  {
+    id: postDataTypeByIdCopyParams.shape.id,
+    body: _zod.z.object(postDataTypeByIdCopyBody.shape)
+  },
+  async ({ id, body }) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.postDataTypeByIdCopy(id, body);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var copy_data_type_default = CopyDataTypeTool;
+
+// src/umb-management-api/tools/data-type/get/is-used-data-type.ts
+var IsUsedDataTypeTool = CreateUmbracoTool(
+  "is-used-data-type",
+  "Checks if a data type is used within Umbraco",
+  getDataTypeByIdIsUsedParams.shape,
+  async ({ id }) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.getDataTypeByIdIsUsed(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var is_used_data_type_default = IsUsedDataTypeTool;
+
+// src/umb-management-api/tools/data-type/put/move-data-type.ts
+
+var MoveDataTypeTool = CreateUmbracoTool(
+  "move-data-type",
+  "Move a data type by Id",
+  {
+    id: putDataTypeByIdMoveParams.shape.id,
+    body: _zod.z.object(putDataTypeByIdMoveBody.shape)
+  },
+  async ({ id, body }) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.putDataTypeByIdMove(id, body);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var move_data_type_default = MoveDataTypeTool;
+
+// src/umb-management-api/tools/data-type/get/get-references-data-type.ts
+var GetReferencesDataTypeTool = CreateUmbracoTool(
+  "get-references-data-type",
+  `Gets the document types and properties that use a specific data type.
+  
+  This is the recommended method to find all document types that reference a particular data type.
+    
+  Usage examples:
+  - Find all document types using the RichText editor data type
+  - Identify properties that reference a specific data type before modifying or deleting it
+  - Perform bulk updates to all properties using a specific data type
+    
+  Returns a detailed list with content type information (id, type, name, icon) and all properties
+  (name, alias) that use the specified data type.
+  `,
+  getDataTypeByIdReferencesParams.shape,
+  async ({ id }) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.getDataTypeByIdReferences(id);
+    return {
+      content: [
+        {
+          type: "text",
           text: JSON.stringify(response)
         }
       ]
@@ -14033,6 +14861,7 @@ var DataTypeCollection = {
       tools.push(is_used_data_type_default());
       tools.push(get_data_type_default());
       tools.push(get_data_type_configuration_default());
+      tools.push(get_data_type_property_editor_template_default());
     }
     if (AuthorizationPolicies.TreeAccessDataTypes(user)) {
       tools.push(get_root_default());
@@ -14119,13 +14948,29 @@ var GetDictionaryItemTool = CreateUmbracoTool(
 var get_dictionary_item_default = GetDictionaryItemTool;
 
 // src/umb-management-api/tools/dictionary/post/create-dictionary-item.ts
+
+var createDictionarySchema = _zod.z.object({
+  name: _zod.z.string().min(1, "Name is required"),
+  parentId: _zod.z.string().uuid().optional(),
+  translations: _zod.z.array(_zod.z.object({
+    isoCode: _zod.z.string().min(1, "ISO code is required"),
+    translation: _zod.z.string()
+  })),
+  id: _zod.z.string().uuid().nullish()
+});
 var CreateDictionaryItemTool = CreateUmbracoTool(
   "create-dictionary",
-  "Creates a new dictionary item",
-  postDictionaryBody.shape,
+  `Creates a new dictionary item.`,
+  createDictionarySchema.shape,
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.postDictionary(model);
+    const payload = {
+      name: model.name,
+      parent: model.parentId ? { id: model.parentId } : void 0,
+      translations: model.translations,
+      id: model.id
+    };
+    var response = await client.postDictionary(payload);
     return {
       content: [
         {
@@ -14275,7 +15120,7 @@ var DictionaryCollection = {
 
 // src/umb-management-api/tools/document-type/post/create-document-type.ts
 
-var _uuid = require('uuid');
+
 
 // src/umb-management-api/tools/document-type/post/helpers/create-container-hierarchy.ts
 
@@ -14290,38 +15135,44 @@ var propertySchema = _zod.z.object({
 function createContainerHierarchy(properties) {
   const containerIds = /* @__PURE__ */ new Map();
   const tabs = /* @__PURE__ */ new Set();
-  const groups = /* @__PURE__ */ new Set();
   properties.forEach((prop) => {
     if (prop.tab) tabs.add(prop.tab);
-    if (prop.group) groups.add(prop.group);
   });
-  const containers = [
-    // Create tabs first
-    ...Array.from(tabs).map((tabName, index) => {
-      const id = _uuid.v4.call(void 0, );
-      containerIds.set(tabName, id);
-      return {
-        id,
-        name: tabName,
-        type: "Tab",
-        parent: null,
-        sortOrder: index
-      };
-    }),
-    // Then create groups, linking to their tabs if specified
-    ...Array.from(groups).map((groupName, index) => {
-      const id = _uuid.v4.call(void 0, );
-      containerIds.set(groupName, id);
-      const prop = properties.find((p) => p.group === groupName);
-      return {
-        id,
-        name: groupName,
-        type: "Group",
-        parent: _optionalChain([prop, 'optionalAccess', _49 => _49.tab]) ? { id: containerIds.get(prop.tab) } : null,
-        sortOrder: index
-      };
-    })
-  ];
+  const groupKeys = /* @__PURE__ */ new Map();
+  properties.forEach((prop) => {
+    if (prop.group) {
+      const key = `${prop.tab || "NO_TAB"}::${prop.group}`;
+      if (!groupKeys.has(key)) {
+        groupKeys.set(key, {
+          groupName: prop.group,
+          tabName: prop.tab
+        });
+      }
+    }
+  });
+  const containers = Array.from(tabs).map((tabName, index) => {
+    const id = _uuid.v4.call(void 0, );
+    containerIds.set(tabName, id);
+    return {
+      id,
+      name: tabName,
+      type: "Tab",
+      parent: null,
+      sortOrder: index
+    };
+  });
+  const groupContainers = Array.from(groupKeys.entries()).map(([key, groupKey], index) => {
+    const id = _uuid.v4.call(void 0, );
+    containerIds.set(key, id);
+    return {
+      id,
+      name: groupKey.groupName,
+      type: "Group",
+      parent: groupKey.tabName ? { id: containerIds.get(groupKey.tabName) } : null,
+      sortOrder: index
+    };
+  });
+  containers.push(...groupContainers);
   return { containers, containerIds };
 }
 
@@ -14332,6 +15183,7 @@ var createDocumentTypeSchema = _zod.z.object({
   description: _zod.z.string().optional(),
   icon: _zod.z.string().min(1, "Icon is required"),
   allowedAsRoot: _zod.z.boolean().default(false),
+  parentId: _zod.z.string().uuid().optional(),
   compositions: _zod.z.array(_zod.z.string().uuid("Must be a valid document type UUID")).default([]),
   allowedDocumentTypes: _zod.z.array(_zod.z.string().uuid("Must be a valid document type UUID")).default([]),
   collection: _zod.z.string().uuid("Must be a valid collection data type UUID").optional(),
@@ -14342,28 +15194,36 @@ var createDocumentTypeSchema = _zod.z.object({
       dataTypeId: _zod.z.string().uuid("Must be a valid data type UUID"),
       tab: _zod.z.string().optional(),
       group: _zod.z.string().optional()
-    })
+    }).refine(
+      (data) => data.tab || data.group,
+      {
+        message: "Property must specify either 'tab' or 'group' (or both) to appear in Umbraco UI. Properties without a container are invisible.",
+        path: ["tab"]
+      }
+    )
   ).default([])
 });
 var CreateDocumentTypeTool = CreateUmbracoTool(
   "create-document-type",
   `Creates a new document type in Umbraco.
-  
+
 IMPORTANT: IMPLEMENTATION REQUIREMENTS
 
 1. ALWAYS use the get-icons tool to find a valid icon name
 2. When referencing data types, first find them using find-data-type to get their correct IDs
 3. When adding compositions or allowed document types, first use get-document-type-root to find the actual IDs
 4. The tool will automatically generate UUIDs for properties and containers
-5. Always create new document types in the root before copying to a new folder if required
+5. Document types can be created in folders by specifying a parentId, or at the root level by omitting the parentId
 6. Do not try to add templates to document types they are not currently supported
-6. Property container structure:
-   - Properties can specify a tab and/or group
-   - Groups will be created inside their specified tab
-   - Properties without a tab/group will be at root level
+7. Property container structure:
+   - Properties MUST specify either a 'tab' or 'group' (or both) to appear in Umbraco UI
+   - Property with only tab: appears directly in the tab
+   - Property with only group: appears in the group (group has no parent tab)
+   - Property with both tab and group: group is nested inside the tab, property appears in the group
    - The tool will automatically create the container hierarchy`,
   createDocumentTypeSchema.shape,
-  async (model) => {
+  async (rawModel) => {
+    const model = createDocumentTypeSchema.parse(rawModel);
     const documentTypeId = _uuid.v4.call(void 0, );
     const { containers, containerIds } = createContainerHierarchy(
       model.properties
@@ -14371,7 +15231,8 @@ IMPORTANT: IMPLEMENTATION REQUIREMENTS
     const properties = model.properties.map((prop, index) => {
       let containerId;
       if (prop.group) {
-        containerId = containerIds.get(prop.group);
+        const key = `${prop.tab || "NO_TAB"}::${prop.group}`;
+        containerId = containerIds.get(key);
       } else if (prop.tab) {
         containerId = containerIds.get(prop.tab);
       }
@@ -14421,18 +15282,42 @@ IMPORTANT: IMPLEMENTATION REQUIREMENTS
         documentType: { id },
         sortOrder: index
       })),
-      collection: model.collection ? { id: model.collection } : void 0
+      collection: model.collection ? { id: model.collection } : void 0,
+      parent: model.parentId ? { id: model.parentId } : void 0
     };
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.postDocumentType(payload);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(response, null, 2)
-        }
-      ]
-    };
+    const response = await client.postDocumentType(payload, {
+      returnFullResponse: true,
+      validateStatus: () => true
+    });
+    if (response.status === 201) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              message: "Document type created successfully",
+              id: documentTypeId
+            })
+          }
+        ]
+      };
+    } else {
+      const errorData = response.data;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              message: "Failed to create document type",
+              status: response.status,
+              error: errorData || response.statusText
+            })
+          }
+        ],
+        isError: true
+      };
+    }
   }
 );
 var create_document_type_default = CreateDocumentTypeTool;
@@ -15367,7 +16252,13 @@ var createElementTypeSchema = _zod.z.object({
       dataTypeId: _zod.z.string().uuid("Must be a valid data type UUID"),
       tab: _zod.z.string().optional(),
       group: _zod.z.string().optional()
-    })
+    }).refine(
+      (data) => data.tab || data.group,
+      {
+        message: "Property must specify either 'tab' or 'group' (or both) to appear in Umbraco UI. Properties without a container are invisible.",
+        path: ["tab"]
+      }
+    )
   ).default([])
 });
 var CreateElementTypeTool = CreateUmbracoTool(
@@ -15382,12 +16273,14 @@ IMPORTANT: IMPLEMENTATION REQUIREMENTS
 4. The tool will automatically generate UUIDs for properties and containers
 5. Always create new element types in the root before copying to a new folder if required
 6. Property container structure:
-   - Properties can specify a tab and/or group
-   - Groups will be created inside their specified tab
-   - Properties without a tab/group will be at root level
+   - Properties MUST specify either a 'tab' or 'group' (or both) to appear in Umbraco UI
+   - Property with only tab: appears directly in the tab
+   - Property with only group: appears in the group (group has no parent tab)
+   - Property with both tab and group: group is nested inside the tab, property appears in the group
    - The tool will automatically create the container hierarchy`,
   createElementTypeSchema.shape,
-  async (model) => {
+  async (rawModel) => {
+    const model = createElementTypeSchema.parse(rawModel);
     const elementTypeId = _uuid.v4.call(void 0, );
     const { containers, containerIds } = createContainerHierarchy(
       model.properties
@@ -15395,7 +16288,8 @@ IMPORTANT: IMPLEMENTATION REQUIREMENTS
     const properties = model.properties.map((prop, index) => {
       let containerId;
       if (prop.group) {
-        containerId = containerIds.get(prop.group);
+        const key = `${prop.tab || "NO_TAB"}::${prop.group}`;
+        containerId = containerIds.get(key);
       } else if (prop.tab) {
         containerId = containerIds.get(prop.tab);
       }
@@ -15444,15 +16338,38 @@ IMPORTANT: IMPLEMENTATION REQUIREMENTS
       allowedDocumentTypes: []
     };
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.postDocumentType(payload);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(response, null, 2)
-        }
-      ]
-    };
+    const response = await client.postDocumentType(payload, {
+      returnFullResponse: true,
+      validateStatus: () => true
+    });
+    if (response.status === 201) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              message: "Element type created successfully",
+              id: elementTypeId
+            })
+          }
+        ]
+      };
+    } else {
+      const errorData = response.data;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              message: "Failed to create element type",
+              status: response.status,
+              error: errorData || response.statusText
+            })
+          }
+        ],
+        isError: true
+      };
+    }
   }
 );
 var create_element_type_default = CreateElementTypeTool;
@@ -15753,7 +16670,136 @@ var UpdateDocumentBlueprintTool = CreateUmbracoTool(
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.putDocumentBlueprintById(model.id, model.data);
+    var response = await client.putDocumentBlueprintById(model.id, model.data);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var update_blueprint_default = UpdateDocumentBlueprintTool;
+
+// src/umb-management-api/tools/document-blueprint/post/create-blueprint.ts
+
+var createDocumentBlueprintSchema = _zod.z.object({
+  values: _zod.z.array(_zod.z.object({
+    culture: _zod.z.string().nullish(),
+    segment: _zod.z.string().nullish(),
+    alias: _zod.z.string().min(1),
+    value: _zod.z.any().nullish()
+  })),
+  variants: _zod.z.array(_zod.z.object({
+    culture: _zod.z.string().nullish(),
+    segment: _zod.z.string().nullish(),
+    name: _zod.z.string().min(1)
+  })),
+  documentType: _zod.z.object({
+    id: _zod.z.string().uuid()
+  }),
+  id: _zod.z.string().uuid().nullish(),
+  parentId: _zod.z.string().uuid().optional()
+  // Flattened parent ID
+});
+var CreateDocumentBlueprintTool = CreateUmbracoTool(
+  "create-document-blueprint",
+  `Creates a new document blueprint.`,
+  createDocumentBlueprintSchema.shape,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const payload = {
+      values: model.values,
+      variants: model.variants,
+      documentType: model.documentType,
+      id: model.id,
+      parent: model.parentId ? { id: model.parentId } : void 0
+    };
+    const response = await client.postDocumentBlueprint(payload);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  },
+  (user) => user.fallbackPermissions.includes("Umb.Document.CreateBlueprint")
+);
+var create_blueprint_default = CreateDocumentBlueprintTool;
+
+// src/umb-management-api/tools/document-blueprint/get/get-ancestors.ts
+var GetDocumentBlueprintAncestorsTool = CreateUmbracoTool(
+  "get-document-blueprint-ancestors",
+  "Gets the ancestors of a document blueprint by Id",
+  getTreeDocumentBlueprintAncestorsQueryParams.shape,
+  async (params) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.getTreeDocumentBlueprintAncestors(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_ancestors_default4 = GetDocumentBlueprintAncestorsTool;
+
+// src/umb-management-api/tools/document-blueprint/get/get-children.ts
+var GetDocumentBlueprintChildrenTool = CreateUmbracoTool(
+  "get-document-blueprint-children",
+  "Gets the children of a document blueprint by Id",
+  getTreeDocumentBlueprintChildrenQueryParams.shape,
+  async (params) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.getTreeDocumentBlueprintChildren(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var get_children_default4 = GetDocumentBlueprintChildrenTool;
+
+// src/umb-management-api/tools/document-blueprint/get/get-root.ts
+var GetDocumentBlueprintRootTool = CreateUmbracoTool(
+  "get-document-blueprint-root",
+  "Gets the root level of the document blueprint tree",
+  getTreeDocumentBlueprintRootQueryParams.shape,
+  async (params) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.getTreeDocumentBlueprintRoot(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+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: [
         {
@@ -15764,16 +16810,33 @@ var UpdateDocumentBlueprintTool = CreateUmbracoTool(
     };
   }
 );
-var update_blueprint_default = UpdateDocumentBlueprintTool;
+var get_document_blueprint_scaffold_default = GetDocumentBlueprintScaffoldTool;
 
-// src/umb-management-api/tools/document-blueprint/post/create-blueprint.ts
-var CreateDocumentBlueprintTool = CreateUmbracoTool(
-  "create-document-blueprint",
-  "Creates a new document blueprint",
-  postDocumentBlueprintBody.shape,
+// src/umb-management-api/tools/document-blueprint/post/create-document-blueprint-from-document.ts
+
+var createDocumentBlueprintFromDocumentSchema = _zod.z.object({
+  document: _zod.z.object({
+    id: _zod.z.string().uuid()
+  }),
+  id: _zod.z.string().uuid().optional(),
+  name: _zod.z.string()
+});
+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.
+
+  Note: Blueprints created from documents are always created at the root level. Use the move-document-blueprint tool to relocate them to folders after creation if needed.`,
+  createDocumentBlueprintFromDocumentSchema.shape,
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.postDocumentBlueprint(model);
+    const payload = {
+      document: model.document,
+      id: _nullishCoalesce(model.id, () => ( void 0)),
+      name: model.name,
+      parent: void 0
+    };
+    const response = await client.postDocumentBlueprintFromDocument(payload);
     return {
       content: [
         {
@@ -15785,16 +16848,16 @@ var CreateDocumentBlueprintTool = CreateUmbracoTool(
   },
   (user) => user.fallbackPermissions.includes("Umb.Document.CreateBlueprint")
 );
-var create_blueprint_default = CreateDocumentBlueprintTool;
+var create_document_blueprint_from_document_default = CreateDocumentBlueprintFromDocumentTool;
 
-// src/umb-management-api/tools/document-blueprint/get/get-ancestors.ts
-var GetDocumentBlueprintAncestorsTool = CreateUmbracoTool(
-  "get-document-blueprint-ancestors",
-  "Gets the ancestors of a document blueprint by Id",
-  getTreeDocumentBlueprintAncestorsQueryParams.shape,
+// src/umb-management-api/tools/document-blueprint/get/get-document-blueprint-by-id-array.ts
+var GetDocumentBlueprintByIdArrayTool = CreateUmbracoTool(
+  "get-document-blueprint-by-id-array",
+  "Gets document blueprints by IDs (or empty array if no IDs are provided)",
+  getItemDocumentBlueprintQueryParams.shape,
   async (params) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.getTreeDocumentBlueprintAncestors(params);
+    const response = await client.getItemDocumentBlueprint(params);
     return {
       content: [
         {
@@ -15805,16 +16868,23 @@ var GetDocumentBlueprintAncestorsTool = CreateUmbracoTool(
     };
   }
 );
-var get_ancestors_default4 = GetDocumentBlueprintAncestorsTool;
+var get_document_blueprint_by_id_array_default = GetDocumentBlueprintByIdArrayTool;
 
-// src/umb-management-api/tools/document-blueprint/get/get-children.ts
-var GetDocumentBlueprintChildrenTool = CreateUmbracoTool(
-  "get-document-blueprint-children",
-  "Gets the children of a document blueprint by Id",
-  getTreeDocumentBlueprintChildrenQueryParams.shape,
-  async (params) => {
+// src/umb-management-api/tools/document-blueprint/put/move-blueprint.ts
+
+var MoveDocumentBlueprintTool = CreateUmbracoTool(
+  "move-document-blueprint",
+  "Moves a document blueprint by Id",
+  {
+    id: putDocumentBlueprintByIdMoveParams.shape.id,
+    data: _zod.z.object(putDocumentBlueprintByIdMoveBody.shape)
+  },
+  async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.getTreeDocumentBlueprintChildren(params);
+    var response = await client.putDocumentBlueprintByIdMove(
+      model.id,
+      model.data
+    );
     return {
       content: [
         {
@@ -15825,16 +16895,16 @@ var GetDocumentBlueprintChildrenTool = CreateUmbracoTool(
     };
   }
 );
-var get_children_default4 = GetDocumentBlueprintChildrenTool;
+var move_blueprint_default = MoveDocumentBlueprintTool;
 
-// src/umb-management-api/tools/document-blueprint/get/get-root.ts
-var GetDocumentBlueprintRootTool = CreateUmbracoTool(
-  "get-document-blueprint-root",
-  "Gets the root level of the document blueprint tree",
-  getTreeDocumentBlueprintRootQueryParams.shape,
-  async (params) => {
+// src/umb-management-api/tools/document-blueprint/folders/post/create-folder.ts
+var CreateDocumentBlueprintFolderTool = CreateUmbracoTool(
+  "create-document-blueprint-folder",
+  "Creates a new document blueprint folder",
+  postDocumentBlueprintFolderBody.shape,
+  async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.getTreeDocumentBlueprintRoot(params);
+    var response = await client.postDocumentBlueprintFolder(model);
     return {
       content: [
         {
@@ -15845,17 +16915,16 @@ var GetDocumentBlueprintRootTool = CreateUmbracoTool(
     };
   }
 );
-var get_root_default4 = GetDocumentBlueprintRootTool;
+var create_folder_default3 = CreateDocumentBlueprintFolderTool;
 
-// 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,
+// src/umb-management-api/tools/document-blueprint/folders/get/get-folder.ts
+var GetDocumentBlueprintFolderTool = CreateUmbracoTool(
+  "get-document-blueprint-folder",
+  "Gets a document blueprint folder by Id",
+  getDocumentBlueprintFolderByIdParams.shape,
   async ({ id }) => {
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.getDocumentBlueprintByIdScaffold(id);
+    var response = await client.getDocumentBlueprintFolderById(id);
     return {
       content: [
         {
@@ -15866,17 +16935,20 @@ var GetDocumentBlueprintScaffoldTool = CreateUmbracoTool(
     };
   }
 );
-var get_document_blueprint_scaffold_default = GetDocumentBlueprintScaffoldTool;
+var get_folder_default3 = GetDocumentBlueprintFolderTool;
 
-// 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) => {
+// src/umb-management-api/tools/document-blueprint/folders/put/update-folder.ts
+
+var UpdateDocumentBlueprintFolderTool = CreateUmbracoTool(
+  "update-document-blueprint-folder",
+  "Updates a document blueprint folder",
+  {
+    id: putDocumentBlueprintFolderByIdParams.shape.id,
+    data: _zod.z.object(putDocumentBlueprintFolderByIdBody.shape)
+  },
+  async ({ id, data }) => {
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.postDocumentBlueprintFromDocument(model);
+    const response = await client.putDocumentBlueprintFolderById(id, data);
     return {
       content: [
         {
@@ -15885,10 +16957,29 @@ var CreateDocumentBlueprintFromDocumentTool = CreateUmbracoTool(
         }
       ]
     };
-  },
-  (user) => user.fallbackPermissions.includes("Umb.Document.CreateBlueprint")
+  }
 );
-var create_document_blueprint_from_document_default = CreateDocumentBlueprintFromDocumentTool;
+var update_folder_default3 = UpdateDocumentBlueprintFolderTool;
+
+// src/umb-management-api/tools/document-blueprint/folders/delete/delete-folder.ts
+var DeleteDocumentBlueprintFolderTool = CreateUmbracoTool(
+  "delete-document-blueprint-folder",
+  "Deletes a document blueprint folder by Id",
+  deleteDocumentBlueprintFolderByIdParams.shape,
+  async ({ id }) => {
+    const client = UmbracoManagementClient2.getClient();
+    var response = await client.deleteDocumentBlueprintFolderById(id);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  }
+);
+var delete_folder_default3 = DeleteDocumentBlueprintFolderTool;
 
 // src/umb-management-api/tools/document-blueprint/index.ts
 var DocumentBlueprintCollection = {
@@ -15902,14 +16993,20 @@ var DocumentBlueprintCollection = {
     const tools = [];
     if (AuthorizationPolicies.TreeAccessDocumentTypes(user)) {
       tools.push(get_blueprint_default());
-      tools.push(delete_blueprint_default());
-      tools.push(update_blueprint_default());
       tools.push(create_blueprint_default());
+      tools.push(update_blueprint_default());
+      tools.push(delete_blueprint_default());
+      tools.push(move_blueprint_default());
+      tools.push(get_document_blueprint_by_id_array_default());
+      tools.push(get_document_blueprint_scaffold_default());
+      tools.push(create_document_blueprint_from_document_default());
       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());
+      tools.push(create_folder_default3());
+      tools.push(get_folder_default3());
+      tools.push(update_folder_default3());
+      tools.push(delete_folder_default3());
     }
     return tools;
   }
@@ -16159,11 +17256,507 @@ var GetDocumentUrlsTool = CreateUmbracoTool(
           type: "text",
           text: JSON.stringify(response)
         }
-      ]
-    };
+      ]
+    };
+  }
+);
+var get_document_urls_default = GetDocumentUrlsTool;
+
+// src/umb-management-api/tools/document/get/get-document-property-value-template.ts
+
+
+// src/umb-management-api/tools/document/post/property-value-templates.ts
+var propertyValueTemplates = {
+  "BlockList": {
+    editorAlias: "Umbraco.BlockList",
+    value: {
+      layout: {
+        "Umbraco.BlockList": [
+          {
+            contentKey: "7a61b31c-792f-4f6b-a665-960a90b49853"
+          }
+        ]
+      },
+      contentData: [
+        {
+          key: "7a61b31c-792f-4f6b-a665-960a90b49853",
+          contentTypeKey: "3a7ec32d-7fd4-49f8-aae6-d9259d5bfee1",
+          values: [
+            {
+              editorAlias: "Umbraco.MediaPicker3",
+              culture: null,
+              segment: null,
+              alias: "recipeImage",
+              value: [
+                {
+                  key: "9bac772d-cd63-4bb6-b2db-1449042129a7",
+                  mediaKey: "3c6c415c-35a0-4629-891e-683506250c31",
+                  mediaTypeAlias: "",
+                  crops: [],
+                  focalPoint: null
+                }
+              ]
+            }
+          ]
+        }
+      ],
+      settingsData: [],
+      expose: [
+        {
+          contentKey: "7a61b31c-792f-4f6b-a665-960a90b49853",
+          culture: null,
+          segment: null
+        }
+      ]
+    },
+    _notes: "Complex structure with layout, contentData, settingsData, and expose arrays. contentData.values contains nested property values. All keys must be unique UUIDs."
+  },
+  "BlockGrid": {
+    editorAlias: "Umbraco.BlockGrid",
+    value: {
+      layout: {
+        "Umbraco.BlockGrid": [
+          {
+            contentKey: "d8fa3d28-79aa-4c60-8e73-5819ed313ea2",
+            columnSpan: 12,
+            rowSpan: 1,
+            areas: [
+              {
+                key: "43743e78-0f2b-465e-a3ce-f381c90b68e0",
+                items: [
+                  {
+                    contentKey: "3145f922-7ec1-41e0-99a5-d9677e558163",
+                    settingsKey: "6248d134-4657-4605-b0d5-ae804858bb88",
+                    columnSpan: 6,
+                    rowSpan: 1
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      },
+      contentData: [
+        {
+          key: "d8fa3d28-79aa-4c60-8e73-5819ed313ea2",
+          contentTypeKey: "6960aaca-0b26-4fae-9cee-db73405d7a3e",
+          values: [
+            {
+              editorAlias: "Umbraco.TextBox",
+              culture: null,
+              segment: null,
+              alias: "title",
+              value: "Title"
+            },
+            {
+              editorAlias: "Umbraco.RichText",
+              culture: null,
+              segment: null,
+              alias: "bodyText",
+              value: {
+                markup: "<p>Content here</p>",
+                blocks: {
+                  layout: {},
+                  contentData: [],
+                  settingsData: [],
+                  expose: []
+                }
+              }
+            },
+            {
+              editorAlias: "Umbraco.MediaPicker3",
+              culture: null,
+              segment: null,
+              alias: "image",
+              value: [
+                {
+                  key: "40edd153-31eb-4c61-82fc-1ec2e695197b",
+                  mediaKey: "3c6c415c-35a0-4629-891e-683506250c31",
+                  mediaTypeAlias: "",
+                  crops: [],
+                  focalPoint: null
+                }
+              ]
+            }
+          ]
+        },
+        {
+          key: "3145f922-7ec1-41e0-99a5-d9677e558163",
+          contentTypeKey: "c80027e5-7e87-49c1-9b4f-1b9d3fbc2e90",
+          values: [
+            {
+              editorAlias: "Umbraco.TextBox",
+              culture: null,
+              segment: null,
+              alias: "title",
+              value: "Nested Title"
+            },
+            {
+              editorAlias: "Umbraco.RichText",
+              culture: null,
+              segment: null,
+              alias: "content",
+              value: {
+                markup: "<p>Nested content</p>",
+                blocks: {
+                  layout: {},
+                  contentData: [],
+                  settingsData: [],
+                  expose: []
+                }
+              }
+            }
+          ]
+        }
+      ],
+      settingsData: [
+        {
+          key: "6248d134-4657-4605-b0d5-ae804858bb88",
+          contentTypeKey: "06200e23-1c29-4298-9582-48b2eaa81fbf",
+          values: []
+        }
+      ],
+      expose: [
+        {
+          contentKey: "d8fa3d28-79aa-4c60-8e73-5819ed313ea2",
+          culture: null,
+          segment: null
+        },
+        {
+          contentKey: "3145f922-7ec1-41e0-99a5-d9677e558163",
+          culture: null,
+          segment: null
+        }
+      ]
+    },
+    _notes: "Complex hierarchical structure with areas and nested items. Layout defines structure with columnSpan/rowSpan. contentData stores actual content. All keys must be unique UUIDs."
+  },
+  "Decimal": {
+    editorAlias: "Umbraco.Decimal",
+    value: 1.2
+  },
+  "EmailAddress": {
+    editorAlias: "Umbraco.EmailAddress",
+    value: "admin@admin.co.uk"
+  },
+  "Integer": {
+    editorAlias: "Umbraco.Integer",
+    value: 1
+  },
+  "Tags": {
+    editorAlias: "Umbraco.Tags",
+    value: [
+      "Tag 1",
+      "Tag 2"
+    ]
+  },
+  "ColorPicker": {
+    editorAlias: "Umbraco.ColorPicker",
+    value: {
+      label: "Green",
+      value: "#00FF00"
+    }
+  },
+  "TrueFalse": {
+    editorAlias: "Umbraco.TrueFalse",
+    value: true
+  },
+  "CheckBoxList": {
+    editorAlias: "Umbraco.CheckBoxList",
+    value: [
+      "item 1",
+      "items 2"
+    ]
+  },
+  "Dropdown": {
+    editorAlias: "Umbraco.DropDown.Flexible",
+    value: [
+      "Item 3"
+    ]
+  },
+  "MultipleTextstring": {
+    editorAlias: "Umbraco.MultipleTextstring",
+    value: [
+      "Item 1",
+      "item 2"
+    ]
+  },
+  "RadioButtonList": {
+    editorAlias: "Umbraco.RadioButtonList",
+    value: "item 1"
+  },
+  "ImageCropper": {
+    editorAlias: "Umbraco.ImageCropper",
+    value: {
+      temporaryFileId: "b45eb1dd-2959-4b0b-a675-761b6a19824c",
+      src: "",
+      crops: [],
+      focalPoint: {
+        left: 0.5,
+        top: 0.5
+      }
+    },
+    _notes: "IMPORTANT: Requires a temporary file uploaded first. Use the temporaryFileId from the upload response."
+  },
+  "MediaPicker3": {
+    editorAlias: "Umbraco.MediaPicker3",
+    value: [
+      {
+        key: "4c82123c-cd3e-4d92-84b8-9c79ad5a5319",
+        mediaKey: "3c6c415c-35a0-4629-891e-683506250c31",
+        mediaTypeAlias: "",
+        crops: [],
+        focalPoint: null
+      }
+    ],
+    _notes: "The key is generated by you. The mediaKey relates to an existing media item id."
+  },
+  "UploadField": {
+    editorAlias: "Umbraco.UploadField",
+    value: {
+      src: "blob:http://localhost:56472/0884388b-41a3-46c2-a224-9b9ff02de24a",
+      temporaryFileId: "fc76f270-83c2-4daa-ba8b-fde4554dda2a"
+    },
+    _notes: "IMPORTANT: Requires a temporary file uploaded first. Use the temporaryFileId from the upload response."
+  },
+  "Slider": {
+    editorAlias: "Umbraco.Slider",
+    value: {
+      from: 31,
+      to: 31
+    }
+  },
+  "MemberGroupPicker": {
+    editorAlias: "Umbraco.MemberGroupPicker",
+    value: "9815503d-a5a9-487f-aee3-827ca43fdb2c",
+    _notes: "The value relates to an existing member group id."
+  },
+  "MemberPicker": {
+    editorAlias: "Umbraco.MemberPicker",
+    value: "f8abd31e-c78d-46ea-bb6b-c00cb9107bfb",
+    _notes: "The value relates to an existing member id."
+  },
+  "UserPicker": {
+    editorAlias: "Umbraco.UserPicker",
+    value: "1e70f841-c261-413b-abb2-2d68cdb96094",
+    _notes: "The value relates to an existing user id."
+  },
+  "MultiNodeTreePicker": {
+    editorAlias: "Umbraco.MultiNodeTreePicker",
+    value: [
+      {
+        type: "document",
+        unique: "dcf18a51-6919-4cf8-89d1-36b94ce4d963"
+      }
+    ],
+    _notes: "The unique property relates to an existing document, media, or member id. Type can be 'document', 'media', or 'member'."
+  },
+  "DateTime": {
+    editorAlias: "Umbraco.DateTime",
+    value: "2025-05-23 00:00:00"
+  },
+  "ContentPicker": {
+    editorAlias: "Umbraco.ContentPicker",
+    value: "dcf18a51-6919-4cf8-89d1-36b94ce4d963",
+    _notes: "The value relates to an existing document id."
+  },
+  "ColorPickerEyeDropper": {
+    editorAlias: "Umbraco.ColorPicker.EyeDropper",
+    value: "#982020"
+  },
+  "MultiUrlPicker": {
+    editorAlias: "Umbraco.MultiUrlPicker",
+    value: [
+      {
+        icon: "icon-home color-blue",
+        name: "Home",
+        type: "document",
+        unique: "dcf18a51-6919-4cf8-89d1-36b94ce4d963",
+        url: "/"
+      },
+      {
+        icon: "icon-picture",
+        name: "Chairs lamps",
+        type: "media",
+        unique: "3c6c415c-35a0-4629-891e-683506250c31",
+        url: "http://localhost:56472/media/0ofdvcwj/chairs-lamps.jpg"
+      },
+      {
+        name: "Title",
+        target: "_blank",
+        type: "external",
+        url: "www.google.com"
+      }
+    ],
+    _notes: "Can contain document, media, or external link entries. For document/media, unique is the content id."
+  },
+  "MarkdownEditor": {
+    editorAlias: "Umbraco.MarkdownEditor",
+    value: "Markdown"
+  },
+  "CodeEditor": {
+    editorAlias: "Umbraco.CodeEditor",
+    value: "Code"
+  },
+  "Textbox": {
+    editorAlias: "Umbraco.TextBox",
+    value: "some string"
+  },
+  "TextArea": {
+    editorAlias: "Umbraco.TextArea",
+    value: "some string"
+  },
+  "RichTextEditor": {
+    editorAlias: "Umbraco.RichText",
+    value: {
+      markup: "<p>some string</p>",
+      blocks: {
+        layout: {},
+        contentData: [],
+        settingsData: [],
+        expose: []
+      }
+    },
+    _notes: "The blocks property has the same structure as BlockList. Can include nested block content within the rich text."
+  }
+};
+
+// src/umb-management-api/tools/document/get/get-document-property-value-template.ts
+var propertyValueTemplateSchema = _zod.z.object({
+  editorAlias: _zod.z.string().optional().describe("The editor alias of the property value template to retrieve (e.g., 'Umbraco.TextBox', 'Umbraco.BlockList', 'Umbraco.MediaPicker3'). If not provided, returns a list of all available property editor aliases.")
+});
+var GetDocumentPropertyValueTemplateTool = CreateUmbracoTool(
+  "get-document-property-value-template",
+  `Retrieves property value templates for creating documents in Umbraco.
+
+IMPORTANT: This tool should be used BEFORE creating documents to understand:
+- What property editors are available
+- The required value structure for each property editor
+- Example values that can be customized for your needs
+
+Usage:
+1. Call without parameters to see all available property editor aliases
+2. Call with a specific editorAlias to get the full value template for that property editor
+3. Use the returned template as a starting point when creating document property values with create-document
+
+The templates include:
+- editorAlias: The property editor identifier (required in create-document values array)
+- value: Example value structure showing the expected format
+- _notes: Important information about special requirements (IDs, temporary files, etc.)
+
+IMPORTANT: Templates only provide editorAlias and value structure. When using with create-document, you must also provide:
+- culture: The culture code or null
+- segment: The segment or null
+- alias: The property alias from your document type
+
+Note: Some templates (BlockList, BlockGrid, ImageCropper, UploadField) have special requirements indicated in their _notes.`,
+  propertyValueTemplateSchema.shape,
+  async (model) => {
+    try {
+      if (!model.editorAlias) {
+        const availableEditors = Object.entries(propertyValueTemplates).map(([name, config]) => {
+          const hasNotes = config._notes ? ` (IMPORTANT: ${config._notes.substring(0, 50)}${config._notes.length > 50 ? "..." : ""})` : "";
+          return `- ${name} (${config.editorAlias})${hasNotes}`;
+        }).sort().join("\n");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Available Property Value Templates:
+
+${availableEditors}
+
+Use get-document-property-value-template with a specific editorAlias to see the full value structure.`
+            }
+          ]
+        };
+      }
+      const editorKey = Object.keys(propertyValueTemplates).find(
+        (key) => propertyValueTemplates[key].editorAlias.toLowerCase() === model.editorAlias.toLowerCase()
+      );
+      if (!editorKey) {
+        const editorKeyByName = Object.keys(propertyValueTemplates).find(
+          (key) => key.toLowerCase() === model.editorAlias.toLowerCase()
+        );
+        if (!editorKeyByName) {
+          const availableAliases = Object.values(propertyValueTemplates).map((t) => t.editorAlias).sort().join(", ");
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Property value template with editorAlias '${model.editorAlias}' not found.
+
+Available editor aliases: ${availableAliases}
+
+Note: Matching is case-insensitive. You can also use the template name (e.g., 'Textbox' instead of 'Umbraco.TextBox').`
+              }
+            ],
+            isError: true
+          };
+        }
+        const template2 = propertyValueTemplates[editorKeyByName];
+        return buildTemplateResponse(editorKeyByName, template2);
+      }
+      const template = propertyValueTemplates[editorKey];
+      return buildTemplateResponse(editorKey, template);
+    } catch (error) {
+      console.error("Error reading property value templates:", error);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error reading property value templates: ${error instanceof Error ? error.message : String(error)}`
+          }
+        ],
+        isError: true
+      };
+    }
   }
 );
-var get_document_urls_default = GetDocumentUrlsTool;
+function buildTemplateResponse(editorKey, template) {
+  let response = `Property Value Template: ${editorKey}
+
+`;
+  if (template._notes) {
+    response += `IMPORTANT NOTES:
+${template._notes}
+
+`;
+  }
+  response += `Template:
+${JSON.stringify({ editorAlias: template.editorAlias, value: template.value }, null, 2)}
+
+`;
+  response += `Usage with create-document:
+`;
+  response += `When creating a document with this property, include in the values array:
+`;
+  response += `{
+`;
+  response += `  "editorAlias": "${template.editorAlias}",  // From template
+`;
+  response += `  "culture": null,                           // Document-specific: culture code or null
+`;
+  response += `  "segment": null,                           // Document-specific: segment or null
+`;
+  response += `  "alias": "yourPropertyAlias",             // Document-specific: property alias from document type
+`;
+  response += `  "value": <customize from template>        // From template - customize as needed
+`;
+  response += `}
+
+`;
+  response += `The template provides editorAlias and value structure. You must add culture, segment, and alias based on your document requirements.`;
+  return {
+    content: [
+      {
+        type: "text",
+        text: response
+      }
+    ]
+  };
+}
+var get_document_property_value_template_default = GetDocumentPropertyValueTemplateTool;
 
 // src/umb-management-api/tools/document/get/search-document.ts
 var SearchDocumentTool = CreateUmbracoTool(
@@ -16458,608 +18051,75 @@ var CreateDocumentTool = CreateUmbracoTool(
   "create-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.
-
-  ## CRITICAL WORKFLOW REQUIREMENTS
-  1. ALWAYS first search for existing documents using search-document to find any documents that use the same document type
-  2. If documents of the same type exist, use copy-document instead to duplicate and modify the existing structure
-  3. ONLY if NO documents of the target document type exist should you analyze the document type structure
-  4. When analyzing document types, use get-document-type-by-id to understand the required properties
-  5. Then create the new document with the proper structure
-  
-  ## CRITICAL FOR DOCUMENT TYPES AND DATA TYPES
-  1. BEFORE creating any new document type or data type, ALWAYS search for existing ones using get-document-type-root, get-document-type-search, or find-data-type
-  2. ONLY create a new document type or data type if NO suitable existing ones are found
-  3. If similar types exist, inform the user and suggest using the existing types instead
-  4. Creation of new types should be a last resort when nothing suitable exists
-
-  ## CRITICAL: For document types with allowedAsRoot=true, DO NOT include the parentId parameter at all in the function call.
-
-  Values must match the aliases of the document type structure. 
-  Block lists, Block Grids and Rich Text Blocks items and settings must match the defined blocks document type structures.
-
-  ## CRITICAL: All generated keys must be unique and randomly generated.
-
-  ## Property Editor Value Examples
-
-  ### Block List
-
-  layout stores references to content and settings keys
-  contentData stores the content of the block list as an array of content items
-  settingsData stores the settings of the block list as an array of settings items
-  expose stores the segment and culture variants of the block list as an array of expose items
-
-  contentdata and settingsDate items
-  .key is the key of the content item, it is referenced by the layout and expose properties
-  contentTypeKey is the document type key
-  values stores a array of property values
-
-  {
-    "editorAlias": "Umbraco.BlockList",
-    "culture": null,
-    "segment": null,
-    "alias": "example",
-    "value": {
-      "layout": {
-        "Umbraco.BlockList": [
-          {
-            "contentKey": "7a61b31c-792f-4f6b-a665-960a90b49853"
-          }
-        ]
-      },
-      "contentData": [
-        {
-          "key": "7a61b31c-792f-4f6b-a665-960a90b49853",
-          "contentTypeKey": "3a7ec32d-7fd4-49f8-aae6-d9259d5bfee1",
-          "values": [
-            {
-              "editorAlias": "Umbraco.MediaPicker3",
-              "culture": null,
-              "segment": null,
-              "alias": "recipeImage",
-              "value": [
-                {
-                  "key": "9bac772d-cd63-4bb6-b2db-1449042129a7",
-                  "mediaKey": "3c6c415c-35a0-4629-891e-683506250c31",
-                  "mediaTypeAlias": "",
-                  "crops": [],
-                  "focalPoint": null
-                }
-              ]
-            }
-          ]
-        }
-      ],
-      "settingsData": [],
-      "expose": [
-        {
-          "contentKey": "7a61b31c-792f-4f6b-a665-960a90b49853",
-          "culture": null,
-          "segment": null
-        }
-      ]
-    }
-  }
-
-  ### Block Grid
-
-  Block grids create a hierarchy structure of content items.
-
-  layout stores the structure of the block grid where items can have multiple areas and each area can items which can in turn have areas and items.
-  areas can have a columnSpan and rowSpan to determine the size of the area.
-  contentData stores the content of the block grid as an array of content items, it has no bearing on the structure.
-  settingsData stores the settings of the block list as an array of settings items, it has no bearing on the structure.
-  expose stores the segment and culture variants of the block list as an array of expose items
-
-  contentdata and settingsDate items
-  .key is the key of the content item, it is referenced by the layout and expose properties
-  contentTypeKey is the document type key
-  values stores a array of property values
-
-  {
-    "editorAlias": "Umbraco.BlockGrid",
-    "culture": null,
-    "segment": null,
-    "alias": "grid",
-    "value": {
-      "layout": {
-        "Umbraco.BlockGrid": [
-          {
-            "contentKey": "d8fa3d28-79aa-4c60-8e73-5819ed313ea2",
-            "columnSpan": 12,
-            "rowSpan": 1,
-            "areas": [
-              {
-                "key": "43743e78-0f2b-465e-a3ce-f381c90b68e0",
-                "items": [
-                  {
-                    "contentKey": "3145f922-7ec1-41e0-99a5-d9677e558163",
-                    "settingsKey": "6248d134-4657-4605-b0d5-ae804858bb88",
-                    "columnSpan": 6,
-                    "rowSpan": 1
-                  }
-                ]
-              }
-            ]
-          }
-        ]
-      },
-      "contentData": [
-        {
-          "key": "d8fa3d28-79aa-4c60-8e73-5819ed313ea2",
-          "contentTypeKey": "6960aaca-0b26-4fae-9cee-db73405d7a3e",
-          "values": [
-            {
-              "editorAlias": "Umbraco.TextBox",
-              "culture": null,
-              "segment": null,
-              "alias": "title",
-              "value": "Title"
-            },
-            {
-              "editorAlias": "Umbraco.RichText",
-              "culture": null,
-              "segment": null,
-              "alias": "bodyText",
-              "value": {
-                "markup": "<p>cxcxcx</p>",
-                "blocks": {
-                  "layout": {},
-                  "contentData": [],
-                  "settingsData": [],
-                  "expose": []
-                }
-              }
-            },
-            {
-              "editorAlias": "Umbraco.MediaPicker3",
-              "culture": null,
-              "segment": null,
-              "alias": "image",
-              "value": [
-                {
-                  "key": "40edd153-31eb-4c61-82fc-1ec2e695197b",
-                  "mediaKey": "3c6c415c-35a0-4629-891e-683506250c31",
-                  "mediaTypeAlias": "",
-                  "crops": [],
-                  "focalPoint": null
-                }
-              ]
-            }
-          ]
-        },
-        {
-          "key": "3145f922-7ec1-41e0-99a5-d9677e558163",
-          "contentTypeKey": "c80027e5-7e87-49c1-9b4f-1b9d3fbc2e90",
-          "values": [
-            {
-              "editorAlias": "Umbraco.TextBox",
-              "culture": null,
-              "segment": null,
-              "alias": "title",
-              "value": "xccx"
-            },
-            {
-              "editorAlias": "Umbraco.RichText",
-              "culture": null,
-              "segment": null,
-              "alias": "content",
-              "value": {
-                "markup": "<p>xccx</p>",
-                "blocks": {
-                  "layout": {},
-                  "contentData": [],
-                  "settingsData": [],
-                  "expose": []
-                }
-              }
-            }
-          ]
-        }
-      ],
-      "settingsData": [
-        {
-          "key": "6248d134-4657-4605-b0d5-ae804858bb88",
-          "contentTypeKey": "06200e23-1c29-4298-9582-48b2eaa81fbf",
-          "values": []
-        }
-      ],
-      "expose": [
-        {
-          "contentKey": "d8fa3d28-79aa-4c60-8e73-5819ed313ea2",
-          "culture": null,
-          "segment": null
-        },
-        {
-          "contentKey": "3145f922-7ec1-41e0-99a5-d9677e558163",
-          "culture": null,
-          "segment": null
-        }
-      ]
-    }
-  }
-
-  ### Decimal
-
-  {
-    "editorAlias": "Umbraco.Decimal",
-    "culture": null,
-    "segment": null,
-    "alias": "example",
-    "value": 1.2
-  }
-
-  ### EmailAddress
-
-  {
-    "editorAlias": "Umbraco.EmailAddress",
-    "culture": null,
-    "segment": null,
-    "alias": "example",
-    "value": "admin@admin.co.uk"
-  }
-
-  ### Integer
-
-  {
-    "editorAlias": "Umbraco.Integer",
-    "culture": null,
-    "segment": null,
-    "alias": "example",
-    "value": 1
-  }
-
-  ### Tags
-
-  {
-    "editorAlias": "Umbraco.Tags",
-    "culture": null,
-    "segment": null,
-    "alias": "example",
-    "value": [
-      "Tag 1",
-      "Tag 2"
-    ]
-  }
-
-  ### Colour Picker
-
-  {
-    "editorAlias": "Umbraco.ColorPicker",
-    "culture": null,
-    "segment": null,
-    "alias": "test",
-    "value": {
-      "label": "Green",
-      "value": "#00FF00"
-    }
-  }
-
-  ### True False
-
-  {
-    "editorAlias": "Umbraco.TrueFalse",
-    "culture": null,
-    "segment": null,
-    "alias": "example",
-    "value": true
-  }
-
-  ### CheckBoxList
-
-  {
-    "editorAlias": "Umbraco.CheckBoxList",
-    "culture": null,
-    "segment": null,
-    "alias": "checkboxList",
-    "value": [
-      "item 1",
-      "items 2"
-    ]
-  }
-
-  ### Dropdown Flexible
-
-  {
-    "editorAlias": "Umbraco.DropDown.Flexible",
-    "culture": null,
-    "segment": null,
-    "alias": "dropdown",
-    "value": [
-      "Item 3"
-    ]
-  }
-
-  ### Multiple Textstring
-
-  {
-    "editorAlias": "Umbraco.MultipleTextstring",
-    "culture": null,
-    "segment": null,
-    "alias": "repeatableStrings",
-    "value": [
-      "Item 1",
-      "item 2"
-    ]
-  }
-
-  ### Radio Button List
-
-  {
-    "editorAlias": "Umbraco.RadioButtonList",
-    "culture": null,
-    "segment": null,
-    "alias": "radioButton",
-    "value": "item 1"
-  }
-
-  ### Image Cropper
-
-  Using this will require a temporary file uploaded first and the id provided
-
-  {
-    "editorAlias": "Umbraco.ImageCropper",
-    "culture": null,
-    "segment": null,
-    "alias": "imageBropper",
-    "value": {
-      "temporaryFileId": "b45eb1dd-2959-4b0b-a675-761b6a19824c",
-      "src": "",
-      "crops": [],
-      "focalPoint": {
-        "left": 0.5,
-        "top": 0.5
-      }
-    }
-  }
-
-  ### Media Picker 3
-
-  This key relates to a media item id. The key is generated by the system and is not provided by the user.
-
-  {
-    "editorAlias": "Umbraco.MediaPicker3",
-    "culture": null,
-    "segment": null,
-    "alias": "mediaPicker",
-    "value": [
-      {
-        "key": "4c82123c-cd3e-4d92-84b8-9c79ad5a5319",
-        "mediaKey": "3c6c415c-35a0-4629-891e-683506250c31",
-        "mediaTypeAlias": "",
-        "crops": [],
-        "focalPoint": null
-      }
-    ]
-  }
-
-  ### Upload Field
-
-  Using this will require a temporary file uploaded first and the id provided
-
-  {
-    "editorAlias": "Umbraco.UploadField",
-    "culture": null,
-    "segment": null,
-    "alias": "upload",
-    "value": {
-      "src": "blob:http://localhost:56472/0884388b-41a3-46c2-a224-9b9ff02de24a",
-      "temporaryFileId": "fc76f270-83c2-4daa-ba8b-fde4554dda2a"
-    }
-  }
-  
-  ### Slider
-
-  {
-    "editorAlias": "Umbraco.Slider",
-    "culture": null,
-    "segment": null,
-    "alias": "slider",
-    "value": {
-      "from": 31,
-      "to": 31
-    }
-  }
-
-  ### Member Group Picker
-
-  The value relates to an existing member group id.
-
-  {
-    "editorAlias": "Umbraco.MemberGroupPicker",
-    "culture": null,
-    "segment": null,
-    "alias": "memberGroup",
-    "value": "9815503d-a5a9-487f-aee3-827ca43fdb2c"
-  }
-
-  ### Member Picker
-
-  The value relates to an existing member id.
-
-  {
-    "editorAlias": "Umbraco.MemberPicker",
-    "culture": null,
-    "segment": null,
-    "alias": "member",
-    "value": "f8abd31e-c78d-46ea-bb6b-c00cb9107bfb"
-  }
-
-  ### User Picker
-
-  The value relates to an existing user id.
-
-  {
-    "editorAlias": "Umbraco.UserPicker",
-    "culture": null,
-    "segment": null,
-    "alias": "user",
-    "value": "1e70f841-c261-413b-abb2-2d68cdb96094"
-  }
-
-  ### Multi Node Tree Picker
-
-  {
-    "editorAlias": "Umbraco.MultiNodeTreePicker",
-    "culture": null,
-    "segment": null,
-    "alias": "contentPicker",
-    "value": [
-      {
-        "type": "document",
-        "unique": "dcf18a51-6919-4cf8-89d1-36b94ce4d963"
-      }
-    ]
-  }
-
-  ### Date Time
-
-  {
-    "editorAlias": "Umbraco.DateTime",
-    "culture": null,
-    "segment": null,
-    "alias": "date",
-    "value": "2025-05-23 00:00:00"
-  }
-
-  ### Content Picker
-
-  The value relates to an existing document id.
-
-  {
-    "editorAlias": "Umbraco.ContentPicker",
-    "culture": null,
-    "segment": null,
-    "alias": "content",
-    "value": "dcf18a51-6919-4cf8-89d1-36b94ce4d963"
-  }
-
-  ### Colour Picker Eye Dropper
-
-  {
-    "editorAlias": "Umbraco.ColorPicker.EyeDropper",
-    "culture": null,
-    "segment": null,
-    "alias": "eyeDropper",
-    "value": "#982020"
-  }
-
-  ### Multi Url Picker
-
-  {
-    "editorAlias": "Umbraco.MultiUrlPicker",
-    "culture": null,
-    "segment": null,
-    "alias": "multiUrl",
-    "value": [
-      {
-        "icon": "icon-home color-blue",
-        "name": "Home",
-        "type": "document",
-        "unique": "dcf18a51-6919-4cf8-89d1-36b94ce4d963",
-        "url": "/"
-      },
-      {
-        "icon": "icon-picture",
-        "name": "Chairs lamps",
-        "type": "media",
-        "unique": "3c6c415c-35a0-4629-891e-683506250c31",
-        "url": "http://localhost:56472/media/0ofdvcwj/chairs-lamps.jpg"
-      },
-      {
-        "name": "Title",
-        "target": "_blank",
-        "type": "external",
-        "url": "www.google.com"
-      }
-    ]
-  }
+  Always follow these requirements when creating documents exactly, do not deviate in any way.
 
-  ### Markdown Editor
+  ## COPY-FIRST APPROACH (RECOMMENDED)
 
-  {
-    "editorAlias": "Umbraco.MarkdownEditor",
-    "culture": null,
-    "segment": null,
-    "alias": "markdown",
-    "value": "Markdown"
-  }
+  **FIRST: Try to copy an existing document**
+  1. Only use this if copy-document and search-document tools are available
+  2. Use search-document to find documents with the same document type
+  3. If similar documents exist AND copy-document tool is available:
+     - Use copy-document to duplicate the existing structure
+     - Use search-document to find the new document (copy returns empty string, not the new ID)
+     - Update with update-document and publish with publish-document as needed
 
-  ### Code Editor
+  **SECOND: Only create from scratch when:**
+  - No similar documents exist in Umbraco
+  - Copy-document tool doesn't exist
+  - You need to create from scratch with unique structure
 
-  {
-    "editorAlias": "Umbraco.CodeEditor",
-    "culture": null,
-    "segment": null,
-    "alias": "code",
-    "value": "Code"
-  }
+  Benefits: Preserves structure, inherits properties, maintains consistency with existing content.
 
-  ### Textbox
-  {
-    "editorAlias": "Umbraco.TextBox",
-    "culture": null,
-    "segment": null,
-    "alias": "example",
-    "value": "some string"
-  }
+  ## Introduction
 
-  ### TextArea
-  {
-    "editorAlias": "Umbraco.TextArea",
-    "culture": null,
-    "segment": null,
-    "alias": "example",
-    "value": "some string"
-  }
+  This tool creates documents with multi-culture support:
+  - 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)
 
+  ## Critical Requirements
 
-  ### Rich Text Editor
+  ### Document Type Analysis (When Creating from Scratch)
+  1. Use get-document-type-by-id to understand the document type structure and required properties
+  2. Ensure all required properties are included in the values array
 
-  value.blocks is the same structure as the block list
+  ### Document Types and Data Types
+  1. BEFORE creating any new document type, ALWAYS search for existing ones using get-all-document-types
+  2. BEFORE creating any new data type, ALWAYS search for existing ones using get-all-data-types
+  3. ONLY create a new document type or data type if NO suitable existing ones are found
+  4. If similar types exist, inform the user and suggest using the existing types instead
+  5. Creation of new types should be a last resort when nothing suitable exists
 
-  {
-    "editorAlias": "Umbraco.RichText",
-    "culture": null,
-    "segment": null,
-    "alias": "example",
-    "value": {
-      "markup": "<p>some string</p>",
-      "blocks": {
-        "layout": {},
-        "contentData": [],
-        "settingsData": [],
-        "expose": []
-      }
-    }
-  }
+  ### Parent ID Handling
+  For document types with allowedAsRoot=true, DO NOT include the parentId parameter at all in the function call.
+  When adding a parent, first find the parent using get-document-root or get-document-children and then use the id of the parent in the parentId parameter. Alway makes sure that the id is valid.
+
+  ### Values Matching
+  - Values must match the aliases of the document type structure
+  - Block lists, Block Grids and Rich Text Blocks items and settings must match the defined blocks document type structures
+
+  ### Unique Keys
+  All generated keys must be unique and randomly generated.
+
+  ## Property Editor Values Reference
 
-  ### Media Picker
+  When creating documents, you need to provide property values that match the property editors defined in the document type.
 
-  value is an array of media
-  value[].id is generated 
-  value[].mediaKey is a media type id
+  IMPORTANT: Use the get-document-property-value-template tool to:
+  - View all available property editors (call without parameters)
+  - Get the correct value structure for a specific property editor (call with editorAlias parameter)
+  - Each template provides the editorAlias and value format
+  - You must add culture, segment, and alias based on your document's specific requirements
 
+  The values parameter is an array of property value objects following this structure:
   {
-    "editorAlias": "Umbraco.MediaPicker3",
-    "culture": null,
-    "segment": null,
-    "alias": "example",
-    "value": [
-      {
-        "key": "9bac772d-cd63-4bb6-b2db-1449042129a7",
-        "mediaKey": "3c6c415c-35a0-4629-891e-683506250c31",
-        "mediaTypeAlias": "",
-        "crops": [],
-        "focalPoint": null
-      }
-    ]
+    "editorAlias": "Umbraco.TextBox",  // From template - the property editor type
+    "culture": null,                    // Document-specific - culture code or null
+    "segment": null,                    // Document-specific - segment or null
+    "alias": "propertyAlias",          // Document-specific - property alias from document type
+    "value": "your value here"         // From template - customize the value structure
   }
 
-  
+  Note: Some property editors (BlockList, BlockGrid, ImageCropper, UploadField) have special requirements - check their templates for important notes.
   `,
   createDocumentSchema.shape,
   async (model) => {
@@ -17088,15 +18148,39 @@ var CreateDocumentTool = CreateUmbracoTool(
       values: model.values,
       variants
     };
-    const response = await client.postDocument(payload);
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(response)
-        }
-      ]
-    };
+    const response = await client.postDocument(payload, {
+      returnFullResponse: true,
+      validateStatus: () => true
+      // Don't throw on any status
+    });
+    if (response.status === 201) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              message: "Document created successfully",
+              id: documentId
+            })
+          }
+        ]
+      };
+    } else {
+      const errorData = response.data;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              message: "Failed to create document",
+              status: response.status,
+              error: errorData || response.statusText
+            })
+          }
+        ],
+        isError: true
+      };
+    }
   },
   (user) => user.fallbackPermissions.includes(UmbracoDocumentPermissions.Create)
 );
@@ -17214,7 +18298,7 @@ var PublishDocumentWithDescendantsTool = CreateUmbracoTool(
     let attempts = 0;
     while (attempts < maxAttempts) {
       attempts++;
-      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+      await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
       try {
         const statusResponse = await client.getDocumentByIdPublishWithDescendantsResultByTaskId(
           model.id,
@@ -17389,6 +18473,29 @@ var EmptyRecycleBinTool = CreateUmbracoTool(
 );
 var empty_recycle_bin_default = EmptyRecycleBinTool;
 
+// src/umb-management-api/tools/document/put/restore-from-recycle-bin.ts
+var RestoreFromRecycleBinTool = CreateUmbracoTool(
+  "restore-document-from-recycle-bin",
+  "Restores a document from the recycle bin.",
+  putRecycleBinDocumentByIdRestoreParams.shape,
+  async ({ id }) => {
+    const client = UmbracoManagementClient2.getClient();
+    const response = await client.putRecycleBinDocumentByIdRestore(id, {
+      target: null
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(response)
+        }
+      ]
+    };
+  },
+  (user) => user.fallbackPermissions.includes(UmbracoDocumentPermissions.Delete)
+);
+var restore_from_recycle_bin_default = RestoreFromRecycleBinTool;
+
 // src/umb-management-api/tools/document/put/move-to-recycle-bin.ts
 var MoveDocumentToRecycleBinTool = CreateUmbracoTool(
   "move-document-to-recycle-bin",
@@ -17551,6 +18658,7 @@ var DocumentCollection = {
       tools.push(get_document_by_id_default());
       tools.push(get_document_publish_default());
       tools.push(get_document_configuration_default());
+      tools.push(get_document_property_value_template_default());
       tools.push(copy_document_default());
       tools.push(create_document_default());
       tools.push(post_document_public_access_default());
@@ -17573,6 +18681,7 @@ var DocumentCollection = {
       tools.push(put_document_public_access_default());
       tools.push(delete_from_recycle_bin_default());
       tools.push(empty_recycle_bin_default());
+      tools.push(restore_from_recycle_bin_default());
       tools.push(get_recycle_bin_root_default());
       tools.push(get_recycle_bin_children_default());
       tools.push(search_document_default());
@@ -17695,20 +18804,292 @@ var DocumentVersionCollection = {
       tools.push(update_document_version_prevent_cleanup_default());
       tools.push(create_document_version_rollback_default());
     }
-    return tools;
+    return tools;
+  }
+};
+
+// src/umb-management-api/tools/media/post/create-media.ts
+
+
+
+// src/umb-management-api/tools/media/post/helpers/media-upload-helpers.ts
+var _fs = require('fs'); var fs2 = _interopRequireWildcard(_fs); var fs = _interopRequireWildcard(_fs); var fs3 = _interopRequireWildcard(_fs);
+var _os = require('os'); var os = _interopRequireWildcard(_os); var os2 = _interopRequireWildcard(_os);
+var _path = require('path'); var path2 = _interopRequireWildcard(_path); var path = _interopRequireWildcard(_path); var path3 = _interopRequireWildcard(_path);
+
+var _mimetypes = require('mime-types'); var _mimetypes2 = _interopRequireDefault(_mimetypes);
+
+// src/constants/constants.ts
+var FOLDER_MEDIA_TYPE_ID = "f38bd2d7-65d0-48e6-95dc-87ce06ec2d3d";
+var IMAGE_MEDIA_TYPE_ID = "cc07b313-0843-4aa8-bbda-871c8da728c8";
+var FILE_MEDIA_TYPE_ID = "4c52d8ab-54e6-40cd-999c-7a5f24903e4d";
+var VIDEO_MEDIA_TYPE_ID = "f6c515bb-653c-4bdc-821c-987729ebe327";
+var AUDIO_MEDIA_TYPE_ID = "a5ddeee0-8fd8-4cee-a658-6f1fcdb00de3";
+var ARTICLE_MEDIA_TYPE_ID = "a43e3414-9599-4230-a7d3-943a21b20122";
+var VECTOR_GRAPHICS_MEDIA_TYPE_ID = "c4b1efcf-a9d5-41c4-9621-e9d273b52a9c";
+var MEDIA_TYPE_FOLDER = "Folder";
+var MEDIA_TYPE_IMAGE = "Image";
+var MEDIA_TYPE_FILE = "File";
+var MEDIA_TYPE_VIDEO = "Video";
+var MEDIA_TYPE_AUDIO = "Audio";
+var MEDIA_TYPE_ARTICLE = "Article";
+var MEDIA_TYPE_VECTOR_GRAPHICS = "SVG";
+var STANDARD_MEDIA_TYPES = {
+  [MEDIA_TYPE_FOLDER]: FOLDER_MEDIA_TYPE_ID,
+  [MEDIA_TYPE_IMAGE]: IMAGE_MEDIA_TYPE_ID,
+  [MEDIA_TYPE_FILE]: FILE_MEDIA_TYPE_ID,
+  [MEDIA_TYPE_VIDEO]: VIDEO_MEDIA_TYPE_ID,
+  [MEDIA_TYPE_AUDIO]: AUDIO_MEDIA_TYPE_ID,
+  [MEDIA_TYPE_ARTICLE]: ARTICLE_MEDIA_TYPE_ID,
+  [MEDIA_TYPE_VECTOR_GRAPHICS]: VECTOR_GRAPHICS_MEDIA_TYPE_ID
+};
+
+// src/umb-management-api/tools/media/post/helpers/validate-file-path.ts
+
+
+
+// src/config.ts
+var _dotenv = require('dotenv');
+var _yargs = require('yargs'); var _yargs2 = _interopRequireDefault(_yargs);
+var _helpers = require('yargs/helpers');
+
+function maskSecret(secret) {
+  if (!secret || secret.length <= 4) return "****";
+  return `****${secret.slice(-4)}`;
+}
+function getServerConfig(isStdioMode) {
+  const argv = _yargs2.default.call(void 0, _helpers.hideBin.call(void 0, process.argv)).options({
+    "umbraco-client-id": {
+      type: "string",
+      description: "Umbraco API client ID"
+    },
+    "umbraco-client-secret": {
+      type: "string",
+      description: "Umbraco API client secret"
+    },
+    "umbraco-base-url": {
+      type: "string",
+      description: "Umbraco base URL (e.g., https://localhost:44391)"
+    },
+    "umbraco-include-tool-collections": {
+      type: "string",
+      description: "Comma-separated list of tool collections to include"
+    },
+    "umbraco-exclude-tool-collections": {
+      type: "string",
+      description: "Comma-separated list of tool collections to exclude"
+    },
+    "umbraco-include-tools": {
+      type: "string",
+      description: "Comma-separated list of tools to include"
+    },
+    "umbraco-exclude-tools": {
+      type: "string",
+      description: "Comma-separated list of tools to exclude"
+    },
+    "umbraco-allowed-media-paths": {
+      type: "string",
+      description: "Comma-separated list of allowed file system paths for media uploads (security: restricts file path access)"
+    },
+    env: {
+      type: "string",
+      description: "Path to custom .env file to load environment variables from"
+    }
+  }).help().version(_nullishCoalesce(process.env.NPM_PACKAGE_VERSION, () => ( "unknown"))).parseSync();
+  let envFilePath;
+  let envFileSource;
+  if (argv["env"]) {
+    envFilePath = _path.resolve.call(void 0, argv["env"]);
+    envFileSource = "cli";
+  } else {
+    envFilePath = _path.resolve.call(void 0, process.cwd(), ".env");
+    envFileSource = "default";
+  }
+  _dotenv.config.call(void 0, { path: envFilePath, override: true });
+  const auth = {
+    clientId: "",
+    clientSecret: "",
+    baseUrl: ""
+  };
+  const config = {
+    includeToolCollections: void 0,
+    excludeToolCollections: void 0,
+    includeTools: void 0,
+    excludeTools: void 0,
+    allowedMediaPaths: void 0,
+    configSources: {
+      clientId: "env",
+      clientSecret: "env",
+      baseUrl: "env",
+      includeToolCollections: "none",
+      excludeToolCollections: "none",
+      includeTools: "none",
+      excludeTools: "none",
+      allowedMediaPaths: "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 (argv["umbraco-allowed-media-paths"]) {
+    config.allowedMediaPaths = argv["umbraco-allowed-media-paths"].split(",").map((p) => _path.resolve.call(void 0, p.trim())).filter(Boolean);
+    config.configSources.allowedMediaPaths = "cli";
+  } else if (process.env.UMBRACO_ALLOWED_MEDIA_PATHS) {
+    config.allowedMediaPaths = process.env.UMBRACO_ALLOWED_MEDIA_PATHS.split(",").map((p) => _path.resolve.call(void 0, p.trim())).filter(Boolean);
+    config.configSources.allowedMediaPaths = "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})`
+      );
+    }
+    if (config.allowedMediaPaths) {
+      console.log(
+        `- UMBRACO_ALLOWED_MEDIA_PATHS: ${config.allowedMediaPaths.join(", ")} (source: ${config.configSources.allowedMediaPaths})`
+      );
+    }
+    console.log();
   }
-};
-
-// src/umb-management-api/tools/media/post/create-media.ts
-
+  return {
+    ...config,
+    auth
+  };
+}
 
+// src/umb-management-api/tools/media/post/helpers/validate-file-path.ts
+function validateFilePath(filePath, allowedPaths) {
+  const allowedMediaPaths = _nullishCoalesce(allowedPaths, () => ( getServerConfig(true).allowedMediaPaths));
+  if (!allowedMediaPaths || allowedMediaPaths.length === 0) {
+    throw new Error(
+      'File path uploads are disabled. To enable, set UMBRACO_ALLOWED_MEDIA_PATHS environment variable with comma-separated allowed directory paths (e.g., UMBRACO_ALLOWED_MEDIA_PATHS="/tmp/uploads,/var/media")'
+    );
+  }
+  const normalizedPath = path.resolve(filePath);
+  const isAllowed = allowedMediaPaths.some((allowedPath) => {
+    const realAllowedPath = fs.realpathSync(allowedPath);
+    return normalizedPath.startsWith(allowedPath) || normalizedPath.startsWith(realAllowedPath);
+  });
+  if (!isAllowed) {
+    throw new Error(
+      `File path "${filePath}" is not in an allowed directory. Allowed directories: ${allowedMediaPaths.join(", ")}`
+    );
+  }
+  try {
+    const stats = fs.lstatSync(normalizedPath);
+    if (stats.isSymbolicLink()) {
+      const realPath = fs.realpathSync(normalizedPath);
+      const symlinkAllowed = allowedMediaPaths.some((allowedPath) => {
+        const realAllowedPath = fs.realpathSync(allowedPath);
+        return realPath.startsWith(allowedPath) || realPath.startsWith(realAllowedPath);
+      });
+      if (!symlinkAllowed) {
+        throw new Error(
+          `File path "${filePath}" is a symbolic link to "${realPath}" which is outside allowed directories`
+        );
+      }
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    throw error;
+  }
+  return normalizedPath;
+}
 
 // src/umb-management-api/tools/media/post/helpers/media-upload-helpers.ts
-var _fs = require('fs'); var fs = _interopRequireWildcard(_fs); var fs2 = _interopRequireWildcard(_fs);
-var _os = require('os'); var os = _interopRequireWildcard(_os); var os2 = _interopRequireWildcard(_os);
-var _path = require('path'); var path = _interopRequireWildcard(_path); var path2 = _interopRequireWildcard(_path);
-
-var _mimetypes = require('mime-types'); var _mimetypes2 = _interopRequireDefault(_mimetypes);
 function getExtensionFromMimeType(mimeType) {
   if (!mimeType) return void 0;
   const baseMimeType = mimeType.split(";")[0].trim();
@@ -17717,13 +19098,19 @@ function getExtensionFromMimeType(mimeType) {
 }
 function validateMediaTypeForSvg(filePath, fileUrl, fileName, mediaTypeName) {
   const isSvg = _optionalChain([filePath, 'optionalAccess', _50 => _50.toLowerCase, 'call', _51 => _51(), 'access', _52 => _52.endsWith, 'call', _53 => _53(".svg")]) || _optionalChain([fileUrl, 'optionalAccess', _54 => _54.toLowerCase, 'call', _55 => _55(), 'access', _56 => _56.endsWith, 'call', _57 => _57(".svg")]) || fileName.toLowerCase().endsWith(".svg");
-  if (isSvg && mediaTypeName === "Image") {
-    console.warn("SVG detected - using Vector Graphic media type instead of Image");
-    return "Vector Graphic (SVG)";
+  if (isSvg && mediaTypeName === MEDIA_TYPE_IMAGE) {
+    console.warn(`SVG detected - using ${MEDIA_TYPE_VECTOR_GRAPHICS} media type instead of ${MEDIA_TYPE_IMAGE}`);
+    return MEDIA_TYPE_VECTOR_GRAPHICS;
   }
   return mediaTypeName;
 }
 async function fetchMediaTypeId(client, mediaTypeName) {
+  const standardTypeKey = Object.keys(STANDARD_MEDIA_TYPES).find(
+    (key) => key.toLowerCase() === mediaTypeName.toLowerCase()
+  );
+  if (standardTypeKey) {
+    return STANDARD_MEDIA_TYPES[standardTypeKey];
+  }
   const response = await client.getItemMediaTypeSearch({ query: mediaTypeName });
   const mediaType = response.items.find(
     (mt) => mt.name.toLowerCase() === mediaTypeName.toLowerCase()
@@ -17737,7 +19124,7 @@ async function fetchMediaTypeId(client, mediaTypeName) {
   return mediaType.id;
 }
 function getEditorAlias(mediaTypeName) {
-  return mediaTypeName === "Image" ? "Umbraco.ImageCropper" : "Umbraco.UploadField";
+  return mediaTypeName === MEDIA_TYPE_IMAGE ? "Umbraco.ImageCropper" : "Umbraco.UploadField";
 }
 function buildValueStructure(mediaTypeName, temporaryFileId) {
   const base = {
@@ -17745,7 +19132,7 @@ function buildValueStructure(mediaTypeName, temporaryFileId) {
     editorAlias: getEditorAlias(mediaTypeName),
     entityType: "media-property-value"
   };
-  if (mediaTypeName === "Image") {
+  if (mediaTypeName === MEDIA_TYPE_IMAGE) {
     return {
       ...base,
       value: {
@@ -17765,7 +19152,7 @@ function buildValueStructure(mediaTypeName, temporaryFileId) {
     value: { temporaryFileId }
   };
 }
-async function createFileStream(sourceType, filePath, fileUrl, fileAsBase64, fileName, temporaryFileId) {
+async function createFileStream(sourceType, filePath, fileUrl, fileAsBase64, fileName) {
   let tempFilePath = null;
   let readStream;
   switch (sourceType) {
@@ -17773,10 +19160,8 @@ async function createFileStream(sourceType, filePath, fileUrl, fileAsBase64, fil
       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);
+      const validatedPath = validateFilePath(filePath);
+      readStream = fs2.createReadStream(validatedPath);
       break;
     case "url":
       if (!fileUrl) {
@@ -17795,7 +19180,7 @@ async function createFileStream(sourceType, filePath, fileUrl, fileAsBase64, fil
         let fileNameWithExtension = fileName;
         if (!fileName.includes(".")) {
           const urlPath = new URL(fileUrl).pathname;
-          const urlExtension = path.extname(urlPath);
+          const urlExtension = path2.extname(urlPath);
           if (urlExtension) {
             fileNameWithExtension = `${fileName}${urlExtension}`;
           } else {
@@ -17808,9 +19193,9 @@ async function createFileStream(sourceType, filePath, fileUrl, fileAsBase64, fil
             }
           }
         }
-        tempFilePath = path.join(os.tmpdir(), fileNameWithExtension);
-        fs.writeFileSync(tempFilePath, response.data);
-        readStream = fs.createReadStream(tempFilePath);
+        tempFilePath = path2.join(os.tmpdir(), fileNameWithExtension);
+        fs2.writeFileSync(tempFilePath, response.data);
+        readStream = fs2.createReadStream(tempFilePath);
       } catch (error) {
         const axiosError = error;
         if (axiosError.response) {
@@ -17828,17 +19213,17 @@ async function createFileStream(sourceType, filePath, fileUrl, fileAsBase64, fil
         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);
+      tempFilePath = path2.join(os.tmpdir(), fileName);
+      fs2.writeFileSync(tempFilePath, fileContent);
+      readStream = fs2.createReadStream(tempFilePath);
       break;
   }
   return { readStream, tempFilePath };
 }
 function cleanupTempFile(tempFilePath) {
-  if (tempFilePath && fs.existsSync(tempFilePath)) {
+  if (tempFilePath && fs2.existsSync(tempFilePath)) {
     try {
-      fs.unlinkSync(tempFilePath);
+      fs2.unlinkSync(tempFilePath);
     } catch (e) {
       console.error("Failed to cleanup temp file:", e);
     }
@@ -17859,8 +19244,7 @@ async function uploadMediaFile(client, params) {
       params.filePath,
       params.fileUrl,
       params.fileAsBase64,
-      params.name,
-      params.temporaryFileId
+      params.name
     );
     tempFilePath = createdTempPath;
     try {
@@ -17902,7 +19286,7 @@ async function uploadMediaFile(client, params) {
 var createMediaSchema = _zod.z.object({
   sourceType: _zod.z.enum(["filePath", "url", "base64"]).describe("Media source type: 'filePath' for local files (most efficient), 'url' for web files, 'base64' for embedded data (small files only)"),
   name: _zod.z.string().describe("The name of the media item"),
-  mediaTypeName: _zod.z.string().describe("Media type: 'Image', 'Article', 'Audio', 'Video', 'Vector Graphic (SVG)', 'File', or custom media type name"),
+  mediaTypeName: _zod.z.string().describe(`Media type: '${MEDIA_TYPE_IMAGE}', '${MEDIA_TYPE_ARTICLE}', '${MEDIA_TYPE_AUDIO}', '${MEDIA_TYPE_VIDEO}', '${MEDIA_TYPE_VECTOR_GRAPHICS}', '${MEDIA_TYPE_FILE}', or custom media type name`),
   filePath: _zod.z.string().optional().describe("Absolute path to the file (required if sourceType is 'filePath')"),
   fileUrl: _zod.z.string().url().optional().describe("URL to fetch the file from (required if sourceType is 'url')"),
   fileAsBase64: _zod.z.string().optional().describe("Base64 encoded file data (required if sourceType is 'base64')"),
@@ -17913,16 +19297,19 @@ var CreateMediaTool = CreateUmbracoTool(
   `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
+  - ${MEDIA_TYPE_IMAGE}: jpg, png, gif, webp, etc. (supports cropping)
+  - ${MEDIA_TYPE_ARTICLE}: pdf, docx, doc (documents)
+  - ${MEDIA_TYPE_AUDIO}: mp3, wav, etc.
+  - ${MEDIA_TYPE_VIDEO}: mp4, webm, etc.
+  - ${MEDIA_TYPE_VECTOR_GRAPHICS}: svg files only
+  - ${MEDIA_TYPE_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
+     SECURITY: Requires UMBRACO_ALLOWED_MEDIA_PATHS environment variable
+     to be configured with comma-separated allowed directories.
+     Example: UMBRACO_ALLOWED_MEDIA_PATHS="/tmp/uploads,/var/media"
   2. url - Fetch from web URL
   3. base64 - Only for small files (<10KB) due to token usage
 
@@ -17978,7 +19365,7 @@ var createMediaMultipleSchema = _zod.z.object({
     name: _zod.z.string().describe("The name of the media item"),
     filePath: _zod.z.string().optional().describe("Absolute path to the file (required if sourceType is 'filePath')"),
     fileUrl: _zod.z.string().url().optional().describe("URL to fetch the file from (required if sourceType is 'url')"),
-    mediaTypeName: _zod.z.string().optional().describe("Optional override: 'Image', 'Article', 'Audio', 'Video', 'Vector Graphic (SVG)', 'File', or custom media type name. If not specified, defaults to 'File'")
+    mediaTypeName: _zod.z.string().optional().describe(`Optional override: '${MEDIA_TYPE_IMAGE}', '${MEDIA_TYPE_ARTICLE}', '${MEDIA_TYPE_AUDIO}', '${MEDIA_TYPE_VIDEO}', '${MEDIA_TYPE_VECTOR_GRAPHICS}', '${MEDIA_TYPE_FILE}', or custom media type name. If not specified, defaults to '${MEDIA_TYPE_FILE}'`)
   })).describe("Array of files to upload (maximum 20 files per batch)"),
   parentId: _zod.z.string().uuid().optional().describe("Parent folder ID (defaults to root)")
 });
@@ -17990,6 +19377,9 @@ var CreateMediaMultipleTool = CreateUmbracoTool(
 
   Source Types:
   1. filePath - Most efficient for local files, works with any size
+     SECURITY: Requires UMBRACO_ALLOWED_MEDIA_PATHS environment variable
+     to be configured with comma-separated allowed directories.
+     Example: UMBRACO_ALLOWED_MEDIA_PATHS="/tmp/uploads,/var/media"
   2. url - Fetch from web URL
 
   Note: base64 is not supported for batch uploads due to token usage.
@@ -18012,7 +19402,7 @@ var CreateMediaMultipleTool = CreateUmbracoTool(
     for (const file of model.files) {
       try {
         const temporaryFileId = _uuid.v4.call(void 0, );
-        const defaultMediaType = file.mediaTypeName || "File";
+        const defaultMediaType = file.mediaTypeName || MEDIA_TYPE_FILE;
         const actualName = await uploadMediaFile(client, {
           sourceType: model.sourceType,
           name: file.name,
@@ -18391,7 +19781,7 @@ var EmptyRecycleBinTool2 = CreateUmbracoTool(
 var empty_recycle_bin_default2 = EmptyRecycleBinTool2;
 
 // src/umb-management-api/tools/media/put/restore-from-recycle-bin.ts
-var RestoreFromRecycleBinTool = CreateUmbracoTool(
+var RestoreFromRecycleBinTool2 = CreateUmbracoTool(
   "restore-media-from-recycle-bin",
   "Restores a media item from the recycle bin.",
   putRecycleBinMediaByIdRestoreParams.shape,
@@ -18410,7 +19800,7 @@ var RestoreFromRecycleBinTool = CreateUmbracoTool(
     };
   }
 );
-var restore_from_recycle_bin_default = RestoreFromRecycleBinTool;
+var restore_from_recycle_bin_default2 = RestoreFromRecycleBinTool2;
 
 // src/umb-management-api/tools/media/put/move-to-recycle-bin.ts
 var MoveMediaToRecycleBinTool = CreateUmbracoTool(
@@ -18630,7 +20020,7 @@ var MediaCollection = {
       tools.push(get_recycle_bin_root_default2());
       tools.push(get_recycle_bin_children_default2());
       tools.push(empty_recycle_bin_default2());
-      tools.push(restore_from_recycle_bin_default());
+      tools.push(restore_from_recycle_bin_default2());
       tools.push(move_to_recycle_bin_default2());
       tools.push(delete_from_recycle_bin_default2());
       tools.push(get_media_are_referenced_default());
@@ -18893,7 +20283,7 @@ var GetMediaTypeFolderTool = CreateUmbracoTool(
     };
   }
 );
-var get_folder_default3 = GetMediaTypeFolderTool;
+var get_folder_default4 = GetMediaTypeFolderTool;
 
 // src/umb-management-api/tools/media-type/folders/post/create-folder.ts
 var CreateMediaTypeFolderTool = CreateUmbracoTool(
@@ -18913,7 +20303,7 @@ var CreateMediaTypeFolderTool = CreateUmbracoTool(
     };
   }
 );
-var create_folder_default3 = CreateMediaTypeFolderTool;
+var create_folder_default4 = CreateMediaTypeFolderTool;
 
 // src/umb-management-api/tools/media-type/folders/delete/delete-folder.ts
 var DeleteMediaTypeFolderTool = CreateUmbracoTool(
@@ -18933,7 +20323,7 @@ var DeleteMediaTypeFolderTool = CreateUmbracoTool(
     };
   }
 );
-var delete_folder_default3 = DeleteMediaTypeFolderTool;
+var delete_folder_default4 = DeleteMediaTypeFolderTool;
 
 // src/umb-management-api/tools/media-type/folders/put/update-folder.ts
 
@@ -18957,16 +20347,57 @@ var UpdateMediaTypeFolderTool = CreateUmbracoTool(
     };
   }
 );
-var update_folder_default3 = UpdateMediaTypeFolderTool;
+var update_folder_default4 = UpdateMediaTypeFolderTool;
 
 // src/umb-management-api/tools/media-type/post/create-media-type.ts
+
+var propertySchema2 = postMediaTypeBody.shape.properties;
+var containerSchema = postMediaTypeBody.shape.containers;
+var allowedMediaTypeSchema = postMediaTypeBody.shape.allowedMediaTypes;
+var compositionSchema = postMediaTypeBody.shape.compositions;
+var collectionSchema = postMediaTypeBody.shape.collection;
+var createMediaTypeSchema = _zod.z.object({
+  alias: _zod.z.string().min(1),
+  name: _zod.z.string().min(1),
+  description: _zod.z.string().nullish(),
+  icon: _zod.z.string().min(1),
+  allowedAsRoot: _zod.z.boolean(),
+  variesByCulture: _zod.z.boolean(),
+  variesBySegment: _zod.z.boolean(),
+  isElement: _zod.z.boolean(),
+  properties: propertySchema2,
+  containers: containerSchema,
+  id: _zod.z.string().uuid().nullish(),
+  parentId: _zod.z.string().uuid().optional(),
+  // Flattened parent ID
+  allowedMediaTypes: allowedMediaTypeSchema,
+  compositions: compositionSchema,
+  collection: collectionSchema
+});
 var CreateMediaTypeTool = CreateUmbracoTool(
   "create-media-type",
   "Creates a new media type",
-  postMediaTypeBody.shape,
+  createMediaTypeSchema.shape,
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.postMediaType(model);
+    const payload = {
+      alias: model.alias,
+      name: model.name,
+      description: model.description,
+      icon: model.icon,
+      allowedAsRoot: model.allowedAsRoot,
+      variesByCulture: model.variesByCulture,
+      variesBySegment: model.variesBySegment,
+      isElement: model.isElement,
+      properties: model.properties,
+      containers: model.containers,
+      id: model.id,
+      parent: model.parentId ? { id: model.parentId } : void 0,
+      allowedMediaTypes: model.allowedMediaTypes,
+      compositions: model.compositions,
+      collection: model.collection
+    };
+    const response = await client.postMediaType(payload);
     return {
       content: [
         {
@@ -19102,10 +20533,10 @@ var MediaTypeCollection = {
   tools: (user) => {
     const tools = [];
     if (AuthorizationPolicies.TreeAccessMediaTypes(user)) {
-      tools.push(get_folder_default3());
-      tools.push(create_folder_default3());
-      tools.push(delete_folder_default3());
-      tools.push(update_folder_default3());
+      tools.push(get_folder_default4());
+      tools.push(create_folder_default4());
+      tools.push(delete_folder_default4());
+      tools.push(update_folder_default4());
       tools.push(create_media_type_default());
       tools.push(copy_media_type_default());
       tools.push(get_media_type_available_compositions_default());
@@ -20070,8 +21501,8 @@ var UpdatePartialViewTool = CreateUmbracoTool(
   }).shape,
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    const { path: path3, ...updateModel } = model;
-    var response = await client.putPartialViewByPath(path3, updateModel);
+    const { path: path4, ...updateModel } = model;
+    var response = await client.putPartialViewByPath(path4, updateModel);
     return {
       content: [
         {
@@ -20095,8 +21526,8 @@ var RenamePartialViewTool = CreateUmbracoTool(
   }).shape,
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    const { path: path3, ...renameModel } = model;
-    const normalizedPath = encodeURIComponent(path3);
+    const { path: path4, ...renameModel } = model;
+    const normalizedPath = encodeURIComponent(path4);
     var response = await client.putPartialViewByPathRename(normalizedPath, renameModel);
     return {
       content: [
@@ -21416,9 +22847,9 @@ var CreateTemporaryFileTool = CreateUmbracoTool(
     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);
+      tempFilePath = path3.join(os2.tmpdir(), `umbraco-upload-${model.id}-${model.fileName}`);
+      fs3.writeFileSync(tempFilePath, fileContent);
+      const readStream = fs3.createReadStream(tempFilePath);
       const client = UmbracoManagementClient2.getClient();
       await client.postTemporaryFile({
         Id: model.id,
@@ -21443,9 +22874,9 @@ var CreateTemporaryFileTool = CreateUmbracoTool(
         isError: true
       };
     } finally {
-      if (tempFilePath && fs2.existsSync(tempFilePath)) {
+      if (tempFilePath && fs3.existsSync(tempFilePath)) {
         try {
-          fs2.unlinkSync(tempFilePath);
+          fs3.unlinkSync(tempFilePath);
         } catch (e) {
           console.error("Failed to cleanup temp file:", e);
         }
@@ -21552,7 +22983,7 @@ var TemporaryFileCollection = {
     name: "temporary-file",
     displayName: "Temporary Files",
     description: "Temporary file management and upload handling",
-    dependencies: ["media"]
+    dependencies: []
   },
   tools: (user) => {
     const tools = [];
@@ -21569,9 +23000,9 @@ var GetScriptByPathTool = CreateUmbracoTool(
   "get-script-by-path",
   "Gets a script by path",
   getScriptByPathParams.shape,
-  async ({ path: path3 }) => {
+  async ({ path: path4 }) => {
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.getScriptByPath(path3);
+    const response = await client.getScriptByPath(path4);
     return {
       content: [
         {
@@ -21589,9 +23020,9 @@ var GetScriptFolderByPathTool = CreateUmbracoTool(
   "get-script-folder-by-path",
   "Gets a script folder by path",
   getScriptFolderByPathParams.shape,
-  async ({ path: path3 }) => {
+  async ({ path: path4 }) => {
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.getScriptFolderByPath(path3);
+    const response = await client.getScriptFolderByPath(path4);
     return {
       content: [
         {
@@ -21800,9 +23231,9 @@ var DeleteScriptTool = CreateUmbracoTool(
   "delete-script",
   "Deletes a script by path",
   deleteScriptByPathParams.shape,
-  async ({ path: path3 }) => {
+  async ({ path: path4 }) => {
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.deleteScriptByPath(path3);
+    const response = await client.deleteScriptByPath(path4);
     return {
       content: [
         {
@@ -21820,9 +23251,9 @@ var DeleteScriptFolderTool = CreateUmbracoTool(
   "delete-script-folder",
   "Deletes a script folder by path",
   deleteScriptFolderByPathParams.shape,
-  async ({ path: path3 }) => {
+  async ({ path: path4 }) => {
     const client = UmbracoManagementClient2.getClient();
-    const response = await client.deleteScriptFolderByPath(path3);
+    const response = await client.deleteScriptFolderByPath(path4);
     return {
       content: [
         {
@@ -21864,13 +23295,26 @@ var ScriptCollection = {
 };
 
 // src/umb-management-api/tools/stylesheet/post/create-stylesheet.ts
+
+var createStylesheetSchema = _zod.z.object({
+  name: _zod.z.string().min(1, "Name is required"),
+  path: _zod.z.string().optional(),
+  content: _zod.z.string().min(1, "Content is required")
+});
 var CreateStylesheetTool = CreateUmbracoTool(
   "create-stylesheet",
-  "Creates a new stylesheet",
-  postStylesheetBody.shape,
+  `Creates a new stylesheet.`,
+  createStylesheetSchema.shape,
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    var response = await client.postStylesheet(model);
+    const normalizedPath = model.path && !model.path.startsWith("/") ? `/${model.path}` : model.path;
+    const name = model.name.endsWith(".css") ? model.name : `${model.name}.css`;
+    const payload = {
+      name,
+      content: model.content,
+      parent: normalizedPath ? { path: normalizedPath } : void 0
+    };
+    const response = await client.postStylesheet(payload);
     return {
       content: [
         {
@@ -21954,8 +23398,8 @@ var UpdateStylesheetTool = CreateUmbracoTool(
   }).shape,
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    const { path: path3, ...updateModel } = model;
-    var response = await client.putStylesheetByPath(path3, updateModel);
+    const { path: path4, ...updateModel } = model;
+    var response = await client.putStylesheetByPath(path4, updateModel);
     return {
       content: [
         {
@@ -21979,8 +23423,8 @@ var RenameStylesheetTool = CreateUmbracoTool(
   }).shape,
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
-    const { path: path3, ...renameModel } = model;
-    const normalizedPath = encodeURIComponent(path3);
+    const { path: path4, ...renameModel } = model;
+    const normalizedPath = encodeURIComponent(path4);
     var response = await client.putStylesheetByPathRename(normalizedPath, renameModel);
     return {
       content: [
@@ -23061,7 +24505,7 @@ var UserCollection = {
     name: "user",
     displayName: "Users",
     description: "User account management and administration",
-    dependencies: []
+    dependencies: ["temporary-file"]
   },
   tools: (user) => {
     const tools = [];
@@ -23529,7 +24973,7 @@ var GetDataTypeFolderResource = CreateUmbracoTemplateResource(
     }
   }
 );
-var get_folder_default4 = GetDataTypeFolderResource;
+var get_folder_default5 = GetDataTypeFolderResource;
 
 // src/umb-management-api/resources/data-types/get/get-is-used.ts
 var GetDataTypeIsUsedResource = CreateUmbracoTemplateResource(
@@ -23754,7 +25198,7 @@ var get_search_default5 = GetDataTypeSearchResource;
 var DataTypeTemplateResources = [
   get_ancestors_default12,
   get_children_default12,
-  get_folder_default4,
+  get_folder_default5,
   get_is_used_default,
   get_query_default,
   get_references_default,
@@ -23811,188 +25255,6 @@ function ResourceFactory(server) {
   );
 }
 
-// src/config.ts
-var _dotenv = require('dotenv');
-var _yargs = require('yargs'); var _yargs2 = _interopRequireDefault(_yargs);
-var _helpers = require('yargs/helpers');
-
-function maskSecret(secret) {
-  if (!secret || secret.length <= 4) return "****";
-  return `****${secret.slice(-4)}`;
-}
-function getServerConfig(isStdioMode) {
-  const argv = _yargs2.default.call(void 0, _helpers.hideBin.call(void 0, process.argv)).options({
-    "umbraco-client-id": {
-      type: "string",
-      description: "Umbraco API client ID"
-    },
-    "umbraco-client-secret": {
-      type: "string",
-      description: "Umbraco API client secret"
-    },
-    "umbraco-base-url": {
-      type: "string",
-      description: "Umbraco base URL (e.g., https://localhost:44391)"
-    },
-    "umbraco-include-tool-collections": {
-      type: "string",
-      description: "Comma-separated list of tool collections to include"
-    },
-    "umbraco-exclude-tool-collections": {
-      type: "string",
-      description: "Comma-separated list of tool collections to exclude"
-    },
-    "umbraco-include-tools": {
-      type: "string",
-      description: "Comma-separated list of tools to include"
-    },
-    "umbraco-exclude-tools": {
-      type: "string",
-      description: "Comma-separated list of tools to exclude"
-    },
-    env: {
-      type: "string",
-      description: "Path to custom .env file to load environment variables from"
-    }
-  }).help().version(_nullishCoalesce(process.env.NPM_PACKAGE_VERSION, () => ( "unknown"))).parseSync();
-  let envFilePath;
-  let envFileSource;
-  if (argv["env"]) {
-    envFilePath = _path.resolve.call(void 0, argv["env"]);
-    envFileSource = "cli";
-  } else {
-    envFilePath = _path.resolve.call(void 0, process.cwd(), ".env");
-    envFileSource = "default";
-  }
-  _dotenv.config.call(void 0, { path: envFilePath, override: true });
-  const auth = {
-    clientId: "",
-    clientSecret: "",
-    baseUrl: ""
-  };
-  const config = {
-    includeToolCollections: void 0,
-    excludeToolCollections: void 0,
-    includeTools: void 0,
-    excludeTools: void 0,
-    configSources: {
-      clientId: "env",
-      clientSecret: "env",
-      baseUrl: "env",
-      includeToolCollections: "none",
-      excludeToolCollections: "none",
-      includeTools: "none",
-      excludeTools: "none",
-      envFile: envFileSource
-    }
-  };
-  if (argv["umbraco-client-id"]) {
-    auth.clientId = argv["umbraco-client-id"];
-    config.configSources.clientId = "cli";
-  } else if (process.env.UMBRACO_CLIENT_ID) {
-    auth.clientId = process.env.UMBRACO_CLIENT_ID;
-    config.configSources.clientId = "env";
-  }
-  if (argv["umbraco-client-secret"]) {
-    auth.clientSecret = argv["umbraco-client-secret"];
-    config.configSources.clientSecret = "cli";
-  } else if (process.env.UMBRACO_CLIENT_SECRET) {
-    auth.clientSecret = process.env.UMBRACO_CLIENT_SECRET;
-    config.configSources.clientSecret = "env";
-  }
-  if (argv["umbraco-base-url"]) {
-    auth.baseUrl = argv["umbraco-base-url"];
-    config.configSources.baseUrl = "cli";
-  } else if (process.env.UMBRACO_BASE_URL) {
-    auth.baseUrl = process.env.UMBRACO_BASE_URL;
-    config.configSources.baseUrl = "env";
-  }
-  if (argv["umbraco-include-tool-collections"]) {
-    config.includeToolCollections = argv["umbraco-include-tool-collections"].split(",").map((c) => c.trim()).filter(Boolean);
-    config.configSources.includeToolCollections = "cli";
-  } else if (process.env.UMBRACO_INCLUDE_TOOL_COLLECTIONS) {
-    config.includeToolCollections = process.env.UMBRACO_INCLUDE_TOOL_COLLECTIONS.split(",").map((c) => c.trim()).filter(Boolean);
-    config.configSources.includeToolCollections = "env";
-  }
-  if (argv["umbraco-exclude-tool-collections"]) {
-    config.excludeToolCollections = argv["umbraco-exclude-tool-collections"].split(",").map((c) => c.trim()).filter(Boolean);
-    config.configSources.excludeToolCollections = "cli";
-  } else if (process.env.UMBRACO_EXCLUDE_TOOL_COLLECTIONS) {
-    config.excludeToolCollections = process.env.UMBRACO_EXCLUDE_TOOL_COLLECTIONS.split(",").map((c) => c.trim()).filter(Boolean);
-    config.configSources.excludeToolCollections = "env";
-  }
-  if (argv["umbraco-include-tools"]) {
-    config.includeTools = argv["umbraco-include-tools"].split(",").map((t) => t.trim()).filter(Boolean);
-    config.configSources.includeTools = "cli";
-  } else if (process.env.UMBRACO_INCLUDE_TOOLS) {
-    config.includeTools = process.env.UMBRACO_INCLUDE_TOOLS.split(",").map((t) => t.trim()).filter(Boolean);
-    config.configSources.includeTools = "env";
-  }
-  if (argv["umbraco-exclude-tools"]) {
-    config.excludeTools = argv["umbraco-exclude-tools"].split(",").map((t) => t.trim()).filter(Boolean);
-    config.configSources.excludeTools = "cli";
-  } else if (process.env.UMBRACO_EXCLUDE_TOOLS) {
-    config.excludeTools = process.env.UMBRACO_EXCLUDE_TOOLS.split(",").map((t) => t.trim()).filter(Boolean);
-    config.configSources.excludeTools = "env";
-  }
-  if (!auth.clientId) {
-    console.error(
-      "UMBRACO_CLIENT_ID is required (via CLI argument --umbraco-client-id or .env file)"
-    );
-    process.exit(1);
-  }
-  if (!auth.clientSecret) {
-    console.error(
-      "UMBRACO_CLIENT_SECRET is required (via CLI argument --umbraco-client-secret or .env file)"
-    );
-    process.exit(1);
-  }
-  if (!auth.baseUrl) {
-    console.error(
-      "UMBRACO_BASE_URL is required (via CLI argument --umbraco-base-url or .env file)"
-    );
-    process.exit(1);
-  }
-  if (!isStdioMode) {
-    console.log("\nUmbraco MCP Configuration:");
-    console.log(`- ENV_FILE: ${envFilePath} (source: ${config.configSources.envFile})`);
-    console.log(
-      `- UMBRACO_CLIENT_ID: ${auth.clientId} (source: ${config.configSources.clientId})`
-    );
-    console.log(
-      `- UMBRACO_CLIENT_SECRET: ${maskSecret(auth.clientSecret)} (source: ${config.configSources.clientSecret})`
-    );
-    console.log(
-      `- UMBRACO_BASE_URL: ${auth.baseUrl} (source: ${config.configSources.baseUrl})`
-    );
-    if (config.includeToolCollections) {
-      console.log(
-        `- UMBRACO_INCLUDE_TOOL_COLLECTIONS: ${config.includeToolCollections.join(", ")} (source: ${config.configSources.includeToolCollections})`
-      );
-    }
-    if (config.excludeToolCollections) {
-      console.log(
-        `- UMBRACO_EXCLUDE_TOOL_COLLECTIONS: ${config.excludeToolCollections.join(", ")} (source: ${config.configSources.excludeToolCollections})`
-      );
-    }
-    if (config.includeTools) {
-      console.log(
-        `- UMBRACO_INCLUDE_TOOLS: ${config.includeTools.join(", ")} (source: ${config.configSources.includeTools})`
-      );
-    }
-    if (config.excludeTools) {
-      console.log(
-        `- UMBRACO_EXCLUDE_TOOLS: ${config.excludeTools.join(", ")} (source: ${config.configSources.excludeTools})`
-      );
-    }
-    console.log();
-  }
-  return {
-    ...config,
-    auth
-  };
-}
-
 // src/index.ts
 var main = async () => {
   const config = getServerConfig(true);
@@ -24000,6 +25262,7 @@ var main = async () => {
   const server = UmbracoMcpServer.GetServer();
   const client = UmbracoManagementClient2.getClient();
   const user = await client.getUserCurrent();
+  await checkUmbracoVersion(client);
   ResourceFactory(server);
   UmbracoToolFactory(server, user, config);
   const transport = new StdioServerTransport();