@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/resources/index.d.ts

@@ -0,0 +1,5 @@
+import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { TM1Client } from "../tm1-client.js";
+import type { ResourceCatalog } from "./list-handler.js";
+export declare function registerAllResources(server: McpServer, tm1: TM1Client): ResourceCatalog;
+//# sourceMappingURL=index.d.ts.map

package/dist/resources/index.js

@@ -0,0 +1,237 @@
+// MCP Resources — read-only data assets exposed via URI. Complements the
+// tool surface so IDE clients (Kiro, VSCode Copilot Chat) can:
+//   - reference TM1 objects in chat as `#tm1://process/foo/code`
+//   - browse a sidebar tree
+//   - subscribe to updates without polling
+//
+// Each resource maps to an existing TM1 service call — same backend logic
+// as the get_* tools, different MCP entry point.
+import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { maskCode } from "../lib/mask-secrets.js";
+function asJsonContent(uri, payload) {
+    return {
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: "application/json",
+                text: JSON.stringify(payload, null, 2),
+            },
+        ],
+    };
+}
+export function registerAllResources(server, tm1) {
+    // Build a parallel catalog as we go so installPaginatedListHandler can
+    // override SDK's default ListResourcesRequestSchema with cursor support.
+    // registerResource still wires the read callbacks; we just keep our own
+    // listing source of truth.
+    const entries = [];
+    // ── Static endpoints ────────────────────────────────────────────────
+    server.registerResource("server-info", "tm1://server/info", {
+        title: "TM1 Server Info",
+        description: "TM1 server configuration snapshot: name, version, data directory, timezone, integrated security mode.",
+        mimeType: "application/json",
+    }, async (uri) => {
+        // Project to the documented identity fields only. getInfo().extra
+        // carries the full merged /Configuration body, which can include
+        // sensitive settings — resources have no params, so unlike the
+        // curated tm1_get_server_info tool there is no place to opt in.
+        const info = await tm1.server.getInfo();
+        return asJsonContent(uri, {
+            serverName: info.serverName,
+            productVersion: info.productVersion,
+            productEdition: info.productEdition,
+            adminHost: info.adminHost,
+            dataDirectory: info.dataDirectory,
+            timeZoneId: info.timeZoneId,
+            integratedSecurityMode: info.integratedSecurityMode,
+        });
+    });
+    entries.push({
+        kind: "static",
+        resource: {
+            uri: "tm1://server/info",
+            name: "server-info",
+            title: "TM1 Server Info",
+            description: "TM1 server configuration snapshot: name, version, data directory, timezone, integrated security mode.",
+            mimeType: "application/json",
+        },
+    });
+    server.registerResource("server-state", "tm1://server/state", {
+        title: "TM1 Server State",
+        description: "Health-check snapshot: connection state, version, capability flags, object counts (cubes/dimensions/processes/chores/clients).",
+        mimeType: "application/json",
+    }, async (uri) => {
+        const [info, cubes, dims, procs, chores, clients] = await Promise.all([
+            tm1.server.getInfo(),
+            tm1.cubes.list(),
+            tm1.dimensions.list(),
+            tm1.processes.list(),
+            tm1.chores.list(),
+            tm1.security.listClients(),
+        ]);
+        return asJsonContent(uri, {
+            connected: tm1.isConnected(),
+            server: {
+                name: info.serverName,
+                productVersion: info.productVersion,
+                dataDirectory: info.dataDirectory,
+                timeZoneId: info.timeZoneId,
+            },
+            counts: {
+                cubes: cubes.length,
+                dimensions: dims.length,
+                processes: procs.length,
+                chores: chores.length,
+                clients: clients.length,
+            },
+        });
+    });
+    entries.push({
+        kind: "static",
+        resource: {
+            uri: "tm1://server/state",
+            name: "server-state",
+            title: "TM1 Server State",
+            description: "Health-check snapshot: connection state, version, capability flags, object counts (cubes/dimensions/processes/chores/clients).",
+            mimeType: "application/json",
+        },
+    });
+    // ── Resource templates ──────────────────────────────────────────────
+    // Process source code — `tm1://process/{name}/code`
+    server.registerResource("process-code", new ResourceTemplate("tm1://process/{name}/code", {
+        list: async () => {
+            const procs = await tm1.processes.list();
+            return {
+                resources: procs
+                    .filter((p) => !p.name.startsWith("}"))
+                    .map((p) => ({
+                    name: `process-code-${p.name}`,
+                    uri: `tm1://process/${encodeURIComponent(p.name)}/code`,
+                    title: `TI: ${p.name}`,
+                    description: `Source code (Prolog/Metadata/Data/Epilog) of TI process '${p.name}'.`,
+                    mimeType: "application/json",
+                })),
+            };
+        },
+        complete: {
+            name: async (value) => {
+                const procs = await tm1.processes.list();
+                const lower = value.toLowerCase();
+                return procs
+                    .filter((p) => !p.name.startsWith("}") && p.name.toLowerCase().includes(lower))
+                    .map((p) => p.name)
+                    .slice(0, 100);
+            },
+        },
+    }), {
+        title: "TI Process Source Code",
+        description: "Source code of any TurboIntegrator process by name. URI: tm1://process/{name}/code.",
+        mimeType: "application/json",
+    }, async (uri, vars) => {
+        const raw = vars.name;
+        const name = decodeURIComponent(Array.isArray(raw) ? raw[0] : (raw ?? ""));
+        const code = await tm1.processes.getCode(name);
+        // Hard-mask credential literals unconditionally: resources take no
+        // parameters, so unlike tm1_get_process_code there is no maskSecrets
+        // opt-out — returning the code verbatim would bypass the tool-path
+        // redaction (ODBCOpen passwords, credential assignments).
+        return asJsonContent(uri, {
+            prolog: maskCode(code.prolog),
+            metadata: maskCode(code.metadata),
+            data: maskCode(code.data),
+            epilog: maskCode(code.epilog),
+        });
+    });
+    entries.push({
+        kind: "template",
+        templateMetadata: {
+            title: "TI Process Source Code",
+            description: "Source code of any TurboIntegrator process by name. URI: tm1://process/{name}/code.",
+            mimeType: "application/json",
+        },
+        list: async () => {
+            const procs = await tm1.processes.list();
+            return {
+                resources: procs
+                    .filter((p) => !p.name.startsWith("}"))
+                    .map((p) => ({
+                    name: `process-code-${p.name}`,
+                    uri: `tm1://process/${encodeURIComponent(p.name)}/code`,
+                    title: `TI: ${p.name}`,
+                    description: `Source code (Prolog/Metadata/Data/Epilog) of TI process '${p.name}'.`,
+                    mimeType: "application/json",
+                })),
+            };
+        },
+    });
+    // Cube rules — `tm1://cube/{name}/rules`
+    server.registerResource("cube-rules", new ResourceTemplate("tm1://cube/{name}/rules", {
+        list: async () => {
+            // Filter to cubes that actually carry rules — avoids cluttering
+            // the resource tree with rule-less cubes whose body is "".
+            const cubes = await tm1.cubes.list({ includeRules: true });
+            return {
+                resources: cubes
+                    .filter((c) => !c.name.startsWith("}") && c.hasRules)
+                    .map((c) => ({
+                    name: `cube-rules-${c.name}`,
+                    uri: `tm1://cube/${encodeURIComponent(c.name)}/rules`,
+                    title: `Rules: ${c.name}`,
+                    description: `Rules text of cube '${c.name}' (SKIPCHECK + FEEDERS sections).`,
+                    mimeType: "text/plain",
+                })),
+            };
+        },
+        complete: {
+            name: async (value) => {
+                const cubes = await tm1.cubes.list();
+                const lower = value.toLowerCase();
+                return cubes
+                    .filter((c) => !c.name.startsWith("}") && c.name.toLowerCase().includes(lower))
+                    .map((c) => c.name)
+                    .slice(0, 100);
+            },
+        },
+    }), {
+        title: "Cube Rules Text",
+        description: "Rules text of any TM1 cube by name. URI: tm1://cube/{name}/rules. Returns plain text.",
+        mimeType: "text/plain",
+    }, async (uri, vars) => {
+        const raw = vars.name;
+        const name = decodeURIComponent(Array.isArray(raw) ? raw[0] : (raw ?? ""));
+        const rules = await tm1.cubes.getRules(name);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "text/plain",
+                    text: rules.rulesText,
+                },
+            ],
+        };
+    });
+    entries.push({
+        kind: "template",
+        templateMetadata: {
+            title: "Cube Rules Text",
+            description: "Rules text of any TM1 cube by name. URI: tm1://cube/{name}/rules. Returns plain text.",
+            mimeType: "text/plain",
+        },
+        list: async () => {
+            const cubes = await tm1.cubes.list({ includeRules: true });
+            return {
+                resources: cubes
+                    .filter((c) => !c.name.startsWith("}") && c.hasRules)
+                    .map((c) => ({
+                    name: `cube-rules-${c.name}`,
+                    uri: `tm1://cube/${encodeURIComponent(c.name)}/rules`,
+                    title: `Rules: ${c.name}`,
+                    description: `Rules text of cube '${c.name}' (SKIPCHECK + FEEDERS sections).`,
+                    mimeType: "text/plain",
+                })),
+            };
+        },
+    });
+    return { entries };
+}
+//# sourceMappingURL=index.js.map

package/dist/resources/list-handler.d.ts

@@ -0,0 +1,40 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type pino from "pino";
+export interface CatalogResource {
+    uri: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+}
+export interface StaticCatalogEntry {
+    kind: "static";
+    resource: CatalogResource;
+}
+export interface TemplateCatalogEntry {
+    kind: "template";
+    templateMetadata: {
+        title?: string;
+        description?: string;
+        mimeType?: string;
+    };
+    list: () => Promise<{
+        resources: CatalogResource[];
+    }>;
+}
+export type CatalogEntry = StaticCatalogEntry | TemplateCatalogEntry;
+export interface ResourceCatalog {
+    entries: CatalogEntry[];
+}
+export declare const DEFAULT_PAGE_SIZE = 200;
+declare function encodeCursor(offset: number): string;
+declare function decodeCursor(cursor: string | undefined): number;
+declare function resolveAll(catalog: ResourceCatalog, logger: pino.Logger): Promise<CatalogResource[]>;
+export declare function installPaginatedListHandler(server: McpServer, catalog: ResourceCatalog, logger: pino.Logger, pageSize?: number): void;
+export declare const __testing: {
+    encodeCursor: typeof encodeCursor;
+    decodeCursor: typeof decodeCursor;
+    resolveAll: typeof resolveAll;
+};
+export {};
+//# sourceMappingURL=list-handler.d.ts.map

package/dist/resources/list-handler.js

@@ -0,0 +1,86 @@
+// R2-07: cursor-based pagination for resources/list.
+//
+// The high-level McpServer.registerResource registers a default
+// ListResourcesRequestSchema handler that ignores `params.cursor` and strips
+// `nextCursor` from the result (SDK 1.29.0). For TM1 servers with thousands
+// of processes/cubes that single-shot response can overflow client buffers
+// and is not spec-compliant.
+//
+// This module installs a replacement handler on the underlying Server,
+// driven by a typed catalog populated by registerAllResources. The replaced
+// handler still defers to template list callbacks for dynamic resources but
+// adds opaque cursor pagination on top.
+//
+// Cursor format: base64url-encoded JSON `{ "o": <offset> }`. Opaque to the
+// client by spec; we only need it to be self-contained and stable across
+// requests so we don't need server-side state.
+import { ListResourcesRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+export const DEFAULT_PAGE_SIZE = 200;
+function encodeCursor(offset) {
+    return Buffer.from(JSON.stringify({ o: offset }), "utf8").toString("base64url");
+}
+// Returns offset >= 0 or 0 when the cursor is malformed / out-of-range.
+// Per spec malformed cursors → InvalidParams; we treat them as "start over"
+// so a stale cursor degrades to a fresh listing rather than an error storm.
+function decodeCursor(cursor) {
+    if (!cursor)
+        return 0;
+    try {
+        const json = Buffer.from(cursor, "base64url").toString("utf8");
+        const parsed = JSON.parse(json);
+        const offset = typeof parsed.o === "number" ? parsed.o : 0;
+        return offset >= 0 ? offset : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+// Resolve the full sorted resource list. Template list callbacks fire in
+// parallel; static entries pass through. Sorting by URI gives stable paging
+// across requests even if a template adds/removes entries between pages.
+async function resolveAll(catalog, logger) {
+    const statics = [];
+    const templatePromises = [];
+    for (const entry of catalog.entries) {
+        if (entry.kind === "static") {
+            statics.push(entry.resource);
+        }
+        else {
+            templatePromises.push(entry
+                .list()
+                .then((r) => r.resources.map((res) => ({
+                ...entry.templateMetadata,
+                // resource-level metadata overrides template defaults per SDK convention
+                ...res,
+            })))
+                // A single failing template (e.g. TM1 briefly unreachable) must not take
+                // down the entire resources/list response — log it and omit its entries.
+                .catch((err) => {
+                logger.warn({ err, template: entry.templateMetadata }, "resource template list() failed; omitting from listing");
+                return [];
+            }));
+        }
+    }
+    const templateResults = await Promise.all(templatePromises);
+    const all = [...statics, ...templateResults.flat()];
+    all.sort((a, b) => a.uri.localeCompare(b.uri));
+    return all;
+}
+export function installPaginatedListHandler(server, catalog, logger, pageSize = DEFAULT_PAGE_SIZE) {
+    server.server.setRequestHandler(ListResourcesRequestSchema, async (request) => {
+        const cursorParam = request.params?.cursor;
+        const offset = decodeCursor(cursorParam ?? undefined);
+        const all = await resolveAll(catalog, logger);
+        const slice = all.slice(offset, offset + pageSize);
+        const next = offset + slice.length;
+        const hasMore = next < all.length;
+        logger.debug({ offset, returned: slice.length, total: all.length, hasMore }, "resources/list paginated");
+        return {
+            resources: slice,
+            ...(hasMore ? { nextCursor: encodeCursor(next) } : {}),
+        };
+    });
+}
+// Test-only exports.
+export const __testing = { encodeCursor, decodeCursor, resolveAll };
+//# sourceMappingURL=list-handler.js.map

package/dist/resources/subscriptions.d.ts

@@ -0,0 +1,19 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type pino from "pino";
+export declare class SubscriptionRegistry {
+    private readonly server;
+    private readonly logger;
+    private readonly subscribed;
+    private mutationListener?;
+    constructor(server: McpServer, logger: pino.Logger);
+    /** Install subscribe/unsubscribe request handlers + mutation listener. */
+    install(): void;
+    /** Detach listener — used for shutdown / tests. */
+    dispose(): void;
+    /** Test introspection only. */
+    isSubscribed(uri: string): boolean;
+    /** Test introspection only. */
+    size(): number;
+    private onMutation;
+}
+//# sourceMappingURL=subscriptions.d.ts.map

package/dist/resources/subscriptions.js

@@ -0,0 +1,80 @@
+// R2-05: MCP resource subscription registry.
+//
+// Tracks which `tm1://...` URIs the client has subscribed to and, when an
+// upstream mutation event fires, pushes `notifications/resources/updated`
+// for the relevant URIs. Bridges the existing HTTP-layer mutation hook
+// (tm1Events) into the MCP spec's pull-then-notify shape.
+//
+// Wiring:
+//   index.ts → new SubscriptionRegistry(server, logger) → install()
+//   HTTP layer → tm1Events.emit('mutation', { method, path })
+//   Registry → server.server.sendResourceUpdated({ uri }) per match
+//
+// Spec: https://modelcontextprotocol.io/specification (resources/subscribe,
+// resources/unsubscribe, notifications/resources/updated).
+import { SubscribeRequestSchema, UnsubscribeRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { tm1Events } from "../lib/tm1-events.js";
+// URIs whose contents are sensitive to *any* mutation. The server-state
+// resource aggregates counts across cubes/dims/processes/chores/clients —
+// almost any non-safe call can change it.
+const STATE_SENSITIVE_URIS = new Set(["tm1://server/state"]);
+export class SubscriptionRegistry {
+    server;
+    logger;
+    // URIs the client has asked us to push updates for.
+    subscribed = new Set();
+    mutationListener;
+    constructor(server, logger) {
+        this.server = server;
+        this.logger = logger;
+    }
+    /** Install subscribe/unsubscribe request handlers + mutation listener. */
+    install() {
+        const lowLevel = this.server.server;
+        lowLevel.setRequestHandler(SubscribeRequestSchema, (req) => {
+            const uri = req.params.uri;
+            this.subscribed.add(uri);
+            this.logger.debug({ uri, count: this.subscribed.size }, "Resource subscribed");
+            return {};
+        });
+        lowLevel.setRequestHandler(UnsubscribeRequestSchema, (req) => {
+            const uri = req.params.uri;
+            this.subscribed.delete(uri);
+            this.logger.debug({ uri, count: this.subscribed.size }, "Resource unsubscribed");
+            return {};
+        });
+        this.mutationListener = (e) => this.onMutation(e);
+        tm1Events.on("mutation", this.mutationListener);
+    }
+    /** Detach listener — used for shutdown / tests. */
+    dispose() {
+        if (this.mutationListener) {
+            tm1Events.off("mutation", this.mutationListener);
+            this.mutationListener = undefined;
+        }
+        this.subscribed.clear();
+    }
+    /** Test introspection only. */
+    isSubscribed(uri) {
+        return this.subscribed.has(uri);
+    }
+    /** Test introspection only. */
+    size() {
+        return this.subscribed.size;
+    }
+    onMutation(_e) {
+        // Iterate subscribed URIs and notify those affected by this mutation.
+        // Currently only the aggregate state resource is mutation-sensitive;
+        // future entries can branch on e.path / e.method for finer-grained
+        // notifications (e.g. tm1://process/{name}/code on /Processes mutations).
+        for (const uri of this.subscribed) {
+            if (!STATE_SENSITIVE_URIS.has(uri))
+                continue;
+            // Fire-and-forget; missing transport (server not connected) throws.
+            this.server.server.sendResourceUpdated({ uri }).catch((err) => {
+                this.logger.warn({ err, uri }, "sendResourceUpdated failed");
+            });
+        }
+    }
+}
+//# sourceMappingURL=subscriptions.js.map

package/dist/schemas/cells.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare const MdxAxisSchema: z.ZodObject<{
+    tuples: z.ZodArray<z.ZodObject<{
+        members: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            hierarchyName: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MdxAxis = z.infer<typeof MdxAxisSchema>;
+export declare const FedCellDescriptorSchema: z.ZodObject<{
+    cube: z.ZodString;
+    tuple: z.ZodArray<z.ZodString>;
+    fed: z.ZodBoolean;
+}, z.core.$strip>;
+export type FedCellDescriptor = z.infer<typeof FedCellDescriptorSchema>;
+//# sourceMappingURL=cells.d.ts.map

package/dist/schemas/cells.js

@@ -0,0 +1,13 @@
+// Cell/MDX domain: axis tuples and the feeder cell descriptor.
+import { z } from "zod";
+export const MdxAxisSchema = z.object({
+    tuples: z.array(z.object({
+        members: z.array(z.object({ name: z.string(), hierarchyName: z.string() })),
+    })),
+});
+export const FedCellDescriptorSchema = z.object({
+    cube: z.string(),
+    tuple: z.array(z.string()),
+    fed: z.boolean(),
+});
+//# sourceMappingURL=cells.js.map

package/dist/schemas/common.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+/** A TM1 cell: text, number, or empty. */
+export declare const CellValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+export type CellValue = z.infer<typeof CellValueSchema>;
+/** Element type as the OData surface spells it. */
+export declare const ELEMENT_TYPE: z.ZodEnum<{
+    Numeric: "Numeric";
+    String: "String";
+    Consolidated: "Consolidated";
+}>;
+/** TI parameter/variable type as the OData surface spells it. */
+export declare const PARAM_TYPE: z.ZodEnum<{
+    Numeric: "Numeric";
+    String: "String";
+}>;
+//# sourceMappingURL=common.d.ts.map

package/dist/schemas/common.js

@@ -0,0 +1,14 @@
+// Shared primitives for the domain schemas.
+//
+// These live below both consumers on purpose: `src/tm1-client/` (which parses
+// them off the wire) and `src/tools/` (which publishes them as outputSchema)
+// import from here, never from each other. Nothing in this directory may import
+// from `../tools/` or `../types.js`.
+import { z } from "zod";
+/** A TM1 cell: text, number, or empty. */
+export const CellValueSchema = z.union([z.string(), z.number(), z.null()]);
+/** Element type as the OData surface spells it. */
+export const ELEMENT_TYPE = z.enum(["Numeric", "String", "Consolidated"]);
+/** TI parameter/variable type as the OData surface spells it. */
+export const PARAM_TYPE = z.enum(["String", "Numeric"]);
+//# sourceMappingURL=common.js.map

package/dist/schemas/index.d.ts

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

package/dist/schemas/index.js

@@ -0,0 +1,23 @@
+// Canonical wire/domain schemas — the single definition of every shape that
+// both the TM1 client and the tool layer need.
+//
+// Before this existed the same shapes were written twice: a hand-kept
+// interface in src/types.ts for the client, and a hand-kept Zod object in
+// src/tools/schemas/items-*.ts for the published outputSchema. They drifted
+// exactly the way you would expect — `lockType` sat in the read shape for
+// months without ever being on the wire, and removing it meant editing two
+// files that had no link between them.
+//
+// Now the Zod object is the definition and the TypeScript type is `z.infer` of
+// it. src/types.ts re-exports those types, so every existing import keeps
+// working; src/tools/schemas/items-*.ts re-export the schemas.
+export * from "./common.js";
+export * from "./cells.js";
+export * from "./metadata.js";
+export * from "./monitoring.js";
+export * from "./processes.js";
+export * from "./scheduling.js";
+export * from "./security.js";
+export * from "./subsets.js";
+export * from "./views.js";
+//# sourceMappingURL=index.js.map

package/dist/schemas/metadata.d.ts

@@ -0,0 +1,70 @@
+import { z } from "zod";
+export declare const CubeSchema: z.ZodObject<{
+    name: z.ZodString;
+    dimensions: z.ZodArray<z.ZodString>;
+    hasRules: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type Cube = z.infer<typeof CubeSchema>;
+export declare const ElementStatsSchema: z.ZodObject<{
+    total: z.ZodNumber;
+    numeric: z.ZodNumber;
+    consolidated: z.ZodNumber;
+    string: z.ZodNumber;
+    maxLevel: z.ZodNumber;
+}, z.core.$strip>;
+export type ElementStats = z.infer<typeof ElementStatsSchema>;
+export declare const ElementAttributeValueSchema: z.ZodObject<{
+    elementName: z.ZodString;
+    attributeName: z.ZodString;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+}, z.core.$strip>;
+export type ElementAttributeValue = z.infer<typeof ElementAttributeValueSchema>;
+export declare const DimensionSchema: z.ZodObject<{
+    name: z.ZodString;
+    hierarchies: z.ZodArray<z.ZodString>;
+    elementCounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    elementStats: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        total: z.ZodNumber;
+        numeric: z.ZodNumber;
+        consolidated: z.ZodNumber;
+        string: z.ZodNumber;
+        maxLevel: z.ZodNumber;
+    }, z.core.$strip>>>;
+    lastUpdated: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type Dimension = z.infer<typeof DimensionSchema>;
+export declare const HierarchyElementSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        Numeric: "Numeric";
+        String: "String";
+        Consolidated: "Consolidated";
+    }>;
+    level: z.ZodNumber;
+    parents: z.ZodArray<z.ZodString>;
+    children: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        weight: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type HierarchyElement = z.infer<typeof HierarchyElementSchema>;
+export declare const HierarchySchema: z.ZodObject<{
+    name: z.ZodString;
+    dimensionName: z.ZodString;
+    elements: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            Numeric: "Numeric";
+            String: "String";
+            Consolidated: "Consolidated";
+        }>;
+        level: z.ZodNumber;
+        parents: z.ZodArray<z.ZodString>;
+        children: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            weight: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Hierarchy = z.infer<typeof HierarchySchema>;
+//# sourceMappingURL=metadata.d.ts.map