coalesce-transform-mcp 0.1.0

package/dist/services/templates/nodes.js

@@ -0,0 +1,336 @@
+import { sanitizeNodeDefinitionSqlOverridePolicy } from "../policies/sql-override.js";
+import { isPlainObject } from "../../utils.js";
+function getString(value) {
+    return typeof value === "string" ? value : null;
+}
+function getFirstOptionValue(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        return undefined;
+    }
+    const [first] = value;
+    if (isPlainObject(first) &&
+        Object.prototype.hasOwnProperty.call(first, "value")) {
+        return first.value;
+    }
+    return first;
+}
+function cloneValue(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function inferDefaultValue(item) {
+    if (Object.prototype.hasOwnProperty.call(item, "default")) {
+        return cloneValue(item.default);
+    }
+    const type = getString(item.type);
+    switch (type) {
+        case "materializationSelector":
+            return getFirstOptionValue(item.options) ?? "table";
+        case "multisourceToggle":
+            return false;
+        case "overrideSQLToggle":
+            return false;
+        case "toggleButton":
+            return false;
+        case "textBox":
+            return "";
+        case "dropdownSelector":
+            return getFirstOptionValue(item.options);
+        default:
+            return undefined;
+    }
+}
+function inferTargetMappings(item) {
+    const type = getString(item.type);
+    const attributeName = getString(item.attributeName);
+    switch (type) {
+        case "materializationSelector": {
+            const mappings = [
+                {
+                    targetPath: "materializationType",
+                    note: "Built-in selector maps to the top-level node materialization field.",
+                },
+            ];
+            if (attributeName) {
+                mappings.push({
+                    targetPath: `config.${attributeName}`,
+                    note: "Built-in selector also persists under config.<attributeName> when the definition supplies a custom attributeName.",
+                });
+            }
+            return mappings;
+        }
+        case "multisourceToggle": {
+            const mappings = [
+                {
+                    targetPath: "isMultisource",
+                    note: "Built-in toggle maps to the top-level multisource flag.",
+                },
+            ];
+            if (attributeName) {
+                mappings.push({
+                    targetPath: `config.${attributeName}`,
+                    note: "Built-in toggle also persists under config.<attributeName> when the definition supplies a custom attributeName.",
+                });
+            }
+            return mappings;
+        }
+        case "overrideSQLToggle": {
+            const mappings = [
+                {
+                    targetPath: "overrideSQL",
+                    note: "Built-in toggle maps to the top-level override SQL flag.",
+                },
+            ];
+            if (attributeName) {
+                mappings.push({
+                    targetPath: `config.${attributeName}`,
+                    note: "Built-in toggle also persists under config.<attributeName> when the definition supplies a custom attributeName.",
+                });
+            }
+            return mappings;
+        }
+        case "columnSelector":
+            if (attributeName) {
+                return [
+                    {
+                        targetPath: `columns[].${attributeName}`,
+                        note: `Column-level attribute. Set "${attributeName}: true" on each column object in metadata.columns that should be selected. Look up the attributeName in the node type definition file under nodeTypes/ in the local repo.`,
+                    },
+                ];
+            }
+            return [
+                {
+                    targetPath: null,
+                    note: "columnSelector without attributeName — cannot determine column-level target.",
+                },
+            ];
+        default:
+            if (attributeName) {
+                return [
+                    {
+                        targetPath: `config.${attributeName}`,
+                        note: "Generic node-definition input maps into the hydrated config object.",
+                    },
+                ];
+            }
+            return [
+                {
+                    targetPath: null,
+                    note: "No attributeName or built-in target mapping was found for this item.",
+                },
+            ];
+    }
+}
+function setByPath(target, path, value) {
+    const parts = path.split(".");
+    let cursor = target;
+    for (let index = 0; index < parts.length - 1; index += 1) {
+        const part = parts[index];
+        const current = cursor[part];
+        if (!isPlainObject(current)) {
+            cursor[part] = {};
+        }
+        cursor = cursor[part];
+    }
+    cursor[parts[parts.length - 1]] = value;
+}
+function getByPath(source, path) {
+    const parts = path.split(".");
+    let current = source;
+    for (const part of parts) {
+        if (!isPlainObject(current) || !(part in current)) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+export function buildSetWorkspaceNodeTemplateFromDefinition(nodeDefinition, options = {}) {
+    const sanitizedDefinition = sanitizeNodeDefinitionSqlOverridePolicy(nodeDefinition);
+    const configGroups = Array.isArray(sanitizedDefinition.nodeDefinition.config)
+        ? sanitizedDefinition.nodeDefinition.config.filter(isPlainObject)
+        : [];
+    const configItemCount = configGroups.reduce((count, group) => {
+        const items = Array.isArray(group.items) ? group.items.filter(isPlainObject) : [];
+        return count + items.length;
+    }, 0);
+    const fieldMappings = [];
+    const inferredTopLevelFields = {};
+    const inferredConfig = {};
+    const warnings = [...sanitizedDefinition.warnings];
+    configGroups.forEach((group, groupIndex) => {
+        const groupName = getString(group.groupName);
+        const items = Array.isArray(group.items) ? group.items.filter(isPlainObject) : [];
+        items.forEach((item, itemIndex) => {
+            const defaultValue = inferDefaultValue(item);
+            const targetMappings = inferTargetMappings(item);
+            targetMappings.forEach(({ targetPath, note }) => {
+                const mapping = {
+                    groupIndex,
+                    itemIndex,
+                    groupName,
+                    itemType: getString(item.type),
+                    displayName: getString(item.displayName),
+                    attributeName: getString(item.attributeName),
+                    targetPath,
+                    defaultValue,
+                    enableIf: getString(item.enableIf),
+                    note,
+                };
+                fieldMappings.push(mapping);
+                if (!targetPath) {
+                    warnings.push(`Config item ${groupIndex}.${itemIndex} (${getString(item.type) ?? "unknown"}) does not map cleanly to set-workspace-node body fields.`);
+                    return;
+                }
+                if (defaultValue === undefined) {
+                    warnings.push(`Config item ${targetPath} has no inferred default. Fill it before calling set-workspace-node if the node type requires it.`);
+                    return;
+                }
+                if (targetPath.startsWith("config.")) {
+                    setByPath(inferredConfig, targetPath.replace(/^config\./u, ""), defaultValue);
+                    return;
+                }
+                setByPath(inferredTopLevelFields, targetPath, defaultValue);
+            });
+        });
+    });
+    const capitalized = getString(sanitizedDefinition.nodeDefinition.capitalized);
+    const short = getString(sanitizedDefinition.nodeDefinition.short);
+    const plural = getString(sanitizedDefinition.nodeDefinition.plural);
+    const tagColor = getString(sanitizedDefinition.nodeDefinition.tagColor);
+    const defaultNodeName = options.nodeName ??
+        (short ? `${short}_NODE` : capitalized ? `${capitalized.toUpperCase()}_NODE` : "NEW_NODE");
+    const nodeType = options.nodeType ?? capitalized ?? "Stage";
+    const setWorkspaceNodeBodyTemplate = {
+        name: defaultNodeName,
+        description: "",
+        nodeType,
+        ...(options.database !== undefined ? { database: options.database } : {}),
+        ...(options.schema !== undefined ? { schema: options.schema } : {}),
+        ...(options.locationName !== undefined
+            ? { locationName: options.locationName }
+            : {}),
+        ...inferredTopLevelFields,
+        config: inferredConfig,
+        metadata: {
+            columns: [],
+            sourceMapping: [],
+            cteString: "",
+            appliedNodeTests: [],
+            enabledColumnTestIDs: [],
+        },
+    };
+    return {
+        definitionSummary: {
+            capitalized,
+            short,
+            plural,
+            tagColor,
+            configGroupCount: configGroups.length,
+            configItemCount,
+        },
+        fieldMappings,
+        inferredTopLevelFields,
+        inferredConfig,
+        setWorkspaceNodeBodyTemplate,
+        usageGuidance: [
+            "Use create-workspace-node-from-predecessor or create-workspace-node-from-scratch first to get a real workspace node ID.",
+            "Fill metadata.columns and metadata.sourceMapping before calling set-workspace-node; those arrays are replace-on-write.",
+            "Keep materializationType and isMultisource at the top level when the definition uses the built-in selector/toggle items.",
+            "Keep generic definition attributes under config.<attributeName>.",
+            "If a built-in selector or toggle also defines attributeName, mirror the same value under both the top-level field and config.<attributeName>.",
+            "For columnSelector items (e.g., isBusinessKey, isChangeTracking), set the attributeName as a boolean directly on each column in metadata.columns — e.g., { name: 'CUSTOMER_ID', isBusinessKey: true, ... }. Look up attribute names in the node type definition file under nodeTypes/ in the local repo.",
+            "Do not add overrideSQL or override.* fields; SQL override is intentionally disallowed in this project.",
+        ],
+        warnings,
+    };
+}
+export function compareGeneratedTemplateToWorkspaceNode(generated, workspaceNode) {
+    const checks = generated.fieldMappings
+        .filter((mapping) => mapping.targetPath)
+        .map((mapping) => {
+        const targetPath = mapping.targetPath;
+        const actualValue = getByPath(workspaceNode, targetPath);
+        const inferredDefault = mapping.defaultValue;
+        if (actualValue === undefined) {
+            return {
+                targetPath,
+                inferredDefault,
+                actualValue: undefined,
+                status: "missing",
+            };
+        }
+        return {
+            targetPath,
+            inferredDefault,
+            actualValue,
+            status: JSON.stringify(actualValue) === JSON.stringify(inferredDefault)
+                ? "matched"
+                : "mismatched",
+        };
+    });
+    return {
+        checkedFieldCount: checks.length,
+        matchedFieldCount: checks.filter((check) => check.status === "matched").length,
+        mismatchedFieldCount: checks.filter((check) => check.status === "mismatched").length,
+        missingFieldCount: checks.filter((check) => check.status === "missing").length,
+        fields: checks,
+    };
+}
+function stringifyYamlScalar(value) {
+    if (typeof value === "string") {
+        if (value.length === 0) {
+            return '""';
+        }
+        if (/^[A-Za-z0-9_.-]+$/u.test(value)) {
+            return value;
+        }
+        return JSON.stringify(value);
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    if (value === null) {
+        return "null";
+    }
+    return JSON.stringify(value);
+}
+function renderYamlValue(value, indentLevel) {
+    const indent = "  ".repeat(indentLevel);
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return [`${indent}[]`];
+        }
+        const lines = [];
+        value.forEach((entry) => {
+            if (Array.isArray(entry) || isPlainObject(entry)) {
+                lines.push(`${indent}-`);
+                lines.push(...renderYamlValue(entry, indentLevel + 1));
+            }
+            else {
+                lines.push(`${indent}- ${stringifyYamlScalar(entry)}`);
+            }
+        });
+        return lines;
+    }
+    if (isPlainObject(value)) {
+        const entries = Object.entries(value);
+        if (entries.length === 0) {
+            return [`${indent}{}`];
+        }
+        const lines = [];
+        for (const [key, entryValue] of entries) {
+            if (Array.isArray(entryValue) || isPlainObject(entryValue)) {
+                lines.push(`${indent}${key}:`);
+                lines.push(...renderYamlValue(entryValue, indentLevel + 1));
+            }
+            else {
+                lines.push(`${indent}${key}: ${stringifyYamlScalar(entryValue)}`);
+            }
+        }
+        return lines;
+    }
+    return [`${indent}${stringifyYamlScalar(value)}`];
+}
+export function renderYaml(value) {
+    return `${renderYamlValue(value, 0).join("\n")}\n`;
+}

package/dist/services/workspace/analysis.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Workspace analysis functions for detecting patterns in Coalesce workspace nodes.
+ * All functions are pure (no I/O) and operate on node data arrays.
+ */
+export interface NodeSummary {
+    nodeType: string;
+    name: string;
+    predecessors?: string[];
+}
+export interface PackageDetectionResult {
+    packages: string[];
+    packageAdoption: Record<string, boolean>;
+    builtInTypes: string[];
+}
+/**
+ * Detect package usage patterns in a workspace by scanning observed node type prefixes.
+ * Presence of any node with a package prefix is strong evidence the package is installed and in use,
+ * but absence is not a reliable negative signal because this is not an installed-type registry.
+ */
+export declare function detectPackages(nodes: NodeSummary[]): PackageDetectionResult;
+export type NodeLayer = "bronze" | "staging" | "intermediate" | "mart" | "unknown";
+export interface LayerSummary {
+    nodeTypes: string[];
+    count: number;
+}
+export interface LayerAnalysis {
+    bronze: LayerSummary;
+    staging: LayerSummary;
+    intermediate: LayerSummary;
+    mart: LayerSummary;
+    unknown: LayerSummary;
+}
+export declare function inferNodeLayer(node: NodeSummary): NodeLayer;
+export declare function inferLayers(nodes: NodeSummary[]): LayerAnalysis;
+export type Methodology = "kimball" | "data-vault" | "dbt-style" | "mixed";
+export declare function detectMethodology(nodes: NodeSummary[]): Methodology;
+export interface WorkspaceProfile {
+    workspaceID: string;
+    analyzedAt: string;
+    nodeCount: number;
+    packageAdoption: PackageDetectionResult;
+    layerPatterns: LayerAnalysis;
+    methodology: Methodology;
+    recommendations: {
+        defaultPackage: string | null;
+        stagingType: string;
+        transformType: string;
+        dimensionType: string;
+        factType: string;
+    };
+}
+/**
+ * Build a complete workspace profile from a list of nodes.
+ * This is the main entry point for workspace analysis.
+ */
+export declare function buildWorkspaceProfile(workspaceID: string, nodes: NodeSummary[]): WorkspaceProfile;

package/dist/services/workspace/analysis.js

@@ -0,0 +1,151 @@
+/**
+ * Workspace analysis functions for detecting patterns in Coalesce workspace nodes.
+ * All functions are pure (no I/O) and operate on node data arrays.
+ */
+/**
+ * Detect package usage patterns in a workspace by scanning observed node type prefixes.
+ * Presence of any node with a package prefix is strong evidence the package is installed and in use,
+ * but absence is not a reliable negative signal because this is not an installed-type registry.
+ */
+export function detectPackages(nodes) {
+    const packageSet = new Set();
+    const builtInSet = new Set();
+    for (const node of nodes) {
+        const separatorIndex = node.nodeType.indexOf(":::");
+        if (separatorIndex > 0) {
+            packageSet.add(node.nodeType.substring(0, separatorIndex));
+        }
+        else {
+            builtInSet.add(node.nodeType);
+        }
+    }
+    const packages = Array.from(packageSet).sort();
+    const packageAdoption = {};
+    for (const pkg of packages) {
+        packageAdoption[pkg] = true;
+    }
+    return {
+        packages,
+        packageAdoption,
+        builtInTypes: Array.from(builtInSet).sort(),
+    };
+}
+const LAYER_NAME_PATTERNS = [
+    [/^(RAW_|SRC_|LANDING_|L0_)/i, "bronze"],
+    [/^(STG_|STAGE_|CLEAN_|L1_)/i, "staging"],
+    [/^(INT_|TMP_|WORK_|TRANSFORM_)/i, "intermediate"],
+    [/^(DIM_|DIMENSION_|FACT_|FCT_|MART_|RPT_)/i, "mart"],
+];
+const MART_NODE_TYPES = new Set(["Dimension", "Fact"]);
+export function inferNodeLayer(node) {
+    const upperName = node.name.toUpperCase();
+    for (const [pattern, layer] of LAYER_NAME_PATTERNS) {
+        if (pattern.test(upperName)) {
+            return layer;
+        }
+    }
+    const baseType = node.nodeType.includes(":::")
+        ? node.nodeType.split(":::")[1]
+        : node.nodeType;
+    if (MART_NODE_TYPES.has(baseType)) {
+        return "mart";
+    }
+    return "unknown";
+}
+export function inferLayers(nodes) {
+    const layers = {
+        bronze: { types: new Set(), count: 0 },
+        staging: { types: new Set(), count: 0 },
+        intermediate: { types: new Set(), count: 0 },
+        mart: { types: new Set(), count: 0 },
+        unknown: { types: new Set(), count: 0 },
+    };
+    for (const node of nodes) {
+        const layer = inferNodeLayer(node);
+        layers[layer].types.add(node.nodeType);
+        layers[layer].count += 1;
+    }
+    const toSummary = (entry) => ({
+        nodeTypes: Array.from(entry.types).sort(),
+        count: entry.count,
+    });
+    return {
+        bronze: toSummary(layers.bronze),
+        staging: toSummary(layers.staging),
+        intermediate: toSummary(layers.intermediate),
+        mart: toSummary(layers.mart),
+        unknown: toSummary(layers.unknown),
+    };
+}
+export function detectMethodology(nodes) {
+    if (nodes.length === 0) {
+        return "mixed";
+    }
+    const upperNames = nodes.map((n) => n.name.toUpperCase());
+    // Data Vault signals: HUB_, SAT_, LINK_ naming
+    const hubCount = upperNames.filter((n) => /^HUB_|_HUB$/.test(n)).length;
+    const satCount = upperNames.filter((n) => /^SAT_|_SAT$/.test(n)).length;
+    const linkCount = upperNames.filter((n) => /^LINK_|_LINK$/.test(n)).length;
+    if (hubCount >= 1 && satCount >= 1) {
+        return "data-vault";
+    }
+    // Kimball signals: DIM_/FACT_ naming or Dimension/Fact node types
+    const dimCount = nodes.filter((n) => /^DIM_|^DIMENSION_/i.test(n.name) ||
+        n.nodeType === "Dimension" ||
+        n.nodeType.endsWith(":::Dimension")).length;
+    const factCount = nodes.filter((n) => /^FACT_|^FCT_/i.test(n.name) ||
+        n.nodeType === "Fact" ||
+        n.nodeType.endsWith(":::Fact")).length;
+    if (dimCount >= 1 && factCount >= 1) {
+        return "kimball";
+    }
+    // dbt-style signals: stg_/int_/fct_ lowercase naming with view intermediates
+    const stgCount = nodes.filter((n) => /^stg_/i.test(n.name)).length;
+    const intCount = nodes.filter((n) => /^int_/i.test(n.name)).length;
+    if (stgCount >= 1 && intCount >= 1) {
+        return "dbt-style";
+    }
+    return "mixed";
+}
+/**
+ * Build a complete workspace profile from a list of nodes.
+ * This is the main entry point for workspace analysis.
+ */
+export function buildWorkspaceProfile(workspaceID, nodes) {
+    const packageAdoption = detectPackages(nodes);
+    const layerPatterns = inferLayers(nodes);
+    const methodology = detectMethodology(nodes);
+    const preferredPackage = packageAdoption.packages.includes("base-nodes")
+        ? "base-nodes"
+        : packageAdoption.packages[0] ?? null;
+    const prefix = preferredPackage ? `${preferredPackage}:::` : "";
+    const findDominantType = (layer, fallback) => {
+        if (layer.nodeTypes.length === 0) {
+            return prefix ? `${prefix}${fallback}` : fallback;
+        }
+        // Prefer the packaged version matching fallback, then any packaged, then matching built-in, then first
+        const packagedMatch = layer.nodeTypes.find((t) => t.includes(":::") && t.endsWith(`:::${fallback}`));
+        if (packagedMatch)
+            return packagedMatch;
+        const builtInMatch = layer.nodeTypes.find((t) => t === fallback);
+        if (builtInMatch)
+            return builtInMatch;
+        const packaged = layer.nodeTypes.find((t) => t.includes(":::"));
+        return packaged ?? layer.nodeTypes[0];
+    };
+    return {
+        workspaceID,
+        analyzedAt: new Date().toISOString(),
+        nodeCount: nodes.length,
+        packageAdoption,
+        layerPatterns,
+        methodology,
+        recommendations: {
+            defaultPackage: preferredPackage,
+            stagingType: findDominantType(layerPatterns.staging, "Stage"),
+            transformType: findDominantType(layerPatterns.intermediate, "View"),
+            dimensionType: findDominantType(layerPatterns.mart, "Dimension"),
+            factType: findDominantType(layerPatterns.mart, "Fact"),
+        },
+    };
+}

package/dist/services/workspace/mutations.d.ts

@@ -0,0 +1,150 @@
+import type { CoalesceClient } from "../../client.js";
+import { type ConfigCompletionResult } from "../config/intelligent.js";
+type ScratchNodeCompletionLevel = "created" | "named" | "configured";
+export type WorkspaceNodeChanges = Record<string, unknown>;
+export declare function buildUpdatedWorkspaceNodeBody(current: unknown, changes: WorkspaceNodeChanges): Record<string, unknown>;
+type JoinColumnSuggestion = {
+    normalizedName: string;
+    leftColumnName: string;
+    rightColumnName: string;
+};
+type JoinSuggestion = {
+    leftPredecessorNodeID: string;
+    leftPredecessorName: string | null;
+    rightPredecessorNodeID: string;
+    rightPredecessorName: string | null;
+    commonColumns: JoinColumnSuggestion[];
+};
+type GroupByAnalysis = {
+    groupByColumns: string[];
+    aggregateColumns: {
+        name: string;
+        transform: string;
+    }[];
+    hasAggregates: boolean;
+    groupByClause: string;
+    validation: {
+        valid: boolean;
+        errors: string[];
+    };
+};
+export declare function updateWorkspaceNode(client: CoalesceClient, params: {
+    workspaceID: string;
+    nodeID: string;
+    changes: Record<string, unknown>;
+}): Promise<unknown>;
+export declare function replaceWorkspaceNodeColumns(client: CoalesceClient, params: {
+    workspaceID: string;
+    nodeID: string;
+    columns: unknown[];
+    whereCondition?: string;
+    additionalChanges?: Record<string, unknown>;
+}): Promise<unknown>;
+export declare function createWorkspaceNodeFromScratch(client: CoalesceClient, params: {
+    workspaceID: string;
+    nodeType: string;
+    completionLevel?: ScratchNodeCompletionLevel;
+    name?: string;
+    description?: string;
+    storageLocations?: unknown[];
+    config?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    changes?: Record<string, unknown>;
+    repoPath?: string;
+    goal?: string;
+}): Promise<unknown>;
+export declare function createWorkspaceNodeFromPredecessor(client: CoalesceClient, params: {
+    workspaceID: string;
+    nodeType: string;
+    predecessorNodeIDs: string[];
+    changes?: Record<string, unknown>;
+    repoPath?: string;
+    goal?: string;
+    /** Replace auto-populated columns with these specific columns+transforms in a single call. */
+    columns?: Array<{
+        name: string;
+        transform?: string;
+        dataType?: string;
+        description?: string;
+    }>;
+    /** WHERE filter to append to the joinCondition. Only valid with `columns`, not with aggregation. */
+    whereCondition?: string;
+    /** GROUP BY columns for aggregation. Must be provided with `aggregates`. */
+    groupByColumns?: string[];
+    /** Aggregate columns. Must be provided with `groupByColumns`. */
+    aggregates?: Array<{
+        name: string;
+        function: string;
+        expression: string;
+        description?: string;
+    }>;
+    /** JOIN type for aggregation nodes. Only used with groupByColumns/aggregates. */
+    joinType?: "INNER JOIN" | "LEFT JOIN" | "RIGHT JOIN" | "FULL OUTER JOIN";
+}): Promise<unknown>;
+export declare function convertJoinToAggregation(client: CoalesceClient, params: {
+    workspaceID: string;
+    nodeID: string;
+    groupByColumns: string[];
+    aggregates: Array<{
+        name: string;
+        function: string;
+        expression: string;
+        description?: string;
+    }>;
+    joinType?: "INNER JOIN" | "LEFT JOIN" | "RIGHT JOIN" | "FULL OUTER JOIN";
+    maintainJoins?: boolean;
+    repoPath?: string;
+}): Promise<{
+    node: unknown;
+    joinSQL: {
+        fromClause: string;
+        joinClauses: string[];
+        fullSQL: string;
+        warnings: string[];
+    };
+    groupByAnalysis: GroupByAnalysis;
+    validation: {
+        valid: boolean;
+        warnings: string[];
+    };
+    configCompletion?: ConfigCompletionResult;
+    configCompletionSkipped?: string;
+}>;
+export declare function applyJoinCondition(client: CoalesceClient, params: {
+    workspaceID: string;
+    nodeID: string;
+    joinType?: "INNER JOIN" | "LEFT JOIN" | "RIGHT JOIN" | "FULL OUTER JOIN";
+    whereClause?: string;
+    qualifyClause?: string;
+    joinColumnOverrides?: Array<{
+        leftPredecessor: string;
+        rightPredecessor: string;
+        leftColumn: string;
+        rightColumn: string;
+    }>;
+}): Promise<{
+    joinCondition: string;
+    joinSuggestions: JoinSuggestion[];
+    predecessors: Array<{
+        nodeID: string;
+        nodeName: string;
+        locationName: string;
+        columnCount: number;
+    }>;
+    warnings: string[];
+}>;
+/**
+ * Returns the distinct node types observed in existing workspace nodes.
+ * This is intentionally observation-based and should not be treated as a true
+ * installed-type registry for the workspace.
+ */
+export declare function listWorkspaceNodeTypes(client: CoalesceClient, params: {
+    workspaceID: string;
+}): Promise<{
+    workspaceID: string;
+    basis: "observed_nodes";
+    nodeTypes: string[];
+    counts: Record<string, number>;
+    total: number;
+}>;
+export {};