@umbraco-cms/mcp-dev 17.0.0 → 17.0.1-beta.1

package/dist/index.js

@@ -7597,7 +7597,7 @@ var UmbracoManagementClient2 = class {
 // package.json
 var package_default = {
   name: "@umbraco-cms/mcp-dev",
-  version: "17.0.0",
+  version: "17.0.1-beta.1",
   type: "module",
   description: "A model context protocol (MCP) server for Umbraco CMS",
   main: "index.js",
@@ -7620,6 +7620,8 @@ var package_default = {
     "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:update-document-properties": "npx mcp-server-tester@1.4.0 evals tests/e2e/update-document-properties/update-document-properties.yaml --server-config tests/e2e/update-document-properties/update-document-properties-config.json",
+    "eval-mcp:update-block-property": "npx mcp-server-tester@1.4.0 evals tests/e2e/update-block-property/update-block-property.yaml --server-config tests/e2e/update-block-property/update-block-property-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: {
@@ -19544,9 +19546,19 @@ var move_to_recycle_bin_default = MoveDocumentToRecycleBinTool;
 import { z as z41 } from "zod";
 var UpdateDocumentTool = CreateUmbracoTool(
   "update-document",
-  `Updates a document by Id
-  Always read the current document value first and only update the required values.
-  Don't miss any properties from the original document that you are updating`,
+  `Updates a document by Id. USE AS LAST RESORT ONLY.
+
+  IMPORTANT: Prefer these specialized tools instead:
+  - update-document-properties: For updating individual property values (simpler, safer)
+  - update-block-property: For updating properties within BlockList/BlockGrid/RichText blocks
+
+  Only use this tool when you need to update document-level metadata (template, variants)
+  or when the specialized tools cannot handle your specific use case.
+
+  If you must use this tool:
+  - Always read the current document value first
+  - Only update the required values
+  - Don't miss any properties from the original document`,
   {
     id: putDocumentByIdParams.shape.id,
     data: z41.object(putDocumentByIdBody.shape)
@@ -19567,6 +19579,761 @@ var UpdateDocumentTool = CreateUmbracoTool(
 );
 var update_document_default = UpdateDocumentTool;
 
+// src/umb-management-api/tools/document/put/update-document-properties.ts
+import { z as z42 } from "zod";
+
+// src/umb-management-api/tools/document/put/helpers/document-type-properties-resolver.ts
+async function getAllDocumentTypeProperties(documentTypeId) {
+  const client = UmbracoManagementClient2.getClient();
+  const visitedIds = /* @__PURE__ */ new Set();
+  const properties = [];
+  async function resolveDocumentType(docTypeId) {
+    if (visitedIds.has(docTypeId)) {
+      return;
+    }
+    visitedIds.add(docTypeId);
+    const docType = await client.getDocumentTypeById(docTypeId);
+    for (const prop of docType.properties) {
+      if (!properties.some((p) => p.alias === prop.alias)) {
+        properties.push({
+          alias: prop.alias,
+          name: prop.name,
+          dataTypeId: prop.dataType.id,
+          variesByCulture: prop.variesByCulture,
+          variesBySegment: prop.variesBySegment
+        });
+      }
+    }
+    for (const composition of docType.compositions) {
+      await resolveDocumentType(composition.documentType.id);
+    }
+  }
+  await resolveDocumentType(documentTypeId);
+  return properties;
+}
+function validateCultureSegment(prop, def) {
+  if (!def.variesByCulture && prop.culture) {
+    return `Property '${prop.alias}' does not vary by culture, but culture '${prop.culture}' was provided`;
+  }
+  if (def.variesByCulture && !prop.culture) {
+    return `Property '${prop.alias}' varies by culture - culture is required`;
+  }
+  if (!def.variesBySegment && prop.segment) {
+    return `Property '${prop.alias}' does not vary by segment, but segment '${prop.segment}' was provided`;
+  }
+  if (def.variesBySegment && !prop.segment) {
+    return `Property '${prop.alias}' varies by segment - segment is required`;
+  }
+  return null;
+}
+
+// src/umb-management-api/tools/document/put/helpers/property-value-validator.ts
+var EDITOR_FORMAT_MAP = {
+  // Editors with allowed values validation
+  "Umbraco.DropDown.Flexible": { valueType: "string[]", allowedValuesKey: "items", validateAllowedValues: true },
+  "Umbraco.RadioButtonList": { valueType: "string", allowedValuesKey: "items", validateAllowedValues: true },
+  "Umbraco.CheckBoxList": { valueType: "string[]", allowedValuesKey: "items", validateAllowedValues: true },
+  "Umbraco.ColorPicker": { valueType: "object", allowedValuesKey: "items", validateAllowedValues: true },
+  // Editors with format-only validation
+  "Umbraco.TextBox": { valueType: "string" },
+  "Umbraco.TextArea": { valueType: "string" },
+  "Umbraco.Integer": { valueType: "number" },
+  "Umbraco.Decimal": { valueType: "number" },
+  "Umbraco.TrueFalse": { valueType: "boolean" },
+  "Umbraco.Tags": { valueType: "string[]" },
+  "Umbraco.MultipleTextstring": { valueType: "string[]" },
+  "Umbraco.DateTime": { valueType: "string" },
+  "Umbraco.EmailAddress": { valueType: "string" },
+  "Umbraco.MarkdownEditor": { valueType: "string" },
+  "Umbraco.ColorPicker.EyeDropper": { valueType: "string" }
+};
+function validateValueType(value, expectedType, propertyAlias, editorAlias) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  switch (expectedType) {
+    case "string":
+      if (typeof value !== "string") {
+        return `Property '${propertyAlias}': Value must be a string for ${editorAlias} editor, got ${typeof value}`;
+      }
+      break;
+    case "string[]":
+      if (!Array.isArray(value)) {
+        return `Property '${propertyAlias}': Value must be an array for ${editorAlias} editor, got ${typeof value}`;
+      }
+      if (!value.every((item) => typeof item === "string")) {
+        return `Property '${propertyAlias}': All array items must be strings for ${editorAlias} editor`;
+      }
+      break;
+    case "number":
+      if (typeof value !== "number") {
+        return `Property '${propertyAlias}': Value must be a number for ${editorAlias} editor, got ${typeof value}`;
+      }
+      break;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        return `Property '${propertyAlias}': Value must be a boolean for ${editorAlias} editor, got ${typeof value}`;
+      }
+      break;
+    case "object":
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return `Property '${propertyAlias}': Value must be an object for ${editorAlias} editor, got ${Array.isArray(value) ? "array" : typeof value}`;
+      }
+      break;
+  }
+  return null;
+}
+function extractAllowedValues(dataType, configKey) {
+  const configItem = dataType.values.find((v) => v.alias === configKey);
+  if (!configItem || !configItem.value) {
+    return null;
+  }
+  const value = configItem.value;
+  if (Array.isArray(value)) {
+    if (value.every((item) => typeof item === "string")) {
+      return value;
+    }
+    if (value.every((item) => typeof item === "object" && item !== null && "value" in item)) {
+      return value.map((item) => item.value);
+    }
+  }
+  return null;
+}
+function validateAllowedValues(value, allowedValues, propertyAlias, editorAlias, valueType) {
+  const errors = [];
+  if (value === null || value === void 0) {
+    return errors;
+  }
+  if (editorAlias === "Umbraco.ColorPicker" && typeof value === "object" && value !== null && "value" in value) {
+    const colorValue = value.value;
+    if (!allowedValues.includes(colorValue)) {
+      errors.push(`Property '${propertyAlias}': Color value '${colorValue}' is not in allowed values: [${allowedValues.map((v) => `'${v}'`).join(", ")}]`);
+    }
+    return errors;
+  }
+  if (valueType === "string[]" && Array.isArray(value)) {
+    for (const item of value) {
+      if (!allowedValues.includes(item)) {
+        errors.push(`Property '${propertyAlias}': Value '${item}' is not in allowed values: [${allowedValues.map((v) => `'${v}'`).join(", ")}]`);
+      }
+    }
+    return errors;
+  }
+  if (valueType === "string" && typeof value === "string") {
+    if (!allowedValues.includes(value)) {
+      errors.push(`Property '${propertyAlias}': Value '${value}' is not in allowed values: [${allowedValues.map((v) => `'${v}'`).join(", ")}]`);
+    }
+    return errors;
+  }
+  return errors;
+}
+function validatePropertyValue(dataType, value, propertyAlias) {
+  const errors = [];
+  const editorAlias = dataType.editorAlias;
+  const formatConfig = EDITOR_FORMAT_MAP[editorAlias];
+  if (!formatConfig) {
+    return { isValid: true, errors: [] };
+  }
+  const typeError = validateValueType(value, formatConfig.valueType, propertyAlias, editorAlias);
+  if (typeError) {
+    errors.push(typeError);
+    return { isValid: false, errors };
+  }
+  if (formatConfig.validateAllowedValues && formatConfig.allowedValuesKey) {
+    const allowedValues = extractAllowedValues(dataType, formatConfig.allowedValuesKey);
+    if (allowedValues && allowedValues.length > 0) {
+      const allowedValueErrors = validateAllowedValues(
+        value,
+        allowedValues,
+        propertyAlias,
+        editorAlias,
+        formatConfig.valueType
+      );
+      errors.push(...allowedValueErrors);
+    }
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+async function validatePropertiesBeforeSave(properties) {
+  const client = UmbracoManagementClient2.getClient();
+  const errors = [];
+  const dataTypeCache = /* @__PURE__ */ new Map();
+  async function getCachedDataType(dataTypeId) {
+    if (!dataTypeCache.has(dataTypeId)) {
+      try {
+        const dataType = await client.getDataTypeById(dataTypeId);
+        dataTypeCache.set(dataTypeId, dataType);
+      } catch (error) {
+        console.error(`Failed to fetch Data Type ${dataTypeId}:`, error);
+        return null;
+      }
+    }
+    return dataTypeCache.get(dataTypeId) ?? null;
+  }
+  for (const prop of properties) {
+    if (!prop.dataTypeId) {
+      continue;
+    }
+    const dataType = await getCachedDataType(prop.dataTypeId);
+    if (!dataType) {
+      continue;
+    }
+    const validation = validatePropertyValue(dataType, prop.value, prop.alias);
+    if (!validation.isValid) {
+      errors.push(...validation.errors);
+    }
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+
+// src/umb-management-api/tools/document/put/helpers/property-matching.ts
+function matchesProperty(value, alias, culture, segment) {
+  return value.alias === alias && (value.culture ?? null) === (culture ?? null) && (value.segment ?? null) === (segment ?? null);
+}
+function getPropertyKey(alias, culture, segment) {
+  let key = alias;
+  if (culture) key += `[${culture}]`;
+  if (segment) key += `[${segment}]`;
+  return key;
+}
+
+// src/umb-management-api/tools/document/put/update-document-properties.ts
+var propertySchema2 = z42.object({
+  alias: z42.string().min(1).describe("The property alias to update or add"),
+  value: z42.any().nullish().describe("The new value for the property"),
+  culture: z42.string().nullish().describe("Optional culture code for variant properties (e.g., 'en-US')"),
+  segment: z42.string().nullish().describe("Optional segment identifier for variant properties")
+});
+var updateDocumentPropertiesSchema = {
+  id: z42.string().uuid().describe("The unique identifier of the document to update"),
+  properties: z42.array(propertySchema2).min(1).describe("Array of properties to update or add - at least one property is required")
+};
+var UpdateDocumentPropertiesTool = CreateUmbracoTool(
+  "update-document-properties",
+  `Updates or adds property values on a document without requiring the full document JSON payload.
+
+  This tool simplifies property updates by handling the read-modify-write cycle internally.
+  You can update existing properties, add new properties, or do both in a single call.
+
+  Key features:
+  - Update existing properties or add new ones
+  - Property must exist on the document type (including compositions)
+  - Full i18n support with culture and segment parameters
+  - Automatic validation of property aliases against document type
+  - Culture/segment requirements validated against property variance flags
+  - Returns detailed error messages with available properties
+
+  Example usage:
+  - Update a single property: { id: "...", properties: [{ alias: "title", value: "New Title" }] }
+  - Add a new property: { id: "...", properties: [{ alias: "author", value: "John Doe" }] }
+  - Update with culture: { id: "...", properties: [{ alias: "title", value: "Nuevo T\xEDtulo", culture: "es-ES" }] }
+  - Mix update and add: { id: "...", properties: [{ alias: "title", value: "New" }, { alias: "newProp", value: "Value" }] }`,
+  updateDocumentPropertiesSchema,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const currentDocument = await client.getDocumentById(model.id);
+    const invalidAliases = [];
+    const varianceErrors = [];
+    const propertiesToUpdate = [];
+    const propertiesToAdd = [];
+    let documentTypeProperties = null;
+    const getDocumentTypeProperties = async () => {
+      if (documentTypeProperties === null) {
+        try {
+          documentTypeProperties = await getAllDocumentTypeProperties(currentDocument.documentType.id);
+        } catch (error) {
+          console.error("Failed to fetch document type properties:", error);
+          documentTypeProperties = [];
+        }
+      }
+      return documentTypeProperties;
+    };
+    for (const prop of model.properties) {
+      const existsOnDocument = currentDocument.values.some(
+        (v) => matchesProperty(v, prop.alias, prop.culture, prop.segment)
+      );
+      if (existsOnDocument) {
+        propertiesToUpdate.push({
+          alias: prop.alias,
+          value: prop.value,
+          culture: prop.culture,
+          segment: prop.segment
+        });
+      } else {
+        const docTypeProperties = await getDocumentTypeProperties();
+        const propertyDef = docTypeProperties.find((p) => p.alias === prop.alias);
+        if (propertyDef) {
+          const validationError = validateCultureSegment(prop, propertyDef);
+          if (validationError) {
+            varianceErrors.push(validationError);
+          } else {
+            propertiesToAdd.push({
+              alias: prop.alias,
+              value: prop.value,
+              culture: prop.culture,
+              segment: prop.segment
+            });
+          }
+        } else if (docTypeProperties.length > 0) {
+          invalidAliases.push(getPropertyKey(prop.alias, prop.culture, prop.segment));
+        } else {
+          invalidAliases.push(getPropertyKey(prop.alias, prop.culture, prop.segment));
+        }
+      }
+    }
+    if (varianceErrors.length > 0) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: false,
+            error: "Culture/segment validation failed",
+            message: varianceErrors.join("; "),
+            errors: varianceErrors,
+            availableProperties: (documentTypeProperties ?? []).map((p) => ({
+              alias: p.alias,
+              name: p.name,
+              variesByCulture: p.variesByCulture,
+              variesBySegment: p.variesBySegment
+            }))
+          }, null, 2)
+        }]
+      };
+    }
+    if (invalidAliases.length > 0) {
+      const docTypeProps = documentTypeProperties ?? [];
+      const availableProperties = docTypeProps.length > 0 ? docTypeProps.map((p) => ({
+        alias: p.alias,
+        name: p.name,
+        variesByCulture: p.variesByCulture,
+        variesBySegment: p.variesBySegment
+      })) : currentDocument.values.map((v) => ({
+        alias: v.alias,
+        culture: v.culture ?? null,
+        segment: v.segment ?? null,
+        editorAlias: v.editorAlias
+      }));
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: false,
+            error: "Invalid property aliases",
+            message: `The following properties do not exist on this document type: ${invalidAliases.join(", ")}`,
+            invalidAliases,
+            availableProperties
+          }, null, 2)
+        }]
+      };
+    }
+    const allPropertiesToValidate = [...propertiesToUpdate, ...propertiesToAdd];
+    if (allPropertiesToValidate.length > 0) {
+      const docTypeProps = await getDocumentTypeProperties();
+      const propsToValidate = allPropertiesToValidate.map((p) => {
+        const def = docTypeProps.find((d) => d.alias === p.alias);
+        return { alias: p.alias, value: p.value, dataTypeId: def?.dataTypeId ?? "" };
+      }).filter((p) => p.dataTypeId);
+      if (propsToValidate.length > 0) {
+        const valueValidation = await validatePropertiesBeforeSave(propsToValidate);
+        if (!valueValidation.isValid) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Property value validation failed",
+                errors: valueValidation.errors
+              }, null, 2)
+            }]
+          };
+        }
+      }
+    }
+    const updatedValues = currentDocument.values.map((existingValue) => {
+      const updateProp = propertiesToUpdate.find(
+        (p) => matchesProperty(existingValue, p.alias, p.culture, p.segment)
+      );
+      if (updateProp) {
+        return {
+          alias: existingValue.alias,
+          culture: existingValue.culture,
+          segment: existingValue.segment,
+          value: updateProp.value
+        };
+      }
+      return {
+        alias: existingValue.alias,
+        culture: existingValue.culture,
+        segment: existingValue.segment,
+        value: existingValue.value
+      };
+    });
+    for (const newProp of propertiesToAdd) {
+      updatedValues.push({
+        alias: newProp.alias,
+        culture: newProp.culture ?? null,
+        segment: newProp.segment ?? null,
+        value: newProp.value
+      });
+    }
+    const variants = currentDocument.variants.map((v) => ({
+      culture: v.culture,
+      segment: v.segment,
+      name: v.name
+    }));
+    const updatePayload = {
+      values: updatedValues,
+      variants,
+      template: currentDocument.template
+    };
+    await client.putDocumentById(model.id, updatePayload);
+    const updatedDocument = await client.getDocumentById(model.id);
+    const updatedPropertyKeys = propertiesToUpdate.map(
+      (p) => getPropertyKey(p.alias, p.culture, p.segment)
+    );
+    const addedPropertyKeys = propertiesToAdd.map(
+      (p) => getPropertyKey(p.alias, p.culture, p.segment)
+    );
+    const totalCount = propertiesToUpdate.length + propertiesToAdd.length;
+    let message = `Successfully processed ${totalCount} property value(s)`;
+    if (propertiesToUpdate.length > 0 && propertiesToAdd.length > 0) {
+      message = `Successfully updated ${propertiesToUpdate.length} and added ${propertiesToAdd.length} property value(s)`;
+    } else if (propertiesToAdd.length > 0) {
+      message = `Successfully added ${propertiesToAdd.length} property value(s)`;
+    } else {
+      message = `Successfully updated ${propertiesToUpdate.length} property value(s)`;
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          message,
+          updatedProperties: updatedPropertyKeys,
+          addedProperties: addedPropertyKeys,
+          document: updatedDocument
+        }, null, 2)
+      }]
+    };
+  },
+  (user) => user.fallbackPermissions.includes(UmbracoDocumentPermissions.Update)
+);
+var update_document_properties_default = UpdateDocumentPropertiesTool;
+
+// src/umb-management-api/tools/document/put/update-block-property.ts
+import { z as z43 } from "zod";
+
+// src/umb-management-api/tools/document/put/helpers/block-discovery.ts
+function isRichTextValue(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (!("markup" in value)) {
+    return false;
+  }
+  if (!value.blocks || typeof value.blocks !== "object") {
+    return false;
+  }
+  return Array.isArray(value.blocks.contentData) && Array.isArray(value.blocks.settingsData);
+}
+function isBlockStructure(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  return Array.isArray(value.contentData) && Array.isArray(value.settingsData);
+}
+function discoverAllBlockArrays(value, path4 = "root") {
+  const results = [];
+  if (!value || typeof value !== "object") {
+    return results;
+  }
+  if (isRichTextValue(value)) {
+    const nestedResults = discoverAllBlockArrays(value.blocks, `${path4}.blocks`);
+    results.push(...nestedResults);
+    return results;
+  }
+  if (isBlockStructure(value)) {
+    results.push({
+      contentData: value.contentData,
+      settingsData: value.settingsData,
+      path: path4
+    });
+    value.contentData.forEach((block, index) => {
+      if (block.values && Array.isArray(block.values)) {
+        block.values.forEach((prop, propIndex) => {
+          const propPath = `${path4}.contentData[${index}].values[${propIndex}](${prop.alias})`;
+          if (isRichTextValue(prop.value)) {
+            const nestedResults = discoverAllBlockArrays(prop.value.blocks, `${propPath}.blocks`);
+            results.push(...nestedResults);
+          } else if (isBlockStructure(prop.value)) {
+            const nestedResults = discoverAllBlockArrays(prop.value, propPath);
+            results.push(...nestedResults);
+          }
+        });
+      }
+    });
+    value.settingsData.forEach((block, index) => {
+      if (block.values && Array.isArray(block.values)) {
+        block.values.forEach((prop, propIndex) => {
+          const propPath = `${path4}.settingsData[${index}].values[${propIndex}](${prop.alias})`;
+          if (isRichTextValue(prop.value)) {
+            const nestedResults = discoverAllBlockArrays(prop.value.blocks, `${propPath}.blocks`);
+            results.push(...nestedResults);
+          } else if (isBlockStructure(prop.value)) {
+            const nestedResults = discoverAllBlockArrays(prop.value, propPath);
+            results.push(...nestedResults);
+          }
+        });
+      }
+    });
+  }
+  return results;
+}
+function findBlockByKey(discoveredArrays, contentKey, blockType) {
+  for (const discovered of discoveredArrays) {
+    const array = blockType === "content" ? discovered.contentData : discovered.settingsData;
+    const block = array.find((b) => b.key === contentKey);
+    if (block) {
+      return { block, arrayRef: array, path: discovered.path };
+    }
+  }
+  return null;
+}
+
+// src/umb-management-api/tools/document/put/update-block-property.ts
+var blockPropertyUpdateSchema = z43.object({
+  alias: z43.string().min(1).describe("The property alias within the block to update"),
+  value: z43.any().nullish().describe("The new value for the property"),
+  culture: z43.string().nullish().describe("Optional culture code for variant block properties"),
+  segment: z43.string().nullish().describe("Optional segment identifier for variant block properties")
+});
+var blockUpdateSchema = z43.object({
+  contentKey: z43.string().uuid().describe("The unique key (UUID) identifying the block"),
+  blockType: z43.enum(["content", "settings"]).describe("'content' for contentData, 'settings' for settingsData"),
+  properties: z43.array(blockPropertyUpdateSchema).min(1).describe("Properties to update within this block")
+});
+var updateBlockPropertySchema = {
+  documentId: z43.string().uuid().describe("The document containing the block"),
+  propertyAlias: z43.string().min(1).describe("Document property alias containing BlockList/BlockGrid"),
+  culture: z43.string().nullish().describe("Optional culture for variant document properties"),
+  segment: z43.string().nullish().describe("Optional segment for variant document properties"),
+  updates: z43.array(blockUpdateSchema).min(1).describe("Array of block updates")
+};
+var UpdateBlockPropertyTool = CreateUmbracoTool(
+  "update-block-property",
+  `Updates or adds property values within BlockList, BlockGrid, or RichText block content.
+
+  This tool enables targeted updates to individual block properties without sending the entire JSON payload.
+  You can update existing properties, add new properties, or do both in a single call.
+  It automatically handles deep traversal of nested block structures (e.g., RichText blocks containing nested blocks).
+
+  Key features:
+  - Update existing properties or add new ones to blocks
+  - Property must exist on the Element Type (including compositions)
+  - Support for both content and settings blocks
+  - Batch updates to multiple blocks in a single call
+  - Deep traversal of nested block structures
+  - Full i18n support with culture and segment parameters
+  - Culture/segment requirements validated against property variance flags
+
+  Example usage:
+  - Update a block property: { documentId: "...", propertyAlias: "mainContent", updates: [{ contentKey: "block-uuid", blockType: "content", properties: [{ alias: "title", value: "New Title" }] }] }
+  - Add a new property to block: { documentId: "...", propertyAlias: "mainContent", updates: [{ contentKey: "block-uuid", blockType: "content", properties: [{ alias: "newProp", value: "Value" }] }] }
+  - Update with culture: { documentId: "...", propertyAlias: "mainContent", culture: "es-ES", updates: [...] }
+  - Batch update multiple blocks: { documentId: "...", propertyAlias: "mainContent", updates: [{ contentKey: "uuid1", ... }, { contentKey: "uuid2", ... }] }`,
+  updateBlockPropertySchema,
+  async (model) => {
+    const client = UmbracoManagementClient2.getClient();
+    const currentDocument = await client.getDocumentById(model.documentId);
+    const documentProperty = currentDocument.values.find(
+      (v) => matchesProperty(v, model.propertyAlias, model.culture, model.segment)
+    );
+    if (!documentProperty) {
+      const availableAliases = currentDocument.values.map((v) => ({
+        alias: v.alias,
+        culture: v.culture ?? null,
+        segment: v.segment ?? null,
+        editorAlias: v.editorAlias
+      }));
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: false,
+            error: "Property not found",
+            message: `Property '${getPropertyKey(model.propertyAlias, model.culture, model.segment)}' does not exist on this document`,
+            availableProperties: availableAliases
+          }, null, 2)
+        }]
+      };
+    }
+    const discoveredArrays = discoverAllBlockArrays(documentProperty.value, `property(${model.propertyAlias})`);
+    if (discoveredArrays.length === 0) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: false,
+            error: "No block structure found",
+            message: `Property '${model.propertyAlias}' does not contain a BlockList, BlockGrid, or RichText block structure`,
+            propertyValue: documentProperty.value
+          }, null, 2)
+        }]
+      };
+    }
+    const results = [];
+    const notFoundBlocks = [];
+    const elementTypePropertiesCache = /* @__PURE__ */ new Map();
+    const getElementTypeProperties = async (contentTypeKey) => {
+      if (!elementTypePropertiesCache.has(contentTypeKey)) {
+        try {
+          const properties = await getAllDocumentTypeProperties(contentTypeKey);
+          elementTypePropertiesCache.set(contentTypeKey, properties);
+        } catch (error) {
+          console.error(`Failed to fetch Element Type properties for ${contentTypeKey}:`, error);
+          elementTypePropertiesCache.set(contentTypeKey, []);
+        }
+      }
+      return elementTypePropertiesCache.get(contentTypeKey);
+    };
+    for (const update of model.updates) {
+      const foundBlock = findBlockByKey(discoveredArrays, update.contentKey, update.blockType);
+      if (!foundBlock) {
+        notFoundBlocks.push({ contentKey: update.contentKey, blockType: update.blockType });
+        results.push({
+          success: false,
+          contentKey: update.contentKey,
+          message: `Block with contentKey '${update.contentKey}' not found in ${update.blockType}Data`
+        });
+        continue;
+      }
+      const warnings = [];
+      const errors = [];
+      let updatedCount = 0;
+      let addedCount = 0;
+      const elementTypeProperties = await getElementTypeProperties(foundBlock.block.contentTypeKey);
+      if (elementTypeProperties.length > 0) {
+        const propsToValidate = update.properties.map((p) => {
+          const def = elementTypeProperties.find((d) => d.alias === p.alias);
+          return { alias: p.alias, value: p.value, dataTypeId: def?.dataTypeId ?? "" };
+        }).filter((p) => p.dataTypeId);
+        if (propsToValidate.length > 0) {
+          const valueValidation = await validatePropertiesBeforeSave(propsToValidate);
+          if (!valueValidation.isValid) {
+            errors.push(...valueValidation.errors);
+          }
+        }
+      }
+      for (const propUpdate of update.properties) {
+        const blockProperty = foundBlock.block.values.find(
+          (v) => matchesProperty(v, propUpdate.alias, propUpdate.culture, propUpdate.segment)
+        );
+        if (blockProperty) {
+          blockProperty.value = propUpdate.value;
+          updatedCount++;
+        } else {
+          const propertyDef = elementTypeProperties.find((p) => p.alias === propUpdate.alias);
+          if (propertyDef) {
+            const validationError = validateCultureSegment(propUpdate, propertyDef);
+            if (validationError) {
+              errors.push(validationError);
+            } else {
+              foundBlock.block.values.push({
+                alias: propUpdate.alias,
+                culture: propUpdate.culture ?? null,
+                segment: propUpdate.segment ?? null,
+                value: propUpdate.value
+              });
+              addedCount++;
+            }
+          } else if (elementTypeProperties.length > 0) {
+            errors.push(
+              `Property '${getPropertyKey(propUpdate.alias, propUpdate.culture, propUpdate.segment)}' does not exist on Element Type`
+            );
+          } else {
+            warnings.push(
+              `Property '${getPropertyKey(propUpdate.alias, propUpdate.culture, propUpdate.segment)}' not found in block (could not validate against Element Type)`
+            );
+          }
+        }
+      }
+      const totalProcessed = updatedCount + addedCount;
+      let message;
+      if (updatedCount > 0 && addedCount > 0) {
+        message = `Updated ${updatedCount} and added ${addedCount} properties in block at ${foundBlock.path}`;
+      } else if (addedCount > 0) {
+        message = `Added ${addedCount} properties in block at ${foundBlock.path}`;
+      } else if (updatedCount > 0) {
+        message = `Updated ${updatedCount} properties in block at ${foundBlock.path}`;
+      } else {
+        message = `No properties were processed in block at ${foundBlock.path}`;
+      }
+      results.push({
+        success: totalProcessed > 0 || errors.length === 0,
+        contentKey: update.contentKey,
+        message,
+        updatedCount: updatedCount > 0 ? updatedCount : void 0,
+        addedCount: addedCount > 0 ? addedCount : void 0,
+        warnings: warnings.length > 0 ? warnings : void 0,
+        errors: errors.length > 0 ? errors : void 0
+      });
+    }
+    if (notFoundBlocks.length === model.updates.length) {
+      const allBlocks = discoveredArrays.flatMap((d) => [
+        ...d.contentData.map((b) => ({ key: b.key, type: "content", path: d.path })),
+        ...d.settingsData.map((b) => ({ key: b.key, type: "settings", path: d.path }))
+      ]);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: false,
+            error: "Blocks not found",
+            message: "None of the specified blocks were found in the document",
+            notFoundBlocks,
+            availableBlocks: allBlocks
+          }, null, 2)
+        }]
+      };
+    }
+    const updatedValues = currentDocument.values.map((existingValue) => ({
+      alias: existingValue.alias,
+      culture: existingValue.culture,
+      segment: existingValue.segment,
+      value: existingValue.value
+    }));
+    const variants = currentDocument.variants.map((v) => ({
+      culture: v.culture,
+      segment: v.segment,
+      name: v.name
+    }));
+    const updatePayload = {
+      values: updatedValues,
+      variants,
+      template: currentDocument.template
+    };
+    await client.putDocumentById(model.documentId, updatePayload);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          message: `Successfully processed ${model.updates.length} block update(s)`,
+          results
+        }, null, 2)
+      }]
+    };
+  },
+  (user) => user.fallbackPermissions.includes(UmbracoDocumentPermissions.Update)
+);
+var update_block_property_default = UpdateBlockPropertyTool;
+
 // src/umb-management-api/tools/document/items/get/get-root.ts
 var GetDocumentRootTool = CreateUmbracoTool(
   "get-document-root",
@@ -19740,6 +20507,8 @@ var DocumentCollection = {
       tools.push(sort_document_default());
       tools.push(unpublish_document_default());
       tools.push(update_document_default());
+      tools.push(update_document_properties_default());
+      tools.push(update_block_property_default());
       tools.push(put_document_domains_default());
       tools.push(put_document_notifications_default());
       tools.push(put_document_public_access_default());
@@ -19877,7 +20646,7 @@ var DocumentVersionCollection = {
 };
 
 // src/umb-management-api/tools/media/post/create-media.ts
-import { z as z42 } from "zod";
+import { z as z44 } from "zod";
 import { v4 as uuidv46 } from "uuid";
 
 // src/umb-management-api/tools/media/post/helpers/media-upload-helpers.ts
@@ -20351,14 +21120,14 @@ async function uploadMediaFile(client, params) {
 }
 
 // src/umb-management-api/tools/media/post/create-media.ts
-var createMediaSchema = z42.object({
-  sourceType: z42.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: z42.string().describe("The name of the media item"),
-  mediaTypeName: z42.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: z42.string().optional().describe("Absolute path to the file (required if sourceType is 'filePath')"),
-  fileUrl: z42.string().url().optional().describe("URL to fetch the file from (required if sourceType is 'url')"),
-  fileAsBase64: z42.string().optional().describe("Base64 encoded file data (required if sourceType is 'base64')"),
-  parentId: z42.string().uuid().optional().describe("Parent folder ID (defaults to root)")
+var createMediaSchema = z44.object({
+  sourceType: z44.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: z44.string().describe("The name of the media item"),
+  mediaTypeName: z44.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: z44.string().optional().describe("Absolute path to the file (required if sourceType is 'filePath')"),
+  fileUrl: z44.string().url().optional().describe("URL to fetch the file from (required if sourceType is 'url')"),
+  fileAsBase64: z44.string().optional().describe("Base64 encoded file data (required if sourceType is 'base64')"),
+  parentId: z44.string().uuid().optional().describe("Parent folder ID (defaults to root)")
 });
 var CreateMediaTool = CreateUmbracoTool(
   "create-media",
@@ -20425,17 +21194,17 @@ var CreateMediaTool = CreateUmbracoTool(
 var create_media_default = CreateMediaTool;
 
 // src/umb-management-api/tools/media/post/create-media-multiple.ts
-import { z as z43 } from "zod";
+import { z as z45 } from "zod";
 import { v4 as uuidv47 } from "uuid";
-var createMediaMultipleSchema = z43.object({
-  sourceType: z43.enum(["filePath", "url"]).describe("Media source type: 'filePath' for local files (most efficient), 'url' for web files. Base64 not supported for batch uploads due to token usage."),
-  files: z43.array(z43.object({
-    name: z43.string().describe("The name of the media item"),
-    filePath: z43.string().optional().describe("Absolute path to the file (required if sourceType is 'filePath')"),
-    fileUrl: z43.string().url().optional().describe("URL to fetch the file from (required if sourceType is 'url')"),
-    mediaTypeName: z43.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}'`)
+var createMediaMultipleSchema = z45.object({
+  sourceType: z45.enum(["filePath", "url"]).describe("Media source type: 'filePath' for local files (most efficient), 'url' for web files. Base64 not supported for batch uploads due to token usage."),
+  files: z45.array(z45.object({
+    name: z45.string().describe("The name of the media item"),
+    filePath: z45.string().optional().describe("Absolute path to the file (required if sourceType is 'filePath')"),
+    fileUrl: z45.string().url().optional().describe("URL to fetch the file from (required if sourceType is 'url')"),
+    mediaTypeName: z45.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: z43.string().uuid().optional().describe("Parent folder ID (defaults to root)")
+  parentId: z45.string().uuid().optional().describe("Parent folder ID (defaults to root)")
 });
 var CreateMediaMultipleTool = CreateUmbracoTool(
   "create-media-multiple",
@@ -20552,7 +21321,7 @@ var GetMediaByIdTool = CreateUmbracoTool(
 var get_media_by_id_default = GetMediaByIdTool;
 
 // src/umb-management-api/tools/media/put/update-media.ts
-import { z as z44 } from "zod";
+import { z as z46 } from "zod";
 var UpdateMediaTool = CreateUmbracoTool(
   "update-media",
   `Updates a media item by Id
@@ -20561,7 +21330,7 @@ var UpdateMediaTool = CreateUmbracoTool(
   This cannot be used for moving media to a new folder. Use the move endpoint to do that`,
   {
     id: putMediaByIdParams.shape.id,
-    data: z44.object(putMediaByIdBody.shape)
+    data: z46.object(putMediaByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -20640,13 +21409,13 @@ var ValidateMediaTool = CreateUmbracoTool(
 var validate_media_default = ValidateMediaTool;
 
 // src/umb-management-api/tools/media/put/validate-media.ts
-import { z as z45 } from "zod";
+import { z as z47 } from "zod";
 var ValidateMediaUpdateTool = CreateUmbracoTool(
   "validate-media-update",
   "Validates media data before updating an existing media item by Id",
   {
     id: putMediaByIdValidateParams.shape.id,
-    data: z45.object(putMediaByIdValidateBody.shape)
+    data: z47.object(putMediaByIdValidateBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -20705,13 +21474,13 @@ var GetMediaByIdArrayTool = CreateUmbracoTool(
 var get_media_by_id_array_default = GetMediaByIdArrayTool;
 
 // src/umb-management-api/tools/media/put/move-media.ts
-import { z as z46 } from "zod";
+import { z as z48 } from "zod";
 var MoveMediaTool = CreateUmbracoTool(
   "move-media",
   "Move a media item to a new location",
   {
-    id: z46.string().uuid(),
-    data: z46.object(putMediaByIdMoveBody.shape)
+    id: z48.string().uuid(),
+    data: z48.object(putMediaByIdMoveBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -20809,13 +21578,13 @@ var GetMediaRootTool = CreateUmbracoTool(
 var get_root_default6 = GetMediaRootTool;
 
 // src/umb-management-api/tools/media/get/get-media-audit-log.ts
-import { z as z47 } from "zod";
+import { z as z49 } from "zod";
 var GetMediaAuditLogTool = CreateUmbracoTool(
   "get-media-audit-log",
   "Fetches the audit log for a media item by Id.",
   {
     id: getMediaByIdAuditLogParams.shape.id,
-    data: z47.object(getMediaByIdAuditLogQueryParams.shape)
+    data: z49.object(getMediaByIdAuditLogQueryParams.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -21016,12 +21785,12 @@ var GetMediaAreReferencedTool = CreateUmbracoTool(
 var get_media_are_referenced_default = GetMediaAreReferencedTool;
 
 // src/umb-management-api/tools/media/get/get-media-by-id-referenced-by.ts
-import { z as z48 } from "zod";
+import { z as z50 } from "zod";
 var GetMediaByIdReferencedByTool = CreateUmbracoTool(
   "get-media-by-id-referenced-by",
   `Get items that reference a specific media item
   Use this to find all content, documents, or other items that are currently referencing a specific media item.`,
-  z48.object({
+  z50.object({
     ...getMediaByIdReferencedByParams.shape,
     ...getMediaByIdReferencedByQueryParams.shape
   }).shape,
@@ -21041,7 +21810,7 @@ var GetMediaByIdReferencedByTool = CreateUmbracoTool(
 var get_media_by_id_referenced_by_default = GetMediaByIdReferencedByTool;
 
 // src/umb-management-api/tools/media/get/get-media-by-id-referenced-descendants.ts
-import { z as z49 } from "zod";
+import { z as z51 } from "zod";
 var GetMediaByIdReferencedDescendantsTool = CreateUmbracoTool(
   "get-media-by-id-referenced-descendants",
   `Get descendant references for a media item
@@ -21051,7 +21820,7 @@ var GetMediaByIdReferencedDescendantsTool = CreateUmbracoTool(
   \u2022 Impact analysis: Before deleting a media folder, see what content would be affected
   \u2022 Dependency tracking: Find all content using media from a specific folder hierarchy
   \u2022 Content auditing: Identify which descendant media items are actually being used`,
-  z49.object({
+  z51.object({
     ...getMediaByIdReferencedDescendantsParams.shape,
     ...getMediaByIdReferencedDescendantsQueryParams.shape
   }).shape,
@@ -21231,12 +22000,12 @@ var GetMediaTypeByIdTool = CreateUmbracoTool(
 var get_media_type_by_id_default = GetMediaTypeByIdTool;
 
 // src/umb-management-api/tools/media-type/get/get-media-type-by-ids.ts
-import { z as z50 } from "zod";
+import { z as z52 } from "zod";
 var GetMediaTypeByIdsTool = CreateUmbracoTool(
   "get-media-type-by-ids",
   "Gets media types by ids",
   {
-    ids: z50.array(z50.string())
+    ids: z52.array(z52.string())
   },
   async ({ ids }) => {
     const client = UmbracoManagementClient2.getClient();
@@ -21522,13 +22291,13 @@ var DeleteMediaTypeFolderTool = CreateUmbracoTool(
 var delete_folder_default4 = DeleteMediaTypeFolderTool;
 
 // src/umb-management-api/tools/media-type/folders/put/update-folder.ts
-import { z as z51 } from "zod";
+import { z as z53 } from "zod";
 var UpdateMediaTypeFolderTool = CreateUmbracoTool(
   "update-media-type-folder",
   "Updates a media type folder by Id",
   {
     id: putMediaTypeFolderByIdParams.shape.id,
-    data: z51.object(putMediaTypeFolderByIdBody.shape)
+    data: z53.object(putMediaTypeFolderByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -21546,25 +22315,25 @@ var UpdateMediaTypeFolderTool = CreateUmbracoTool(
 var update_folder_default4 = UpdateMediaTypeFolderTool;
 
 // src/umb-management-api/tools/media-type/post/create-media-type.ts
-import { z as z52 } from "zod";
-var propertySchema2 = postMediaTypeBody.shape.properties;
+import { z as z54 } from "zod";
+var propertySchema3 = 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 = z52.object({
-  alias: z52.string().min(1),
-  name: z52.string().min(1),
-  description: z52.string().nullish(),
-  icon: z52.string().min(1),
-  allowedAsRoot: z52.boolean(),
-  variesByCulture: z52.boolean(),
-  variesBySegment: z52.boolean(),
-  isElement: z52.boolean(),
-  properties: propertySchema2,
+var createMediaTypeSchema = z54.object({
+  alias: z54.string().min(1),
+  name: z54.string().min(1),
+  description: z54.string().nullish(),
+  icon: z54.string().min(1),
+  allowedAsRoot: z54.boolean(),
+  variesByCulture: z54.boolean(),
+  variesBySegment: z54.boolean(),
+  isElement: z54.boolean(),
+  properties: propertySchema3,
   containers: containerSchema,
-  id: z52.string().uuid().nullish(),
-  parentId: z52.string().uuid().optional(),
+  id: z54.string().uuid().nullish(),
+  parentId: z54.string().uuid().optional(),
   // Flattened parent ID
   allowedMediaTypes: allowedMediaTypeSchema,
   compositions: compositionSchema,
@@ -21607,13 +22376,13 @@ var CreateMediaTypeTool = CreateUmbracoTool(
 var create_media_type_default = CreateMediaTypeTool;
 
 // src/umb-management-api/tools/media-type/post/copy-media-type.ts
-import { z as z53 } from "zod";
+import { z as z55 } from "zod";
 var CopyMediaTypeTool = CreateUmbracoTool(
   "copy-media-type",
   "Copy a media type to a new location",
   {
-    id: z53.string().uuid(),
-    data: z53.object(postMediaTypeByIdCopyBody.shape)
+    id: z55.string().uuid(),
+    data: z55.object(postMediaTypeByIdCopyBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -21651,13 +22420,13 @@ var GetMediaTypeAvailableCompositionsTool = CreateUmbracoTool(
 var get_media_type_available_compositions_default = GetMediaTypeAvailableCompositionsTool;
 
 // src/umb-management-api/tools/media-type/put/update-media-type.ts
-import { z as z54 } from "zod";
+import { z as z56 } from "zod";
 var UpdateMediaTypeTool = CreateUmbracoTool(
   "update-media-type",
   "Updates a media type by Id",
   {
     id: putMediaTypeByIdParams.shape.id,
-    data: z54.object(putMediaTypeByIdBody.shape)
+    data: z56.object(putMediaTypeByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -21675,13 +22444,13 @@ var UpdateMediaTypeTool = CreateUmbracoTool(
 var update_media_type_default = UpdateMediaTypeTool;
 
 // src/umb-management-api/tools/media-type/put/move-media-type.ts
-import { z as z55 } from "zod";
+import { z as z57 } from "zod";
 var MoveMediaTypeTool = CreateUmbracoTool(
   "move-media-type",
   "Move a media type to a new location",
   {
-    id: z55.string().uuid(),
-    data: z55.object(putMediaTypeByIdMoveBody.shape)
+    id: z57.string().uuid(),
+    data: z57.object(putMediaTypeByIdMoveBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -21842,13 +22611,13 @@ var DeleteMemberTool = CreateUmbracoTool(
 var delete_member_default = DeleteMemberTool;
 
 // src/umb-management-api/tools/member/put/update-member.ts
-import { z as z56 } from "zod";
+import { z as z58 } from "zod";
 var UpdateMemberTool = CreateUmbracoTool(
   "update-member",
   "Updates a member by Id",
   {
     id: putMemberByIdParams.shape.id,
-    data: z56.object(putMemberByIdBody.shape)
+    data: z58.object(putMemberByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -21866,14 +22635,14 @@ var UpdateMemberTool = CreateUmbracoTool(
 var update_member_default = UpdateMemberTool;
 
 // src/umb-management-api/tools/member/put/validate-member-update.ts
-import { z as z57 } from "zod";
+import { z as z59 } from "zod";
 var ValidateMemberUpdateTool = CreateUmbracoTool(
   "validate-member-update",
   `Validates member data before updating using the Umbraco API.
   Use this endpoint to validate member data structure, properties, and business rules before attempting to update an existing member.`,
   {
     id: putMemberByIdValidateParams.shape.id,
-    data: z57.object(putMemberByIdValidateBody.shape)
+    data: z59.object(putMemberByIdValidateBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -21932,12 +22701,12 @@ var GetMemberAreReferencedTool = CreateUmbracoTool(
 var get_member_are_referenced_default = GetMemberAreReferencedTool;
 
 // src/umb-management-api/tools/member/get/get-member-by-id-referenced-by.ts
-import { z as z58 } from "zod";
+import { z as z60 } from "zod";
 var GetMemberByIdReferencedByTool = CreateUmbracoTool(
   "get-member-by-id-referenced-by",
   `Get items that reference a specific member
   Use this to find all content, documents, or other items that are currently referencing a specific member account.`,
-  z58.object({
+  z60.object({
     ...getMemberByIdReferencedByParams.shape,
     ...getMemberByIdReferencedByQueryParams.shape
   }).shape,
@@ -21957,12 +22726,12 @@ var GetMemberByIdReferencedByTool = CreateUmbracoTool(
 var get_member_by_id_referenced_by_default = GetMemberByIdReferencedByTool;
 
 // src/umb-management-api/tools/member/get/get-member-by-id-referenced-descendants.ts
-import { z as z59 } from "zod";
+import { z as z61 } from "zod";
 var GetMemberByIdReferencedDescendantsTool = CreateUmbracoTool(
   "get-member-by-id-referenced-descendants",
   `Get descendant references for a member
   Use this to find all descendant references that are being referenced for a specific member account.`,
-  z59.object({
+  z61.object({
     ...getMemberByIdReferencedDescendantsParams.shape,
     ...getMemberByIdReferencedDescendantsQueryParams.shape
   }).shape,
@@ -22130,13 +22899,13 @@ var CreateMemberGroupTool = CreateUmbracoTool(
 var create_member_group_default = CreateMemberGroupTool;
 
 // src/umb-management-api/tools/member-group/put/update-member-group.ts
-import { z as z60 } from "zod";
+import { z as z62 } from "zod";
 var UpdateMemberGroupTool = CreateUmbracoTool(
   "update-member-group",
   "Updates a member group by Id",
   {
     id: putMemberGroupByIdParams.shape.id,
-    data: z60.object(putMemberGroupByIdBody.shape)
+    data: z62.object(putMemberGroupByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -22279,13 +23048,13 @@ var DeleteMemberTypeTool = CreateUmbracoTool(
 var delete_member_type_default = DeleteMemberTypeTool;
 
 // src/umb-management-api/tools/member-type/put/update-member-type.ts
-import { z as z61 } from "zod";
+import { z as z63 } from "zod";
 var UpdateMemberTypeTool = CreateUmbracoTool(
   "update-member-type",
   "Updates a member type by id",
   {
     id: putMemberTypeByIdParams.shape.id,
-    data: z61.object(putMemberTypeByIdBody.shape)
+    data: z63.object(putMemberTypeByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -22303,12 +23072,12 @@ var UpdateMemberTypeTool = CreateUmbracoTool(
 var update_member_type_default = UpdateMemberTypeTool;
 
 // src/umb-management-api/tools/member-type/post/copy-member-type.ts
-import { z as z62 } from "zod";
+import { z as z64 } from "zod";
 var CopyMemberTypeTool = CreateUmbracoTool(
   "copy-member-type",
   "Copy a member type to a new location",
   {
-    id: z62.string().uuid()
+    id: z64.string().uuid()
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -22679,11 +23448,11 @@ var LogViewerCollection = {
 };
 
 // src/umb-management-api/tools/partial-view/post/create-partial-view.ts
-import z63 from "zod";
-var createPartialViewSchema = z63.object({
-  name: z63.string().min(1, "Name is required"),
-  path: z63.string().optional(),
-  content: z63.string().min(1, "Content is required")
+import z65 from "zod";
+var createPartialViewSchema = z65.object({
+  name: z65.string().min(1, "Name is required"),
+  path: z65.string().optional(),
+  content: z65.string().min(1, "Content is required")
 });
 var CreatePartialViewTool = CreateUmbracoTool(
   "create-partial-view",
@@ -22773,11 +23542,11 @@ var GetPartialViewFolderByPathTool = CreateUmbracoTool(
 var get_partial_view_folder_by_path_default = GetPartialViewFolderByPathTool;
 
 // src/umb-management-api/tools/partial-view/put/update-partial-view.ts
-import { z as z64 } from "zod";
+import { z as z66 } from "zod";
 var UpdatePartialViewTool = CreateUmbracoTool(
   "update-partial-view",
   "Updates a partial view",
-  z64.object({
+  z66.object({
     ...putPartialViewByPathParams.shape,
     ...putPartialViewByPathBody.shape
   }).shape,
@@ -22798,11 +23567,11 @@ var UpdatePartialViewTool = CreateUmbracoTool(
 var update_partial_view_default = UpdatePartialViewTool;
 
 // src/umb-management-api/tools/partial-view/put/rename-partial-view.ts
-import { z as z65 } from "zod";
+import { z as z67 } from "zod";
 var RenamePartialViewTool = CreateUmbracoTool(
   "rename-partial-view",
   `Renames a partial view`,
-  z65.object({
+  z67.object({
     ...putPartialViewByPathRenameParams.shape,
     ...putPartialViewByPathRenameBody.shape
   }).shape,
@@ -23152,13 +23921,13 @@ var GetTemplatesByIdArrayTool = CreateUmbracoTool(
 var get_template_by_id_array_default = GetTemplatesByIdArrayTool;
 
 // src/umb-management-api/tools/template/put/update-template.ts
-import { z as z66 } from "zod";
+import { z as z68 } from "zod";
 var UpdateTemplateTool = CreateUmbracoTool(
   "update-template",
   "Updates a template by Id",
   {
     id: putTemplateByIdParams.shape.id,
-    data: z66.object(putTemplateByIdBody.shape)
+    data: z68.object(putTemplateByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -23454,13 +24223,13 @@ var DeleteWebhookTool = CreateUmbracoTool(
 var delete_webhook_default = DeleteWebhookTool;
 
 // src/umb-management-api/tools/webhook/put/update-webhook.ts
-import { z as z67 } from "zod";
+import { z as z69 } from "zod";
 var UpdateWebhookTool = CreateUmbracoTool(
   "update-webhook",
   "Updates a webhook by id",
   {
     id: putWebhookByIdParams.shape.id,
-    data: z67.object(putWebhookByIdBody.shape)
+    data: z69.object(putWebhookByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -24060,13 +24829,13 @@ var CreateUserGroupTool = CreateUmbracoTool(
 var create_user_group_default = CreateUserGroupTool;
 
 // src/umb-management-api/tools/user-group/put/update-user-group.ts
-import { z as z68 } from "zod";
+import { z as z70 } from "zod";
 var UpdateUserGroupTool = CreateUmbracoTool(
   "update-user-group",
   "Updates a user group by Id",
   {
     id: putUserGroupByIdParams.shape.id,
-    data: z68.object(putUserGroupByIdBody.shape)
+    data: z70.object(putUserGroupByIdBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -24148,14 +24917,14 @@ var UserGroupCollection = {
 };
 
 // src/umb-management-api/tools/temporary-file/post/create-temporary-file.ts
-import { z as z69 } from "zod";
+import { z as z71 } from "zod";
 import * as fs3 from "fs";
 import * as os2 from "os";
 import * as path3 from "path";
-var createTemporaryFileSchema = z69.object({
-  id: z69.string().uuid().describe("Unique identifier for the temporary file"),
-  fileName: z69.string().describe("Name of the file"),
-  fileAsBase64: z69.string().describe("File content encoded as base64 string")
+var createTemporaryFileSchema = z71.object({
+  id: z71.string().uuid().describe("Unique identifier for the temporary file"),
+  fileName: z71.string().describe("Name of the file"),
+  fileAsBase64: z71.string().describe("File content encoded as base64 string")
 });
 var CreateTemporaryFileTool = CreateUmbracoTool(
   "create-temporary-file",
@@ -24460,11 +25229,11 @@ var GetScriptTreeSiblingsTool = CreateUmbracoTool(
 var get_script_tree_siblings_default = GetScriptTreeSiblingsTool;
 
 // src/umb-management-api/tools/script/post/create-script.ts
-import z70 from "zod";
-var createScriptSchema = z70.object({
-  name: z70.string().min(1, "Name is required"),
-  path: z70.string().optional(),
-  content: z70.string().min(1, "Content is required")
+import z72 from "zod";
+var createScriptSchema = z72.object({
+  name: z72.string().min(1, "Name is required"),
+  path: z72.string().optional(),
+  content: z72.string().min(1, "Content is required")
 });
 var CreateScriptTool = CreateUmbracoTool(
   "create-script",
@@ -24513,13 +25282,13 @@ var CreateScriptFolderTool = CreateUmbracoTool(
 var create_script_folder_default = CreateScriptFolderTool;
 
 // src/umb-management-api/tools/script/put/update-script.ts
-import { z as z71 } from "zod";
+import { z as z73 } from "zod";
 var UpdateScriptTool = CreateUmbracoTool(
   "update-script",
   "Updates a script by path",
   {
     path: putScriptByPathParams.shape.path,
-    data: z71.object(putScriptByPathBody.shape)
+    data: z73.object(putScriptByPathBody.shape)
   },
   async (model) => {
     const client = UmbracoManagementClient2.getClient();
@@ -24537,11 +25306,11 @@ var UpdateScriptTool = CreateUmbracoTool(
 var update_script_default = UpdateScriptTool;
 
 // src/umb-management-api/tools/script/put/rename-script.ts
-import { z as z72 } from "zod";
-var renameScriptSchema = z72.object({
-  name: z72.string().min(1, "Current script name is required"),
-  folderPath: z72.string().optional().describe("Path to the folder containing the script (optional, leave empty for root)"),
-  newName: z72.string().min(1, "New script name is required")
+import { z as z74 } from "zod";
+var renameScriptSchema = z74.object({
+  name: z74.string().min(1, "Current script name is required"),
+  folderPath: z74.string().optional().describe("Path to the folder containing the script (optional, leave empty for root)"),
+  newName: z74.string().min(1, "New script name is required")
 });
 var RenameScriptTool = CreateUmbracoTool(
   "rename-script",
@@ -24640,11 +25409,11 @@ var ScriptCollection = {
 };
 
 // src/umb-management-api/tools/stylesheet/post/create-stylesheet.ts
-import { z as z73 } from "zod";
-var createStylesheetSchema = z73.object({
-  name: z73.string().min(1, "Name is required"),
-  path: z73.string().optional(),
-  content: z73.string().min(1, "Content is required")
+import { z as z75 } from "zod";
+var createStylesheetSchema = z75.object({
+  name: z75.string().min(1, "Name is required"),
+  path: z75.string().optional(),
+  content: z75.string().min(1, "Content is required")
 });
 var CreateStylesheetTool = CreateUmbracoTool(
   "create-stylesheet",
@@ -24733,11 +25502,11 @@ var GetStylesheetFolderByPathTool = CreateUmbracoTool(
 var get_stylesheet_folder_by_path_default = GetStylesheetFolderByPathTool;
 
 // src/umb-management-api/tools/stylesheet/put/update-stylesheet.ts
-import { z as z74 } from "zod";
+import { z as z76 } from "zod";
 var UpdateStylesheetTool = CreateUmbracoTool(
   "update-stylesheet",
   "Updates a stylesheet by path",
-  z74.object({
+  z76.object({
     ...putStylesheetByPathParams.shape,
     ...putStylesheetByPathBody.shape
   }).shape,
@@ -24758,11 +25527,11 @@ var UpdateStylesheetTool = CreateUmbracoTool(
 var update_stylesheet_default = UpdateStylesheetTool;
 
 // src/umb-management-api/tools/stylesheet/put/rename-stylesheet.ts
-import { z as z75 } from "zod";
+import { z as z77 } from "zod";
 var RenameStylesheetTool = CreateUmbracoTool(
   "rename-stylesheet",
   `Renames a stylesheet`,
-  z75.object({
+  z77.object({
     ...putStylesheetByPathRenameParams.shape,
     ...putStylesheetByPathRenameBody.shape
   }).shape,
@@ -25518,11 +26287,11 @@ var RelationTypeCollection = {
 };
 
 // src/umb-management-api/tools/relation/get/get-relation-by-relation-type-id.ts
-import { z as z76 } from "zod";
+import { z as z78 } from "zod";
 var GetRelationByRelationTypeIdTool = CreateUmbracoTool(
   "get-relation-by-relation-type-id",
   "Gets relations by relation type ID",
-  z76.object({
+  z78.object({
     ...getRelationByRelationTypeIdParams.shape,
     ...getRelationByRelationTypeIdQueryParams.shape
   }).shape,