drizzle-kit 0.20.17-cab52ad → 0.20.17-d71f2ee

package/serializer/sqliteSchema.d.ts

@@ -0,0 +1,2801 @@
+import { TypeOf } from "zod";
+declare const index: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+    where: import("zod").ZodOptional<import("zod").ZodString>;
+    isUnique: import("zod").ZodBoolean;
+}, "strict", import("zod").ZodTypeAny, {
+    name: string;
+    columns: string[];
+    isUnique: boolean;
+    where?: string | undefined;
+}, {
+    name: string;
+    columns: string[];
+    isUnique: boolean;
+    where?: string | undefined;
+}>;
+declare const fk: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    tableFrom: import("zod").ZodString;
+    columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
+    tableTo: import("zod").ZodString;
+    columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
+    onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
+    onDelete: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strict", import("zod").ZodTypeAny, {
+    name: string;
+    tableFrom: string;
+    columnsFrom: string[];
+    tableTo: string;
+    columnsTo: string[];
+    onUpdate?: string | undefined;
+    onDelete?: string | undefined;
+}, {
+    name: string;
+    tableFrom: string;
+    columnsFrom: string[];
+    tableTo: string;
+    columnsTo: string[];
+    onUpdate?: string | undefined;
+    onDelete?: string | undefined;
+}>;
+declare const compositePK: import("zod").ZodObject<{
+    columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strict", import("zod").ZodTypeAny, {
+    columns: string[];
+    name?: string | undefined;
+}, {
+    columns: string[];
+    name?: string | undefined;
+}>;
+declare const column: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    type: import("zod").ZodString;
+    primaryKey: import("zod").ZodBoolean;
+    notNull: import("zod").ZodBoolean;
+    autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    default: import("zod").ZodOptional<import("zod").ZodAny>;
+}, "strict", import("zod").ZodTypeAny, {
+    name: string;
+    type: string;
+    primaryKey: boolean;
+    notNull: boolean;
+    default?: any;
+    autoincrement?: boolean | undefined;
+}, {
+    name: string;
+    type: string;
+    primaryKey: boolean;
+    notNull: boolean;
+    default?: any;
+    autoincrement?: boolean | undefined;
+}>;
+declare const uniqueConstraint: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+}, "strict", import("zod").ZodTypeAny, {
+    name: string;
+    columns: string[];
+}, {
+    name: string;
+    columns: string[];
+}>;
+declare const table: import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        type: import("zod").ZodString;
+        primaryKey: import("zod").ZodBoolean;
+        notNull: import("zod").ZodBoolean;
+        autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        default: import("zod").ZodOptional<import("zod").ZodAny>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        type: string;
+        primaryKey: boolean;
+        notNull: boolean;
+        default?: any;
+        autoincrement?: boolean | undefined;
+    }, {
+        name: string;
+        type: string;
+        primaryKey: boolean;
+        notNull: boolean;
+        default?: any;
+        autoincrement?: boolean | undefined;
+    }>>;
+    indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+        where: import("zod").ZodOptional<import("zod").ZodString>;
+        isUnique: import("zod").ZodBoolean;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: string[];
+        isUnique: boolean;
+        where?: string | undefined;
+    }, {
+        name: string;
+        columns: string[];
+        isUnique: boolean;
+        where?: string | undefined;
+    }>>;
+    foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        tableFrom: import("zod").ZodString;
+        columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
+        tableTo: import("zod").ZodString;
+        columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
+        onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
+        onDelete: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        tableFrom: string;
+        columnsFrom: string[];
+        tableTo: string;
+        columnsTo: string[];
+        onUpdate?: string | undefined;
+        onDelete?: string | undefined;
+    }, {
+        name: string;
+        tableFrom: string;
+        columnsFrom: string[];
+        tableTo: string;
+        columnsTo: string[];
+        onUpdate?: string | undefined;
+        onDelete?: string | undefined;
+    }>>;
+    compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strict", import("zod").ZodTypeAny, {
+        columns: string[];
+        name?: string | undefined;
+    }, {
+        columns: string[];
+        name?: string | undefined;
+    }>>;
+    uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: string[];
+    }, {
+        name: string;
+        columns: string[];
+    }>>>;
+}, "strict", import("zod").ZodTypeAny, {
+    name: string;
+    columns: Record<string, {
+        name: string;
+        type: string;
+        primaryKey: boolean;
+        notNull: boolean;
+        default?: any;
+        autoincrement?: boolean | undefined;
+    }>;
+    indexes: Record<string, {
+        name: string;
+        columns: string[];
+        isUnique: boolean;
+        where?: string | undefined;
+    }>;
+    foreignKeys: Record<string, {
+        name: string;
+        tableFrom: string;
+        columnsFrom: string[];
+        tableTo: string;
+        columnsTo: string[];
+        onUpdate?: string | undefined;
+        onDelete?: string | undefined;
+    }>;
+    compositePrimaryKeys: Record<string, {
+        columns: string[];
+        name?: string | undefined;
+    }>;
+    uniqueConstraints: Record<string, {
+        name: string;
+        columns: string[];
+    }>;
+}, {
+    name: string;
+    columns: Record<string, {
+        name: string;
+        type: string;
+        primaryKey: boolean;
+        notNull: boolean;
+        default?: any;
+        autoincrement?: boolean | undefined;
+    }>;
+    indexes: Record<string, {
+        name: string;
+        columns: string[];
+        isUnique: boolean;
+        where?: string | undefined;
+    }>;
+    foreignKeys: Record<string, {
+        name: string;
+        tableFrom: string;
+        columnsFrom: string[];
+        tableTo: string;
+        columnsTo: string[];
+        onUpdate?: string | undefined;
+        onDelete?: string | undefined;
+    }>;
+    compositePrimaryKeys: Record<string, {
+        columns: string[];
+        name?: string | undefined;
+    }>;
+    uniqueConstraints?: Record<string, {
+        name: string;
+        columns: string[];
+    }> | undefined;
+}>;
+declare const dialect: import("zod").ZodEnum<["sqlite"]>;
+export declare const schemaInternalV3: import("zod").ZodObject<{
+    version: import("zod").ZodLiteral<"3">;
+    dialect: import("zod").ZodEnum<["sqlite"]>;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            primaryKey: import("zod").ZodBoolean;
+            notNull: import("zod").ZodBoolean;
+            autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            default: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            where: import("zod").ZodOptional<import("zod").ZodString>;
+            isUnique: import("zod").ZodBoolean;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>>;
+        foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            tableFrom: import("zod").ZodString;
+            columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
+            tableTo: import("zod").ZodString;
+            columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
+            onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
+            onDelete: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+    }>>;
+    enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
+}, "strict", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+    }>;
+    version: "3";
+    dialect: "sqlite";
+    enums: {};
+}, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+    }>;
+    version: "3";
+    dialect: "sqlite";
+    enums: {};
+}>;
+export declare const schemaInternalV4: import("zod").ZodObject<{
+    version: import("zod").ZodLiteral<"4">;
+    dialect: import("zod").ZodEnum<["sqlite"]>;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            primaryKey: import("zod").ZodBoolean;
+            notNull: import("zod").ZodBoolean;
+            autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            default: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            where: import("zod").ZodOptional<import("zod").ZodString>;
+            isUnique: import("zod").ZodBoolean;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>>;
+        foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            tableFrom: import("zod").ZodString;
+            columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
+            tableTo: import("zod").ZodString;
+            columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
+            onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
+            onDelete: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>>;
+        compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            columns: string[];
+            name?: string | undefined;
+        }, {
+            columns: string[];
+            name?: string | undefined;
+        }>>;
+        uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+        }, {
+            name: string;
+            columns: string[];
+        }>>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>>;
+    enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
+}, "strict", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>;
+    version: "4";
+    dialect: "sqlite";
+    enums: {};
+}, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>;
+    version: "4";
+    dialect: "sqlite";
+    enums: {};
+}>;
+export declare const schemaInternal: import("zod").ZodObject<{
+    version: import("zod").ZodLiteral<"5">;
+    dialect: import("zod").ZodEnum<["sqlite"]>;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            primaryKey: import("zod").ZodBoolean;
+            notNull: import("zod").ZodBoolean;
+            autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            default: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            where: import("zod").ZodOptional<import("zod").ZodString>;
+            isUnique: import("zod").ZodBoolean;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>>;
+        foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            tableFrom: import("zod").ZodString;
+            columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
+            tableTo: import("zod").ZodString;
+            columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
+            onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
+            onDelete: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>>;
+        compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            columns: string[];
+            name?: string | undefined;
+        }, {
+            columns: string[];
+            name?: string | undefined;
+        }>>;
+        uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+        }, {
+            name: string;
+            columns: string[];
+        }>>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>>;
+    enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
+    _meta: import("zod").ZodObject<{
+        tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    }, {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>;
+    version: "5";
+    dialect: "sqlite";
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    };
+    enums: {};
+}, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>;
+    version: "5";
+    dialect: "sqlite";
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    };
+    enums: {};
+}>;
+export declare const schemaV3: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    version: import("zod").ZodLiteral<"3">;
+    dialect: import("zod").ZodEnum<["sqlite"]>;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            primaryKey: import("zod").ZodBoolean;
+            notNull: import("zod").ZodBoolean;
+            autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            default: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            where: import("zod").ZodOptional<import("zod").ZodString>;
+            isUnique: import("zod").ZodBoolean;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>>;
+        foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            tableFrom: import("zod").ZodString;
+            columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
+            tableTo: import("zod").ZodString;
+            columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
+            onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
+            onDelete: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+    }>>;
+    enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
+}, {
+    id: import("zod").ZodString;
+    prevId: import("zod").ZodString;
+}>, "strict", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "3";
+    dialect: "sqlite";
+    enums: {};
+}, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "3";
+    dialect: "sqlite";
+    enums: {};
+}>;
+export declare const schemaV4: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    version: import("zod").ZodLiteral<"4">;
+    dialect: import("zod").ZodEnum<["sqlite"]>;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            primaryKey: import("zod").ZodBoolean;
+            notNull: import("zod").ZodBoolean;
+            autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            default: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            where: import("zod").ZodOptional<import("zod").ZodString>;
+            isUnique: import("zod").ZodBoolean;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>>;
+        foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            tableFrom: import("zod").ZodString;
+            columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
+            tableTo: import("zod").ZodString;
+            columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
+            onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
+            onDelete: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>>;
+        compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            columns: string[];
+            name?: string | undefined;
+        }, {
+            columns: string[];
+            name?: string | undefined;
+        }>>;
+        uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+        }, {
+            name: string;
+            columns: string[];
+        }>>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>>;
+    enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
+}, {
+    id: import("zod").ZodString;
+    prevId: import("zod").ZodString;
+}>, "strict", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "4";
+    dialect: "sqlite";
+    enums: {};
+}, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>;
+    id: string;
+    prevId: string;
+    version: "4";
+    dialect: "sqlite";
+    enums: {};
+}>;
+export declare const schema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    version: import("zod").ZodLiteral<"5">;
+    dialect: import("zod").ZodEnum<["sqlite"]>;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            primaryKey: import("zod").ZodBoolean;
+            notNull: import("zod").ZodBoolean;
+            autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            default: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            where: import("zod").ZodOptional<import("zod").ZodString>;
+            isUnique: import("zod").ZodBoolean;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>>;
+        foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            tableFrom: import("zod").ZodString;
+            columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
+            tableTo: import("zod").ZodString;
+            columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
+            onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
+            onDelete: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>>;
+        compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            columns: string[];
+            name?: string | undefined;
+        }, {
+            columns: string[];
+            name?: string | undefined;
+        }>>;
+        uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+        }, {
+            name: string;
+            columns: string[];
+        }>>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>>;
+    enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
+    _meta: import("zod").ZodObject<{
+        tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    }, {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    }>;
+}, {
+    id: import("zod").ZodString;
+    prevId: import("zod").ZodString;
+}>, "strict", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "sqlite";
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    };
+    enums: {};
+}, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "sqlite";
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    };
+    enums: {};
+}>;
+export declare const schemaSquashed: import("zod").ZodObject<{
+    version: import("zod").ZodLiteral<"5">;
+    dialect: import("zod").ZodEnum<["sqlite"]>;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            primaryKey: import("zod").ZodBoolean;
+            notNull: import("zod").ZodBoolean;
+            autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            default: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints: Record<string, string>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints?: Record<string, string> | undefined;
+    }>>;
+    enums: import("zod").ZodAny;
+}, "strict", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints: Record<string, string>;
+    }>;
+    version: "5";
+    dialect: "sqlite";
+    enums?: any;
+}, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints?: Record<string, string> | undefined;
+    }>;
+    version: "5";
+    dialect: "sqlite";
+    enums?: any;
+}>;
+export type Dialect = TypeOf<typeof dialect>;
+export type Column = TypeOf<typeof column>;
+export type Table = TypeOf<typeof table>;
+export type SQLiteSchema = TypeOf<typeof schema>;
+export type SQLiteSchemaV3 = TypeOf<typeof schemaV3>;
+export type SQLiteSchemaV4 = TypeOf<typeof schemaV4>;
+export type SQLiteSchemaInternal = TypeOf<typeof schemaInternal>;
+export type SQLiteSchemaSquashed = TypeOf<typeof schemaSquashed>;
+export type Index = TypeOf<typeof index>;
+export type ForeignKey = TypeOf<typeof fk>;
+export type PrimaryKey = TypeOf<typeof compositePK>;
+export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
+export declare const SQLiteSquasher: {
+    squashIdx: (idx: Index) => string;
+    unsquashIdx: (input: string) => Index;
+    squashUnique: (unq: UniqueConstraint) => string;
+    unsquashUnique: (unq: string) => UniqueConstraint;
+    squashFK: (fk: ForeignKey) => string;
+    unsquashFK: (input: string) => ForeignKey;
+    squashPK: (pk: PrimaryKey) => string;
+    unsquashPK: (pk: string) => string[];
+};
+export declare const squashSqliteScheme: (json: SQLiteSchema | SQLiteSchemaV4) => SQLiteSchemaSquashed;
+export declare const drySQLite: {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "sqlite";
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    };
+    enums: {};
+};
+export declare const sqliteSchemaV3: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    version: import("zod").ZodLiteral<"3">;
+    dialect: import("zod").ZodEnum<["sqlite"]>;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            primaryKey: import("zod").ZodBoolean;
+            notNull: import("zod").ZodBoolean;
+            autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            default: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            where: import("zod").ZodOptional<import("zod").ZodString>;
+            isUnique: import("zod").ZodBoolean;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>>;
+        foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            tableFrom: import("zod").ZodString;
+            columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
+            tableTo: import("zod").ZodString;
+            columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
+            onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
+            onDelete: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+    }>>;
+    enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
+}, {
+    id: import("zod").ZodString;
+    prevId: import("zod").ZodString;
+}>, "strict", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "3";
+    dialect: "sqlite";
+    enums: {};
+}, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "3";
+    dialect: "sqlite";
+    enums: {};
+}>;
+export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    version: import("zod").ZodLiteral<"4">;
+    dialect: import("zod").ZodEnum<["sqlite"]>;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            primaryKey: import("zod").ZodBoolean;
+            notNull: import("zod").ZodBoolean;
+            autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            default: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            where: import("zod").ZodOptional<import("zod").ZodString>;
+            isUnique: import("zod").ZodBoolean;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>>;
+        foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            tableFrom: import("zod").ZodString;
+            columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
+            tableTo: import("zod").ZodString;
+            columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
+            onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
+            onDelete: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>>;
+        compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            columns: string[];
+            name?: string | undefined;
+        }, {
+            columns: string[];
+            name?: string | undefined;
+        }>>;
+        uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+        }, {
+            name: string;
+            columns: string[];
+        }>>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>>;
+    enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
+}, {
+    id: import("zod").ZodString;
+    prevId: import("zod").ZodString;
+}>, "strict", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "4";
+    dialect: "sqlite";
+    enums: {};
+}, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>;
+    id: string;
+    prevId: string;
+    version: "4";
+    dialect: "sqlite";
+    enums: {};
+}>;
+export declare const sqliteSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    version: import("zod").ZodLiteral<"5">;
+    dialect: import("zod").ZodEnum<["sqlite"]>;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            primaryKey: import("zod").ZodBoolean;
+            notNull: import("zod").ZodBoolean;
+            autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            default: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            where: import("zod").ZodOptional<import("zod").ZodString>;
+            isUnique: import("zod").ZodBoolean;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>>;
+        foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            tableFrom: import("zod").ZodString;
+            columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
+            tableTo: import("zod").ZodString;
+            columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
+            onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
+            onDelete: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>>;
+        compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            columns: string[];
+            name?: string | undefined;
+        }, {
+            columns: string[];
+            name?: string | undefined;
+        }>>;
+        uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+        }, {
+            name: string;
+            columns: string[];
+        }>>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>>;
+    enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
+    _meta: import("zod").ZodObject<{
+        tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    }, {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    }>;
+}, {
+    id: import("zod").ZodString;
+    prevId: import("zod").ZodString;
+}>, "strict", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "sqlite";
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    };
+    enums: {};
+}, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "sqlite";
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    };
+    enums: {};
+}>;
+export declare const SQLiteSchemaSquashed: import("zod").ZodObject<{
+    version: import("zod").ZodLiteral<"5">;
+    dialect: import("zod").ZodEnum<["sqlite"]>;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            primaryKey: import("zod").ZodBoolean;
+            notNull: import("zod").ZodBoolean;
+            autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            default: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints: Record<string, string>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints?: Record<string, string> | undefined;
+    }>>;
+    enums: import("zod").ZodAny;
+}, "strict", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints: Record<string, string>;
+    }>;
+    version: "5";
+    dialect: "sqlite";
+    enums?: any;
+}, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints?: Record<string, string> | undefined;
+    }>;
+    version: "5";
+    dialect: "sqlite";
+    enums?: any;
+}>;
+export declare const backwardCompatibleSqliteSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+    version: import("zod").ZodLiteral<"5">;
+    dialect: import("zod").ZodEnum<["sqlite"]>;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            type: import("zod").ZodString;
+            primaryKey: import("zod").ZodBoolean;
+            notNull: import("zod").ZodBoolean;
+            autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            default: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            where: import("zod").ZodOptional<import("zod").ZodString>;
+            isUnique: import("zod").ZodBoolean;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>>;
+        foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            tableFrom: import("zod").ZodString;
+            columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
+            tableTo: import("zod").ZodString;
+            columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
+            onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
+            onDelete: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>>;
+        compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            name: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            columns: string[];
+            name?: string | undefined;
+        }, {
+            columns: string[];
+            name?: string | undefined;
+        }>>;
+        uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+        }, {
+            name: string;
+            columns: string[];
+        }>>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>>;
+    enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
+    _meta: import("zod").ZodObject<{
+        tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    }, {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    }>;
+}, {
+    id: import("zod").ZodString;
+    prevId: import("zod").ZodString;
+}>, "strict", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "sqlite";
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    };
+    enums: {};
+}, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+            default?: any;
+            autoincrement?: boolean | undefined;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+            where?: string | undefined;
+        }>;
+        foreignKeys: Record<string, {
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+        }>;
+        compositePrimaryKeys: Record<string, {
+            columns: string[];
+            name?: string | undefined;
+        }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+    }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "sqlite";
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+    };
+    enums: {};
+}>;
+export {};