convex 1.45.0 → 1.47.0

package/dist/cjs-types/cli/lib/deployApi/evaluateSchema.d.ts

@@ -0,0 +1,897 @@
+import { z } from "zod";
+export declare const tableValidationOutcome: z.ZodEnum<["notValidated", "supersetOfEnforced", "supersetOfStagedValidated", "supersetOfShape", "mustWalk"]>;
+export type TableValidationOutcome = z.infer<typeof tableValidationOutcome>;
+export declare const indexChangePrediction: z.ZodEnum<["added", "identical", "enabled", "disabled", "dropped"]>;
+export type IndexChangePrediction = z.infer<typeof indexChangePrediction>;
+export declare const stagedValidatorState: z.ZodUnion<[z.ZodObject<{
+    state: z.ZodLiteral<"pending">;
+    numDocsValidated: z.ZodNumber;
+    totalDocs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, "passthrough", z.ZodTypeAny, {
+    state: "pending";
+    numDocsValidated: number;
+    totalDocs?: number | null | undefined;
+}, {
+    state: "pending";
+    numDocsValidated: number;
+    totalDocs?: number | null | undefined;
+}>, z.ZodObject<{
+    state: z.ZodLiteral<"valid">;
+}, "passthrough", z.ZodTypeAny, {
+    state: "valid";
+}, {
+    state: "valid";
+}>, z.ZodObject<{
+    state: z.ZodLiteral<"failed">;
+    error: z.ZodString;
+}, "passthrough", z.ZodTypeAny, {
+    state: "failed";
+    error: string;
+}, {
+    state: "failed";
+    error: string;
+}>]>;
+export type StagedValidatorState = z.infer<typeof stagedValidatorState>;
+export declare const tablePrediction: z.ZodObject<{
+    name: z.ZodString;
+    outcome: z.ZodEnum<["notValidated", "supersetOfEnforced", "supersetOfStagedValidated", "supersetOfShape", "mustWalk"]>;
+    numDocs: z.ZodNumber;
+    sizeBytes: z.ZodNumber;
+    staged: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"pending">;
+        numDocsValidated: z.ZodNumber;
+        totalDocs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, "passthrough", z.ZodTypeAny, {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    }, {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    }>, z.ZodObject<{
+        state: z.ZodLiteral<"valid">;
+    }, "passthrough", z.ZodTypeAny, {
+        state: "valid";
+    }, {
+        state: "valid";
+    }>, z.ZodObject<{
+        state: z.ZodLiteral<"failed">;
+        error: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, {
+        state: "failed";
+        error: string;
+    }, {
+        state: "failed";
+        error: string;
+    }>]>>;
+    canSkipAfterStagedValidation: z.ZodOptional<z.ZodBoolean>;
+}, "passthrough", z.ZodTypeAny, {
+    name: string;
+    outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
+    numDocs: number;
+    sizeBytes: number;
+    staged?: {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    } | {
+        state: "valid";
+    } | {
+        state: "failed";
+        error: string;
+    } | undefined;
+    canSkipAfterStagedValidation?: boolean | undefined;
+}, {
+    name: string;
+    outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
+    numDocs: number;
+    sizeBytes: number;
+    staged?: {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    } | {
+        state: "valid";
+    } | {
+        state: "failed";
+        error: string;
+    } | undefined;
+    canSkipAfterStagedValidation?: boolean | undefined;
+}>;
+export type TablePrediction = z.infer<typeof tablePrediction>;
+export declare const indexPrediction: z.ZodIntersection<z.ZodIntersection<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"database">;
+    fields: z.ZodArray<z.ZodString, "many">;
+}, "passthrough", z.ZodTypeAny, {
+    type: "database";
+    fields: string[];
+    name: string;
+}, {
+    type: "database";
+    fields: string[];
+    name: string;
+}>, z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"search">;
+    searchField: z.ZodString;
+    filterFields: z.ZodArray<z.ZodString, "many">;
+}, "passthrough", z.ZodTypeAny, {
+    type: "search";
+    name: string;
+    searchField: string;
+    filterFields: string[];
+}, {
+    type: "search";
+    name: string;
+    searchField: string;
+    filterFields: string[];
+}>, z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"vector">;
+    dimensions: z.ZodNumber;
+    vectorField: z.ZodString;
+    filterFields: z.ZodArray<z.ZodString, "many">;
+}, "passthrough", z.ZodTypeAny, {
+    type: "vector";
+    name: string;
+    filterFields: string[];
+    vectorField: string;
+    dimensions: number;
+}, {
+    type: "vector";
+    name: string;
+    filterFields: string[];
+    vectorField: string;
+    dimensions: number;
+}>]>, z.ZodObject<{
+    staged: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    staged?: boolean | undefined;
+}, {
+    staged?: boolean | undefined;
+}>>, z.ZodObject<{
+    change: z.ZodEnum<["added", "identical", "enabled", "disabled", "dropped"]>;
+    needsBackfill: z.ZodBoolean;
+    numDocs: z.ZodNumber;
+}, "passthrough", z.ZodTypeAny, {
+    change: "disabled" | "added" | "enabled" | "identical" | "dropped";
+    numDocs: number;
+    needsBackfill: boolean;
+}, {
+    change: "disabled" | "added" | "enabled" | "identical" | "dropped";
+    numDocs: number;
+    needsBackfill: boolean;
+}>>;
+export type IndexPrediction = z.infer<typeof indexPrediction>;
+export declare const discardedStagedValidator: z.ZodObject<{
+    tableName: z.ZodString;
+    state: z.ZodUnion<[z.ZodObject<{
+        state: z.ZodLiteral<"pending">;
+        numDocsValidated: z.ZodNumber;
+        totalDocs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, "passthrough", z.ZodTypeAny, {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    }, {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    }>, z.ZodObject<{
+        state: z.ZodLiteral<"valid">;
+    }, "passthrough", z.ZodTypeAny, {
+        state: "valid";
+    }, {
+        state: "valid";
+    }>]>;
+    replaced: z.ZodBoolean;
+}, "passthrough", z.ZodTypeAny, {
+    tableName: string;
+    state: {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    } | {
+        state: "valid";
+    };
+    replaced: boolean;
+}, {
+    tableName: string;
+    state: {
+        state: "pending";
+        numDocsValidated: number;
+        totalDocs?: number | null | undefined;
+    } | {
+        state: "valid";
+    };
+    replaced: boolean;
+}>;
+export type DiscardedStagedValidator = z.infer<typeof discardedStagedValidator>;
+export declare const componentSchemaPrediction: z.ZodObject<{
+    definitionPath: z.ZodString;
+    schemaValidation: z.ZodBoolean;
+    tables: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        outcome: z.ZodEnum<["notValidated", "supersetOfEnforced", "supersetOfStagedValidated", "supersetOfShape", "mustWalk"]>;
+        numDocs: z.ZodNumber;
+        sizeBytes: z.ZodNumber;
+        staged: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"pending">;
+            numDocsValidated: z.ZodNumber;
+            totalDocs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, "passthrough", z.ZodTypeAny, {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        }, {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        }>, z.ZodObject<{
+            state: z.ZodLiteral<"valid">;
+        }, "passthrough", z.ZodTypeAny, {
+            state: "valid";
+        }, {
+            state: "valid";
+        }>, z.ZodObject<{
+            state: z.ZodLiteral<"failed">;
+            error: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, {
+            state: "failed";
+            error: string;
+        }, {
+            state: "failed";
+            error: string;
+        }>]>>;
+        canSkipAfterStagedValidation: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, {
+        name: string;
+        outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
+        numDocs: number;
+        sizeBytes: number;
+        staged?: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        } | {
+            state: "failed";
+            error: string;
+        } | undefined;
+        canSkipAfterStagedValidation?: boolean | undefined;
+    }, {
+        name: string;
+        outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
+        numDocs: number;
+        sizeBytes: number;
+        staged?: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        } | {
+            state: "failed";
+            error: string;
+        } | undefined;
+        canSkipAfterStagedValidation?: boolean | undefined;
+    }>, "many">;
+    indexes: z.ZodArray<z.ZodIntersection<z.ZodIntersection<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodLiteral<"database">;
+        fields: z.ZodArray<z.ZodString, "many">;
+    }, "passthrough", z.ZodTypeAny, {
+        type: "database";
+        fields: string[];
+        name: string;
+    }, {
+        type: "database";
+        fields: string[];
+        name: string;
+    }>, z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodLiteral<"search">;
+        searchField: z.ZodString;
+        filterFields: z.ZodArray<z.ZodString, "many">;
+    }, "passthrough", z.ZodTypeAny, {
+        type: "search";
+        name: string;
+        searchField: string;
+        filterFields: string[];
+    }, {
+        type: "search";
+        name: string;
+        searchField: string;
+        filterFields: string[];
+    }>, z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodLiteral<"vector">;
+        dimensions: z.ZodNumber;
+        vectorField: z.ZodString;
+        filterFields: z.ZodArray<z.ZodString, "many">;
+    }, "passthrough", z.ZodTypeAny, {
+        type: "vector";
+        name: string;
+        filterFields: string[];
+        vectorField: string;
+        dimensions: number;
+    }, {
+        type: "vector";
+        name: string;
+        filterFields: string[];
+        vectorField: string;
+        dimensions: number;
+    }>]>, z.ZodObject<{
+        staged: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        staged?: boolean | undefined;
+    }, {
+        staged?: boolean | undefined;
+    }>>, z.ZodObject<{
+        change: z.ZodEnum<["added", "identical", "enabled", "disabled", "dropped"]>;
+        needsBackfill: z.ZodBoolean;
+        numDocs: z.ZodNumber;
+    }, "passthrough", z.ZodTypeAny, {
+        change: "disabled" | "added" | "enabled" | "identical" | "dropped";
+        numDocs: number;
+        needsBackfill: boolean;
+    }, {
+        change: "disabled" | "added" | "enabled" | "identical" | "dropped";
+        numDocs: number;
+        needsBackfill: boolean;
+    }>>, "many">;
+    discardedStagedValidators: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        tableName: z.ZodString;
+        state: z.ZodUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"pending">;
+            numDocsValidated: z.ZodNumber;
+            totalDocs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, "passthrough", z.ZodTypeAny, {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        }, {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        }>, z.ZodObject<{
+            state: z.ZodLiteral<"valid">;
+        }, "passthrough", z.ZodTypeAny, {
+            state: "valid";
+        }, {
+            state: "valid";
+        }>]>;
+        replaced: z.ZodBoolean;
+    }, "passthrough", z.ZodTypeAny, {
+        tableName: string;
+        state: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        };
+        replaced: boolean;
+    }, {
+        tableName: string;
+        state: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        };
+        replaced: boolean;
+    }>, "many">>;
+}, "passthrough", z.ZodTypeAny, {
+    indexes: ((({
+        type: "database";
+        fields: string[];
+        name: string;
+    } | {
+        type: "search";
+        name: string;
+        searchField: string;
+        filterFields: string[];
+    } | {
+        type: "vector";
+        name: string;
+        filterFields: string[];
+        vectorField: string;
+        dimensions: number;
+    }) & {
+        staged?: boolean | undefined;
+    }) & {
+        change: "disabled" | "added" | "enabled" | "identical" | "dropped";
+        numDocs: number;
+        needsBackfill: boolean;
+    })[];
+    schemaValidation: boolean;
+    tables: {
+        name: string;
+        outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
+        numDocs: number;
+        sizeBytes: number;
+        staged?: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        } | {
+            state: "failed";
+            error: string;
+        } | undefined;
+        canSkipAfterStagedValidation?: boolean | undefined;
+    }[];
+    definitionPath: string;
+    discardedStagedValidators?: {
+        tableName: string;
+        state: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        };
+        replaced: boolean;
+    }[] | undefined;
+}, {
+    indexes: ((({
+        type: "database";
+        fields: string[];
+        name: string;
+    } | {
+        type: "search";
+        name: string;
+        searchField: string;
+        filterFields: string[];
+    } | {
+        type: "vector";
+        name: string;
+        filterFields: string[];
+        vectorField: string;
+        dimensions: number;
+    }) & {
+        staged?: boolean | undefined;
+    }) & {
+        change: "disabled" | "added" | "enabled" | "identical" | "dropped";
+        numDocs: number;
+        needsBackfill: boolean;
+    })[];
+    schemaValidation: boolean;
+    tables: {
+        name: string;
+        outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
+        numDocs: number;
+        sizeBytes: number;
+        staged?: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        } | {
+            state: "failed";
+            error: string;
+        } | undefined;
+        canSkipAfterStagedValidation?: boolean | undefined;
+    }[];
+    definitionPath: string;
+    discardedStagedValidators?: {
+        tableName: string;
+        state: {
+            state: "pending";
+            numDocsValidated: number;
+            totalDocs?: number | null | undefined;
+        } | {
+            state: "valid";
+        };
+        replaced: boolean;
+    }[] | undefined;
+}>;
+export type ComponentSchemaPrediction = z.infer<typeof componentSchemaPrediction>;
+export declare const evaluateSchemaResponse: z.ZodObject<{
+    componentSchemaEvaluations: z.ZodRecord<z.ZodString, z.ZodObject<{
+        definitionPath: z.ZodString;
+        schemaValidation: z.ZodBoolean;
+        tables: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            outcome: z.ZodEnum<["notValidated", "supersetOfEnforced", "supersetOfStagedValidated", "supersetOfShape", "mustWalk"]>;
+            numDocs: z.ZodNumber;
+            sizeBytes: z.ZodNumber;
+            staged: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+                state: z.ZodLiteral<"pending">;
+                numDocsValidated: z.ZodNumber;
+                totalDocs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, "passthrough", z.ZodTypeAny, {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            }, {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            }>, z.ZodObject<{
+                state: z.ZodLiteral<"valid">;
+            }, "passthrough", z.ZodTypeAny, {
+                state: "valid";
+            }, {
+                state: "valid";
+            }>, z.ZodObject<{
+                state: z.ZodLiteral<"failed">;
+                error: z.ZodString;
+            }, "passthrough", z.ZodTypeAny, {
+                state: "failed";
+                error: string;
+            }, {
+                state: "failed";
+                error: string;
+            }>]>>;
+            canSkipAfterStagedValidation: z.ZodOptional<z.ZodBoolean>;
+        }, "passthrough", z.ZodTypeAny, {
+            name: string;
+            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
+            numDocs: number;
+            sizeBytes: number;
+            staged?: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            } | {
+                state: "failed";
+                error: string;
+            } | undefined;
+            canSkipAfterStagedValidation?: boolean | undefined;
+        }, {
+            name: string;
+            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
+            numDocs: number;
+            sizeBytes: number;
+            staged?: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            } | {
+                state: "failed";
+                error: string;
+            } | undefined;
+            canSkipAfterStagedValidation?: boolean | undefined;
+        }>, "many">;
+        indexes: z.ZodArray<z.ZodIntersection<z.ZodIntersection<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodLiteral<"database">;
+            fields: z.ZodArray<z.ZodString, "many">;
+        }, "passthrough", z.ZodTypeAny, {
+            type: "database";
+            fields: string[];
+            name: string;
+        }, {
+            type: "database";
+            fields: string[];
+            name: string;
+        }>, z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodLiteral<"search">;
+            searchField: z.ZodString;
+            filterFields: z.ZodArray<z.ZodString, "many">;
+        }, "passthrough", z.ZodTypeAny, {
+            type: "search";
+            name: string;
+            searchField: string;
+            filterFields: string[];
+        }, {
+            type: "search";
+            name: string;
+            searchField: string;
+            filterFields: string[];
+        }>, z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodLiteral<"vector">;
+            dimensions: z.ZodNumber;
+            vectorField: z.ZodString;
+            filterFields: z.ZodArray<z.ZodString, "many">;
+        }, "passthrough", z.ZodTypeAny, {
+            type: "vector";
+            name: string;
+            filterFields: string[];
+            vectorField: string;
+            dimensions: number;
+        }, {
+            type: "vector";
+            name: string;
+            filterFields: string[];
+            vectorField: string;
+            dimensions: number;
+        }>]>, z.ZodObject<{
+            staged: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            staged?: boolean | undefined;
+        }, {
+            staged?: boolean | undefined;
+        }>>, z.ZodObject<{
+            change: z.ZodEnum<["added", "identical", "enabled", "disabled", "dropped"]>;
+            needsBackfill: z.ZodBoolean;
+            numDocs: z.ZodNumber;
+        }, "passthrough", z.ZodTypeAny, {
+            change: "disabled" | "added" | "enabled" | "identical" | "dropped";
+            numDocs: number;
+            needsBackfill: boolean;
+        }, {
+            change: "disabled" | "added" | "enabled" | "identical" | "dropped";
+            numDocs: number;
+            needsBackfill: boolean;
+        }>>, "many">;
+        discardedStagedValidators: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            tableName: z.ZodString;
+            state: z.ZodUnion<[z.ZodObject<{
+                state: z.ZodLiteral<"pending">;
+                numDocsValidated: z.ZodNumber;
+                totalDocs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, "passthrough", z.ZodTypeAny, {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            }, {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            }>, z.ZodObject<{
+                state: z.ZodLiteral<"valid">;
+            }, "passthrough", z.ZodTypeAny, {
+                state: "valid";
+            }, {
+                state: "valid";
+            }>]>;
+            replaced: z.ZodBoolean;
+        }, "passthrough", z.ZodTypeAny, {
+            tableName: string;
+            state: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            };
+            replaced: boolean;
+        }, {
+            tableName: string;
+            state: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            };
+            replaced: boolean;
+        }>, "many">>;
+    }, "passthrough", z.ZodTypeAny, {
+        indexes: ((({
+            type: "database";
+            fields: string[];
+            name: string;
+        } | {
+            type: "search";
+            name: string;
+            searchField: string;
+            filterFields: string[];
+        } | {
+            type: "vector";
+            name: string;
+            filterFields: string[];
+            vectorField: string;
+            dimensions: number;
+        }) & {
+            staged?: boolean | undefined;
+        }) & {
+            change: "disabled" | "added" | "enabled" | "identical" | "dropped";
+            numDocs: number;
+            needsBackfill: boolean;
+        })[];
+        schemaValidation: boolean;
+        tables: {
+            name: string;
+            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
+            numDocs: number;
+            sizeBytes: number;
+            staged?: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            } | {
+                state: "failed";
+                error: string;
+            } | undefined;
+            canSkipAfterStagedValidation?: boolean | undefined;
+        }[];
+        definitionPath: string;
+        discardedStagedValidators?: {
+            tableName: string;
+            state: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            };
+            replaced: boolean;
+        }[] | undefined;
+    }, {
+        indexes: ((({
+            type: "database";
+            fields: string[];
+            name: string;
+        } | {
+            type: "search";
+            name: string;
+            searchField: string;
+            filterFields: string[];
+        } | {
+            type: "vector";
+            name: string;
+            filterFields: string[];
+            vectorField: string;
+            dimensions: number;
+        }) & {
+            staged?: boolean | undefined;
+        }) & {
+            change: "disabled" | "added" | "enabled" | "identical" | "dropped";
+            numDocs: number;
+            needsBackfill: boolean;
+        })[];
+        schemaValidation: boolean;
+        tables: {
+            name: string;
+            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
+            numDocs: number;
+            sizeBytes: number;
+            staged?: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            } | {
+                state: "failed";
+                error: string;
+            } | undefined;
+            canSkipAfterStagedValidation?: boolean | undefined;
+        }[];
+        definitionPath: string;
+        discardedStagedValidators?: {
+            tableName: string;
+            state: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            };
+            replaced: boolean;
+        }[] | undefined;
+    }>>;
+    newComponentDefinitions: z.ZodArray<z.ZodString, "many">;
+}, "passthrough", z.ZodTypeAny, {
+    componentSchemaEvaluations: Record<string, {
+        indexes: ((({
+            type: "database";
+            fields: string[];
+            name: string;
+        } | {
+            type: "search";
+            name: string;
+            searchField: string;
+            filterFields: string[];
+        } | {
+            type: "vector";
+            name: string;
+            filterFields: string[];
+            vectorField: string;
+            dimensions: number;
+        }) & {
+            staged?: boolean | undefined;
+        }) & {
+            change: "disabled" | "added" | "enabled" | "identical" | "dropped";
+            numDocs: number;
+            needsBackfill: boolean;
+        })[];
+        schemaValidation: boolean;
+        tables: {
+            name: string;
+            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
+            numDocs: number;
+            sizeBytes: number;
+            staged?: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            } | {
+                state: "failed";
+                error: string;
+            } | undefined;
+            canSkipAfterStagedValidation?: boolean | undefined;
+        }[];
+        definitionPath: string;
+        discardedStagedValidators?: {
+            tableName: string;
+            state: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            };
+            replaced: boolean;
+        }[] | undefined;
+    }>;
+    newComponentDefinitions: string[];
+}, {
+    componentSchemaEvaluations: Record<string, {
+        indexes: ((({
+            type: "database";
+            fields: string[];
+            name: string;
+        } | {
+            type: "search";
+            name: string;
+            searchField: string;
+            filterFields: string[];
+        } | {
+            type: "vector";
+            name: string;
+            filterFields: string[];
+            vectorField: string;
+            dimensions: number;
+        }) & {
+            staged?: boolean | undefined;
+        }) & {
+            change: "disabled" | "added" | "enabled" | "identical" | "dropped";
+            numDocs: number;
+            needsBackfill: boolean;
+        })[];
+        schemaValidation: boolean;
+        tables: {
+            name: string;
+            outcome: "notValidated" | "supersetOfEnforced" | "supersetOfStagedValidated" | "supersetOfShape" | "mustWalk";
+            numDocs: number;
+            sizeBytes: number;
+            staged?: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            } | {
+                state: "failed";
+                error: string;
+            } | undefined;
+            canSkipAfterStagedValidation?: boolean | undefined;
+        }[];
+        definitionPath: string;
+        discardedStagedValidators?: {
+            tableName: string;
+            state: {
+                state: "pending";
+                numDocsValidated: number;
+                totalDocs?: number | null | undefined;
+            } | {
+                state: "valid";
+            };
+            replaced: boolean;
+        }[] | undefined;
+    }>;
+    newComponentDefinitions: string[];
+}>;
+export type EvaluateSchemaResponse = z.infer<typeof evaluateSchemaResponse>;
+//# sourceMappingURL=evaluateSchema.d.ts.map