@kaelio/ktx 0.4.1 → 0.5.0

package/dist/context/ingest/adapters/looker/tools/looker-query-to-sl.tool.js

@@ -0,0 +1,237 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { stagedLookerQuerySchema } from '../types.js';
+const lookerUsageInputSchema = z.object({
+    queryCount30d: z.number().int().nonnegative().default(0),
+    uniqueUsers30d: z.number().int().nonnegative().default(0),
+});
+const lookerQueryToSlInputSchema = z.object({
+    query: stagedLookerQuerySchema,
+    contentTitle: z.string().min(1).optional(),
+    contentType: z.enum(['look', 'dashboard_tile']).default('look'),
+    usage: lookerUsageInputSchema.optional(),
+});
+const MEASURE_FIELD_RE = /\b(count|sum|total|revenue|arr|mrr|amount|avg|average|rate|ratio|percent|pct|margin|profit|value|score)\b/i;
+function targetStatus(targetWarehouseConnectionId, targetTable) {
+    if (targetTable?.ok === true && targetWarehouseConnectionId) {
+        return 'mapped';
+    }
+    if (targetTable?.ok === false && targetTable.reason === 'no_connection_mapping') {
+        return 'unmapped';
+    }
+    if (targetTable?.ok === false) {
+        return 'unparseable';
+    }
+    return 'missing_target_table';
+}
+function targetNotes(status, targetTable) {
+    if (status === 'mapped') {
+        return [
+            'targetTable.ok is true: write or edit SL on targetWarehouseConnectionId using targetTable.canonicalTable as source.table.',
+            'Use targetTable.catalog, targetTable.schema, and targetTable.name only for source_tables preflight matching.',
+            'Never use rawSqlTableName as source.table; it may contain aliases, templates, or derived-table SQL.',
+        ];
+    }
+    if (targetTable?.ok === false) {
+        return [
+            `targetTable.ok is false (${targetTable.reason}): keep this query wiki-only and pass the reason through emit_unmapped_fallback.`,
+        ];
+    }
+    return [
+        'No targetTable was staged for this query; read the parent explore dependency before attempting any SL write.',
+    ];
+}
+/** @internal */
+export function buildLookerSlProposal(raw) {
+    const input = lookerQueryToSlInputSchema.parse(raw);
+    const sourceName = `looker__${toSlName(input.query.model)}__${toSlName(input.query.view)}`;
+    const usage = input.usage;
+    const targetWarehouseConnectionId = input.query.targetWarehouseConnectionId ?? null;
+    const targetTable = input.query.targetTable ?? null;
+    const status = targetStatus(targetWarehouseConnectionId, targetTable);
+    const sourceTable = targetTable?.ok === true ? targetTable.canonicalTable : null;
+    const canWriteStandaloneSource = status === 'mapped';
+    const triageLane = usage && usage.queryCount30d === 0 && usage.uniqueUsers30d === 0 ? 'skip' : isHighUsage(usage) ? 'full' : 'light';
+    const dimensions = [];
+    const measures = [];
+    for (const field of input.query.fields) {
+        const proposal = { name: toSlName(fieldLeaf(field)), lookerField: field };
+        if (isMeasureLikeField(field)) {
+            measures.push({
+                ...proposal,
+                expr: suggestedMeasureExpr(field),
+                description: `Suggested from Looker ${contentLabel(input)}; verify against explore field SQL before writing.`,
+            });
+        }
+        else {
+            dimensions.push(proposal);
+        }
+    }
+    const filters = nonEmptyFilters(input.query.filters);
+    const segments = Object.keys(filters).length === 0
+        ? []
+        : [
+            {
+                name: toSlName(input.contentTitle ?? Object.keys(filters).map(fieldLeaf).join('_')),
+                filters,
+                suggestedPredicate: Object.entries(filters)
+                    .map(([field, value]) => filterValueToPredicate(field, value))
+                    .join(' AND '),
+                description: `Reusable filter candidate from Looker ${contentLabel(input)}.`,
+            },
+        ];
+    const decision = measures.length > 0 ? 'measure_added' : segments.length > 0 && isHighUsage(usage) ? 'source_created' : 'wiki_only';
+    const notes = [
+        ...targetNotes(status, targetTable),
+        'Treat this as a proposal, not an instruction to write SL blindly.',
+        'Verify field SQL, source shape, and existing SL overlap with sl_discover/sl_read_source before sl_write_source or sl_edit_source.',
+        'Usage signals can raise priority, but query counts, users, owners, and folders must not be written as wiki narrative.',
+    ];
+    if (triageLane === 'skip') {
+        notes.push('Zero recent usage is a skip signal unless the raw content clearly defines durable business semantics.');
+    }
+    return {
+        sourceName,
+        targetWarehouseConnectionId,
+        targetTable,
+        targetStatus: status,
+        sourceTable,
+        canWriteStandaloneSource,
+        triageLane,
+        decision,
+        dimensions,
+        measures,
+        segments,
+        notes,
+    };
+}
+export function createLookerQueryToSlTool() {
+    return tool({
+        description: 'Given one staged Looker query JSON, return a conservative proposal for SL measures, dimensions, reusable filters, and triage priority. The proposal is advisory; verify with SL tools before writing.',
+        inputSchema: lookerQueryToSlInputSchema,
+        execute: async (input) => {
+            const structured = buildLookerSlProposal(input);
+            return {
+                markdown: formatLookerSlProposal(structured),
+                structured,
+            };
+        },
+        toModelOutput: ({ output }) => {
+            const markdown = output && typeof output === 'object' && 'markdown' in output
+                ? String(output.markdown)
+                : String(output);
+            return { type: 'content', value: [{ type: 'text', text: markdown }] };
+        },
+    });
+}
+function formatLookerSlProposal(proposal) {
+    const lines = [
+        '## Looker query SL proposal',
+        '',
+        `- sourceName: ${proposal.sourceName}`,
+        `- targetStatus: ${proposal.targetStatus}`,
+        `- targetWarehouseConnectionId: ${proposal.targetWarehouseConnectionId ?? '(none)'}`,
+        `- sourceTable: ${proposal.sourceTable ?? '(none)'}`,
+        `- canWriteStandaloneSource: ${proposal.canWriteStandaloneSource}`,
+        `- triageLane: ${proposal.triageLane}`,
+        `- decision: ${proposal.decision}`,
+        '',
+        '### Measures',
+        ...(proposal.measures.length === 0
+            ? ['- (none)']
+            : proposal.measures.map((measure) => `- ${measure.name}: ${measure.expr} (${measure.lookerField})`)),
+        '',
+        '### Dimensions',
+        ...(proposal.dimensions.length === 0
+            ? ['- (none)']
+            : proposal.dimensions.map((dimension) => `- ${dimension.name}: ${dimension.lookerField}`)),
+        '',
+        '### Segments',
+        ...(proposal.segments.length === 0
+            ? ['- (none)']
+            : proposal.segments.map((segment) => `- ${segment.name}: ${segment.suggestedPredicate}`)),
+        '',
+        '### Notes',
+        ...proposal.notes.map((note) => `- ${note}`),
+    ];
+    return lines.join('\n');
+}
+function isHighUsage(usage) {
+    return !!usage && (usage.queryCount30d >= 10 || usage.uniqueUsers30d >= 3);
+}
+function isMeasureLikeField(field) {
+    return MEASURE_FIELD_RE.test(fieldLeaf(field).replace(/_/g, ' '));
+}
+function suggestedMeasureExpr(field) {
+    const leaf = fieldLeaf(field);
+    if (/\b(count|count_distinct)\b/i.test(leaf.replace(/_/g, ' '))) {
+        return `count(${field})`;
+    }
+    if (/\b(avg|average|rate|ratio|percent|pct|margin|score)\b/i.test(leaf.replace(/_/g, ' '))) {
+        return `avg(${field})`;
+    }
+    return `sum(${field})`;
+}
+function fieldLeaf(field) {
+    const parts = field.split('.');
+    return parts[parts.length - 1] || field;
+}
+function nonEmptyFilters(filters) {
+    return Object.fromEntries(Object.entries(filters).filter(([, value]) => {
+        if (value === null || value === undefined) {
+            return false;
+        }
+        if (typeof value === 'string') {
+            return value.trim().length > 0;
+        }
+        if (Array.isArray(value)) {
+            return value.length > 0;
+        }
+        return true;
+    }));
+}
+function filterValueToPredicate(field, value) {
+    if (Array.isArray(value)) {
+        return `${field} IN (${value.map(sqlLiteral).join(', ')})`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return `${field} = ${String(value)}`;
+    }
+    const raw = String(value).trim();
+    if (raw.includes(',') && !raw.includes('"') && !raw.includes("'")) {
+        return `${field} IN (${raw
+            .split(',')
+            .map((part) => sqlLiteral(part.trim()))
+            .join(', ')})`;
+    }
+    if (raw.startsWith('-') && raw.length > 1) {
+        return `${field} != ${sqlLiteral(raw.slice(1).trim())}`;
+    }
+    if (raw.includes('%')) {
+        return `${field} LIKE ${sqlLiteral(raw)}`;
+    }
+    return `${field} = ${sqlLiteral(raw)}`;
+}
+function sqlLiteral(value) {
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return `'${String(value).replace(/'/g, "''")}'`;
+}
+function contentLabel(input) {
+    const noun = input.contentType === 'dashboard_tile' ? 'dashboard tile' : 'look';
+    return input.contentTitle ? `${noun} "${input.contentTitle}"` : noun;
+}
+function toSlName(value) {
+    const normalized = value
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .replace(/_+/g, '_');
+    if (!normalized) {
+        throw new Error(`Cannot derive semantic-layer name from empty Looker value`);
+    }
+    return /^[0-9]/.test(normalized) ? `n_${normalized}` : normalized;
+}

package/dist/context/ingest/adapters/looker/types.d.ts

@@ -0,0 +1,439 @@
+import { z } from 'zod';
+declare const lookerRuntimeCursorsSchema: z.ZodObject<{
+    dashboardsLastSyncedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+    looksLastSyncedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+}, z.core.$strip>;
+export type LookerRuntimeCursors = z.infer<typeof lookerRuntimeCursorsSchema>;
+/** @internal */
+export declare const lookerPullConfigSchema: z.ZodObject<{
+    lookerConnectionId: z.ZodOptional<z.ZodString>;
+    instanceBaseUrl: z.ZodOptional<z.ZodURL>;
+    dashboardUpdatedSince: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+    lookUpdatedSince: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+    connectionMappings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    connectionTypes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        POSTGRESQL: "POSTGRESQL";
+        BIGQUERY: "BIGQUERY";
+        SNOWFLAKE: "SNOWFLAKE";
+        MYSQL: "MYSQL";
+        SQLSERVER: "SQLSERVER";
+        SQLITE: "SQLITE";
+        CLICKHOUSE: "CLICKHOUSE";
+        CENTRALREACH: "CENTRALREACH";
+        EPIC: "EPIC";
+        CERNER: "CERNER";
+        ATHENA: "ATHENA";
+        QUICKBOOKS: "QUICKBOOKS";
+        WORKDAY: "WORKDAY";
+        REST: "REST";
+        S3: "S3";
+        SLACK: "SLACK";
+        METABASE: "METABASE";
+        LOOKER: "LOOKER";
+        NOTION: "NOTION";
+        PLAIN: "PLAIN";
+        BETTERSTACK: "BETTERSTACK";
+    }>>>;
+    parsedTargetTables: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        catalog: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        canonicalTable: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<false>;
+        reason: z.ZodEnum<{
+            no_connection_mapping: "no_connection_mapping";
+            looker_template_unresolved: "looker_template_unresolved";
+            derived_table_not_supported: "derived_table_not_supported";
+            no_physical_table: "no_physical_table";
+            multiple_table_references: "multiple_table_references";
+            unsupported_dialect: "unsupported_dialect";
+            parse_error: "parse_error";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "ok">>>;
+}, z.core.$strip>;
+export type LookerPullConfig = z.infer<typeof lookerPullConfigSchema>;
+export declare function parseLookerPullConfig(raw: unknown): LookerPullConfig;
+export declare const stagedSyncConfigSchema: z.ZodObject<{
+    lookerConnectionId: z.ZodString;
+    fetchedAt: z.ZodISODateTime;
+    instanceBaseUrl: z.ZodOptional<z.ZodURL>;
+    previousCursors: z.ZodDefault<z.ZodObject<{
+        dashboardsLastSyncedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+        looksLastSyncedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+    }, z.core.$strip>>;
+    nextCursors: z.ZodDefault<z.ZodObject<{
+        dashboardsLastSyncedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+        looksLastSyncedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const stagedLookerQuerySchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>>;
+    model: z.ZodString;
+    view: z.ZodString;
+    fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    filters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    sorts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    limit: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    dynamicFields: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    targetWarehouseConnectionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    targetTable: z.ZodDefault<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        catalog: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        canonicalTable: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<false>;
+        reason: z.ZodEnum<{
+            no_connection_mapping: "no_connection_mapping";
+            looker_template_unresolved: "looker_template_unresolved";
+            derived_table_not_supported: "derived_table_not_supported";
+            no_physical_table: "no_physical_table";
+            multiple_table_references: "multiple_table_references";
+            unsupported_dialect: "unsupported_dialect";
+            parse_error: "parse_error";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "ok">>>;
+}, z.core.$strip>;
+export type StagedLookerQuery = z.infer<typeof stagedLookerQuerySchema>;
+export declare const stagedDashboardFileSchema: z.ZodObject<{
+    lookerId: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>;
+    title: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    folderId: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>, z.ZodNull]>>;
+    ownerId: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>, z.ZodNull]>>;
+    updatedAt: z.ZodNullable<z.ZodString>;
+    tiles: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>;
+        title: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        lookId: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>, z.ZodNull]>>;
+        query: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            id: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>>;
+            model: z.ZodString;
+            view: z.ZodString;
+            fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            filters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            sorts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            limit: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+            dynamicFields: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            targetWarehouseConnectionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            targetTable: z.ZodDefault<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                ok: z.ZodLiteral<true>;
+                catalog: z.ZodNullable<z.ZodString>;
+                schema: z.ZodNullable<z.ZodString>;
+                name: z.ZodString;
+                canonicalTable: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                ok: z.ZodLiteral<false>;
+                reason: z.ZodEnum<{
+                    no_connection_mapping: "no_connection_mapping";
+                    looker_template_unresolved: "looker_template_unresolved";
+                    derived_table_not_supported: "derived_table_not_supported";
+                    no_physical_table: "no_physical_table";
+                    multiple_table_references: "multiple_table_references";
+                    unsupported_dialect: "unsupported_dialect";
+                    parse_error: "parse_error";
+                }>;
+                detail: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "ok">>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type StagedDashboardFile = z.infer<typeof stagedDashboardFileSchema>;
+export declare const stagedLookFileSchema: z.ZodObject<{
+    lookerId: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>;
+    title: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+    folderId: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>, z.ZodNull]>>;
+    ownerId: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>, z.ZodNull]>>;
+    updatedAt: z.ZodNullable<z.ZodString>;
+    query: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        id: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>>;
+        model: z.ZodString;
+        view: z.ZodString;
+        fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        filters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        sorts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        limit: z.ZodNullable<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        dynamicFields: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+        targetWarehouseConnectionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        targetTable: z.ZodDefault<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            catalog: z.ZodNullable<z.ZodString>;
+            schema: z.ZodNullable<z.ZodString>;
+            name: z.ZodString;
+            canonicalTable: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            ok: z.ZodLiteral<false>;
+            reason: z.ZodEnum<{
+                no_connection_mapping: "no_connection_mapping";
+                looker_template_unresolved: "looker_template_unresolved";
+                derived_table_not_supported: "derived_table_not_supported";
+                no_physical_table: "no_physical_table";
+                multiple_table_references: "multiple_table_references";
+                unsupported_dialect: "unsupported_dialect";
+                parse_error: "parse_error";
+            }>;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "ok">>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type StagedLookFile = z.infer<typeof stagedLookFileSchema>;
+export declare const stagedFoldersTreeFileSchema: z.ZodObject<{
+    folders: z.ZodArray<z.ZodObject<{
+        id: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>;
+        name: z.ZodString;
+        parentId: z.ZodDefault<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>, z.ZodNull]>>;
+        path: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StagedFoldersTreeFile = z.infer<typeof stagedFoldersTreeFileSchema>;
+export declare const stagedUserFileSchema: z.ZodObject<{
+    id: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>;
+    displayName: z.ZodNullable<z.ZodString>;
+    email: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type StagedUserFile = z.infer<typeof stagedUserFileSchema>;
+export declare const stagedGroupFileSchema: z.ZodObject<{
+    id: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>;
+    name: z.ZodString;
+}, z.core.$strip>;
+export type StagedGroupFile = z.infer<typeof stagedGroupFileSchema>;
+export declare const stagedLookmlModelsFileSchema: z.ZodObject<{
+    models: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        explores: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StagedLookmlModelsFile = z.infer<typeof stagedLookmlModelsFileSchema>;
+export declare const stagedExploreFileSchema: z.ZodObject<{
+    modelName: z.ZodString;
+    exploreName: z.ZodString;
+    label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    rawSqlTableName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    connectionName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    viewName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    fields: z.ZodObject<{
+        dimensions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            sql: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        measures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            sql: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    joins: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        relationship: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        rawSqlTableName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        sqlOn: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        from: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        targetTable: z.ZodDefault<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            catalog: z.ZodNullable<z.ZodString>;
+            schema: z.ZodNullable<z.ZodString>;
+            name: z.ZodString;
+            canonicalTable: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            ok: z.ZodLiteral<false>;
+            reason: z.ZodEnum<{
+                no_connection_mapping: "no_connection_mapping";
+                looker_template_unresolved: "looker_template_unresolved";
+                derived_table_not_supported: "derived_table_not_supported";
+                no_physical_table: "no_physical_table";
+                multiple_table_references: "multiple_table_references";
+                unsupported_dialect: "unsupported_dialect";
+                parse_error: "parse_error";
+            }>;
+            detail: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "ok">>>;
+    }, z.core.$strip>>>;
+    targetWarehouseConnectionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    targetTable: z.ZodDefault<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        catalog: z.ZodNullable<z.ZodString>;
+        schema: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        canonicalTable: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        ok: z.ZodLiteral<false>;
+        reason: z.ZodEnum<{
+            no_connection_mapping: "no_connection_mapping";
+            looker_template_unresolved: "looker_template_unresolved";
+            derived_table_not_supported: "derived_table_not_supported";
+            no_physical_table: "no_physical_table";
+            multiple_table_references: "multiple_table_references";
+            unsupported_dialect: "unsupported_dialect";
+            parse_error: "parse_error";
+        }>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "ok">>>;
+}, z.core.$strip>;
+export type StagedExploreFile = z.infer<typeof stagedExploreFileSchema>;
+export declare const stagedLookerSignalsFileSchema: z.ZodObject<{
+    dashboardUsage: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        contentId: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>;
+        queryCount30d: z.ZodDefault<z.ZodNumber>;
+        uniqueUsers30d: z.ZodDefault<z.ZodNumber>;
+        lastRunAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        topUsers: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>>>;
+    }, z.core.$strip>>>;
+    lookUsage: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        contentId: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>;
+        queryCount30d: z.ZodDefault<z.ZodNumber>;
+        uniqueUsers30d: z.ZodDefault<z.ZodNumber>;
+        lastRunAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        topUsers: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>>>;
+    }, z.core.$strip>>>;
+    scheduledPlans: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        contentId: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>;
+        contentType: z.ZodEnum<{
+            dashboard: "dashboard";
+            look: "look";
+        }>;
+        isScheduled: z.ZodBoolean;
+        scheduleCount: z.ZodDefault<z.ZodNumber>;
+        recipientCount: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    favorites: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        contentId: z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>, z.ZodTransform<string, string | number>>;
+        contentType: z.ZodEnum<{
+            dashboard: "dashboard";
+            look: "look";
+        }>;
+        favoriteCount: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type StagedLookerSignalsFile = z.infer<typeof stagedLookerSignalsFileSchema>;
+export declare const stagedLookerScopeFileSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        full: "full";
+        incremental: "incremental";
+    }>;
+    knownCurrentRawPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    fetchedRawPaths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type StagedLookerScopeFile = z.infer<typeof stagedLookerScopeFileSchema>;
+/** @internal */
+export declare const stagedLookerFetchIssueSchema: z.ZodObject<{
+    rawPath: z.ZodString;
+    entityType: z.ZodEnum<{
+        dashboard: "dashboard";
+        look: "look";
+        explore: "explore";
+        signals: "signals";
+        lookml_models: "lookml_models";
+        looker_connection_mapping: "looker_connection_mapping";
+    }>;
+    entityId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    severity: z.ZodEnum<{
+        error: "error";
+        warning: "warning";
+    }>;
+    statusCode: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    message: z.ZodString;
+    retryRecommended: z.ZodDefault<z.ZodBoolean>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        lookml_connection_mismatch: "lookml_connection_mismatch";
+        looker_template_unresolved: "looker_template_unresolved";
+        derived_table_not_supported: "derived_table_not_supported";
+        unmapped_looker_connection: "unmapped_looker_connection";
+        unparseable_sql_table_name: "unparseable_sql_table_name";
+    }>>;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type StagedLookerFetchIssue = z.infer<typeof stagedLookerFetchIssueSchema>;
+export declare const stagedLookerFetchReportSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        success: "success";
+        partial: "partial";
+    }>;
+    retryRecommended: z.ZodDefault<z.ZodBoolean>;
+    skipped: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        rawPath: z.ZodString;
+        entityType: z.ZodEnum<{
+            dashboard: "dashboard";
+            look: "look";
+            explore: "explore";
+            signals: "signals";
+            lookml_models: "lookml_models";
+            looker_connection_mapping: "looker_connection_mapping";
+        }>;
+        entityId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        severity: z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+        }>;
+        statusCode: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        message: z.ZodString;
+        retryRecommended: z.ZodDefault<z.ZodBoolean>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            lookml_connection_mismatch: "lookml_connection_mismatch";
+            looker_template_unresolved: "looker_template_unresolved";
+            derived_table_not_supported: "derived_table_not_supported";
+            unmapped_looker_connection: "unmapped_looker_connection";
+            unparseable_sql_table_name: "unparseable_sql_table_name";
+        }>>;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        rawPath: z.ZodString;
+        entityType: z.ZodEnum<{
+            dashboard: "dashboard";
+            look: "look";
+            explore: "explore";
+            signals: "signals";
+            lookml_models: "lookml_models";
+            looker_connection_mapping: "looker_connection_mapping";
+        }>;
+        entityId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        severity: z.ZodEnum<{
+            error: "error";
+            warning: "warning";
+        }>;
+        statusCode: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        message: z.ZodString;
+        retryRecommended: z.ZodDefault<z.ZodBoolean>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            lookml_connection_mismatch: "lookml_connection_mismatch";
+            looker_template_unresolved: "looker_template_unresolved";
+            derived_table_not_supported: "derived_table_not_supported";
+            unmapped_looker_connection: "unmapped_looker_connection";
+            unparseable_sql_table_name: "unparseable_sql_table_name";
+        }>>;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type StagedLookerFetchReport = z.infer<typeof stagedLookerFetchReportSchema>;
+export declare const STAGED_FILES: {
+    readonly syncConfig: "sync-config.json";
+    readonly scope: "looker-scope.json";
+    readonly fetchReport: "looker-fetch-report.json";
+    readonly evidenceRoot: "evidence";
+    readonly lookmlModels: "lookml_models.json";
+    readonly foldersTree: "folders/tree.json";
+    readonly signals: {
+        readonly dashboardUsage: "signals/dashboard_usage.json";
+        readonly lookUsage: "signals/look_usage.json";
+        readonly scheduledPlans: "signals/scheduled_plans.json";
+        readonly favorites: "signals/favorites.json";
+    };
+};
+export {};