@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/tools/dimension-management/create-element-attribute.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { WRITE } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { HIERARCHY_NAME_OPTIONAL, resolveHierarchy } from "../hierarchy.js";
+export const registerCreateElementAttribute = defineTool({
+    name: "tm1_create_element_attribute",
+    description: "Create an element attribute definition (schema) on a TM1 hierarchy. For reproducible deployments prefer a TI process (DimensionElementInsert on the }ElementAttributes_{dim} control cube). Use this tool for ad-hoc / debugging scenarios or when explicitly requested.",
+    annotations: WRITE,
+    output: MutationResultSchema,
+    input: {
+        dimensionName: z.string().describe("Name of the TM1 dimension"),
+        ...HIERARCHY_NAME_OPTIONAL,
+        attributeName: z.string().describe("Name of the new attribute"),
+        attributeType: z
+            .enum(["Numeric", "String", "Alias"])
+            .describe("Attribute type: Numeric (ATTRN), String (ATTRS), or Alias"),
+    },
+    handler: async ({ dimensionName, hierarchyName, attributeName, attributeType }, tm1Client) => {
+        const hierarchy = resolveHierarchy(dimensionName, hierarchyName);
+        await tm1Client.elements.createAttribute(dimensionName, hierarchy, attributeName, attributeType);
+        return actionResponse({ success: true, attributeName, attributeType });
+    },
+});
+//# sourceMappingURL=create-element-attribute.js.map

package/dist/tools/dimension-management/create-element.d.ts

@@ -0,0 +1,2 @@
+export declare const registerCreateElement: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=create-element.d.ts.map

package/dist/tools/dimension-management/create-element.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { WRITE } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { HIERARCHY_NAME_OPTIONAL, resolveHierarchy } from "../hierarchy.js";
+const elementSchema = z.object({
+    name: z.string().describe("Element name"),
+    type: z.enum(["Numeric", "String", "Consolidated"]).describe("Element type"),
+    components: z
+        .array(z.object({ name: z.string(), weight: z.number() }))
+        .optional()
+        .describe("Child components for consolidated elements"),
+});
+export const registerCreateElement = defineTool({
+    name: "tm1_create_element",
+    description: "Create a new element in a TM1 dimension hierarchy",
+    annotations: WRITE,
+    output: MutationResultSchema,
+    input: {
+        dimensionName: z.string().describe("Name of the dimension"),
+        ...HIERARCHY_NAME_OPTIONAL,
+        element: elementSchema.describe("Element definition with name, type and optional components"),
+    },
+    handler: async ({ dimensionName, hierarchyName, element }, tm1Client) => {
+        const hierarchy = resolveHierarchy(dimensionName, hierarchyName);
+        await tm1Client.elements.create(dimensionName, hierarchy, element);
+        return actionResponse({ success: true, elementName: element.name });
+    },
+});
+//# sourceMappingURL=create-element.js.map

package/dist/tools/dimension-management/create-hierarchy.d.ts

@@ -0,0 +1,2 @@
+export declare const registerCreateHierarchy: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=create-hierarchy.d.ts.map

package/dist/tools/dimension-management/create-hierarchy.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { WRITE } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+export const registerCreateHierarchy = defineTool({
+    name: "tm1_create_hierarchy",
+    description: "Create a new (alternate) hierarchy inside an existing dimension. The dimension's default hierarchy already has the same name as the dimension — use this for additional rollup structures.",
+    annotations: WRITE,
+    output: MutationResultSchema,
+    input: {
+        dimensionName: z.string().describe("Existing dimension name"),
+        hierarchyName: z
+            .string()
+            .describe("New hierarchy name (must differ from existing hierarchies)"),
+    },
+    handler: async ({ dimensionName, hierarchyName }, tm1Client) => {
+        await tm1Client.hierarchies.create(dimensionName, hierarchyName);
+        return actionResponse({ success: true, dimensionName, hierarchyName });
+    },
+});
+//# sourceMappingURL=create-hierarchy.js.map

package/dist/tools/dimension-management/delete-dimension.d.ts

@@ -0,0 +1,2 @@
+export declare const registerDeleteDimension: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=delete-dimension.d.ts.map

package/dist/tools/dimension-management/delete-dimension.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
+import { DESTRUCTIVE } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+export const registerDeleteDimension = defineTool({
+    name: "tm1_delete_dimension",
+    description: [
+        "Delete a TM1 dimension and all its hierarchies. Warning: fails if the dimension is used in a cube.",
+        "Before: tm1_find_orphan_dimensions to confirm the dimension is unused, or tm1_analyze_object_usage for a targeted check.",
+    ],
+    annotations: DESTRUCTIVE,
+    output: MutationResultSchema,
+    input: {
+        dimensionName: z.string().describe("Dimension name (case-sensitive)"),
+        ...CONFIRM_SCHEMA,
+    },
+    handler: async ({ dimensionName, confirm }, tm1Client) => {
+        requireConfirm(confirm, dimensionName, "dimension");
+        await tm1Client.dimensions.delete(dimensionName);
+        return actionResponse({ success: true, dimensionName });
+    },
+});
+//# sourceMappingURL=delete-dimension.js.map

package/dist/tools/dimension-management/delete-element.d.ts

@@ -0,0 +1,2 @@
+export declare const registerDeleteElement: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=delete-element.d.ts.map

package/dist/tools/dimension-management/delete-element.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
+import { actionResponse } from "../format.js";
+import { DESTRUCTIVE } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { HIERARCHY_NAME_OPTIONAL, resolveHierarchy } from "../hierarchy.js";
+export const registerDeleteElement = defineTool({
+    name: "tm1_delete_element",
+    description: "Delete an element from a TM1 dimension hierarchy. Irreversible — pass confirm=<element name verbatim>.",
+    annotations: DESTRUCTIVE,
+    output: MutationResultSchema,
+    input: {
+        dimensionName: z.string().describe("Name of the dimension"),
+        ...HIERARCHY_NAME_OPTIONAL,
+        elementName: z.string().describe("Name of the element to delete"),
+        ...CONFIRM_SCHEMA,
+    },
+    handler: async ({ dimensionName, hierarchyName, elementName, confirm }, tm1Client) => {
+        const hierarchy = resolveHierarchy(dimensionName, hierarchyName);
+        requireConfirm(confirm, elementName, "element");
+        await tm1Client.elements.delete(dimensionName, hierarchy, elementName);
+        return actionResponse({ success: true, elementName });
+    },
+});
+//# sourceMappingURL=delete-element.js.map

package/dist/tools/dimension-management/delete-elements.d.ts

@@ -0,0 +1,2 @@
+export declare const registerDeleteElements: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=delete-elements.d.ts.map

package/dist/tools/dimension-management/delete-elements.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
+import { actionResponse } from "../format.js";
+import { DESTRUCTIVE } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { HIERARCHY_NAME_OPTIONAL, resolveHierarchy } from "../hierarchy.js";
+export const registerDeleteElements = defineTool({
+    name: "tm1_delete_elements",
+    description: [
+        "Delete many elements from one TM1 dimension hierarchy in a single call ($batch where the server supports it).",
+        "Not all-or-nothing: each element reports deleted or its error, and success is true only when every one was deleted. Irreversible — pass confirm=<dimension name verbatim>.",
+        "For one element tm1_delete_element works too.",
+    ],
+    annotations: DESTRUCTIVE,
+    output: MutationResultSchema,
+    input: {
+        dimensionName: z.string().describe("Name of the dimension"),
+        ...HIERARCHY_NAME_OPTIONAL,
+        elementNames: z
+            .array(z.string())
+            .min(1)
+            .max(5000)
+            .describe("Elements to delete"),
+        ...CONFIRM_SCHEMA,
+    },
+    handler: async ({ dimensionName, hierarchyName, elementNames, confirm }, tm1Client) => {
+        requireConfirm(confirm, dimensionName, "dimension");
+        const hierarchy = resolveHierarchy(dimensionName, hierarchyName);
+        const results = await tm1Client.elements.deleteMany(dimensionName, hierarchy, elementNames);
+        const failures = results.filter((r) => !r.deleted);
+        return actionResponse({
+            success: failures.length === 0,
+            dimensionName,
+            hierarchyName: hierarchy,
+            deleted: results.length - failures.length,
+            failed: failures.length,
+            // Only the failures carry detail; listing every deleted name back would
+            // just echo the request.
+            failures,
+        });
+    },
+});
+//# sourceMappingURL=delete-elements.js.map

package/dist/tools/dimension-management/delete-hierarchy.d.ts

@@ -0,0 +1,2 @@
+export declare const registerDeleteHierarchy: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=delete-hierarchy.d.ts.map

package/dist/tools/dimension-management/delete-hierarchy.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { CONFIRM_SCHEMA, requireConfirm } from "../confirm.js";
+import { actionResponse } from "../format.js";
+import { DESTRUCTIVE } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+// TM1 names ignore case and spaces.
+const norm = (s) => s.toLowerCase().replace(/ /g, "");
+export const registerDeleteHierarchy = defineTool({
+    name: "tm1_delete_hierarchy",
+    description: "Delete a hierarchy from a dimension. The default (dimension-named) hierarchy cannot be deleted — use tm1_delete_dimension for that. Irreversible — pass confirm=<hierarchy name verbatim>.",
+    annotations: DESTRUCTIVE,
+    output: MutationResultSchema,
+    input: {
+        dimensionName: z.string().describe("Dimension name"),
+        hierarchyName: z.string().describe("Hierarchy name to delete"),
+        ...CONFIRM_SCHEMA,
+    },
+    handler: async ({ dimensionName, hierarchyName, confirm }, tm1Client) => {
+        requireConfirm(confirm, hierarchyName, "hierarchy");
+        // TM1 does NOT refuse this itself: 11.8 answers 204 and leaves a dimension
+        // listed with no hierarchies at all (verified live). Refuse it here.
+        if (norm(hierarchyName) === norm(dimensionName)) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: `'${hierarchyName}' is the default hierarchy of '${dimensionName}' and cannot be deleted on its own.`,
+                hint: "Delete the whole dimension with tm1_delete_dimension, or name an alternate hierarchy.",
+            });
+        }
+        await tm1Client.hierarchies.delete(dimensionName, hierarchyName);
+        return actionResponse({ success: true, dimensionName, hierarchyName });
+    },
+});
+//# sourceMappingURL=delete-hierarchy.js.map

package/dist/tools/dimension-management/get-element-attribute-values.d.ts

@@ -0,0 +1,2 @@
+export declare const registerGetElementAttributeValues: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=get-element-attribute-values.d.ts.map

package/dist/tools/dimension-management/get-element-attribute-values.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { FORMAT_SCHEMA, payloadResponse, renderTable, columnsOf, } from "../format.js";
+import { ElementAttributeValueSchema } from "../schemas/items.js";
+import { CellValueSchema } from "../../schemas/common.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { PAGINATION_SCHEMA, UNBOUNDED_MAX_ITEMS, pageFromServer, } from "../pagination.js";
+import { pageShapeFor } from "../schemas/common.js";
+const ElementValuesRowSchema = z.object({
+    elementName: z.string(),
+    values: z.record(z.string(), CellValueSchema),
+});
+// Two shapes behind one tool: a single element's attribute rows, or a page of
+// elements with an attribute → value map each. Every field of both is
+// optional here so either payload validates.
+const pageShape = pageShapeFor(ElementValuesRowSchema);
+export const registerGetElementAttributeValues = defineTool({
+    name: "tm1_get_element_attribute_values",
+    description: [
+        "Read attribute values (Numeric/String/Alias) via MDX on the }ElementAttributes_{Dim} control cube. Use this to verify alias values, attribute lookups, or to debug rules referencing ATTRN/ATTRS.",
+        "With elementName: that element's attributes. Without: every element of the dimension, name-sorted and paged (items[{elementName, values}]); narrow the columns with attributeNames.",
+    ],
+    annotations: READ_ONLY,
+    output: {
+        dimensionName: z.string(),
+        elementName: z.string().optional(),
+        attributes: z.array(ElementAttributeValueSchema).optional(),
+        total: pageShape.total.optional(),
+        count: pageShape.count.optional(),
+        offset: pageShape.offset.optional(),
+        has_more: pageShape.has_more.optional(),
+        next_offset: pageShape.next_offset.optional(),
+        items: pageShape.items.optional(),
+    },
+    input: {
+        dimensionName: z.string().describe("Dimension name"),
+        elementName: z
+            .string()
+            .optional()
+            .describe("Element whose attribute values should be read. Omit to page through all elements."),
+        attributeNames: z
+            .array(z.string())
+            .optional()
+            .describe("Only these attributes (all-elements mode). Default: all."),
+        ...PAGINATION_SCHEMA,
+        ...FORMAT_SCHEMA,
+    },
+    handler: async ({ dimensionName, elementName, attributeNames, limit, offset, fetchAll, format, }, tm1Client) => {
+        if (elementName === undefined) {
+            const unbounded = fetchAll || limit === 0;
+            const start = unbounded ? 0 : offset;
+            const { total, items } = await tm1Client.elements.getAttributeValuesPage(dimensionName, {
+                offset: start,
+                limit: unbounded ? UNBOUNDED_MAX_ITEMS : limit,
+                ...(attributeNames !== undefined ? { attributeNames } : {}),
+            });
+            const payload = {
+                dimensionName,
+                ...pageFromServer(items, total, start),
+            };
+            const attrs = Object.keys(items[0]?.values ?? {});
+            const columns = columnsOf([
+                "elementName",
+                ...attrs.map((a) => ({ header: a, get: (r) => r.values[a] })),
+            ]);
+            return payloadResponse(payload, format, (p) => `## Attributes of ${p.dimensionName} (${p.offset + 1}–${p.offset + p.count} of ${p.total})\n\n${renderTable(p.items, columns)}`);
+        }
+        const values = await tm1Client.elements.getAttributeValues(dimensionName, elementName);
+        const payload = { dimensionName, elementName, attributes: values };
+        const columns = columnsOf([
+            { header: "attribute", get: (a) => a.attributeName },
+            "value",
+        ]);
+        return payloadResponse(payload, format, (p) => `## Attributes of ${p.dimensionName}/${p.elementName}\n\n${renderTable(p.attributes, columns)}`);
+    },
+});
+//# sourceMappingURL=get-element-attribute-values.js.map

package/dist/tools/dimension-management/list-element-attributes.d.ts

@@ -0,0 +1,2 @@
+export declare const registerListElementAttributes: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=list-element-attributes.d.ts.map

package/dist/tools/dimension-management/list-element-attributes.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { PAGINATION_SCHEMA, paginate } from "../pagination.js";
+import { FORMAT_SCHEMA, pageResponse, columnsOf } from "../format.js";
+import { ElementAttributeDefinitionSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { HIERARCHY_NAME_OPTIONAL, resolveHierarchy } from "../hierarchy.js";
+import { pageShapeFor } from "../schemas/common.js";
+export const registerListElementAttributes = defineTool({
+    name: "tm1_list_element_attributes",
+    description: "List element attribute definitions of a TM1 hierarchy with their types (Numeric/String/Alias). Useful to verify attribute schema before writing values or referencing them in rules (ATTRN/ATTRS).",
+    annotations: READ_ONLY,
+    output: pageShapeFor(ElementAttributeDefinitionSchema),
+    input: {
+        dimensionName: z.string().describe("Name of the TM1 dimension"),
+        ...HIERARCHY_NAME_OPTIONAL,
+        ...PAGINATION_SCHEMA,
+        ...FORMAT_SCHEMA,
+    },
+    handler: async ({ dimensionName, hierarchyName, limit, offset, fetchAll, format }, tm1Client) => {
+        const hierarchy = resolveHierarchy(dimensionName, hierarchyName);
+        const attributes = await tm1Client.elements.listAttributes(dimensionName, hierarchy);
+        const page = paginate(attributes, limit, offset, fetchAll);
+        const columns = columnsOf(["name", "type"]);
+        return pageResponse(page, format, {
+            title: `Element attributes of ${dimensionName}/${hierarchy}`,
+            columns,
+        });
+    },
+});
+//# sourceMappingURL=list-element-attributes.js.map

package/dist/tools/dimension-management/move-element.d.ts

@@ -0,0 +1,2 @@
+export declare const registerMoveElement: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=move-element.d.ts.map

package/dist/tools/dimension-management/move-element.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { WRITE } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { HIERARCHY_NAME_OPTIONAL, resolveHierarchy } from "../hierarchy.js";
+export const registerMoveElement = defineTool({
+    name: "tm1_move_element",
+    description: "Move an element to a new parent within a TM1 dimension hierarchy",
+    annotations: WRITE,
+    output: MutationResultSchema,
+    input: {
+        dimensionName: z.string().describe("Name of the dimension"),
+        ...HIERARCHY_NAME_OPTIONAL,
+        elementName: z.string().describe("Name of the element to move"),
+        newParent: z.string().describe("Name of the new parent element"),
+        weight: z
+            .number()
+            .optional()
+            .describe("Weight for the parent-child relationship (default: 1)"),
+    },
+    handler: async ({ dimensionName, hierarchyName, elementName, newParent, weight }, tm1Client) => {
+        const hierarchy = resolveHierarchy(dimensionName, hierarchyName);
+        await tm1Client.elements.move(dimensionName, hierarchy, elementName, newParent, weight);
+        return actionResponse({ success: true, elementName, newParent });
+    },
+});
+//# sourceMappingURL=move-element.js.map

package/dist/tools/dimension-management/update-element-attribute-value.d.ts

@@ -0,0 +1,2 @@
+export declare const registerUpdateElementAttributeValue: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=update-element-attribute-value.d.ts.map

package/dist/tools/dimension-management/update-element-attribute-value.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { IDEMPOTENT_WRITE } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+// Advertised as a string; a bare number is still accepted and read as text.
+// The server coerces to the attribute's type, so callers never have to pick
+// between string and number — picking wrong was a recurring malformed call.
+const valueSchema = z.preprocess((v) => (typeof v === "number" ? String(v) : v), z.string());
+export const registerUpdateElementAttributeValue = defineTool({
+    name: "tm1_update_element_attribute_value",
+    description: [
+        "Set attribute values on elements by writing to the }ElementAttributes_{Dim} control cube.",
+        "One value (elementName + attributeName + value) or many in a single write (updates[]). Values are strings, coerced server-side for Numeric attributes.",
+        "For reproducible deployments prefer a TI process (AttrPutS / AttrPutN); this REST-direct tool is for ad-hoc / debugging scenarios.",
+    ],
+    annotations: IDEMPOTENT_WRITE,
+    output: MutationResultSchema,
+    input: {
+        dimensionName: z.string().describe("Dimension name"),
+        elementName: z
+            .string()
+            .optional()
+            .describe("Element whose attribute value should be set"),
+        attributeName: z
+            .string()
+            .optional()
+            .describe("Attribute name (must already exist as schema)"),
+        value: valueSchema
+            .optional()
+            .describe("New value as text, e.g. '12.5' for a Numeric attribute. Numeric attributes reject non-numbers."),
+        updates: z
+            .array(z.object({
+            elementName: z.string(),
+            attributeName: z.string(),
+            value: valueSchema,
+        }))
+            .min(1)
+            .max(5000)
+            .optional()
+            .describe("Batch form: many {elementName, attributeName, value} in one cellset write. Replaces elementName/attributeName/value."),
+    },
+    handler: async ({ dimensionName, elementName, attributeName, value, updates }, tm1Client) => {
+        const single = elementName !== undefined ||
+            attributeName !== undefined ||
+            value !== undefined;
+        if (updates !== undefined && single) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "Pass either updates[] or elementName/attributeName/value, not both.",
+            });
+        }
+        if (updates !== undefined) {
+            await tm1Client.elements.updateAttributeValues(dimensionName, updates);
+            return actionResponse({
+                success: true,
+                dimensionName,
+                updated: updates.length,
+            });
+        }
+        if (elementName === undefined ||
+            attributeName === undefined ||
+            value === undefined) {
+            throw new TM1Error({
+                code: TM1ErrorCode.VALIDATION_ERROR,
+                message: "elementName, attributeName and value are all required (or pass updates[]).",
+            });
+        }
+        await tm1Client.elements.updateAttributeValue(dimensionName, elementName, attributeName, value);
+        return actionResponse({
+            success: true,
+            dimensionName,
+            elementName,
+            attributeName,
+            value,
+        });
+    },
+});
+//# sourceMappingURL=update-element-attribute-value.js.map

package/dist/tools/dimension-management/update-element.d.ts

@@ -0,0 +1,2 @@
+export declare const registerUpdateElement: import("../define-tool.js").ToolRegistrar;
+//# sourceMappingURL=update-element.d.ts.map

package/dist/tools/dimension-management/update-element.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { actionResponse } from "../format.js";
+import { IDEMPOTENT_WRITE } from "../annotations.js";
+import { MutationResultSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { HIERARCHY_NAME_OPTIONAL, resolveHierarchy } from "../hierarchy.js";
+const updateSchema = z.object({
+    newName: z.string().optional().describe("New name for the element"),
+    type: z
+        .enum(["Numeric", "String", "Consolidated"])
+        .optional()
+        .describe("New element type"),
+    components: z
+        .array(z.object({ name: z.string(), weight: z.number() }))
+        .optional()
+        .describe("New child components for consolidated elements"),
+});
+export const registerUpdateElement = defineTool({
+    name: "tm1_update_element",
+    description: "Update an existing element in a TM1 dimension hierarchy (name, type, or components)",
+    annotations: IDEMPOTENT_WRITE,
+    output: MutationResultSchema,
+    input: {
+        dimensionName: z.string().describe("Name of the dimension"),
+        ...HIERARCHY_NAME_OPTIONAL,
+        elementName: z.string().describe("Current name of the element to update"),
+        update: updateSchema.describe("Fields to update on the element"),
+    },
+    handler: async ({ dimensionName, hierarchyName, elementName, update }, tm1Client) => {
+        const hierarchy = resolveHierarchy(dimensionName, hierarchyName);
+        await tm1Client.elements.update(dimensionName, hierarchy, elementName, update);
+        return actionResponse({ success: true, elementName });
+    },
+});
+//# sourceMappingURL=update-element.js.map

package/dist/tools/error-format.d.ts

@@ -0,0 +1,22 @@
+import { TM1ErrorCode } from "../types.js";
+interface UniformErrorPayload {
+    code: TM1ErrorCode | string;
+    message: string;
+    httpStatus?: number | undefined;
+    endpoint?: string | undefined;
+    details?: string | undefined;
+    hint: string;
+}
+interface McpToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+    structuredContent?: unknown;
+}
+export declare function formatTm1ErrorResult(err: unknown): McpToolResult;
+export declare function normalizeErrorResult(result: McpToolResult): McpToolResult;
+export declare function withToolHint<T>(p: Promise<T>, hint: string): Promise<T>;
+export type { UniformErrorPayload, McpToolResult };
+//# sourceMappingURL=error-format.d.ts.map