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";
    name: string;
    fields: string[];
}, {
    type: "database";
    name: string;
    fields: 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";
        name: string;
        fields: string[];
    }, {
        type: "database";
        name: string;
        fields: 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";
        name: string;
        fields: 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";
        name: string;
        fields: 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";
            name: string;
            fields: string[];
        }, {
            type: "database";
            name: string;
            fields: 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";
            name: string;
            fields: 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";
            name: string;
            fields: 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";
            name: string;
            fields: 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";
            name: string;
            fields: 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