@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/tools/schemas/items.d.ts

@@ -0,0 +1,12 @@
+export * from "./items-common.js";
+export * from "./items-metadata.js";
+export * from "./items-processes.js";
+export * from "./items-cells.js";
+export * from "./items-views.js";
+export * from "./items-subsets.js";
+export * from "./items-scheduling.js";
+export * from "./items-security.js";
+export * from "./items-monitoring.js";
+export * from "./items-fileops.js";
+export * from "./items-analysis.js";
+//# sourceMappingURL=items.d.ts.map

package/dist/tools/schemas/items.js

@@ -0,0 +1,23 @@
+// Zod schemas for the per-item types returned by the paginated list_* tools and
+// the result payloads of the other tools. Mirrors the TypeScript interfaces in
+// src/types.ts so the runtime outputSchema and the static type cannot drift.
+//
+// Schemas are intentionally permissive (`.passthrough()` where the upstream
+// REST surface is loose) — TM1 occasionally returns extra fields and we don't
+// want validation to break an otherwise useful payload.
+//
+// This module is a RE-EXPORT BARREL. The schema definitions live in the
+// per-category `items-<domain>.ts` files so no single file grows unwieldy;
+// every existing importer keeps importing from `./schemas/items.js` unchanged.
+export * from "./items-common.js";
+export * from "./items-metadata.js";
+export * from "./items-processes.js";
+export * from "./items-cells.js";
+export * from "./items-views.js";
+export * from "./items-subsets.js";
+export * from "./items-scheduling.js";
+export * from "./items-security.js";
+export * from "./items-monitoring.js";
+export * from "./items-fileops.js";
+export * from "./items-analysis.js";
+//# sourceMappingURL=items.js.map

package/dist/tools/schemas/markdown-capable.d.ts

@@ -0,0 +1,21 @@
+import { z, type ZodRawShape, type ZodTypeAny } from "zod";
+export interface StrictVariants {
+    /** Full payload shape, exactly as before the loosening. */
+    json: ZodTypeAny;
+    /** The only shape a markdown response may take. */
+    markdown: ZodTypeAny;
+}
+export declare const MARKDOWN_ONLY_SCHEMA: z.ZodObject<{
+    markdown: z.ZodString;
+}, z.core.$strict>;
+/**
+ * Widen an outputSchema so the tool may answer with either its full JSON
+ * payload or `{ markdown }`. Use for every tool that accepts FORMAT_SCHEMA.
+ */
+export declare function markdownCapable(entry: ZodRawShape | ZodTypeAny): ZodTypeAny;
+/**
+ * Strict counterparts for a schema produced by `markdownCapable`, or undefined
+ * for any other schema.
+ */
+export declare function strictVariants(entry: ZodRawShape | ZodTypeAny | object | undefined): StrictVariants | undefined;
+//# sourceMappingURL=markdown-capable.d.ts.map

package/dist/tools/schemas/markdown-capable.js

@@ -0,0 +1,58 @@
+// Output-schema wrapper for tools that offer `format: "markdown"`.
+//
+// Why this exists: clients that read `structuredContent` (Claude Code) discard
+// the `content` array entirely, so a rendered Markdown table shipped only in
+// `content` never reaches the model — `format:"markdown"` was a silent no-op
+// there. The table therefore has to travel inside `structuredContent`, as
+// `{ markdown: "<table>" }`.
+//
+// That collides with the declared outputSchema three ways, all measured
+// against @modelcontextprotocol/sdk 1.30.0:
+//   1. Omitting structuredContent is not allowed once an outputSchema exists —
+//      the SDK answers `-32602 ... has an output schema but no structured
+//      content was provided` (server/mcp.js, validateToolOutput).
+//   2. Adding `markdown` alongside a strict payload is rejected client-side
+//      with "must NOT have additional properties".
+//   3. A `z.union` / `z.discriminatedUnion` outputSchema cannot express
+//      "either shape": the SDK's zod-compat throws on the non-object schema
+//      and then publishes NO outputSchema for the tool at all.
+//
+// So the schema handed to the SDK is `Payload.partial()` plus an optional
+// `markdown`, which accepts both shapes. `.partial()` only relaxes TOP-LEVEL
+// keys — nested objects and array items stay strict, which is where drift
+// usually appears. The top-level strictness that is lost here is restored by
+// the guard in ../with-annotations.ts, which picks the matching strict variant
+// per response via `strictVariants()`.
+import { z } from "zod";
+// Keyed by the loosened schema object we hand to the SDK. A WeakMap keeps the
+// pairing out of the wire format — the SDK only ever sees plain Zod.
+const VARIANTS = new WeakMap();
+// Strict on purpose: a markdown response that also carries payload fields
+// means a handler mixed the two paths, and the client the markdown was meant
+// for would render the leaked JSON.
+export const MARKDOWN_ONLY_SCHEMA = z.strictObject({
+    markdown: z.string(),
+});
+function isZodSchema(entry) {
+    return "_def" in entry;
+}
+/**
+ * Widen an outputSchema so the tool may answer with either its full JSON
+ * payload or `{ markdown }`. Use for every tool that accepts FORMAT_SCHEMA.
+ */
+export function markdownCapable(entry) {
+    const strict = (isZodSchema(entry) ? entry : z.object(entry));
+    const loose = strict.partial().extend({ markdown: z.string().optional() });
+    VARIANTS.set(loose, { json: strict, markdown: MARKDOWN_ONLY_SCHEMA });
+    return loose;
+}
+/**
+ * Strict counterparts for a schema produced by `markdownCapable`, or undefined
+ * for any other schema.
+ */
+export function strictVariants(entry) {
+    if (entry === null || typeof entry !== "object")
+        return undefined;
+    return VARIANTS.get(entry);
+}
+//# sourceMappingURL=markdown-capable.js.map

package/dist/tools/schemas/output-schema.d.ts

@@ -0,0 +1,24 @@
+import type { ZodObject, ZodRawShape, ZodTypeAny } from "zod";
+/**
+ * Return the correct MCP outputSchema representation for a Zod object.
+ *
+ * Schemas built with `.passthrough()` / `.catchall(...)` MUST be published
+ * as full ZodTypeAny so the SDK preserves `additionalProperties: true` in
+ * the generated JSON Schema. Extracting `.shape` from such a schema silently
+ * loses the flag and makes the SDK reject legitimate per-tool extras with
+ * "data must NOT have additional properties".
+ *
+ * Plain object schemas are passed as ZodRawShape (`.shape`) per SDK convention.
+ *
+ * Detection: zod 4 stores the catchall/passthrough fallback under
+ * `def.catchall`. For plain `z.object({...})` it is undefined; for a
+ * `.passthrough()` / `.catchall(...)` schema it is a Zod type.
+ *
+ * `.def` is zod 4's public, typed accessor for the schema definition (the
+ * classic `ZodObject` types `.def` identically to the internal `._def`), so
+ * no `_def` reach-in or `as unknown as` cast is needed. The exact-pinned zod
+ * version (see package.json) plus the co-located regression test guard against
+ * a point release changing this shape. Bump zod manually and re-run tests.
+ */
+export declare function asOutputSchema<T extends ZodObject<ZodRawShape>>(schema: T): ZodTypeAny | ZodRawShape;
+//# sourceMappingURL=output-schema.d.ts.map

package/dist/tools/schemas/output-schema.js

@@ -0,0 +1,25 @@
+/**
+ * Return the correct MCP outputSchema representation for a Zod object.
+ *
+ * Schemas built with `.passthrough()` / `.catchall(...)` MUST be published
+ * as full ZodTypeAny so the SDK preserves `additionalProperties: true` in
+ * the generated JSON Schema. Extracting `.shape` from such a schema silently
+ * loses the flag and makes the SDK reject legitimate per-tool extras with
+ * "data must NOT have additional properties".
+ *
+ * Plain object schemas are passed as ZodRawShape (`.shape`) per SDK convention.
+ *
+ * Detection: zod 4 stores the catchall/passthrough fallback under
+ * `def.catchall`. For plain `z.object({...})` it is undefined; for a
+ * `.passthrough()` / `.catchall(...)` schema it is a Zod type.
+ *
+ * `.def` is zod 4's public, typed accessor for the schema definition (the
+ * classic `ZodObject` types `.def` identically to the internal `._def`), so
+ * no `_def` reach-in or `as unknown as` cast is needed. The exact-pinned zod
+ * version (see package.json) plus the co-located regression test guard against
+ * a point release changing this shape. Bump zod manually and re-run tests.
+ */
+export function asOutputSchema(schema) {
+    return schema.def.catchall != null ? schema : schema.shape;
+}
+//# sourceMappingURL=output-schema.js.map

package/dist/tools/security/assign-client-group.d.ts

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

package/dist/tools/security/assign-client-group.js

@@ -0,0 +1,20 @@
+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";
+export const registerAssignClientGroup = defineTool({
+    name: "tm1_assign_client_group",
+    description: "Assign a TM1 client to a group. Idempotent - assigning twice is a no-op.",
+    annotations: IDEMPOTENT_WRITE,
+    output: MutationResultSchema,
+    input: {
+        clientName: z.string().describe("Client (user) name"),
+        groupName: z.string().describe("Group name"),
+    },
+    handler: async ({ clientName, groupName }, tm1Client) => {
+        await tm1Client.security.assignClientGroup(clientName, groupName);
+        return actionResponse({ success: true, clientName, groupName });
+    },
+});
+//# sourceMappingURL=assign-client-group.js.map

package/dist/tools/security/create-client.d.ts

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

package/dist/tools/security/create-client.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";
+export const registerCreateClient = defineTool({
+    name: "tm1_create_client",
+    description: "Create a new TM1 client (user). Optionally set initial password, friendly name, and group memberships.",
+    annotations: WRITE,
+    output: MutationResultSchema,
+    input: {
+        clientName: z.string().describe("Client (user) name"),
+        password: z
+            .string()
+            .optional()
+            .describe("Initial password (omit if external auth)"),
+        friendlyName: z.string().optional().describe("Display name"),
+        groups: z
+            .array(z.string())
+            .optional()
+            .describe("Group names to assign on creation"),
+    },
+    handler: async ({ clientName, ...rest }, tm1Client) => {
+        await tm1Client.security.createClient({ name: clientName, ...rest });
+        return actionResponse({ success: true, name: clientName });
+    },
+});
+//# sourceMappingURL=create-client.js.map

package/dist/tools/security/delete-client.d.ts

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

package/dist/tools/security/delete-client.js

@@ -0,0 +1,22 @@
+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";
+export const registerDeleteClient = defineTool({
+    name: "tm1_delete_client",
+    description: "Delete a TM1 client (user). Irreversible - the client must not have active sessions. Pass confirm=<client name verbatim>.",
+    annotations: DESTRUCTIVE,
+    output: MutationResultSchema,
+    input: {
+        clientName: z.string().describe("Client (user) name"),
+        ...CONFIRM_SCHEMA,
+    },
+    handler: async ({ clientName, confirm }, tm1Client) => {
+        requireConfirm(confirm, clientName, "client");
+        await tm1Client.security.deleteClient(clientName);
+        return actionResponse({ success: true, clientName });
+    },
+});
+//# sourceMappingURL=delete-client.js.map

package/dist/tools/security/get-client.d.ts

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

package/dist/tools/security/get-client.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { FORMAT_SCHEMA, payloadResponse, renderKV } from "../format.js";
+import { ClientItemSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+export const registerGetClient = defineTool({
+    name: "tm1_get_client",
+    description: "Get details for a single TM1 client (user) including group memberships.",
+    annotations: READ_ONLY,
+    output: ClientItemSchema,
+    input: {
+        clientName: z.string().describe("Client (user) name"),
+        ...FORMAT_SCHEMA,
+    },
+    handler: async ({ clientName, format }, tm1Client) => {
+        const client = await tm1Client.security.getClient(clientName);
+        return payloadResponse(client, format, (c) => renderKV(c, `Client ${clientName}`));
+    },
+});
+//# sourceMappingURL=get-client.js.map

package/dist/tools/security/list-clients.d.ts

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

package/dist/tools/security/list-clients.js

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import { PAGINATION_SCHEMA, paginate } from "../pagination.js";
+import { FORMAT_SCHEMA, pageResponse, columnsOf } from "../format.js";
+import { ClientItemSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { pageShapeFor } from "../schemas/common.js";
+const FIELD_KEYS = [
+    "name",
+    "friendlyName",
+    "type",
+    "enabled",
+    "groups",
+    "groupCount",
+];
+function project(clients, fields, groupCount) {
+    // No projection requested -> keep current shape, optionally swap Groups for groupCount.
+    if (!fields || fields.length === 0) {
+        if (!groupCount)
+            return clients;
+        return clients.map((c) => {
+            const { Groups, ...rest } = c;
+            return { ...rest, groupCount: Groups?.length ?? 0 };
+        });
+    }
+    const want = new Set(fields);
+    // groupCount=true wins over fields=['groups'] — explicit flag drops the array.
+    if (groupCount) {
+        want.add("groupCount");
+        want.delete("groups");
+    }
+    return clients.map((c) => {
+        const out = {};
+        if (want.has("name"))
+            out.Name = c.Name;
+        if (want.has("friendlyName") && c.FriendlyName !== undefined)
+            out.FriendlyName = c.FriendlyName;
+        if (want.has("type") && c.Type !== undefined)
+            out.Type = c.Type;
+        if (want.has("enabled") && c.Enabled !== undefined)
+            out.Enabled = c.Enabled;
+        if (want.has("groups") && c.Groups !== undefined)
+            out.Groups = c.Groups;
+        if (want.has("groupCount"))
+            out.groupCount = c.Groups?.length ?? 0;
+        return out;
+    });
+}
+export const registerListClients = defineTool({
+    name: "tm1_list_clients",
+    description: "List TM1 clients (users). Defaults return name, friendly name, enabled state, and full Groups[]. Use fields=['name','type'] for a lean projection or groupCount=true to replace the Groups[] array with an integer count (large savings when groups>>10).",
+    annotations: READ_ONLY,
+    output: pageShapeFor(ClientItemSchema),
+    input: {
+        ...PAGINATION_SCHEMA,
+        ...FORMAT_SCHEMA,
+        fields: z
+            .array(z.enum(FIELD_KEYS))
+            .optional()
+            .describe("Projection: subset of ['name','friendlyName','type','enabled','groups','groupCount']. Omit for full default payload."),
+        groupCount: z
+            .boolean()
+            .optional()
+            .describe("If true, replace the per-client Groups[] array with an integer groupCount. Combine with fields=['name','groupCount'] for the smallest payload."),
+    },
+    handler: async ({ limit, offset, fetchAll, format, fields, groupCount }, tm1Client) => {
+        const clients = await tm1Client.security.listClients();
+        const page = paginate(clients, limit, offset, fetchAll);
+        const projectedItems = project(page.items, fields, groupCount === true);
+        const projectedPage = { ...page, items: projectedItems };
+        const columns = columnsOf([
+            "Name",
+            "FriendlyName",
+            "Type",
+            "Enabled",
+            {
+                header: "Groups",
+                get: (c) => c.groupCount !== undefined
+                    ? `${c.groupCount} (count)`
+                    : (c.Groups ?? []).join(", "),
+            },
+        ]);
+        return pageResponse(projectedPage, format, { title: "Clients", columns });
+    },
+});
+//# sourceMappingURL=list-clients.js.map

package/dist/tools/security/list-groups.d.ts

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

package/dist/tools/security/list-groups.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { PAGINATION_SCHEMA, paginate } from "../pagination.js";
+import { FORMAT_SCHEMA, pageResponse, columnsOf } from "../format.js";
+import { GroupItemSchema } from "../schemas/items.js";
+import { READ_ONLY } from "../annotations.js";
+import { defineTool } from "../define-tool.js";
+import { pageShapeFor } from "../schemas/common.js";
+export const registerListGroups = defineTool({
+    name: "tm1_list_groups",
+    description: "List TM1 groups. Defaults return Name + Clients[] (member usernames). Use compact=true to replace Clients[] with an integer clientCount — large savings when groups have many members.",
+    annotations: READ_ONLY,
+    output: pageShapeFor(GroupItemSchema),
+    input: {
+        ...PAGINATION_SCHEMA,
+        ...FORMAT_SCHEMA,
+        compact: z
+            .boolean()
+            .optional()
+            .describe("If true, replace Clients[] with clientCount: number on each group. Use for audits where membership names aren't needed."),
+    },
+    handler: async ({ limit, offset, fetchAll, format, compact }, tm1Client) => {
+        const groups = await tm1Client.security.listGroups();
+        const page = paginate(groups, limit, offset, fetchAll);
+        const items = compact
+            ? page.items.map(({ Clients, ...rest }) => ({
+                ...rest,
+                clientCount: Clients?.length ?? 0,
+            }))
+            : page.items;
+        const projectedPage = { ...page, items };
+        const columns = columnsOf([
+            "Name",
+            {
+                header: "Clients",
+                get: (g) => "clientCount" in g
+                    ? `${g.clientCount} (count)`
+                    : (g.Clients ?? []).join(", "),
+            },
+        ]);
+        return pageResponse(projectedPage, format, { title: "Groups", columns });
+    },
+});
+//# sourceMappingURL=list-groups.js.map

package/dist/tools/security/remove-client-group.d.ts

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

package/dist/tools/security/remove-client-group.js

@@ -0,0 +1,27 @@
+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";
+export const registerRemoveClientGroup = defineTool({
+    name: "tm1_remove_client_group",
+    description: [
+        "Remove a TM1 client from a group.",
+        "Inverse of tm1_assign_client_group. Before: tm1_get_client to inspect current group memberships.",
+        "Safety: pass confirm=<client name verbatim>.",
+    ],
+    annotations: DESTRUCTIVE,
+    output: MutationResultSchema,
+    input: {
+        clientName: z.string().describe("Client (user) name"),
+        groupName: z.string().describe("Group name"),
+        ...CONFIRM_SCHEMA,
+    },
+    handler: async ({ clientName, groupName, confirm }, tm1Client) => {
+        requireConfirm(confirm, clientName, "client");
+        await tm1Client.security.removeClientGroup(clientName, groupName);
+        return actionResponse({ success: true, clientName, groupName });
+    },
+});
+//# sourceMappingURL=remove-client-group.js.map

package/dist/tools/security/update-client.d.ts

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

package/dist/tools/security/update-client.js

@@ -0,0 +1,22 @@
+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";
+export const registerUpdateClient = defineTool({
+    name: "tm1_update_client",
+    description: "Update a TM1 client. Allowed fields: password, friendlyName, enabled (true=active, false=disabled).",
+    annotations: IDEMPOTENT_WRITE,
+    output: MutationResultSchema,
+    input: {
+        clientName: z.string().describe("Client (user) name"),
+        password: z.string().optional().describe("New password"),
+        friendlyName: z.string().optional().describe("New display name"),
+        enabled: z.boolean().optional().describe("Enable/disable the client"),
+    },
+    handler: async ({ clientName, ...payload }, tm1Client) => {
+        await tm1Client.security.updateClient(clientName, payload);
+        return actionResponse({ success: true, clientName });
+    },
+});
+//# sourceMappingURL=update-client.js.map

package/dist/tools/subsets/create-subset.d.ts

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

package/dist/tools/subsets/create-subset.js

@@ -0,0 +1,44 @@
+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 registerCreateSubset = defineTool({
+    name: "tm1_create_subset",
+    description: "Create a public TM1 subset. Provide either expression (MDX-based, dynamic) OR elements (static list) — not both. Optional alias attribute name controls the displayed alias.",
+    annotations: WRITE,
+    output: MutationResultSchema,
+    input: {
+        dimensionName: z.string().describe("Dimension name"),
+        ...HIERARCHY_NAME_OPTIONAL,
+        subsetName: z.string().describe("New subset name"),
+        expression: z
+            .string()
+            .optional()
+            .describe("MDX expression (e.g. '{TM1FILTERBYLEVEL({TM1SUBSETALL([Dim])}, 0)}'). Mutually exclusive with elements."),
+        elements: z
+            .array(z.string())
+            .optional()
+            .describe("Static element name list. Mutually exclusive with expression."),
+        alias: z
+            .string()
+            .optional()
+            .describe("Alias attribute used as display name in the subset"),
+    },
+    handler: async ({ dimensionName, hierarchyName, subsetName, expression, elements, alias }, tm1Client) => {
+        const hierarchy = resolveHierarchy(dimensionName, hierarchyName);
+        await tm1Client.subsets.create(dimensionName, hierarchy, {
+            name: subsetName,
+            expression,
+            elements,
+            alias,
+        });
+        return actionResponse({
+            success: true,
+            subsetName,
+            kind: expression ? "mdx" : "static",
+        });
+    },
+});
+//# sourceMappingURL=create-subset.js.map

package/dist/tools/subsets/delete-subset.d.ts

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

package/dist/tools/subsets/delete-subset.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 registerDeleteSubset = defineTool({
+    name: "tm1_delete_subset",
+    description: "Delete a public TM1 subset. Fails if the subset is referenced by views/processes (404 if not found). Irreversible — pass confirm=<subset name verbatim>.",
+    annotations: DESTRUCTIVE,
+    output: MutationResultSchema,
+    input: {
+        dimensionName: z.string().describe("Dimension name"),
+        ...HIERARCHY_NAME_OPTIONAL,
+        subsetName: z.string().describe("Subset to delete"),
+        ...CONFIRM_SCHEMA,
+    },
+    handler: async ({ dimensionName, hierarchyName, subsetName, confirm }, tm1Client) => {
+        const hierarchy = resolveHierarchy(dimensionName, hierarchyName);
+        requireConfirm(confirm, subsetName, "subset");
+        await tm1Client.subsets.delete(dimensionName, hierarchy, subsetName);
+        return actionResponse({ success: true, subsetName });
+    },
+});
+//# sourceMappingURL=delete-subset.js.map

package/dist/tools/subsets/get-subset.d.ts

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

package/dist/tools/subsets/get-subset.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { READ_ONLY } from "../annotations.js";
+import { SubsetSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { HIERARCHY_NAME_OPTIONAL, resolveHierarchy } from "../hierarchy.js";
+export const registerGetSubset = defineTool({
+    name: "tm1_get_subset",
+    description: "Get a single TM1 subset with its MDX expression (if any) and resolved element list. Use isPrivate=true for private subsets.",
+    annotations: READ_ONLY,
+    output: SubsetSchema,
+    input: {
+        dimensionName: z.string().describe("Dimension name"),
+        ...HIERARCHY_NAME_OPTIONAL,
+        subsetName: z.string().describe("Subset name"),
+        isPrivate: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Look up the subset in PrivateSubsets instead of public Subsets"),
+    },
+    handler: async ({ dimensionName, hierarchyName, subsetName, isPrivate }, tm1Client) => {
+        const hierarchy = resolveHierarchy(dimensionName, hierarchyName);
+        const subset = await tm1Client.subsets.get(dimensionName, hierarchy, subsetName, isPrivate ?? false);
+        return {
+            content: [{ type: "text", text: JSON.stringify(subset) }],
+        };
+    },
+});
+//# sourceMappingURL=get-subset.js.map

package/dist/tools/subsets/list-subsets.d.ts

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

package/dist/tools/subsets/list-subsets.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { PAGINATION_SCHEMA, paginate } from "../pagination.js";
+import { FORMAT_SCHEMA, pageResponse, columnsOf } from "../format.js";
+import { READ_ONLY } from "../annotations.js";
+import { SubsetSchema } from "../schemas/items.js";
+import { defineTool } from "../define-tool.js";
+import { HIERARCHY_NAME_OPTIONAL, resolveHierarchy } from "../hierarchy.js";
+import { pageShapeFor } from "../schemas/common.js";
+export const registerListSubsets = defineTool({
+    name: "tm1_list_subsets",
+    description: "List public + private subsets of a TM1 hierarchy. Returns names, scope (public/private), MDX expression preview, and alias. Paginated (default 50/page).",
+    annotations: READ_ONLY,
+    output: pageShapeFor(SubsetSchema),
+    input: {
+        dimensionName: z.string().describe("Dimension name"),
+        ...HIERARCHY_NAME_OPTIONAL,
+        ...PAGINATION_SCHEMA,
+        ...FORMAT_SCHEMA,
+    },
+    handler: async ({ dimensionName, hierarchyName, limit, offset, fetchAll, format }, tm1Client) => {
+        const hierarchy = resolveHierarchy(dimensionName, hierarchyName);
+        const subsets = await tm1Client.subsets.list(dimensionName, hierarchy);
+        const page = paginate(subsets, limit, offset, fetchAll);
+        const columns = columnsOf([
+            "name",
+            { header: "scope", get: (s) => (s.private ? "private" : "public") },
+            "alias",
+            "expression",
+        ]);
+        return pageResponse(page, format, {
+            title: `Subsets of ${dimensionName}/${hierarchy}`,
+            columns,
+        });
+    },
+});
+//# sourceMappingURL=list-subsets.js.map

package/dist/tools/subsets/update-subset.d.ts

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