import * as drizzle_orm from 'drizzle-orm';
import { AnyMySqlTable, MySqlSchema, MySqlView } from 'drizzle-orm/mysql-core';
import { D as DrizzleLab } from './symbols-CdI5QtS4.cjs';
import { D as DrizzleSchema } from './global-v_LCR4XD.cjs';
import { Relations } from 'drizzle-orm/relations';
import { P as PartialConfig } from './loader.node-Bo9Dqnt1.cjs';
import * as zod from 'zod';
import { TypeOf } from 'zod';

declare const schemaInternal: zod.ZodObject<{
    version: zod.ZodLiteral<"5">;
    dialect: zod.ZodLiteral<"mysql">;
    tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
        name: zod.ZodString;
        columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
            name: zod.ZodString;
            type: zod.ZodString;
            primaryKey: zod.ZodBoolean;
            notNull: zod.ZodBoolean;
            autoincrement: zod.ZodOptional<zod.ZodBoolean>;
            default: zod.ZodOptional<zod.ZodAny>;
            onUpdate: zod.ZodOptional<zod.ZodAny>;
            generated: zod.ZodOptional<zod.ZodObject<{
                type: zod.ZodEnum<["stored", "virtual"]>;
                as: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                type: "virtual" | "stored";
                as: string;
            }, {
                type: "virtual" | "stored";
                as: string;
            }>>;
            enumValues: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
            defaultFn: zod.ZodOptional<zod.ZodString>;
            onUpdateFn: zod.ZodOptional<zod.ZodString>;
            description: zod.ZodOptional<zod.ZodString>;
            jsonShape: zod.ZodOptional<zod.ZodString>;
        }, "strict", zod.ZodTypeAny, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            default?: any;
            onUpdate?: any;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
            autoincrement?: boolean | undefined;
        }, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            default?: any;
            onUpdate?: any;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
            autoincrement?: boolean | undefined;
        }>>;
        indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
            name: zod.ZodString;
            columns: zod.ZodArray<zod.ZodString, "many">;
            isUnique: zod.ZodBoolean;
            using: zod.ZodOptional<zod.ZodEnum<["btree", "hash"]>>;
            algorithm: zod.ZodOptional<zod.ZodEnum<["default", "inplace", "copy"]>>;
            lock: zod.ZodOptional<zod.ZodEnum<["default", "none", "shared", "exclusive"]>>;
        }, "strict", zod.ZodTypeAny, {
            name: string;
            columns: string[];
            isUnique: boolean;
            using?: "btree" | "hash" | undefined;
            algorithm?: "default" | "inplace" | "copy" | undefined;
            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
        }, {
            name: string;
            columns: string[];
            isUnique: boolean;
            using?: "btree" | "hash" | undefined;
            algorithm?: "default" | "inplace" | "copy" | undefined;
            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
        }>>;
        foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
            name: zod.ZodString;
            tableFrom: zod.ZodString;
            columnsFrom: zod.ZodArray<zod.ZodString, "many">;
            tableTo: zod.ZodString;
            schemaTo: zod.ZodOptional<zod.ZodString>;
            columnsTo: zod.ZodArray<zod.ZodString, "many">;
            onUpdate: zod.ZodOptional<zod.ZodString>;
            onDelete: zod.ZodOptional<zod.ZodString>;
        }, "strict", zod.ZodTypeAny, {
            name: string;
            tableFrom: string;
            columnsFrom: string[];
            tableTo: string;
            columnsTo: string[];
            onDelete?: string | undefined;
            onUpdate?: string | undefined;
            schemaTo?: string | undefined;
        }, {
            name: string;
            tableFrom: string;
            columnsFrom: string[];
            tableTo: string;
            columnsTo: string[];
            onDelete?: string | undefined;
            onUpdate?: string | undefined;
            schemaTo?: string | undefined;
        }>>;
        compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
            name: zod.ZodString;
            columns: zod.ZodArray<zod.ZodString, "many">;
        }, "strict", zod.ZodTypeAny, {
            name: string;
            columns: string[];
        }, {
            name: string;
            columns: string[];
        }>>;
        uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
            name: zod.ZodString;
            columns: zod.ZodArray<zod.ZodString, "many">;
        }, "strict", zod.ZodTypeAny, {
            name: string;
            columns: string[];
        }, {
            name: string;
            columns: string[];
        }>>>;
        checkConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
            name: zod.ZodString;
            value: zod.ZodString;
        }, "strict", zod.ZodTypeAny, {
            value: string;
            name: string;
        }, {
            value: string;
            name: string;
        }>>>;
        schema: zod.ZodString;
        relations: zod.ZodDefault<zod.ZodArray<zod.ZodObject<{
            type: zod.ZodEnum<["many", "one"]>;
            fieldName: zod.ZodString;
            relationName: zod.ZodString;
            referencedTableName: zod.ZodString;
        }, "strict", zod.ZodTypeAny, {
            type: "many" | "one";
            fieldName: string;
            relationName: string;
            referencedTableName: string;
        }, {
            type: "many" | "one";
            fieldName: string;
            relationName: string;
            referencedTableName: string;
        }>, "many">>;
        description: zod.ZodOptional<zod.ZodString>;
    }, "strict", zod.ZodTypeAny, {
        name: string;
        schema: string;
        columns: Record<string, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            default?: any;
            onUpdate?: any;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
            autoincrement?: boolean | undefined;
        }>;
        relations: {
            type: "many" | "one";
            fieldName: string;
            relationName: string;
            referencedTableName: string;
        }[];
        indexes: Record<string, {
            name: string;
            columns: string[];
            isUnique: boolean;
            using?: "btree" | "hash" | undefined;
            algorithm?: "default" | "inplace" | "copy" | undefined;
            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
        }>;
        foreignKeys: Record<string, {
            name: string;
            tableFrom: string;
            columnsFrom: string[];
            tableTo: string;
            columnsTo: string[];
            onDelete?: string | undefined;
            onUpdate?: string | undefined;
            schemaTo?: string | undefined;
        }>;
        compositePrimaryKeys: Record<string, {
            name: string;
            columns: string[];
        }>;
        uniqueConstraints: Record<string, {
            name: string;
            columns: string[];
        }>;
        checkConstraints: Record<string, {
            value: string;
            name: string;
        }>;
        description?: string | undefined;
    }, {
        name: string;
        schema: string;
        columns: Record<string, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            default?: any;
            onUpdate?: any;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
            autoincrement?: boolean | undefined;
        }>;
        indexes: Record<string, {
            name: string;
            columns: string[];
            isUnique: boolean;
            using?: "btree" | "hash" | undefined;
            algorithm?: "default" | "inplace" | "copy" | undefined;
            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
        }>;
        foreignKeys: Record<string, {
            name: string;
            tableFrom: string;
            columnsFrom: string[];
            tableTo: string;
            columnsTo: string[];
            onDelete?: string | undefined;
            onUpdate?: string | undefined;
            schemaTo?: string | undefined;
        }>;
        compositePrimaryKeys: Record<string, {
            name: string;
            columns: string[];
        }>;
        description?: string | undefined;
        relations?: {
            type: "many" | "one";
            fieldName: string;
            relationName: string;
            referencedTableName: string;
        }[] | undefined;
        uniqueConstraints?: Record<string, {
            name: string;
            columns: string[];
        }> | undefined;
        checkConstraints?: Record<string, {
            value: string;
            name: string;
        }> | undefined;
    }>>;
    views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<zod.objectUtil.extendShape<{
        name: zod.ZodString;
        schema: zod.ZodString;
        columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
            name: zod.ZodString;
            type: zod.ZodString;
            primaryKey: zod.ZodBoolean;
            notNull: zod.ZodBoolean;
            autoincrement: zod.ZodOptional<zod.ZodBoolean>;
            default: zod.ZodOptional<zod.ZodAny>;
            onUpdate: zod.ZodOptional<zod.ZodAny>;
            generated: zod.ZodOptional<zod.ZodObject<{
                type: zod.ZodEnum<["stored", "virtual"]>;
                as: zod.ZodString;
            }, "strip", zod.ZodTypeAny, {
                type: "virtual" | "stored";
                as: string;
            }, {
                type: "virtual" | "stored";
                as: string;
            }>>;
            enumValues: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
            defaultFn: zod.ZodOptional<zod.ZodString>;
            onUpdateFn: zod.ZodOptional<zod.ZodString>;
            description: zod.ZodOptional<zod.ZodString>;
            jsonShape: zod.ZodOptional<zod.ZodString>;
        }, "strict", zod.ZodTypeAny, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            default?: any;
            onUpdate?: any;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
            autoincrement?: boolean | undefined;
        }, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            default?: any;
            onUpdate?: any;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
            autoincrement?: boolean | undefined;
        }>>;
        definition: zod.ZodOptional<zod.ZodString>;
        isExisting: zod.ZodBoolean;
        description: zod.ZodOptional<zod.ZodString>;
    }, {
        algorithm: zod.ZodEnum<["undefined", "merge", "temptable"]>;
        sqlSecurity: zod.ZodEnum<["definer", "invoker"]>;
        withCheckOption: zod.ZodOptional<zod.ZodEnum<["local", "cascaded"]>>;
    }>, "strict", zod.ZodTypeAny, {
        name: string;
        schema: string;
        columns: Record<string, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            default?: any;
            onUpdate?: any;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
            autoincrement?: boolean | undefined;
        }>;
        isExisting: boolean;
        algorithm: "undefined" | "merge" | "temptable";
        sqlSecurity: "definer" | "invoker";
        description?: string | undefined;
        definition?: string | undefined;
        withCheckOption?: "local" | "cascaded" | undefined;
    }, {
        name: string;
        schema: string;
        columns: Record<string, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            default?: any;
            onUpdate?: any;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
            autoincrement?: boolean | undefined;
        }>;
        isExisting: boolean;
        algorithm: "undefined" | "merge" | "temptable";
        sqlSecurity: "definer" | "invoker";
        description?: string | undefined;
        definition?: string | undefined;
        withCheckOption?: "local" | "cascaded" | undefined;
    }>>>;
    _meta: zod.ZodObject<{
        tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
        columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
    }, "strip", zod.ZodTypeAny, {
        columns: Record<string, string>;
        tables: Record<string, string>;
    }, {
        columns: Record<string, string>;
        tables: Record<string, string>;
    }>;
    internal: zod.ZodOptional<zod.ZodObject<{
        tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
            columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
                isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
            }, "strip", zod.ZodTypeAny, {
                isDefaultAnExpression?: boolean | undefined;
            }, {
                isDefaultAnExpression?: boolean | undefined;
            }>>>;
        }, "strip", zod.ZodTypeAny, {
            columns: Record<string, {
                isDefaultAnExpression?: boolean | undefined;
            } | undefined>;
        }, {
            columns: Record<string, {
                isDefaultAnExpression?: boolean | undefined;
            } | undefined>;
        }>>>>;
        indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
            columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
                isExpression: zod.ZodOptional<zod.ZodBoolean>;
            }, "strip", zod.ZodTypeAny, {
                isExpression?: boolean | undefined;
            }, {
                isExpression?: boolean | undefined;
            }>>>;
        }, "strip", zod.ZodTypeAny, {
            columns: Record<string, {
                isExpression?: boolean | undefined;
            } | undefined>;
        }, {
            columns: Record<string, {
                isExpression?: boolean | undefined;
            } | undefined>;
        }>>>>;
    }, "strip", zod.ZodTypeAny, {
        tables?: Record<string, {
            columns: Record<string, {
                isDefaultAnExpression?: boolean | undefined;
            } | undefined>;
        } | undefined> | undefined;
        indexes?: Record<string, {
            columns: Record<string, {
                isExpression?: boolean | undefined;
            } | undefined>;
        } | undefined> | undefined;
    }, {
        tables?: Record<string, {
            columns: Record<string, {
                isDefaultAnExpression?: boolean | undefined;
            } | undefined>;
        } | undefined> | undefined;
        indexes?: Record<string, {
            columns: Record<string, {
                isExpression?: boolean | undefined;
            } | undefined>;
        } | undefined> | undefined;
    }>>;
    schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
    projectId: zod.ZodDefault<zod.ZodOptional<zod.ZodString>>;
}, "strict", zod.ZodTypeAny, {
    dialect: "mysql";
    tables: Record<string, {
        name: string;
        schema: string;
        columns: Record<string, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            default?: any;
            onUpdate?: any;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
            autoincrement?: boolean | undefined;
        }>;
        relations: {
            type: "many" | "one";
            fieldName: string;
            relationName: string;
            referencedTableName: string;
        }[];
        indexes: Record<string, {
            name: string;
            columns: string[];
            isUnique: boolean;
            using?: "btree" | "hash" | undefined;
            algorithm?: "default" | "inplace" | "copy" | undefined;
            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
        }>;
        foreignKeys: Record<string, {
            name: string;
            tableFrom: string;
            columnsFrom: string[];
            tableTo: string;
            columnsTo: string[];
            onDelete?: string | undefined;
            onUpdate?: string | undefined;
            schemaTo?: string | undefined;
        }>;
        compositePrimaryKeys: Record<string, {
            name: string;
            columns: string[];
        }>;
        uniqueConstraints: Record<string, {
            name: string;
            columns: string[];
        }>;
        checkConstraints: Record<string, {
            value: string;
            name: string;
        }>;
        description?: string | undefined;
    }>;
    schemas: Record<string, string>;
    views: Record<string, {
        name: string;
        schema: string;
        columns: Record<string, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            default?: any;
            onUpdate?: any;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
            autoincrement?: boolean | undefined;
        }>;
        isExisting: boolean;
        algorithm: "undefined" | "merge" | "temptable";
        sqlSecurity: "definer" | "invoker";
        description?: string | undefined;
        definition?: string | undefined;
        withCheckOption?: "local" | "cascaded" | undefined;
    }>;
    projectId: string;
    version: "5";
    _meta: {
        columns: Record<string, string>;
        tables: Record<string, string>;
    };
    internal?: {
        tables?: Record<string, {
            columns: Record<string, {
                isDefaultAnExpression?: boolean | undefined;
            } | undefined>;
        } | undefined> | undefined;
        indexes?: Record<string, {
            columns: Record<string, {
                isExpression?: boolean | undefined;
            } | undefined>;
        } | undefined> | undefined;
    } | undefined;
}, {
    dialect: "mysql";
    tables: Record<string, {
        name: string;
        schema: string;
        columns: Record<string, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            default?: any;
            onUpdate?: any;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
            autoincrement?: boolean | undefined;
        }>;
        indexes: Record<string, {
            name: string;
            columns: string[];
            isUnique: boolean;
            using?: "btree" | "hash" | undefined;
            algorithm?: "default" | "inplace" | "copy" | undefined;
            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
        }>;
        foreignKeys: Record<string, {
            name: string;
            tableFrom: string;
            columnsFrom: string[];
            tableTo: string;
            columnsTo: string[];
            onDelete?: string | undefined;
            onUpdate?: string | undefined;
            schemaTo?: string | undefined;
        }>;
        compositePrimaryKeys: Record<string, {
            name: string;
            columns: string[];
        }>;
        description?: string | undefined;
        relations?: {
            type: "many" | "one";
            fieldName: string;
            relationName: string;
            referencedTableName: string;
        }[] | undefined;
        uniqueConstraints?: Record<string, {
            name: string;
            columns: string[];
        }> | undefined;
        checkConstraints?: Record<string, {
            value: string;
            name: string;
        }> | undefined;
    }>;
    schemas: Record<string, string>;
    version: "5";
    _meta: {
        columns: Record<string, string>;
        tables: Record<string, string>;
    };
    views?: Record<string, {
        name: string;
        schema: string;
        columns: Record<string, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            default?: any;
            onUpdate?: any;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
            autoincrement?: boolean | undefined;
        }>;
        isExisting: boolean;
        algorithm: "undefined" | "merge" | "temptable";
        sqlSecurity: "definer" | "invoker";
        description?: string | undefined;
        definition?: string | undefined;
        withCheckOption?: "local" | "cascaded" | undefined;
    }> | undefined;
    projectId?: string | undefined;
    internal?: {
        tables?: Record<string, {
            columns: Record<string, {
                isDefaultAnExpression?: boolean | undefined;
            } | undefined>;
        } | undefined> | undefined;
        indexes?: Record<string, {
            columns: Record<string, {
                isExpression?: boolean | undefined;
            } | undefined>;
        } | undefined> | undefined;
    } | undefined;
}>;
type MySqlSchemaInternal = TypeOf<typeof schemaInternal>;
type Snapshot = MySqlSchemaInternal;

type DrizzleObjects = Omit<ReturnType<typeof schemaToDrizzleObjects>, typeof DrizzleLab>;
/**
 * Map the Drizzle objects from the Drizzle schema.
 * @param drizzleSchema - The Drizzle schema to map the objects from.
 * @returns Drizzle objects
 */
declare function schemaToDrizzleObjects(drizzleSchema: DrizzleSchema): {
    tables: AnyMySqlTable[];
    schemas: MySqlSchema<string>[];
    views: MySqlView<string, boolean, drizzle_orm.ColumnsSelection>[];
    relations: drizzle_orm.TableRelationalConfig[];
    [DrizzleLab]: {
        drizzleRelations: Relations<string, Record<string, drizzle_orm.Relation<string>>>[];
    };
};

declare function schemaToSnapshot(schema: DrizzleSchema, config?: PartialConfig): {
    dialect: "mysql";
    projectId: string;
    tables: Record<string, {
        schema: string;
        name: string;
        columns: Record<string, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            default?: any;
            onUpdate?: any;
            autoincrement?: boolean | undefined;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
        }>;
        indexes: Record<string, {
            name: string;
            columns: string[];
            isUnique: boolean;
            using?: "btree" | "hash" | undefined;
            algorithm?: "default" | "inplace" | "copy" | undefined;
            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
        }>;
        foreignKeys: Record<string, {
            name: string;
            tableFrom: string;
            columnsFrom: string[];
            tableTo: string;
            columnsTo: string[];
            schemaTo?: string | undefined;
            onUpdate?: string | undefined;
            onDelete?: string | undefined;
        }>;
        compositePrimaryKeys: Record<string, {
            name: string;
            columns: string[];
        }>;
        uniqueConstraints: Record<string, {
            name: string;
            columns: string[];
        }>;
        checkConstraints: Record<string, {
            value: string;
            name: string;
        }>;
        relations: {
            type: "many" | "one";
            fieldName: string;
            relationName: string;
            referencedTableName: string;
        }[];
        description?: string | undefined;
    }>;
    version: "5";
    schemas: Record<string, string>;
    _meta: {
        columns: Record<string, string>;
        tables: Record<string, string>;
    };
    views: Record<string, {
        schema: string;
        name: string;
        columns: Record<string, {
            type: string;
            name: string;
            notNull: boolean;
            primaryKey: boolean;
            enumValues?: string[] | undefined;
            description?: string | undefined;
            default?: any;
            onUpdate?: any;
            autoincrement?: boolean | undefined;
            generated?: {
                type: "virtual" | "stored";
                as: string;
            } | undefined;
            defaultFn?: string | undefined;
            onUpdateFn?: string | undefined;
            jsonShape?: string | undefined;
        }>;
        algorithm: "undefined" | "merge" | "temptable";
        sqlSecurity: "definer" | "invoker";
        isExisting: boolean;
        description?: string | undefined;
        withCheckOption?: "local" | "cascaded" | undefined;
        definition?: string | undefined;
    }>;
    internal?: {
        indexes?: Record<string, {
            columns: Record<string, {
                isExpression?: boolean | undefined;
            } | undefined>;
        } | undefined> | undefined;
        tables?: Record<string, {
            columns: Record<string, {
                isDefaultAnExpression?: boolean | undefined;
            } | undefined>;
        } | undefined> | undefined;
    } | undefined;
};
/**
 * Generate a snapshot from the Drizzle objects.
 * @param drizzleObjects - The Drizzle objects to generate a snapshot from.
 * @param config - The Drizzle configuration to use for the snapshot.
 * @returns A snapshot of the Drizzle objects.
 */
declare function drizzleObjectsToSnapshot({ tables, views, relations, schemas }: DrizzleObjects, config?: PartialConfig): Snapshot;

export { type DrizzleObjects as D, type MySqlSchemaInternal as M, type Snapshot as S, schemaToSnapshot as a, drizzleObjectsToSnapshot as d, schemaToDrizzleObjects as s };