@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/node_modules/@ktx/context/dist/sl/tools/sl-warehouse-validation.js

@@ -0,0 +1,238 @@
+import YAML from 'yaml';
+import { SYSTEM_GIT_AUTHOR } from '../../tools/index.js';
+import { sourceOverlaySchema } from '../schemas.js';
+import { SemanticLayerService } from '../semantic-layer.service.js';
+import { sourceDefinitionSchema } from './base-semantic-layer.tool.js';
+const slSourcePath = (connectionId, sourceName) => `semantic-layer/${connectionId}/${sourceName}.yaml`;
+function resolveDialect(warehouse) {
+    if (!warehouse) {
+        return null;
+    }
+    return SemanticLayerService.mapDialect(warehouse);
+}
+function wrapWithZeroRowQuery(sql, dialect) {
+    if (dialect === 'tsql') {
+        return `SELECT TOP 0 * FROM (${sql}) AS _discovery`;
+    }
+    return `SELECT * FROM (${sql}) AS _discovery LIMIT 0`;
+}
+function wrapWithSingleRowQuery(sql, dialect) {
+    if (dialect === 'tsql') {
+        return `SELECT TOP 1 * FROM (${sql}) AS _base`;
+    }
+    return `SELECT * FROM (${sql}) AS _base LIMIT 1`;
+}
+/**
+ * Validate one SL source end-to-end: YAML parse, Zod schema, duplicate-measure detection,
+ * warehouse dry-run (`SELECT * FROM (sql) LIMIT 1` — forces runtime policy enforcement).
+ *
+ * Returns errors and hint-style warnings. An empty errors array means the YAML is
+ * structurally valid AND the warehouse can execute a probe against its embedded sql.
+ */
+export async function validateSingleSource(deps, connectionId, sourceName) {
+    const errors = [];
+    const warnings = [];
+    let content;
+    try {
+        const result = await deps.semanticLayerService.readSourceFile(connectionId, sourceName);
+        content = result.content;
+    }
+    catch {
+        errors.push(`${sourceName}.yaml: file not found`);
+        return { errors, warnings };
+    }
+    let parsed;
+    try {
+        parsed = YAML.parse(content);
+    }
+    catch (e) {
+        errors.push(`${sourceName}.yaml: invalid YAML — ${e instanceof Error ? e.message : String(e)}`);
+        return { errors, warnings };
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        errors.push(`${sourceName}.yaml: top-level content is not an object`);
+        return { errors, warnings };
+    }
+    const isOverlay = !parsed.table && !parsed.sql;
+    if (!isOverlay) {
+        const isManifestBacked = await deps.semanticLayerService.isManifestBacked(connectionId, sourceName);
+        if (isManifestBacked) {
+            errors.push(`${sourceName}.yaml: standalone source shadows an existing manifest entry — ` +
+                `writing it as-is drops the manifest's columns and joins. ` +
+                `Remove "sql:", "table:", "grain:", "columns:", and "joins:" and keep only ` +
+                `"name:" plus "measures:"/"segments:"/"description:" to write an overlay ` +
+                `that inherits the manifest schema. Call sl_describe_table to see it first.`);
+            return { errors, warnings };
+        }
+    }
+    const schema = isOverlay ? sourceOverlaySchema : sourceDefinitionSchema;
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+        const issues = result.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; ');
+        errors.push(`${sourceName}.yaml: schema — ${issues}`);
+        const errorPaths = new Set(result.error.issues.map((i) => String(i.path[0])));
+        if (errorPaths.has('joins')) {
+            warnings.push(`${sourceName}.yaml: hint — join format: {to, on: 'local_col = TARGET.col', relationship: 'many_to_one|one_to_many|one_to_one'}`);
+        }
+        if (errorPaths.has('columns')) {
+            warnings.push(`${sourceName}.yaml: hint — overlay columns must be computed: {name, expr, type}. Do NOT include base table columns.`);
+        }
+        if (errorPaths.has('measures')) {
+            warnings.push(`${sourceName}.yaml: hint — measure format: {name, expr, description (optional), filter (optional)}`);
+        }
+        return { errors, warnings };
+    }
+    const measures = parsed.measures ?? [];
+    const seenMeasures = new Set();
+    for (const m of measures) {
+        if (seenMeasures.has(m.name)) {
+            errors.push(`${sourceName}.yaml: duplicate measure name "${m.name}"`);
+        }
+        seenMeasures.add(m.name);
+    }
+    let warehouse = null;
+    try {
+        const connection = await deps.connections.getConnectionById(connectionId);
+        warehouse = connection?.connectionType ?? null;
+    }
+    catch {
+        warehouse = null;
+    }
+    if (typeof parsed.sql === 'string' && parsed.sql.trim().length > 0) {
+        const innerSql = parsed.sql.trim().replace(/;+\s*$/, '');
+        const probeRowCount = deps.probeRowCount;
+        const dialect = resolveDialect(warehouse);
+        let probeSql;
+        if (dialect) {
+            probeSql =
+                probeRowCount === 0 ? wrapWithZeroRowQuery(innerSql, dialect) : wrapWithSingleRowQuery(innerSql, dialect);
+        }
+        else {
+            probeSql = `SELECT * FROM (${innerSql}) AS _probe LIMIT ${probeRowCount}`;
+        }
+        const sourceColumns = (parsed.columns ?? [])
+            .map((c) => ({ name: c.name ?? '', type: c.type ?? '' }))
+            .filter((c) => c.name);
+        try {
+            const probe = await deps.connections.executeQuery(connectionId, probeSql);
+            const actual = new Set((probe.headers ?? []).map((h) => h.toLowerCase()));
+            const missing = sourceColumns.map((c) => c.name).filter((n) => !actual.has(n.toLowerCase()));
+            if (missing.length > 0) {
+                errors.push(`${sourceName}.yaml: declared columns absent from sql result — ${missing.join(', ')} (warehouse returned: ${[...actual].slice(0, 10).join(', ')}${actual.size > 10 ? ', …' : ''})`);
+            }
+        }
+        catch (e) {
+            errors.push(formatProbeError({
+                sourceName,
+                measureName: null,
+                probeSql,
+                warehouse,
+                sourceColumns,
+                error: e,
+                headline: 'embedded sql dry-run failed',
+            }));
+        }
+    }
+    else if (isOverlay) {
+        const measureErrors = await probeOverlayMeasures(deps, connectionId, sourceName, warehouse);
+        errors.push(...measureErrors);
+    }
+    return { errors, warnings };
+}
+function formatProbeError(args) {
+    const { sourceName, measureName, probeSql, warehouse, sourceColumns, error, headline } = args;
+    const errMsg = error instanceof Error ? error.message : String(error);
+    const refColumns = sourceColumns.filter((c) => referencesColumn(probeSql, c.name));
+    const lines = [
+        measureName ? `${sourceName}.yaml: measure "${measureName}" ${headline}.` : `${sourceName}.yaml: ${headline}.`,
+    ];
+    if (warehouse) {
+        lines.push(`  Warehouse: ${warehouse}`);
+    }
+    lines.push(`  Probe SQL: ${probeSql}`);
+    if (refColumns.length > 0) {
+        lines.push(`  Referenced columns: ${refColumns.map((c) => `${c.name} (${c.type || '?'})`).join(', ')}`);
+    }
+    lines.push(`  Error: ${errMsg}`);
+    return lines.join('\n');
+}
+function referencesColumn(sql, columnName) {
+    if (!columnName) {
+        return false;
+    }
+    const escaped = columnName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`\\b${escaped}\\b`).test(sql);
+}
+async function probeOverlayMeasures(deps, connectionId, sourceName, warehouse) {
+    const errors = [];
+    let composed;
+    try {
+        const all = await deps.semanticLayerService.loadAllSources(connectionId);
+        composed = all.find((s) => s.name === sourceName);
+    }
+    catch (e) {
+        errors.push(`${sourceName}.yaml: failed to load composed source for probe — ${e instanceof Error ? e.message : String(e)}`);
+        return errors;
+    }
+    if (!composed?.table || composed.measures.length === 0) {
+        return errors;
+    }
+    const sourceColumns = (composed.columns ?? [])
+        .map((c) => ({ name: c.name ?? '', type: c.type ?? '' }))
+        .filter((c) => c.name);
+    for (const measure of composed.measures) {
+        const measureRef = `${sourceName}.${measure.name}`;
+        let probeSql = `<composed via semantic-layer engine for ${measureRef}>`;
+        try {
+            const result = await deps.semanticLayerService.executeQuery(connectionId, {
+                measures: [measureRef],
+                dimensions: [],
+                filters: [],
+                limit: 1,
+            });
+            probeSql = result.sql ?? probeSql;
+        }
+        catch (e) {
+            errors.push(formatProbeError({
+                sourceName,
+                measureName: measure.name,
+                probeSql,
+                warehouse,
+                sourceColumns,
+                error: e,
+                headline: 'dry-run failed',
+            }));
+        }
+    }
+    return errors;
+}
+/**
+ * Restore `sourceName` to the content it had at `preHead`, or delete it if it didn't
+ * exist then. Used by sl_rollback (agent-driven) and the pre-squash revert gate
+ * (automatic). Returns a short human-readable description of what happened.
+ */
+export async function revertSourceToPreHead(deps, connectionId, preHead, sourceName) {
+    const relPath = slSourcePath(connectionId, sourceName);
+    let preContent = null;
+    if (preHead) {
+        try {
+            preContent = await deps.gitService.getFileAtCommit(relPath, preHead);
+        }
+        catch {
+            preContent = null;
+        }
+    }
+    if (preContent !== null) {
+        await deps.configService.writeFile(relPath, preContent, SYSTEM_GIT_AUTHOR.name, SYSTEM_GIT_AUTHOR.email, `Revert SL source to pre-session state: ${sourceName}`, { skipLock: true });
+        return 'restored to pre-session content';
+    }
+    try {
+        await deps.configService.deleteFile(relPath, SYSTEM_GIT_AUTHOR.name, SYSTEM_GIT_AUTHOR.email, `Drop SL source (not present at session start): ${sourceName}`, { skipLock: true });
+        await deps.slSourcesRepository.deleteByConnectionAndName(connectionId, sourceName);
+        return 'deleted (did not exist at session start)';
+    }
+    catch {
+        await deps.slSourcesRepository.deleteByConnectionAndName(connectionId, sourceName);
+        return 'no-op (already absent)';
+    }
+}

package/node_modules/@ktx/context/dist/sl/tools/sl-warehouse-validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@ktx/context/dist/sl/tools/sl-warehouse-validation.test.js

@@ -0,0 +1,115 @@
+import { describe, expect, it, vi } from 'vitest';
+import { validateSingleSource } from './sl-warehouse-validation.js';
+function makeDeps(opts) {
+    return {
+        semanticLayerService: {
+            readSourceFile: vi.fn().mockResolvedValue({ content: opts.sourceYaml, path: 'x' }),
+            isManifestBacked: vi.fn().mockResolvedValue(false),
+            listManifestSourceNames: vi.fn().mockResolvedValue([]),
+            loadSource: vi.fn().mockResolvedValue(null),
+            loadAllSources: vi.fn().mockResolvedValue([]),
+        },
+        connections: {
+            executeQuery: opts.executeQuery,
+            getConnectionById: vi.fn().mockResolvedValue({ id: 'conn-1', name: 'conn-1', connectionType: 'bigquery' }),
+            listEnabledConnections: vi.fn().mockResolvedValue([]),
+        },
+        configService: {},
+        gitService: {},
+        slSourcesRepository: { deleteByConnectionAndName: vi.fn().mockResolvedValue(undefined) },
+        probeRowCount: 1,
+    };
+}
+describe('validateSingleSource warehouse dry-run', () => {
+    it('surfaces warehouse error when dry-run fails on unknown column', async () => {
+        const yaml = `name: fct_arr_delta
+source_type: sql
+sql: |
+  SELECT * FROM analytics.fct_arr_delta WHERE date_date < CURRENT_DATE()
+grain: [date_date]
+columns:
+  - name: date_date
+    type: time
+measures:
+  - name: count_delta_events
+    expr: count(*)
+joins: []
+`;
+        const executeQuery = vi.fn().mockRejectedValue(new Error('Unrecognized name: date_date at [1:42]'));
+        const deps = makeDeps({ sourceYaml: yaml, executeQuery });
+        const result = await validateSingleSource(deps, 'conn-1', 'fct_arr_delta');
+        expect(result.errors.join('\n')).toMatch(/Unrecognized name: date_date/);
+        expect(result.errors.join('\n')).toMatch(/embedded sql dry-run failed/);
+    });
+    it('flags declared columns missing from the dry-run result', async () => {
+        const yaml = `name: fct_arr_delta
+source_type: sql
+sql: |
+  SELECT date, customer_id FROM analytics.fct_arr_delta
+columns:
+  - name: date_date
+    type: time
+  - name: customer_id
+    type: string
+measures:
+  - name: count_delta
+    expr: count(*)
+joins: []
+grain: [customer_id]
+`;
+        const executeQuery = vi.fn().mockResolvedValue({
+            headers: ['date', 'customer_id'],
+            rows: [],
+            totalRows: 0,
+            error: null,
+        });
+        const deps = makeDeps({ sourceYaml: yaml, executeQuery });
+        const result = await validateSingleSource(deps, 'conn-1', 'fct_arr_delta');
+        expect(result.errors.join('\n')).toMatch(/declared columns absent from sql result — date_date/);
+        expect(result.errors.join('\n')).toMatch(/warehouse returned:/);
+    });
+    it('passes cleanly when dry-run succeeds and declared columns match', async () => {
+        const yaml = `name: lab_results
+source_type: sql
+sql: |
+  SELECT lab_order_id, admin_user_id FROM analytics.raw_lab_results
+grain: [lab_order_id]
+columns:
+  - name: lab_order_id
+    type: string
+  - name: admin_user_id
+    type: string
+measures:
+  - name: count_lab_results
+    expr: count(lab_order_id)
+joins: []
+`;
+        const executeQuery = vi.fn().mockResolvedValue({
+            headers: ['lab_order_id', 'admin_user_id'],
+            rows: [],
+            totalRows: 0,
+            error: null,
+        });
+        const deps = makeDeps({ sourceYaml: yaml, executeQuery });
+        const result = await validateSingleSource(deps, 'conn-1', 'lab_results');
+        expect(result.errors).toEqual([]);
+    });
+    it('uses LIMIT 1 (not LIMIT 0) so runtime policies fire', async () => {
+        const yaml = `name: foo
+source_type: sql
+sql: |
+  SELECT a FROM analytics.bar
+grain: [a]
+columns:
+  - {name: a, type: string}
+measures: []
+joins: []
+`;
+        const executeQuery = vi.fn().mockResolvedValue({ headers: ['a'], rows: [], totalRows: 0, error: null });
+        const deps = makeDeps({ sourceYaml: yaml, executeQuery });
+        await validateSingleSource(deps, 'conn-1', 'foo');
+        const probeSql = executeQuery.mock.calls[0][1];
+        expect(probeSql).toMatch(/LIMIT 1\b/);
+        expect(probeSql).not.toMatch(/LIMIT 0\b/);
+    });
+});

package/node_modules/@ktx/context/dist/sl/tools/sl-write-source.tool.d.ts

@@ -0,0 +1,296 @@
+import { z } from 'zod';
+import { type ToolContext, type ToolOutput } from '../../tools/index.js';
+import { BaseSemanticLayerTool, type BaseSemanticLayerToolDeps, type SemanticLayerStructured } from './base-semantic-layer.tool.js';
+declare const slWriteSourceInputSchema: z.ZodObject<{
+    connectionId: z.ZodString;
+    sourceName: z.ZodString;
+    source: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        source_type: z.ZodOptional<z.ZodEnum<{
+            table: "table";
+            sql: "sql";
+        }>>;
+        table: z.ZodOptional<z.ZodString>;
+        sql: z.ZodOptional<z.ZodString>;
+        inherits_columns_from: z.ZodOptional<z.ZodString>;
+        grain: z.ZodArray<z.ZodString>;
+        columns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodOptional<z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                time: "time";
+            }>>;
+            role: z.ZodOptional<z.ZodEnum<{
+                time: "time";
+                default: "default";
+            }>>;
+            visibility: z.ZodOptional<z.ZodEnum<{
+                public: "public";
+                internal: "internal";
+                hidden: "hidden";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+            expr: z.ZodOptional<z.ZodString>;
+            constraints: z.ZodOptional<z.ZodObject<{
+                dbt: z.ZodOptional<z.ZodObject<{
+                    not_null: z.ZodOptional<z.ZodBoolean>;
+                    unique: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            enum_values: z.ZodOptional<z.ZodObject<{
+                dbt: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            tests: z.ZodOptional<z.ZodObject<{
+                dbt: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    package: z.ZodString;
+                    kwargs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>>;
+                dbt_by_package: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        joins: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            to: z.ZodString;
+            on: z.ZodString;
+            relationship: z.ZodEnum<{
+                many_to_one: "many_to_one";
+                one_to_many: "one_to_many";
+                one_to_one: "one_to_one";
+            }>;
+            alias: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        measures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            expr: z.ZodString;
+            filter: z.ZodOptional<z.ZodString>;
+            segments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        segments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            expr: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        default_time_dimension: z.ZodOptional<z.ZodObject<{
+            dbt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        tags: z.ZodOptional<z.ZodObject<{
+            dbt: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        freshness: z.ZodOptional<z.ZodObject<{
+            dbt: z.ZodOptional<z.ZodObject<{
+                raw: z.ZodOptional<z.ZodUnknown>;
+                loaded_at_field: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>, z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        descriptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        grain: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodOptional<z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                time: "time";
+            }>>;
+            role: z.ZodOptional<z.ZodEnum<{
+                time: "time";
+                default: "default";
+            }>>;
+            visibility: z.ZodOptional<z.ZodEnum<{
+                public: "public";
+                internal: "internal";
+                hidden: "hidden";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+            expr: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        joins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            to: z.ZodString;
+            on: z.ZodString;
+            relationship: z.ZodEnum<{
+                many_to_one: "many_to_one";
+                one_to_many: "one_to_many";
+                one_to_one: "one_to_one";
+            }>;
+            alias: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        measures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            expr: z.ZodString;
+            filter: z.ZodOptional<z.ZodString>;
+            segments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        segments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            expr: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        exclude_columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disable_joins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        default_time_dimension: z.ZodOptional<z.ZodObject<{
+            dbt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>]>>;
+    delete: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type SlWriteSourceInput = z.infer<typeof slWriteSourceInputSchema>;
+export declare class SlWriteSourceTool extends BaseSemanticLayerTool<typeof slWriteSourceInputSchema> {
+    readonly name = "sl_write_source";
+    constructor(deps: BaseSemanticLayerToolDeps);
+    get description(): string;
+    get inputSchema(): z.ZodObject<{
+        connectionId: z.ZodString;
+        sourceName: z.ZodString;
+        source: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            source_type: z.ZodOptional<z.ZodEnum<{
+                table: "table";
+                sql: "sql";
+            }>>;
+            table: z.ZodOptional<z.ZodString>;
+            sql: z.ZodOptional<z.ZodString>;
+            inherits_columns_from: z.ZodOptional<z.ZodString>;
+            grain: z.ZodArray<z.ZodString>;
+            columns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodOptional<z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    time: "time";
+                }>>;
+                role: z.ZodOptional<z.ZodEnum<{
+                    time: "time";
+                    default: "default";
+                }>>;
+                visibility: z.ZodOptional<z.ZodEnum<{
+                    public: "public";
+                    internal: "internal";
+                    hidden: "hidden";
+                }>>;
+                description: z.ZodOptional<z.ZodString>;
+                expr: z.ZodOptional<z.ZodString>;
+                constraints: z.ZodOptional<z.ZodObject<{
+                    dbt: z.ZodOptional<z.ZodObject<{
+                        not_null: z.ZodOptional<z.ZodBoolean>;
+                        unique: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                enum_values: z.ZodOptional<z.ZodObject<{
+                    dbt: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+                tests: z.ZodOptional<z.ZodObject<{
+                    dbt: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        package: z.ZodString;
+                        kwargs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    }, z.core.$strip>>>;
+                    dbt_by_package: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            joins: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                to: z.ZodString;
+                on: z.ZodString;
+                relationship: z.ZodEnum<{
+                    many_to_one: "many_to_one";
+                    one_to_many: "one_to_many";
+                    one_to_one: "one_to_one";
+                }>;
+                alias: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            measures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                expr: z.ZodString;
+                filter: z.ZodOptional<z.ZodString>;
+                segments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            segments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                expr: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            default_time_dimension: z.ZodOptional<z.ZodObject<{
+                dbt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            tags: z.ZodOptional<z.ZodObject<{
+                dbt: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            freshness: z.ZodOptional<z.ZodObject<{
+                dbt: z.ZodOptional<z.ZodObject<{
+                    raw: z.ZodOptional<z.ZodUnknown>;
+                    loaded_at_field: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>, z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            descriptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            grain: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            columns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                type: z.ZodOptional<z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    time: "time";
+                }>>;
+                role: z.ZodOptional<z.ZodEnum<{
+                    time: "time";
+                    default: "default";
+                }>>;
+                visibility: z.ZodOptional<z.ZodEnum<{
+                    public: "public";
+                    internal: "internal";
+                    hidden: "hidden";
+                }>>;
+                description: z.ZodOptional<z.ZodString>;
+                expr: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            joins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                to: z.ZodString;
+                on: z.ZodString;
+                relationship: z.ZodEnum<{
+                    many_to_one: "many_to_one";
+                    one_to_many: "one_to_many";
+                    one_to_one: "one_to_one";
+                }>;
+                alias: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            measures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                expr: z.ZodString;
+                filter: z.ZodOptional<z.ZodString>;
+                segments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            segments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                expr: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            exclude_columns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            disable_joins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            default_time_dimension: z.ZodOptional<z.ZodObject<{
+                dbt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>]>>;
+        delete: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    call(input: SlWriteSourceInput, context: ToolContext): Promise<ToolOutput<SemanticLayerStructured>>;
+    private writeFullSource;
+    private readSourceYamlFromService;
+    private rejectOrphanOverlay;
+    private rejectStandaloneShadow;
+    private nearestMatches;
+}
+export {};