@ffschrattenecker/tm1-mcp-server 6.0.0

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

@@ -0,0 +1,279 @@
+import { z } from "zod";
+export { IgnoredColumnSchema, ProcessParameterSchema, ProcessVariableSchema, } from "../../schemas/processes.js";
+export declare const ProcessItemSchema: z.ZodObject<{
+    name: z.ZodString;
+    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            Numeric: "Numeric";
+            String: "String";
+        }>;
+        defaultValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        prompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const ProcessCodeSchema: z.ZodObject<{
+    prolog: z.ZodString;
+    metadata: z.ZodString;
+    data: z.ZodString;
+    epilog: z.ZodString;
+    hint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const CompileErrorSchema: z.ZodObject<{
+    lineNumber: z.ZodOptional<z.ZodNumber>;
+    procedure: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export declare const DataSourceSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        None: "None";
+        TM1CubeView: "TM1CubeView";
+        TM1DimensionSubset: "TM1DimensionSubset";
+        ASCII: "ASCII";
+        ODBC: "ODBC";
+        TM1Process: "TM1Process";
+    }>;
+    dataSourceNameForServer: z.ZodOptional<z.ZodString>;
+    dataSourceNameForClient: z.ZodOptional<z.ZodString>;
+    asciiDelimiterType: z.ZodOptional<z.ZodString>;
+    asciiDelimiterChar: z.ZodOptional<z.ZodString>;
+    asciiQuoteCharacter: z.ZodOptional<z.ZodString>;
+    asciiHeaderRecords: z.ZodOptional<z.ZodNumber>;
+    asciiDecimalSeparator: z.ZodOptional<z.ZodString>;
+    asciiThousandSeparator: z.ZodOptional<z.ZodString>;
+    usesUnicode: z.ZodOptional<z.ZodBoolean>;
+    userName: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    view: z.ZodOptional<z.ZodString>;
+    subset: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const GetProcessResultSchema: z.ZodObject<{
+    name: z.ZodString;
+    prolog: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodString>;
+    epilog: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            Numeric: "Numeric";
+            String: "String";
+        }>;
+        defaultValue: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        prompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    variables: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            Numeric: "Numeric";
+            String: "String";
+        }>;
+        position: z.ZodNumber;
+        startByte: z.ZodOptional<z.ZodNumber>;
+        endByte: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    ignoredColumns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        position: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    dataSource: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            None: "None";
+            TM1CubeView: "TM1CubeView";
+            TM1DimensionSubset: "TM1DimensionSubset";
+            ASCII: "ASCII";
+            ODBC: "ODBC";
+            TM1Process: "TM1Process";
+        }>;
+        dataSourceNameForServer: z.ZodOptional<z.ZodString>;
+        dataSourceNameForClient: z.ZodOptional<z.ZodString>;
+        asciiDelimiterType: z.ZodOptional<z.ZodString>;
+        asciiDelimiterChar: z.ZodOptional<z.ZodString>;
+        asciiQuoteCharacter: z.ZodOptional<z.ZodString>;
+        asciiHeaderRecords: z.ZodOptional<z.ZodNumber>;
+        asciiDecimalSeparator: z.ZodOptional<z.ZodString>;
+        asciiThousandSeparator: z.ZodOptional<z.ZodString>;
+        usesUnicode: z.ZodOptional<z.ZodBoolean>;
+        userName: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        query: z.ZodOptional<z.ZodString>;
+        view: z.ZodOptional<z.ZodString>;
+        subset: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    hasSecurityAccess: z.ZodOptional<z.ZodBoolean>;
+    hint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ProcessCodeBundleSchema: z.ZodObject<{
+    name: z.ZodString;
+    hasSecurityAccess: z.ZodBoolean;
+    prolog: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodString>;
+    epilog: z.ZodOptional<z.ZodString>;
+    totalLines: z.ZodOptional<z.ZodNumber>;
+    prologLines: z.ZodOptional<z.ZodNumber>;
+    metadataLines: z.ZodOptional<z.ZodNumber>;
+    dataLines: z.ZodOptional<z.ZodNumber>;
+    epilogLines: z.ZodOptional<z.ZodNumber>;
+    commentLines: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ValidateProcessRefsResultSchema: z.ZodObject<{
+    processName: z.ZodNullable<z.ZodString>;
+    cubeRefsScanned: z.ZodNumber;
+    dimensionRefsScanned: z.ZodNumber;
+    elementRefsScanned: z.ZodNumber;
+    unresolved: z.ZodNumber;
+    issues: z.ZodArray<z.ZodUnknown>;
+    tabsChecked: z.ZodArray<z.ZodString>;
+    unresolvableArgs: z.ZodNumber;
+    partial: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const ProcessResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    outcome: z.ZodEnum<{
+        succeeded: "succeeded";
+        completed_with_errors: "completed_with_errors";
+        rolled_back: "rolled_back";
+        indeterminate: "indeterminate";
+    }>;
+    processErrorStatus: z.ZodString;
+    errorLogFile: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const DiffProcessResultSchema: z.ZodObject<{
+    processName: z.ZodString;
+    identical: z.ZodBoolean;
+    tabs: z.ZodUnknown;
+    parameters: z.ZodUnknown;
+    variables: z.ZodUnknown;
+    ignoredColumns: z.ZodUnknown;
+    dataSource: z.ZodUnknown;
+}, z.core.$loose>;
+export declare const UpsertProcessResultSchema: z.ZodObject<{
+    processName: z.ZodString;
+    action: z.ZodEnum<{
+        created: "created";
+        updated: "updated";
+    }>;
+    appliedSteps: z.ZodArray<z.ZodString>;
+    backup: z.ZodOptional<z.ZodObject<{
+        json: z.ZodString;
+        ti: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+export declare const InstallProBundleResultSchema: z.ZodObject<{
+    directory: z.ZodString;
+    filesFound: z.ZodNumber;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodOptional<z.ZodString>;
+    counts: z.ZodOptional<z.ZodObject<{
+        created: z.ZodNumber;
+        updated: z.ZodNumber;
+        preflight_failed: z.ZodNumber;
+        error: z.ZodNumber;
+        skipped: z.ZodNumber;
+    }, z.core.$strip>>;
+    results: z.ZodArray<z.ZodObject<{
+        file: z.ZodOptional<z.ZodString>;
+        processName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        status: z.ZodString;
+        backup: z.ZodOptional<z.ZodObject<{
+            json: z.ZodString;
+            ti: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const ImportProFileResultSchema: z.ZodObject<{
+    action: z.ZodString;
+    processName: z.ZodString;
+    backup: z.ZodOptional<z.ZodObject<{
+        json: z.ZodString;
+        ti: z.ZodString;
+    }, z.core.$strip>>;
+    parsed: z.ZodObject<{
+        prologLines: z.ZodNumber;
+        metadataLines: z.ZodNumber;
+        dataLines: z.ZodNumber;
+        epilogLines: z.ZodNumber;
+        parameterCount: z.ZodNumber;
+        variableCount: z.ZodNumber;
+        dataSourceType: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ImportProcessFromGitResultSchema: z.ZodObject<{
+    action: z.ZodString;
+    processName: z.ZodString;
+    backup: z.ZodOptional<z.ZodObject<{
+        json: z.ZodString;
+        ti: z.ZodString;
+    }, z.core.$strip>>;
+    hasSecurityAccess: z.ZodOptional<z.ZodBoolean>;
+    parsed: z.ZodObject<{
+        prologLines: z.ZodNumber;
+        metadataLines: z.ZodNumber;
+        dataLines: z.ZodNumber;
+        epilogLines: z.ZodNumber;
+        parameterCount: z.ZodNumber;
+        variableCount: z.ZodNumber;
+        dataSourceType: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const CopyProcessResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    sourceName: z.ZodString;
+    targetName: z.ZodString;
+}, z.core.$strip>;
+export declare const DiffProcessesResultSchema: z.ZodObject<{
+    processA: z.ZodString;
+    processB: z.ZodString;
+    identical: z.ZodBoolean;
+    tabs: z.ZodUnknown;
+    parameters: z.ZodUnknown;
+    variables: z.ZodUnknown;
+    ignoredColumns: z.ZodUnknown;
+    dataSource: z.ZodUnknown;
+}, z.core.$loose>;
+export declare const ProcessesGroupedResultSchema: z.ZodObject<{
+    totalProcesses: z.ZodNumber;
+    groupCount: z.ZodNumber;
+    prefixSegments: z.ZodNumber;
+    groups: z.ZodArray<z.ZodObject<{
+        prefix: z.ZodString;
+        count: z.ZodNumber;
+        processes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const DiagnoseProcessErrorResultSchema: z.ZodObject<{
+    processName: z.ZodString;
+    since: z.ZodNullable<z.ZodString>;
+    logsFound: z.ZodNumber;
+    logsReturned: z.ZodNumber;
+    logs: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const ExportProcessToProResultSchema: z.ZodObject<{
+    processName: z.ZodString;
+    byteLength: z.ZodNumber;
+    writtenTo: z.ZodNullable<z.ZodString>;
+    parameterCount: z.ZodNumber;
+    variableCount: z.ZodNumber;
+    dataSourceType: z.ZodString;
+    credentialsIncluded: z.ZodBoolean;
+    content: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ExportProcessToGitResultSchema: z.ZodObject<{
+    processName: z.ZodString;
+    jsonFileName: z.ZodString;
+    tiFileName: z.ZodString;
+    parameterCount: z.ZodNumber;
+    variableCount: z.ZodNumber;
+    dataSourceType: z.ZodString;
+    credentialsOmitted: z.ZodBoolean;
+    hasSecurityAccess: z.ZodBoolean;
+    writtenTo: z.ZodObject<{
+        json: z.ZodNullable<z.ZodString>;
+        ti: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    json: z.ZodOptional<z.ZodString>;
+    ti: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//# sourceMappingURL=items-processes.d.ts.map

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

@@ -0,0 +1,235 @@
+// Process/TI-domain schemas: parameters, variables, code tabs, datasource,
+// get/execute/diff/upsert/copy results plus .pro & git import/export shapes.
+import { z } from "zod";
+export { IgnoredColumnSchema, ProcessParameterSchema, ProcessVariableSchema, } from "../../schemas/processes.js";
+import { DataSourceSchema as DataSourceBase, IgnoredColumnSchema, ProcessCodeSchema as ProcessCodeBase, ProcessParameterSchema, ProcessSchema, ProcessVariableSchema, } from "../../schemas/processes.js";
+// Omitted when caller passes fields=['name'] to tm1_list_processes.
+export const ProcessItemSchema = ProcessSchema.partial({ parameters: true });
+// `hint` is a tool-side addition: guidance attached when the code could not be
+// read in full, never part of the stored process.
+export const ProcessCodeSchema = ProcessCodeBase.extend({
+    hint: z.string().optional(),
+});
+import { PROCESS_OUTCOME } from "./items-common.js";
+export const CompileErrorSchema = z.object({
+    lineNumber: z.number().int().optional(),
+    procedure: z.string().optional(),
+    message: z.string(),
+});
+// Published as passthrough: `ProcessDataSource` is an OpenType entity, so a
+// server may hand back fields this shape does not model and rejecting them
+// would fail the whole call. The field set itself is the canonical one.
+export const DataSourceSchema = DataSourceBase.passthrough();
+// tm1_get_process — every section is gated by an include-flag, so all fields
+// except `name` are optional. The code tabs sit at the TOP level (the handler
+// spreads them into the payload), not under a `tabs` object.
+export const GetProcessResultSchema = z.object({
+    name: z.string(),
+    prolog: z.string().optional(),
+    metadata: z.string().optional(),
+    data: z.string().optional(),
+    epilog: z.string().optional(),
+    parameters: z.array(ProcessParameterSchema).optional(),
+    variables: z.array(ProcessVariableSchema).optional(),
+    // Datasource columns set to "Ignore": they carry no variable and so are
+    // absent from `variables`, which is what leaves gaps in the positions.
+    ignoredColumns: z.array(IgnoredColumnSchema).optional(),
+    dataSource: DataSourceSchema.optional(),
+    hasSecurityAccess: z.boolean().optional(),
+    hint: z.string().optional(),
+});
+export const ProcessCodeBundleSchema = z.object({
+    name: z.string(),
+    hasSecurityAccess: z.boolean(),
+    // Full mode (default): the four TI tab bodies verbatim (credentials masked
+    // by default via maskSecrets).
+    prolog: z.string().optional(),
+    metadata: z.string().optional(),
+    data: z.string().optional(),
+    epilog: z.string().optional(),
+    // Summary mode (tm1_get_all_processes_code summary=true): tab bodies are
+    // replaced by aggregate line metrics so analysis agents can survey the
+    // process landscape without paying full token cost.
+    totalLines: z.number().int().optional(),
+    prologLines: z.number().int().optional(),
+    metadataLines: z.number().int().optional(),
+    dataLines: z.number().int().optional(),
+    epilogLines: z.number().int().optional(),
+    commentLines: z.number().int().optional(),
+});
+export const ValidateProcessRefsResultSchema = z.object({
+    processName: z.string().nullable(),
+    cubeRefsScanned: z.number().int(),
+    dimensionRefsScanned: z.number().int(),
+    elementRefsScanned: z.number().int(),
+    unresolved: z.number().int(),
+    issues: z.array(z.unknown()),
+    tabsChecked: z.array(z.string()),
+    unresolvableArgs: z.number().int(),
+    partial: z.boolean(),
+});
+// Mirrors the `ProcessResult` union in src/types.ts. The wire schema stays a
+// flat object: an MCP outputSchema has to be a single JSON-Schema object, so
+// the success/outcome correlation cannot be expressed here (a oneOf would not
+// survive the SDK's object-shape requirement). TypeScript enforces the
+// invariant at the producing end; this schema's job is the strict-completeness
+// gate — `outcome` is a field the handler returns, so it must be listed or the
+// SDK rejects the payload at runtime. `outcome: "completed_with_errors"` is
+// the value a reader must not skim past: the run committed what it wrote, so
+// `success: false` there is not licence to re-run.
+export const ProcessResultSchema = z.object({
+    success: z.boolean(),
+    outcome: PROCESS_OUTCOME,
+    processErrorStatus: z.string(),
+    errorLogFile: z.string().optional(),
+});
+// ── Phase 2d: diff/bundle/upsert ─────────────────────────────────────────────
+export const DiffProcessResultSchema = z
+    .object({
+    processName: z.string(),
+    identical: z.boolean(),
+    tabs: z.unknown(),
+    parameters: z.unknown(),
+    variables: z.unknown(),
+    ignoredColumns: z.unknown(),
+    dataSource: z.unknown(),
+})
+    .passthrough();
+// Written by the overwrite tools before they replace an installed process:
+// the tm1-git pair of the previous version, restorable with
+// tm1_import_process_from_git. Absent on a create or with backups off.
+const ProcessBackupSchema = z.object({ json: z.string(), ti: z.string() });
+export const UpsertProcessResultSchema = z
+    .object({
+    processName: z.string(),
+    action: z.enum(["created", "updated"]),
+    appliedSteps: z.array(z.string()),
+    backup: ProcessBackupSchema.optional(),
+})
+    .passthrough();
+const InstallBundleEntrySchema = z
+    .object({
+    file: z.string().optional(),
+    processName: z.string().nullable().optional(),
+    status: z.string(),
+    backup: ProcessBackupSchema.optional(),
+})
+    .passthrough();
+export const InstallProBundleResultSchema = z
+    .object({
+    directory: z.string(),
+    filesFound: z.number().int(),
+    dryRun: z.boolean().optional(),
+    mode: z.string().optional(),
+    counts: z
+        .object({
+        created: z.number().int(),
+        updated: z.number().int(),
+        preflight_failed: z.number().int(),
+        error: z.number().int(),
+        skipped: z.number().int(),
+    })
+        .optional(),
+    results: z.array(InstallBundleEntrySchema),
+})
+    .passthrough();
+export const ImportProFileResultSchema = z.object({
+    action: z.string(),
+    processName: z.string(),
+    backup: ProcessBackupSchema.optional(),
+    parsed: z.object({
+        prologLines: z.number().int(),
+        metadataLines: z.number().int(),
+        dataLines: z.number().int(),
+        epilogLines: z.number().int(),
+        parameterCount: z.number().int(),
+        variableCount: z.number().int(),
+        dataSourceType: z.string(),
+    }),
+});
+// Dedicated schema for tm1_import_process_from_git. Currently identical in
+// shape to ImportProFileResultSchema, but kept separate so the two import
+// paths can diverge (e.g. a .pro-specific field) without one silently
+// rejecting the other's payload. Mirror any git-import handler change here.
+export const ImportProcessFromGitResultSchema = z.object({
+    action: z.string(),
+    processName: z.string(),
+    backup: ProcessBackupSchema.optional(),
+    hasSecurityAccess: z.boolean().optional(),
+    parsed: z.object({
+        prologLines: z.number().int(),
+        metadataLines: z.number().int(),
+        dataLines: z.number().int(),
+        epilogLines: z.number().int(),
+        parameterCount: z.number().int(),
+        variableCount: z.number().int(),
+        dataSourceType: z.string(),
+    }),
+});
+export const CopyProcessResultSchema = z.object({
+    success: z.boolean(),
+    sourceName: z.string(),
+    targetName: z.string(),
+});
+export const DiffProcessesResultSchema = z
+    .object({
+    processA: z.string(),
+    processB: z.string(),
+    identical: z.boolean(),
+    tabs: z.unknown(),
+    parameters: z.unknown(),
+    variables: z.unknown(),
+    ignoredColumns: z.unknown(),
+    dataSource: z.unknown(),
+})
+    .passthrough();
+export const ProcessesGroupedResultSchema = z.object({
+    totalProcesses: z.number().int(),
+    groupCount: z.number().int(),
+    prefixSegments: z.number().int(),
+    groups: z.array(z.object({
+        prefix: z.string(),
+        count: z.number().int(),
+        processes: z.array(z.string()).optional(),
+    })),
+});
+export const DiagnoseProcessErrorResultSchema = z.object({
+    processName: z.string(),
+    since: z.string().nullable(),
+    logsFound: z.number().int(),
+    logsReturned: z.number().int(),
+    logs: z.array(z.unknown()),
+});
+export const ExportProcessToProResultSchema = z.object({
+    processName: z.string(),
+    byteLength: z.number().int(),
+    writtenTo: z.string().nullable(),
+    parameterCount: z.number().int(),
+    variableCount: z.number().int(),
+    dataSourceType: z.string(),
+    // True only on v12, the only version whose credential survives export.
+    credentialsIncluded: z.boolean(),
+    // Omitted when credentials were exported — the body then only exists on disk
+    // so the password cannot reach the caller or the model.
+    content: z.string().optional(),
+});
+export const ExportProcessToGitResultSchema = z.object({
+    processName: z.string(),
+    jsonFileName: z.string(),
+    tiFileName: z.string(),
+    parameterCount: z.number().int(),
+    variableCount: z.number().int(),
+    dataSourceType: z.string(),
+    credentialsOmitted: z.boolean(),
+    hasSecurityAccess: z.boolean(),
+    writtenTo: z.object({
+        json: z.string().nullable(),
+        ti: z.string().nullable(),
+    }),
+    // Full file bodies are echoed inline only when writeToDir is NOT set; when
+    // exporting to disk the caller already has the files, so we omit them to
+    // avoid flooding the context window with duplicate code.
+    json: z.string().optional(),
+    ti: z.string().optional(),
+});
+//# sourceMappingURL=items-processes.js.map

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

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const ChoreItemSchema: z.ZodObject<{
+    name: z.ZodString;
+    active: z.ZodBoolean;
+    startTime: z.ZodString;
+    frequency: z.ZodString;
+    processes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        parameters: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    }, z.core.$strip>>>;
+    processCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const ChoreResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    outcome: z.ZodEnum<{
+        succeeded: "succeeded";
+        completed_with_errors: "completed_with_errors";
+        rolled_back: "rolled_back";
+        indeterminate: "indeterminate";
+    }>;
+    choreErrorStatus: z.ZodString;
+    errorLogFile: z.ZodOptional<z.ZodString>;
+    statusUnavailable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+//# sourceMappingURL=items-scheduling.d.ts.map

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

@@ -0,0 +1,26 @@
+// Scheduling-domain schemas: chore list item for tm1_list_chores, run result
+// for tm1_execute_chore.
+import { z } from "zod";
+import { ChoreSchema } from "../../schemas/scheduling.js";
+import { CHORE_OUTCOME } from "./items-common.js";
+// In compact mode (tm1_list_chores compact=true) the full processes[] array is
+// replaced by processCount, so both are optional at schema level; the tool
+// guarantees exactly one is present.
+export const ChoreItemSchema = ChoreSchema.partial({ processes: true }).extend({
+    processCount: z.number().int().optional(),
+});
+// Result of tm1_execute_chore. `choreErrorStatus` carries TM1's raw
+// ChoreExecuteStatusCode, or — when the outcome is indeterminate — the reason
+// it is unknown, since there is no separate hint field.
+export const ChoreResultSchema = z.object({
+    success: z.boolean(),
+    outcome: CHORE_OUTCOME,
+    choreErrorStatus: z.string(),
+    // Present on every v12 chore run, successful ones included: a chore always
+    // writes a ChoreLog. Its presence is not a failure signal.
+    errorLogFile: z.string().optional(),
+    // true = the server cannot report chore status at all (v11, and v12 before
+    // 12.5.0). The chore ran; how it ended is unknown.
+    statusUnavailable: z.boolean().optional(),
+});
+//# sourceMappingURL=items-scheduling.js.map

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

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const ClientItemSchema: z.ZodObject<{
+    Name: z.ZodString;
+    FriendlyName: z.ZodOptional<z.ZodString>;
+    Type: z.ZodOptional<z.ZodString>;
+    Enabled: z.ZodOptional<z.ZodBoolean>;
+    Groups: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        Name: z.ZodString;
+    }, z.core.$strip>>>;
+    groupCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const GroupItemSchema: z.ZodObject<{
+    Name: z.ZodString;
+    Clients: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        Name: z.ZodString;
+    }, z.core.$strip>>>;
+    clientCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+//# sourceMappingURL=items-security.d.ts.map

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

@@ -0,0 +1,12 @@
+// Security-domain schemas: client and group list items.
+import { z } from "zod";
+import { ClientSchema, GroupSchema } from "../../schemas/security.js";
+// The list tools add a count field in compact mode; passthrough because the
+// security entities carry server-specific extras.
+export const ClientItemSchema = ClientSchema.extend({
+    groupCount: z.number().int().optional(),
+}).passthrough();
+export const GroupItemSchema = GroupSchema.extend({
+    clientCount: z.number().int().optional(),
+}).passthrough();
+//# sourceMappingURL=items-security.js.map

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

@@ -0,0 +1,2 @@
+export { SubsetSchema } from "../../schemas/subsets.js";
+//# sourceMappingURL=items-subsets.d.ts.map

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

@@ -0,0 +1,4 @@
+// Subset-domain schema: list item for tm1_list_subsets / tm1_get_subset.
+// Canonical definition lives in src/schemas/subsets.ts.
+export { SubsetSchema } from "../../schemas/subsets.js";
+//# sourceMappingURL=items-subsets.js.map

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

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export declare const ViewItemSchema: z.ZodObject<{
+    name: z.ZodString;
+    mdx: z.ZodOptional<z.ZodString>;
+    private: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const ViewDefinitionResultSchema: z.ZodObject<{
+    cubeName: z.ZodString;
+    viewName: z.ZodString;
+    private: z.ZodBoolean;
+    type: z.ZodEnum<{
+        MDX: "MDX";
+        Native: "Native";
+    }>;
+    mdx: z.ZodOptional<z.ZodString>;
+    native: z.ZodOptional<z.ZodObject<{
+        titles: z.ZodArray<z.ZodObject<{
+            dimensionName: z.ZodOptional<z.ZodString>;
+            hierarchyName: z.ZodOptional<z.ZodString>;
+            subsetName: z.ZodOptional<z.ZodString>;
+            expression: z.ZodOptional<z.ZodString>;
+            selectedElement: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        columns: z.ZodArray<z.ZodObject<{
+            dimensionName: z.ZodOptional<z.ZodString>;
+            hierarchyName: z.ZodOptional<z.ZodString>;
+            subsetName: z.ZodOptional<z.ZodString>;
+            expression: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        rows: z.ZodArray<z.ZodObject<{
+            dimensionName: z.ZodOptional<z.ZodString>;
+            hierarchyName: z.ZodOptional<z.ZodString>;
+            subsetName: z.ZodOptional<z.ZodString>;
+            expression: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+//# sourceMappingURL=items-views.d.ts.map

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

@@ -0,0 +1,26 @@
+// View-domain schemas: list item and the view-definition (MDX/Native) result.
+import { z } from "zod";
+import { ViewAxisSubsetRefSchema } from "../../schemas/views.js";
+export const ViewItemSchema = z.object({
+    name: z.string(),
+    mdx: z.string().optional(),
+    private: z.boolean(),
+});
+const ViewTitleRefSchema = ViewAxisSubsetRefSchema.extend({
+    selectedElement: z.string().optional(),
+});
+export const ViewDefinitionResultSchema = z.object({
+    cubeName: z.string(),
+    viewName: z.string(),
+    private: z.boolean(),
+    type: z.enum(["MDX", "Native"]),
+    mdx: z.string().optional(),
+    native: z
+        .object({
+        titles: z.array(ViewTitleRefSchema),
+        columns: z.array(ViewAxisSubsetRefSchema),
+        rows: z.array(ViewAxisSubsetRefSchema),
+    })
+        .optional(),
+});
+//# sourceMappingURL=items-views.js.map