@ekairos/dataset 1.22.34-beta.development.0 → 1.22.35

package/dist/builder/materializeQuery.js

@@ -0,0 +1,31 @@
+import { materializeRowsToDataset } from "./persistence.js";
+import { getDomainDescriptor, normalizeQueryRows } from "./rows.js";
+async function readQueryResourceRowsStep(params) {
+    "use step";
+    const db = await params.runtime.db();
+    const result = await db.query(params.query);
+    return { rows: normalizeQueryRows(result) };
+}
+export async function materializeQueryResource(runtime, resource, params) {
+    const { rows } = await readQueryResourceRowsStep({
+        runtime,
+        query: resource.query,
+    });
+    const domainDescriptor = getDomainDescriptor(resource.domain);
+    return await materializeRowsToDataset(runtime, {
+        datasetId: params.datasetId,
+        sandboxId: params.sandboxId,
+        title: params.title ?? resource.title,
+        instructions: params.instructions,
+        contextId: params.contextId,
+        analysis: {
+            query: resource.query,
+            explanation: resource.explanation,
+            ...domainDescriptor,
+        },
+        rows,
+        schema: params.schema,
+        inferSchema: !params.schema,
+        first: params.first,
+    });
+}

package/dist/builder/persistence.d.ts

@@ -0,0 +1,22 @@
+import type { AnyDatasetRuntime, DatasetBuildResult, DatasetTextResourceInput, MaterializeRowsParams } from "./types.js";
+export declare function defaultTextResourceName(resource: DatasetTextResourceInput): string;
+export declare function getDatasetDb<Runtime extends AnyDatasetRuntime>(runtime: Runtime): Promise<any>;
+export declare function createOrUpdateDatasetMetadata<Runtime extends AnyDatasetRuntime>(runtime: Runtime, params: {
+    datasetId: string;
+    sandboxId?: string;
+    title?: string;
+    instructions?: string;
+    contextId: string;
+    analysis?: any;
+    schema?: any;
+    status?: string;
+}): Promise<void>;
+export declare function materializeRowsToDataset<Runtime extends AnyDatasetRuntime>(runtime: Runtime, params: MaterializeRowsParams): Promise<string>;
+export declare function uploadInlineTextResource<Runtime extends AnyDatasetRuntime>(runtime: Runtime, datasetId: string, resource: DatasetTextResourceInput): Promise<string>;
+export declare function finalizeBuildResult<Runtime extends AnyDatasetRuntime>(runtime: Runtime, datasetId: string, withFirst: boolean): Promise<DatasetBuildResult>;
+export declare function createDatasetBuildResult<Runtime extends AnyDatasetRuntime>(runtime: Runtime, params: {
+    datasetId: string;
+    dataset: any;
+    previewRows: any[];
+    firstRow?: any | null;
+}): DatasetBuildResult;

package/dist/builder/persistence.js

@@ -0,0 +1,153 @@
+import { DatasetService } from "../service.js";
+import { datasetDomain } from "../schema.js";
+import { datasetGetByIdStep, datasetPreviewRowsStep, datasetReadOneStep, datasetReadRowsStep, } from "../dataset/steps.js";
+import { inferDatasetSchema, validateRows } from "./schemaInference.js";
+import { rowsToJsonl } from "./rows.js";
+export function defaultTextResourceName(resource) {
+    if (resource.name?.trim())
+        return resource.name.trim();
+    const mimeType = String(resource.mimeType ?? "").toLowerCase();
+    if (mimeType.includes("csv"))
+        return "resource.csv";
+    if (mimeType.includes("json"))
+        return "resource.json";
+    if (mimeType.includes("yaml") || mimeType.includes("yml"))
+        return "resource.yaml";
+    return "resource.txt";
+}
+export async function getDatasetDb(runtime) {
+    const scoped = await runtime.use(datasetDomain);
+    return scoped.db;
+}
+export async function createOrUpdateDatasetMetadata(runtime, params) {
+    "use step";
+    if (!params.contextId.trim()) {
+        throw new Error("dataset_context_required");
+    }
+    const db = await getDatasetDb(runtime);
+    const service = new DatasetService(db);
+    const result = await service.createDataset({
+        id: params.datasetId,
+        sandboxId: params.sandboxId,
+        title: params.title ?? params.datasetId,
+        instructions: params.instructions ?? "",
+        contextId: params.contextId,
+        analysis: params.analysis,
+        schema: params.schema,
+        status: params.status ?? "building",
+        organizationId: runtime.env.orgId,
+    });
+    if (!result.ok) {
+        throw new Error(result.error);
+    }
+}
+export async function materializeRowsToDataset(runtime, params) {
+    "use step";
+    if (params.first && params.rows.length > 1) {
+        throw new Error("dataset_first_expected_zero_or_one_row");
+    }
+    const resolvedSchema = params.schema ??
+        inferDatasetSchema(params.rows, params.title ? `${params.title}Row` : "DatasetRow", params.title ? `One row for ${params.title}` : "One dataset row");
+    validateRows(params.rows, resolvedSchema);
+    await createOrUpdateDatasetMetadata(runtime, {
+        datasetId: params.datasetId,
+        sandboxId: params.sandboxId,
+        title: params.title,
+        instructions: params.instructions,
+        contextId: params.contextId,
+        analysis: params.analysis,
+        schema: resolvedSchema,
+        status: "building",
+    });
+    const db = await getDatasetDb(runtime);
+    const service = new DatasetService(db);
+    const uploadResult = await service.uploadDatasetOutputFile({
+        datasetId: params.datasetId,
+        fileBuffer: Buffer.from(rowsToJsonl(params.rows), "utf-8"),
+    });
+    if (!uploadResult.ok) {
+        throw new Error(uploadResult.error);
+    }
+    const statusResult = await service.updateDatasetStatus({
+        datasetId: params.datasetId,
+        status: "completed",
+        calculatedTotalRows: params.rows.length,
+        actualGeneratedRowCount: params.rows.length,
+    });
+    if (!statusResult.ok) {
+        throw new Error(statusResult.error);
+    }
+    return params.datasetId;
+}
+export async function uploadInlineTextResource(runtime, datasetId, resource) {
+    "use step";
+    const db = await getDatasetDb(runtime);
+    const fileName = defaultTextResourceName(resource);
+    const storagePath = `/dataset/resource/${datasetId}/${Date.now()}-${fileName}`;
+    const uploadResult = await db.storage.uploadFile(storagePath, Buffer.from(resource.text, "utf-8"), {
+        contentType: resource.mimeType ?? "text/plain",
+        contentDisposition: fileName,
+    });
+    const fileId = uploadResult?.data?.id;
+    if (!fileId) {
+        throw new Error("dataset_text_resource_upload_failed");
+    }
+    return fileId;
+}
+export async function finalizeBuildResult(runtime, datasetId, withFirst) {
+    const datasetResult = await datasetGetByIdStep({ runtime, datasetId });
+    if (!datasetResult.ok)
+        throw new Error(datasetResult.error);
+    const previewResult = await datasetPreviewRowsStep({ runtime, datasetId, limit: 20 });
+    const reader = {
+        async read(cursorOrParams, limit) {
+            const params = typeof cursorOrParams === "object" && cursorOrParams !== null
+                ? cursorOrParams
+                : { cursor: cursorOrParams, limit };
+            return await datasetReadRowsStep({
+                runtime,
+                datasetId,
+                cursor: params.cursor,
+                limit: params.limit,
+            });
+        },
+    };
+    if (!withFirst) {
+        return {
+            datasetId,
+            dataset: datasetResult.data,
+            previewRows: previewResult.rows,
+            reader,
+        };
+    }
+    const firstResult = await datasetReadOneStep({ runtime, datasetId });
+    return {
+        datasetId,
+        dataset: datasetResult.data,
+        previewRows: previewResult.rows,
+        reader,
+        firstRow: firstResult.row,
+    };
+}
+export function createDatasetBuildResult(runtime, params) {
+    const reader = {
+        async read(cursorOrParams, limit) {
+            const readParams = typeof cursorOrParams === "object" && cursorOrParams !== null
+                ? cursorOrParams
+                : { cursor: cursorOrParams, limit };
+            return await datasetReadRowsStep({
+                runtime,
+                datasetId: params.datasetId,
+                cursor: readParams.cursor,
+                limit: readParams.limit,
+            });
+        },
+    };
+    return {
+        datasetId: params.datasetId,
+        dataset: params.dataset,
+        previewRows: params.previewRows,
+        reader,
+        ...(params.firstRow !== undefined ? { firstRow: params.firstRow } : {}),
+    };
+}

package/dist/builder/rows.d.ts

@@ -0,0 +1,7 @@
+import type { DomainSchemaResult } from "@ekairos/domain";
+export declare function rowsToJsonl(rows: any[]): string;
+export declare function normalizeQueryRows(result: any): any[];
+export declare function getDomainDescriptor(domain: DomainSchemaResult): {
+    domainPackageName?: string | undefined;
+    domainName: string;
+};

package/dist/builder/rows.js

@@ -0,0 +1,56 @@
+export function rowsToJsonl(rows) {
+    return rows
+        .map((row) => JSON.stringify({
+        type: "row",
+        data: row,
+    }))
+        .join("\n")
+        .concat(rows.length > 0 ? "\n" : "");
+}
+export function normalizeQueryRows(result) {
+    if (!result || typeof result !== "object")
+        return [];
+    const entries = Object.entries(result);
+    if (entries.length === 0)
+        return [];
+    if (entries.length === 1) {
+        const [key, value] = entries[0];
+        if (Array.isArray(value)) {
+            return value.map((row) => (row && typeof row === "object" ? row : { value: row }));
+        }
+        if (value && typeof value === "object") {
+            return [value];
+        }
+        return [{ [key]: value }];
+    }
+    const rows = [];
+    for (const [key, value] of entries) {
+        if (Array.isArray(value)) {
+            for (const row of value) {
+                if (row && typeof row === "object") {
+                    rows.push({ __entity: key, ...row });
+                }
+                else {
+                    rows.push({ __entity: key, value: row });
+                }
+            }
+            continue;
+        }
+        if (value && typeof value === "object") {
+            rows.push({ __entity: key, ...value });
+            continue;
+        }
+        rows.push({ __entity: key, value });
+    }
+    return rows;
+}
+export function getDomainDescriptor(domain) {
+    const meta = domain?.meta ?? {};
+    const context = typeof domain?.context === "function" ? domain.context() : {};
+    const name = String(meta?.name ?? context?.name ?? "domain");
+    const packageName = String(meta?.packageName ?? "");
+    return {
+        domainName: name,
+        ...(packageName ? { domainPackageName: packageName } : {}),
+    };
+}

package/dist/builder/schemaInference.d.ts

@@ -0,0 +1,3 @@
+import type { DatasetSchemaInput } from "./types.js";
+export declare function inferDatasetSchema(rows: any[], title?: string, description?: string): DatasetSchemaInput;
+export declare function validateRows(rows: any[], schema: DatasetSchemaInput): void;

package/dist/builder/schemaInference.js

@@ -0,0 +1,61 @@
+import Ajv from "ajv";
+const ajv = new Ajv({ allErrors: true, strict: false });
+function inferJsonSchemaType(value) {
+    if (value === null)
+        return { type: "null" };
+    if (Array.isArray(value))
+        return { type: "array" };
+    switch (typeof value) {
+        case "number":
+            return { type: "number" };
+        case "boolean":
+            return { type: "boolean" };
+        case "object":
+            return { type: "object", additionalProperties: true };
+        default:
+            return { type: "string" };
+    }
+}
+export function inferDatasetSchema(rows, title = "DatasetRow", description = "One dataset row") {
+    const properties = {};
+    const required = [];
+    const keys = new Set();
+    for (const row of rows) {
+        if (!row || typeof row !== "object")
+            continue;
+        for (const key of Object.keys(row)) {
+            keys.add(key);
+        }
+    }
+    for (const key of keys) {
+        const values = rows.map((row) => (row && typeof row === "object" ? row[key] : undefined));
+        const firstDefined = values.find((value) => value !== undefined);
+        properties[key] = {
+            ...inferJsonSchemaType(firstDefined),
+            description: `${key} value`,
+        };
+        if (values.every((value) => value !== undefined)) {
+            required.push(key);
+        }
+    }
+    return {
+        title,
+        description,
+        schema: {
+            type: "object",
+            additionalProperties: false,
+            properties,
+            required,
+        },
+    };
+}
+export function validateRows(rows, schema) {
+    const validator = ajv.compile(schema.schema);
+    for (const row of rows) {
+        const valid = validator(row);
+        if (!valid) {
+            const error = validator.errors?.map((entry) => entry.message || "validation_error").join("; ");
+            throw new Error(error || "dataset_schema_validation_failed");
+        }
+    }
+}

package/dist/builder/types.d.ts

@@ -0,0 +1,140 @@
+import type { InstaQLParams, ValidQuery } from "@instantdb/core";
+import type { DomainInstantSchema, DomainSchemaResult } from "@ekairos/domain";
+import type { EkairosRuntime, RuntimeForDomain } from "@ekairos/domain/runtime";
+import type { ContextIdentifier, ContextReactor, StoredContextResource } from "@ekairos/events";
+import { datasetDomain } from "../schema.js";
+export type DatasetQueryResourceInput<D extends DomainSchemaResult = DomainSchemaResult> = {
+    query: InstaQLParams<DomainInstantSchema<D>>;
+    title?: string;
+    explanation?: string;
+    domain: D;
+};
+export type DatasetFileResourceInput = {
+    fileId: string;
+    description?: string;
+    filename?: string;
+    mediaType?: string;
+};
+export type DatasetTextResourceInput = {
+    text: string;
+    mimeType?: string;
+    name?: string;
+    description?: string;
+};
+export type DatasetExistingResourceInput = {
+    datasetId: string;
+    description?: string;
+};
+export type DatasetContextResourceInput = ContextIdentifier;
+export type DatasetFileResource = {
+    kind: "file";
+} & DatasetFileResourceInput;
+export type DatasetTextResource = {
+    kind: "text";
+} & DatasetTextResourceInput;
+export type DatasetExistingResource = {
+    kind: "dataset";
+} & DatasetExistingResourceInput;
+export type DatasetContextResource = {
+    kind: "context";
+} & DatasetContextResourceInput;
+export type DatasetResourceInput = DatasetFileResourceInput | DatasetTextResourceInput | DatasetExistingResourceInput | DatasetContextResourceInput | DatasetFileResource | DatasetTextResource | DatasetExistingResource | DatasetContextResource;
+export type DatasetSchemaInput = {
+    title?: string;
+    description?: string;
+    schema: any;
+};
+export type DatasetOutput = "rows" | "object";
+export type DatasetMode = "auto" | "schema";
+export type DatasetBuilderOptions = {
+    datasetId?: string;
+    durable?: boolean;
+};
+export type DatasetBuildOptions = {
+    datasetId?: string;
+    durable?: boolean;
+};
+export type InternalDatasetResource = DatasetFileResource | DatasetTextResource | DatasetExistingResource | DatasetContextResource | ({
+    kind: "query";
+} & DatasetQueryResourceInput);
+export type DatasetReaderResult = {
+    rows: any[];
+    cursor: number;
+    done: boolean;
+};
+export type DatasetReader = {
+    read(cursor?: number, limit?: number): Promise<DatasetReaderResult>;
+    read(params?: {
+        cursor?: number;
+        limit?: number;
+    }): Promise<DatasetReaderResult>;
+};
+export type DatasetBuildResult = {
+    datasetId: string;
+    dataset: any;
+    previewRows: any[];
+    reader: DatasetReader;
+    object?: any | null;
+    firstRow?: any | null;
+};
+export type DatasetRuntimeEnv = {
+    orgId: string;
+};
+export type AnyDatasetRuntime = EkairosRuntime<any, any, any>;
+export type DatasetRuntimeHandle<Runtime extends AnyDatasetRuntime> = RuntimeForDomain<Runtime, typeof datasetDomain>;
+export type CompatibleQueryDomain<Runtime extends AnyDatasetRuntime, D extends DomainSchemaResult> = RuntimeForDomain<Runtime, D> extends never ? never : D;
+export type DatasetQueryResourceOptions<D extends DomainSchemaResult, Q extends ValidQuery<Q, DomainInstantSchema<D>>> = {
+    query: Q;
+    title?: string;
+    explanation?: string;
+};
+export type DatasetBuilderState<Runtime extends AnyDatasetRuntime> = {
+    runtime: Runtime;
+    env: Runtime["env"] & DatasetRuntimeEnv;
+    resources: InternalDatasetResource[];
+    contextResources?: StoredContextResource[];
+    title?: string;
+    sandboxId?: string;
+    contextId?: string;
+    outputSchema?: DatasetSchemaInput;
+    output: DatasetOutput;
+    inferSchema: boolean;
+    instructions?: string;
+    reactor?: ContextReactor<any, any>;
+    durable?: boolean;
+    first: boolean;
+};
+export type MaterializeRowsParams = {
+    datasetId: string;
+    sandboxId?: string;
+    title?: string;
+    instructions?: string;
+    contextId: string;
+    analysis?: any;
+    rows: any[];
+    schema?: DatasetSchemaInput;
+    inferSchema?: boolean;
+    first?: boolean;
+};
+export type DatasetBuilder<Runtime extends AnyDatasetRuntime> = {
+    readonly datasetId: string;
+    fromFile(resource: DatasetFileResourceInput): DatasetBuilder<Runtime>;
+    fromText(resource: DatasetTextResourceInput): DatasetBuilder<Runtime>;
+    fromDataset(resource: DatasetExistingResourceInput): DatasetBuilder<Runtime>;
+    fromContext(context: DatasetContextResourceInput): DatasetBuilder<Runtime>;
+    from(...resources: DatasetResourceInput[]): DatasetBuilder<Runtime>;
+    fromQuery<D extends DomainSchemaResult, Q extends ValidQuery<Q, DomainInstantSchema<D>>>(domain: D & CompatibleQueryDomain<Runtime, D>, resource: DatasetQueryResourceOptions<D, Q>): DatasetBuilder<Runtime>;
+    title(title: string): DatasetBuilder<Runtime>;
+    sandbox(input: {
+        sandboxId: string;
+    }): DatasetBuilder<Runtime>;
+    schema(schema: DatasetSchemaInput): DatasetBuilder<Runtime>;
+    inferSchema(): DatasetBuilder<Runtime>;
+    auto(): DatasetBuilder<Runtime>;
+    asRows(): DatasetBuilder<Runtime>;
+    asObject(): DatasetBuilder<Runtime>;
+    instructions(instructions: string): DatasetBuilder<Runtime>;
+    reactor(reactor: ContextReactor<any, any>): DatasetBuilder<Runtime>;
+    first(): DatasetBuilder<Runtime>;
+    build(options?: DatasetBuildOptions): Promise<DatasetBuildResult>;
+};

package/dist/builder/types.js

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

package/dist/clearDataset.tool.d.ts

@@ -1,9 +1,9 @@
 interface ClearDatasetToolParams {
     datasetId: string;
     sandboxId: string;
-    env?: any;
+    runtime: any;
 }
-export declare function createClearDatasetTool({ datasetId, sandboxId, env }: ClearDatasetToolParams): import("ai").Tool<{
+export declare function createClearDatasetTool({ datasetId, sandboxId, runtime }: ClearDatasetToolParams): import("ai").Tool<{
     reason: string;
 }, {
     success: boolean;
@@ -17,4 +17,3 @@ export declare function createClearDatasetTool({ datasetId, sandboxId, env }: Cl
     error?: undefined;
 }>;
 export {};
-//# sourceMappingURL=clearDataset.tool.d.ts.map

package/dist/clearDataset.tool.js

@@ -1,27 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createClearDatasetTool = createClearDatasetTool;
-const ai_1 = require("ai");
-const zod_1 = require("zod");
-const steps_1 = require("./sandbox/steps");
-const datasetFiles_1 = require("./datasetFiles");
-const steps_2 = require("./dataset/steps");
-function createClearDatasetTool({ datasetId, sandboxId, env }) {
-    return (0, ai_1.tool)({
+import { tool } from "ai";
+import { z } from "zod";
+import { runDatasetSandboxCommandStep } from "./sandbox/steps.js";
+import { getDatasetOutputPath } from "./datasetFiles.js";
+import { datasetClearStep } from "./dataset/steps.js";
+export function createClearDatasetTool({ datasetId, sandboxId, runtime }) {
+    return tool({
         description: "Clear all dataset records and output files. This will delete all generated data and reset the dataset to its initial state.",
-        inputSchema: zod_1.z.object({
-            reason: zod_1.z.string().describe("The reason for clearing the dataset"),
+        inputSchema: z.object({
+            reason: z.string().describe("The reason for clearing the dataset"),
         }),
         execute: async ({ reason }) => {
             console.log(`[Dataset ${datasetId}] ========================================`);
             console.log(`[Dataset ${datasetId}] Tool: clearDataset`);
             console.log(`[Dataset ${datasetId}] Reason: ${reason}`);
             console.log(`[Dataset ${datasetId}] ========================================`);
-            const outputPath = (0, datasetFiles_1.getDatasetOutputPath)(datasetId);
+            const outputPath = getDatasetOutputPath(datasetId);
             console.log(`[Dataset ${datasetId}] Step 1: Deleting output file`);
             try {
-                const result = await (0, steps_1.runDatasetSandboxCommandStep)({
-                    env,
+                const result = await runDatasetSandboxCommandStep({
+                    runtime,
                     sandboxId,
                     cmd: "rm",
                     args: ["-f", outputPath],
@@ -38,7 +35,7 @@ function createClearDatasetTool({ datasetId, sandboxId, env }) {
                 console.warn(`[Dataset ${datasetId}] Error deleting output file: ${message}`);
             }
             console.log(`[Dataset ${datasetId}] Step 2: Clearing dataset records`);
-            const clearResult = await (0, steps_2.datasetClearStep)({ env, datasetId });
+            const clearResult = await datasetClearStep({ runtime, datasetId });
             if (!clearResult.ok) {
                 console.error(`[Dataset ${datasetId}] Failed to clear dataset: ${clearResult.error}`);
                 return {
@@ -58,4 +55,3 @@ function createClearDatasetTool({ datasetId, sandboxId, env }) {
         },
     });
 }
-//# sourceMappingURL=clearDataset.tool.js.map

package/dist/completeDataset.steps.d.ts

@@ -0,0 +1,117 @@
+export interface PersistDatasetStepParams {
+    datasetId: string;
+    sandboxId: string;
+    runtime: any;
+    summary?: string;
+    outputPath?: string;
+}
+export declare function persistDatasetStep({ runtime, datasetId, sandboxId, summary, outputPath }: PersistDatasetStepParams): Promise<{
+    rowSource: string;
+    outputPath: string;
+    storagePath: string;
+    success: boolean;
+    validation?: RowValidationEntry[];
+    validationTruncated?: number;
+    failureSummary?: ValidationFailureSummary;
+    repairInstructions?: string[];
+    validRowCount?: number;
+    rowRecordCount?: number;
+    error?: string;
+    status?: string;
+    message?: string;
+    validRows?: undefined;
+    dataFileId?: undefined;
+    records?: undefined;
+    summary?: undefined;
+} | {
+    success: boolean;
+    status: string;
+    rowSource: string;
+    validRows: number;
+    rowRecordCount: number;
+    validation: RowValidationEntry[] | undefined;
+    error: string;
+    message: string;
+    outputPath: string;
+    storagePath: string;
+    dataFileId?: undefined;
+    records?: undefined;
+    summary?: undefined;
+} | {
+    success: boolean;
+    status: string;
+    rowSource: string;
+    validRows: number;
+    rowRecordCount: number;
+    validation: RowValidationEntry[] | undefined;
+    error: string;
+    message: string;
+    outputPath: string;
+    storagePath: string;
+    dataFileId: string;
+    records?: undefined;
+    summary?: undefined;
+} | {
+    success: boolean;
+    status: string;
+    rowSource: string;
+    records: number;
+    summary: string;
+    outputPath: string;
+    storagePath: string;
+    dataFileId: string;
+    validRows?: undefined;
+    rowRecordCount?: undefined;
+    validation?: undefined;
+    error?: undefined;
+    message?: undefined;
+}>;
+type RowValidationEntry = {
+    index: number;
+    valid: boolean;
+    errors?: string[];
+    errorDetails?: Array<{
+        path: string;
+        keyword: string;
+        message: string;
+        params?: Record<string, unknown>;
+        schemaPath?: string;
+    }>;
+    dataKeys?: string[];
+};
+type ValidationFailureSummary = {
+    rowRecordCount: number;
+    validRowCount: number;
+    invalidRowCount: number;
+    expectedTopLevelKeys: string[];
+    requiredTopLevelKeys: string[];
+    requiredPaths: string[];
+    enumConstraints: Array<{
+        path: string;
+        values: unknown[];
+    }>;
+    topErrors: Array<{
+        message: string;
+        count: number;
+    }>;
+    missingRequiredProperties: Array<{
+        property: string;
+        count: number;
+    }>;
+    additionalProperties: Array<{
+        property: string;
+        count: number;
+    }>;
+    enumFailures: Array<{
+        path: string;
+        allowedValues: unknown[];
+        count: number;
+    }>;
+    observedTopLevelKeys: string[];
+    sampleInvalidRows: Array<{
+        index: number;
+        dataKeys?: string[];
+        errors?: string[];
+    }>;
+};
+export {};