@ffschrattenecker/tm1-mcp-server 6.0.0

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

@@ -0,0 +1,262 @@
+import { z } from "zod";
+export { ElementAttributeValueSchema, ElementStatsSchema, } from "../../schemas/metadata.js";
+export declare const CubeItemSchema: z.ZodObject<{
+    name: z.ZodString;
+    dimensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    hasRules: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const DimensionItemSchema: 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 declare const HierarchyElementSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        Numeric: "Numeric";
+        String: "String";
+        Consolidated: "Consolidated";
+    }>;
+    level: z.ZodNumber;
+    parents: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    children: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        weight: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+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.ZodOptional<z.ZodArray<z.ZodString>>;
+        children: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            weight: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+    offset: z.ZodNumber;
+    has_more: z.ZodBoolean;
+    truncated: z.ZodBoolean;
+    counts: z.ZodOptional<z.ZodObject<{
+        byType: z.ZodObject<{
+            Numeric: z.ZodNumber;
+            String: z.ZodNumber;
+            Consolidated: z.ZodNumber;
+        }, z.core.$strip>;
+        byLevel: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        maxLevel: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const BulkUpsertElementsResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    dimension: z.ZodString;
+    hierarchy: z.ZodString;
+    totalElements: z.ZodNumber;
+    counts: z.ZodObject<{
+        N: z.ZodNumber;
+        C: z.ZodNumber;
+        S: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ElementAttributeDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        Numeric: "Numeric";
+        String: "String";
+        Alias: "Alias";
+    }>;
+}, z.core.$strip>;
+export declare const CubeRulesSchema: z.ZodObject<{
+    cubeName: z.ZodString;
+    skipCheck: z.ZodBoolean;
+    rulesText: z.ZodOptional<z.ZodString>;
+    lineCount: z.ZodOptional<z.ZodNumber>;
+    ruleCount: z.ZodOptional<z.ZodNumber>;
+    feederCount: z.ZodOptional<z.ZodNumber>;
+    commentLineCount: z.ZodOptional<z.ZodNumber>;
+    referencedCubes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    outline: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        line: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>>>;
+    outlineTruncated: z.ZodOptional<z.ZodBoolean>;
+    lineRange: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+export declare const CubeStatsItemSchema: z.ZodObject<{
+    cubeName: z.ZodString;
+    populatedNumeric: z.ZodOptional<z.ZodNumber>;
+    populatedString: z.ZodOptional<z.ZodNumber>;
+    storedCalculated: z.ZodOptional<z.ZodNumber>;
+    storedViews: z.ZodOptional<z.ZodNumber>;
+    fedCells: z.ZodOptional<z.ZodNumber>;
+    memoryViews: z.ZodOptional<z.ZodNumber>;
+    memoryInput: z.ZodOptional<z.ZodNumber>;
+    memoryFeeders: z.ZodOptional<z.ZodNumber>;
+    memoryCalculations: z.ZodOptional<z.ZodNumber>;
+    memoryTotal: z.ZodOptional<z.ZodNumber>;
+    avgCalculationSteps: z.ZodOptional<z.ZodNumber>;
+    cacheMissRate: z.ZodOptional<z.ZodNumber>;
+    feederEfficiency: z.ZodOptional<z.ZodNumber>;
+    raw: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const StatsUnavailableSchema: z.ZodObject<{
+    reason: z.ZodEnum<{
+        absent: "absent";
+        denied: "denied";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const CubeStatsResultSchema: z.ZodObject<{
+    count: z.ZodNumber;
+    items: z.ZodArray<z.ZodObject<{
+        cubeName: z.ZodString;
+        populatedNumeric: z.ZodOptional<z.ZodNumber>;
+        populatedString: z.ZodOptional<z.ZodNumber>;
+        storedCalculated: z.ZodOptional<z.ZodNumber>;
+        storedViews: z.ZodOptional<z.ZodNumber>;
+        fedCells: z.ZodOptional<z.ZodNumber>;
+        memoryViews: z.ZodOptional<z.ZodNumber>;
+        memoryInput: z.ZodOptional<z.ZodNumber>;
+        memoryFeeders: z.ZodOptional<z.ZodNumber>;
+        memoryCalculations: z.ZodOptional<z.ZodNumber>;
+        memoryTotal: z.ZodOptional<z.ZodNumber>;
+        avgCalculationSteps: z.ZodOptional<z.ZodNumber>;
+        cacheMissRate: z.ZodOptional<z.ZodNumber>;
+        feederEfficiency: z.ZodOptional<z.ZodNumber>;
+        raw: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    statsUnavailable: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodEnum<{
+            absent: "absent";
+            denied: "denied";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+export declare const AncestorsResultSchema: z.ZodObject<{
+    element: z.ZodString;
+    ancestors: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        level: z.ZodNumber;
+    }, z.core.$strip>>;
+    paths: z.ZodArray<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const DescendantsResultSchema: z.ZodObject<{
+    element: z.ZodString;
+    descendants: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        level: z.ZodNumber;
+        depth: z.ZodNumber;
+    }, z.core.$strip>>;
+    truncated: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const DefaultMemberResolutionSchema: z.ZodObject<{
+    dimension: z.ZodString;
+    hierarchy: z.ZodString;
+    resolved: z.ZodObject<{
+        name: z.ZodString;
+        level: z.ZodNumber;
+    }, z.core.$strip>;
+    source: z.ZodEnum<{
+        defined: "defined";
+        single_root: "single_root";
+        first_root: "first_root";
+        index_1: "index_1";
+    }>;
+    confidence: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    alternatives: z.ZodOptional<z.ZodObject<{
+        roots: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            level: z.ZodNumber;
+        }, z.core.$strip>>;
+        indexOne: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    warning: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const DefaultMemberErrorSchema: z.ZodObject<{
+    dimension: z.ZodString;
+    hierarchy: z.ZodString;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const DefaultMembersBulkResultSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        dimension: z.ZodString;
+        hierarchy: z.ZodString;
+        resolved: z.ZodObject<{
+            name: z.ZodString;
+            level: z.ZodNumber;
+        }, z.core.$strip>;
+        source: z.ZodEnum<{
+            defined: "defined";
+            single_root: "single_root";
+            first_root: "first_root";
+            index_1: "index_1";
+        }>;
+        confidence: z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>;
+        alternatives: z.ZodOptional<z.ZodObject<{
+            roots: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                level: z.ZodNumber;
+            }, z.core.$strip>>;
+            indexOne: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        warning: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        dimension: z.ZodString;
+        hierarchy: z.ZodString;
+        error: z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+export declare const OrphanDimensionSchema: z.ZodObject<{
+    name: z.ZodString;
+    hierarchies: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const FindOrphanDimensionsResultSchema: z.ZodObject<{
+    totalDimensions: z.ZodNumber;
+    totalCubes: z.ZodNumber;
+    orphanCount: z.ZodNumber;
+    includeControl: z.ZodBoolean;
+    total: z.ZodNumber;
+    count: z.ZodNumber;
+    offset: z.ZodNumber;
+    has_more: z.ZodBoolean;
+    next_offset: z.ZodNullable<z.ZodNumber>;
+    items: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        hierarchies: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+//# sourceMappingURL=items-metadata.d.ts.map

package/dist/tools/schemas/items-metadata.js

@@ -0,0 +1,184 @@
+// Metadata-domain item/result schemas: cubes, dimensions, hierarchies,
+// elements, attributes, rules, cube stats and hierarchy navigation.
+import { z } from "zod";
+export { ElementAttributeValueSchema, ElementStatsSchema, } from "../../schemas/metadata.js";
+import { CubeSchema, DimensionSchema, HierarchyElementSchema as HierarchyElementBase, HierarchySchema as HierarchyBase, } from "../../schemas/metadata.js";
+// Published list item = the canonical shape with the projections tm1_list_cubes
+// offers made optional. Derived, so a new cube field cannot reach the client
+// without appearing here.
+export const CubeItemSchema = CubeSchema.partial({
+    // Omitted when caller sets includeDimensions=false on tm1_list_cubes.
+    dimensions: true,
+});
+// `lastUpdated` is only attached when the caller asks for it — but it IS part
+// of the payload then, so the published schema has to carry it (a strict
+// schema that omits it makes the client reject the whole response).
+export const DimensionItemSchema = DimensionSchema;
+// parents/children are omitted when the caller passes compact=true to
+// tm1_get_hierarchy.
+export const HierarchyElementSchema = HierarchyElementBase.partial({
+    parents: true,
+    children: true,
+});
+// The tool wraps the canonical hierarchy in a page envelope.
+export const HierarchySchema = HierarchyBase.extend({
+    elements: z.array(HierarchyElementSchema),
+    total: z.number().int(),
+    offset: z.number().int(),
+    has_more: z.boolean(),
+    // true when the topN cap clipped the (post-filter) element set — raise topN.
+    truncated: z.boolean(),
+    // countOnly=true: totals of the filtered set; elements is then empty.
+    counts: z
+        .object({
+        byType: z.object({
+            Numeric: z.number().int(),
+            String: z.number().int(),
+            Consolidated: z.number().int(),
+        }),
+        byLevel: z.record(z.string(), z.number().int()),
+        maxLevel: z.number().int(),
+    })
+        .optional(),
+});
+export const BulkUpsertElementsResultSchema = z.object({
+    success: z.boolean(),
+    dimension: z.string(),
+    hierarchy: z.string(),
+    totalElements: z.number().int(),
+    counts: z.object({
+        N: z.number().int(),
+        C: z.number().int(),
+        S: z.number().int(),
+    }),
+});
+// Attribute *definition* (as returned by listAttributes) — distinct from a
+// per-element attribute *value* above. Used by tm1_list_element_attributes.
+export const ElementAttributeDefinitionSchema = z.object({
+    name: z.string().describe("Attribute name"),
+    type: z
+        .enum(["Numeric", "String", "Alias"])
+        .describe("Attribute storage type"),
+});
+export const CubeRulesSchema = z.object({
+    cubeName: z.string(),
+    skipCheck: z.boolean(),
+    // Full mode (default): rulesText carries the verbatim TM1 rule body.
+    // Summary mode (tm1_get_all_cube_rules summary=true): rulesText is replaced
+    // by aggregate metrics so analysis agents can survey rule landscapes
+    // without paying full token cost.
+    rulesText: z.string().optional(),
+    lineCount: z.number().int().optional(),
+    ruleCount: z.number().int().optional(),
+    feederCount: z.number().int().optional(),
+    commentLineCount: z.number().int().optional(),
+    referencedCubes: z.array(z.string()).optional(),
+    // tm1_get_cube_rules outline=true: section markers instead of the text.
+    outline: z
+        .array(z.object({ line: z.number().int(), text: z.string() }))
+        .optional(),
+    outlineTruncated: z.boolean().optional(),
+    // tm1_get_cube_rules lineRange: the [from, to] actually returned (clamped).
+    lineRange: z.array(z.number().int()).optional(),
+});
+// ── tm1_get_cube_stats result schemas ────────────────────────────────────────
+// Stats elements differ between TM1 v11 and v12. We expose well-known names
+// as typed fields (best-effort match) and the entire raw element-name → value
+// map under `raw` so callers can read whatever the server actually returned
+// — no version drift breaks the tool, only renames new well-known fields.
+export const CubeStatsItemSchema = z
+    .object({
+    cubeName: z.string(),
+    // Cell counts
+    populatedNumeric: z.number().optional(),
+    populatedString: z.number().optional(),
+    storedCalculated: z.number().optional(),
+    storedViews: z.number().optional(),
+    fedCells: z.number().optional(),
+    // Memory (bytes)
+    memoryViews: z.number().optional(),
+    memoryInput: z.number().optional(),
+    memoryFeeders: z.number().optional(),
+    memoryCalculations: z.number().optional(),
+    memoryTotal: z.number().optional(),
+    // Performance
+    avgCalculationSteps: z.number().optional(),
+    cacheMissRate: z.number().optional(),
+    // Derived
+    feederEfficiency: z.number().optional(),
+    // Always present: full element-name → value map (carries everything,
+    // including v12-only or new-build metrics that aren't in KNOWN_METRICS).
+    raw: z.record(z.string(), z.union([z.number(), z.null()])),
+    error: z.string().optional(),
+})
+    .passthrough();
+// Set only when EVERY requested cube failed the same server- or account-wide
+// way: `absent` = no }Stats* control cubes here (TM1 v12 ships none),
+// `denied` = they exist but this account may not read them.
+export const StatsUnavailableSchema = z.object({
+    reason: z.enum(["absent", "denied"]),
+    message: z.string(),
+});
+export const CubeStatsResultSchema = z
+    .object({
+    count: z.number().int(),
+    items: z.array(CubeStatsItemSchema),
+    statsUnavailable: StatsUnavailableSchema.optional(),
+})
+    .passthrough();
+// ── Phase 2i: hierarchy navigation, server snapshots, diagnostics ────────────
+export const AncestorsResultSchema = z.object({
+    element: z.string(),
+    ancestors: z.array(z.object({ name: z.string(), level: z.number().int() })),
+    paths: z.array(z.array(z.string())),
+});
+export const DescendantsResultSchema = z.object({
+    element: z.string(),
+    descendants: z.array(z.object({
+        name: z.string(),
+        type: z.string(),
+        level: z.number().int(),
+        depth: z.number().int(),
+    })),
+    // true when the topN cap clipped the descendant set — raise topN.
+    truncated: z.boolean(),
+});
+export const DefaultMemberResolutionSchema = z.object({
+    dimension: z.string(),
+    hierarchy: z.string(),
+    resolved: z.object({ name: z.string(), level: z.number().int() }),
+    source: z.enum(["defined", "single_root", "first_root", "index_1"]),
+    confidence: z.enum(["high", "medium", "low"]),
+    alternatives: z
+        .object({
+        roots: z.array(z.object({ name: z.string(), level: z.number().int() })),
+        indexOne: z.string().optional(),
+    })
+        .optional(),
+    warning: z.string().optional(),
+});
+export const DefaultMemberErrorSchema = z.object({
+    dimension: z.string(),
+    hierarchy: z.string(),
+    error: z.object({ code: z.string(), message: z.string() }),
+});
+export const DefaultMembersBulkResultSchema = z.object({
+    results: z.array(z.union([DefaultMemberResolutionSchema, DefaultMemberErrorSchema])),
+});
+export const OrphanDimensionSchema = z.object({
+    name: z.string(),
+    hierarchies: z.array(z.string()),
+});
+export const FindOrphanDimensionsResultSchema = z.object({
+    totalDimensions: z.number().int(),
+    totalCubes: z.number().int(),
+    orphanCount: z.number().int(),
+    includeControl: z.boolean(),
+    total: z.number().int(),
+    count: z.number().int(),
+    offset: z.number().int(),
+    has_more: z.boolean(),
+    next_offset: z.number().int().nullable(),
+    items: z.array(OrphanDimensionSchema),
+});
+//# sourceMappingURL=items-metadata.js.map

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

@@ -0,0 +1,79 @@
+import { z } from "zod";
+export { AuditLogDetailSchema, ErrorLogFileSchema, JobSchema, MessageLogEntrySchema, SessionSchema, ThreadSchema, TransactionLogEntrySchema, } from "../../schemas/monitoring.js";
+export declare const ServerInfoSchema: z.ZodObject<{
+    mcpServer: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strip>>;
+    serverName: z.ZodString;
+    productVersion: z.ZodString;
+    productEdition: z.ZodOptional<z.ZodString>;
+    adminHost: z.ZodOptional<z.ZodString>;
+    dataDirectory: z.ZodOptional<z.ZodString>;
+    timeZoneId: z.ZodOptional<z.ZodString>;
+    integratedSecurityMode: z.ZodOptional<z.ZodString>;
+    modelling: z.ZodOptional<z.ZodUnknown>;
+    ti: z.ZodOptional<z.ZodUnknown>;
+    rules: z.ZodOptional<z.ZodUnknown>;
+    mtq: z.ZodOptional<z.ZodUnknown>;
+    jobQueuing: z.ZodOptional<z.ZodUnknown>;
+    memory: z.ZodOptional<z.ZodUnknown>;
+    logging: z.ZodOptional<z.ZodUnknown>;
+    http: z.ZodOptional<z.ZodUnknown>;
+    security: z.ZodOptional<z.ZodUnknown>;
+    _raw: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>;
+export declare const AuditLogEntrySchema: z.ZodObject<{
+    id: z.ZodNumber;
+    timestamp: z.ZodString;
+    user: z.ZodString;
+    description: z.ZodString;
+    objectType: z.ZodString;
+    objectName: z.ZodString;
+    details: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        timestamp: z.ZodString;
+        user: z.ZodString;
+        description: z.ZodString;
+        objectType: z.ZodString;
+        objectName: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const ErrorLogGroupSchema: z.ZodObject<{
+    process: z.ZodString;
+    count: z.ZodNumber;
+    firstSeen: z.ZodNullable<z.ZodString>;
+    lastSeen: z.ZodNullable<z.ZodString>;
+    spanDays: z.ZodNumber;
+    perDay: z.ZodNumber;
+}, z.core.$strip>;
+export declare const ErrorLogContentResultSchema: z.ZodObject<{
+    filename: z.ZodString;
+    totalBytes: z.ZodNumber;
+    returnedBytes: z.ZodNumber;
+    truncated: z.ZodBoolean;
+    truncationReason: z.ZodOptional<z.ZodString>;
+    content: z.ZodString;
+    related: z.ZodOptional<z.ZodObject<{
+        windowSec: z.ZodOptional<z.ZodNumber>;
+        found: z.ZodOptional<z.ZodNumber>;
+        maxFiles: z.ZodOptional<z.ZodNumber>;
+        note: z.ZodOptional<z.ZodString>;
+        files: z.ZodArray<z.ZodObject<{
+            filename: z.ZodString;
+            deltaSec: z.ZodNumber;
+            totalBytes: z.ZodOptional<z.ZodNumber>;
+            returnedBytes: z.ZodOptional<z.ZodNumber>;
+            truncated: z.ZodOptional<z.ZodBoolean>;
+            content: z.ZodOptional<z.ZodString>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ServerStateResultSchema: z.ZodObject<{
+    connected: z.ZodBoolean;
+    server: z.ZodUnknown;
+    capabilities: z.ZodUnknown;
+    counts: z.ZodUnknown;
+}, z.core.$loose>;
+//# sourceMappingURL=items-monitoring.d.ts.map

package/dist/tools/schemas/items-monitoring.js

@@ -0,0 +1,78 @@
+// Monitoring/server-domain schemas: server info & state, message/transaction/
+// audit/error logs, threads, jobs and sessions.
+import { z } from "zod";
+// Canonical shapes — defined once in src/schemas/monitoring.ts, re-exported so
+// the output-schema side and the TM1 client cannot drift apart.
+export { AuditLogDetailSchema, ErrorLogFileSchema, JobSchema, MessageLogEntrySchema, SessionSchema, ThreadSchema, TransactionLogEntrySchema, } from "../../schemas/monitoring.js";
+import { AuditLogDetailSchema } from "../../schemas/monitoring.js";
+export const ServerInfoSchema = z
+    .object({
+    mcpServer: z.object({ name: z.string(), version: z.string() }).optional(),
+    serverName: z.string(),
+    productVersion: z.string(),
+    productEdition: z.string().optional(),
+    adminHost: z.string().optional(),
+    dataDirectory: z.string().optional(),
+    timeZoneId: z.string().optional(),
+    integratedSecurityMode: z.string().optional(),
+    modelling: z.unknown().optional(),
+    ti: z.unknown().optional(),
+    rules: z.unknown().optional(),
+    mtq: z.unknown().optional(),
+    jobQueuing: z.unknown().optional(),
+    memory: z.unknown().optional(),
+    logging: z.unknown().optional(),
+    http: z.unknown().optional(),
+    security: z.unknown().optional(),
+    _raw: z.record(z.string(), z.unknown()).optional(),
+})
+    .passthrough();
+export const AuditLogEntrySchema = AuditLogDetailSchema.extend({
+    details: z.array(AuditLogDetailSchema).optional(),
+});
+// groupBy='process' audit-summary item: per-process failure aggregation.
+export const ErrorLogGroupSchema = z.object({
+    process: z.string(),
+    count: z.number().int(),
+    firstSeen: z.string().nullable(),
+    lastSeen: z.string().nullable(),
+    spanDays: z.number().int(),
+    perDay: z.number(),
+});
+const RelatedErrorLogFileSchema = z.object({
+    filename: z.string(),
+    deltaSec: z.number().int(),
+    totalBytes: z.number().int().optional(),
+    returnedBytes: z.number().int().optional(),
+    truncated: z.boolean().optional(),
+    content: z.string().optional(),
+    error: z.string().optional(),
+});
+export const ErrorLogContentResultSchema = z.object({
+    filename: z.string(),
+    totalBytes: z.number().int(),
+    returnedBytes: z.number().int(),
+    truncated: z.boolean(),
+    truncationReason: z.string().optional(),
+    content: z.string(),
+    related: z
+        .object({
+        windowSec: z.number().int().optional(),
+        found: z.number().int().optional(),
+        maxFiles: z.number().int().optional(),
+        note: z.string().optional(),
+        files: z.array(RelatedErrorLogFileSchema),
+    })
+        .optional(),
+});
+// Server state snapshot curates a few config flags whose surface differs
+// per TM1 build — every section is permissive (.passthrough()).
+export const ServerStateResultSchema = z
+    .object({
+    connected: z.boolean(),
+    server: z.unknown(),
+    capabilities: z.unknown(),
+    counts: z.unknown(),
+})
+    .passthrough();
+//# sourceMappingURL=items-monitoring.js.map