drizzle-kit 0.20.14-1ebe0ff → 0.20.14-1f99bf7

package/serializer/mysqlSchema.d.ts

@@ -395,6 +395,37 @@ declare const table: import("zod").ZodObject<{
         columns: string[];
     }>;
 }>;
+export declare const kitInternals: import("zod").ZodOptional<import("zod").ZodObject<{
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+            isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, "strip", import("zod").ZodTypeAny, {
+            isDefaultAnExpression?: boolean | undefined;
+        }, {
+            isDefaultAnExpression?: boolean | undefined;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        columns: Record<string, {
+            isDefaultAnExpression?: boolean | undefined;
+        } | undefined>;
+    }, {
+        columns: Record<string, {
+            isDefaultAnExpression?: boolean | undefined;
+        } | undefined>;
+    }>>>;
+}, "strip", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        columns: Record<string, {
+            isDefaultAnExpression?: boolean | undefined;
+        } | undefined>;
+    } | undefined>;
+}, {
+    tables: Record<string, {
+        columns: Record<string, {
+            isDefaultAnExpression?: boolean | undefined;
+        } | undefined>;
+    } | undefined>;
+}>>;
 declare const dialect: import("zod").ZodLiteral<"mysql">;
 export declare const schemaInternalV3: import("zod").ZodObject<{
     version: import("zod").ZodLiteral<"3">;
@@ -531,8 +562,6 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
         }>;
     }>>;
 }, "strict", import("zod").ZodTypeAny, {
-    version: "3";
-    dialect: "mysql";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
@@ -562,9 +591,9 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
             columnsTo: string[];
         }>;
     }>;
-}, {
     version: "3";
     dialect: "mysql";
+}, {
     tables: Record<string, {
         name: string;
         columns: Record<string, {
@@ -594,6 +623,8 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
             columnsTo: string[];
         }>;
     }>;
+    version: "3";
+    dialect: "mysql";
 }>;
 export declare const schemaInternalV4: import("zod").ZodObject<{
     version: import("zod").ZodLiteral<"4">;
@@ -734,8 +765,6 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
     }>>;
     schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
 }, "strict", import("zod").ZodTypeAny, {
-    version: "4";
-    dialect: "mysql";
     tables: Record<string, {
         schema?: string | undefined;
         name: string;
@@ -766,10 +795,10 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
             columnsTo: string[];
         }>;
     }>;
-    schemas: Record<string, string>;
-}, {
     version: "4";
     dialect: "mysql";
+    schemas: Record<string, string>;
+}, {
     tables: Record<string, {
         schema?: string | undefined;
         name: string;
@@ -800,40 +829,11 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
             columnsTo: string[];
         }>;
     }>;
+    version: "4";
+    dialect: "mysql";
     schemas: Record<string, string>;
 }>;
-export declare const kitInternals: import("zod").ZodOptional<import("zod").ZodObject<{
-    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
-        columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
-            isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        }, "strip", import("zod").ZodTypeAny, {
-            isDefaultAnExpression?: boolean | undefined;
-        }, {
-            isDefaultAnExpression?: boolean | undefined;
-        }>>>;
-    }, "strip", import("zod").ZodTypeAny, {
-        columns: Record<string, {
-            isDefaultAnExpression?: boolean | undefined;
-        } | undefined>;
-    }, {
-        columns: Record<string, {
-            isDefaultAnExpression?: boolean | undefined;
-        } | undefined>;
-    }>>>;
-}, "strip", import("zod").ZodTypeAny, {
-    tables: Record<string, {
-        columns: Record<string, {
-            isDefaultAnExpression?: boolean | undefined;
-        } | undefined>;
-    } | undefined>;
-}, {
-    tables: Record<string, {
-        columns: Record<string, {
-            isDefaultAnExpression?: boolean | undefined;
-        } | undefined>;
-    } | undefined>;
-}>>;
-export declare const schemaInternal: import("zod").ZodObject<{
+export declare const schemaInternalV5: import("zod").ZodObject<{
     version: import("zod").ZodLiteral<"5">;
     dialect: import("zod").ZodLiteral<"mysql">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1059,8 +1059,6 @@ export declare const schemaInternal: import("zod").ZodObject<{
             } | undefined>;
         } | undefined>;
     } | undefined;
-    version: "5";
-    dialect: "mysql";
     tables: Record<string, {
         schema?: string | undefined;
         name: string;
@@ -1099,6 +1097,8 @@ export declare const schemaInternal: import("zod").ZodObject<{
             columns: string[];
         }>;
     }>;
+    version: "5";
+    dialect: "mysql";
     schemas: Record<string, string>;
     _meta: {
         columns: Record<string, string>;
@@ -1113,8 +1113,6 @@ export declare const schemaInternal: import("zod").ZodObject<{
             } | undefined>;
         } | undefined>;
     } | undefined;
-    version: "5";
-    dialect: "mysql";
     tables: Record<string, {
         schema?: string | undefined;
         uniqueConstraints?: Record<string, {
@@ -1153,6 +1151,8 @@ export declare const schemaInternal: import("zod").ZodObject<{
             columns: string[];
         }>;
     }>;
+    version: "5";
+    dialect: "mysql";
     schemas: Record<string, string>;
     _meta: {
         columns: Record<string, string>;
@@ -1160,11 +1160,12 @@ export declare const schemaInternal: import("zod").ZodObject<{
         schemas: Record<string, string>;
     };
 }>;
-export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
-    version: import("zod").ZodLiteral<"3">;
+export declare const schemaInternalV6: import("zod").ZodObject<{
+    version: import("zod").ZodLiteral<"6">;
     dialect: import("zod").ZodLiteral<"mysql">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
+        schema: import("zod").ZodOptional<import("zod").ZodString>;
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
@@ -1237,7 +1238,28 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
             tableTo: string;
             columnsTo: string[];
         }>>;
+        compositePrimaryKeys: 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[];
+        }>>;
+        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, {
+        schema?: string | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -1265,7 +1287,20 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
             tableTo: string;
             columnsTo: string[];
         }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }, {
+        schema?: string | undefined;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -1293,16 +1328,66 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
             tableTo: string;
             columnsTo: string[];
         }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>>;
-}, {
-    id: import("zod").ZodString;
-    prevId: import("zod").ZodString;
-}>, "strip", import("zod").ZodTypeAny, {
-    id: string;
-    prevId: string;
-    version: "3";
-    dialect: "mysql";
+    schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    _meta: import("zod").ZodObject<{
+        schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        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>;
+        schemas: Record<string, string>;
+    }, {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    }>;
+    internal: import("zod").ZodOptional<import("zod").ZodObject<{
+        tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+            columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+                isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, "strip", import("zod").ZodTypeAny, {
+                isDefaultAnExpression?: boolean | undefined;
+            }, {
+                isDefaultAnExpression?: boolean | undefined;
+            }>>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    }, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    }>>;
+}, "strict", import("zod").ZodTypeAny, {
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
     tables: Record<string, {
+        schema?: string | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -1330,13 +1415,37 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
             tableTo: string;
             columnsTo: string[];
         }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>;
-}, {
-    id: string;
-    prevId: string;
-    version: "3";
+    version: "6";
     dialect: "mysql";
+    schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
+}, {
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
     tables: Record<string, {
+        schema?: string | undefined;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -1364,10 +1473,22 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
             tableTo: string;
             columnsTo: string[];
         }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>;
+    version: "6";
+    dialect: "mysql";
+    schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
 }>;
-export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
-    version: import("zod").ZodLiteral<"4">;
+export declare const schemaInternal: import("zod").ZodObject<{
+    version: import("zod").ZodLiteral<"6">;
     dialect: import("zod").ZodLiteral<"mysql">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -1444,6 +1565,26 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
             tableTo: string;
             columnsTo: string[];
         }>>;
+        compositePrimaryKeys: 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[];
+        }>>;
+        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, {
         schema?: string | undefined;
         name: string;
@@ -1473,9 +1614,21 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
             tableTo: string;
             columnsTo: string[];
         }>;
-    }, {
-        schema?: string | undefined;
-        name: string;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }, {
+        schema?: string | undefined;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+        name: string;
         columns: Record<string, {
             default?: any;
             onUpdate?: any;
@@ -1502,16 +1655,64 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
             tableTo: string;
             columnsTo: string[];
         }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>>;
     schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
-}, {
-    id: import("zod").ZodString;
-    prevId: import("zod").ZodString;
-}>, "strip", import("zod").ZodTypeAny, {
-    id: string;
-    prevId: string;
-    version: "4";
-    dialect: "mysql";
+    _meta: import("zod").ZodObject<{
+        schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        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>;
+        schemas: Record<string, string>;
+    }, {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    }>;
+    internal: import("zod").ZodOptional<import("zod").ZodObject<{
+        tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+            columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+                isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, "strip", import("zod").ZodTypeAny, {
+                isDefaultAnExpression?: boolean | undefined;
+            }, {
+                isDefaultAnExpression?: boolean | undefined;
+            }>>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    }, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    }>>;
+}, "strict", import("zod").ZodTypeAny, {
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
     tables: Record<string, {
         schema?: string | undefined;
         name: string;
@@ -1541,15 +1742,37 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
             tableTo: string;
             columnsTo: string[];
         }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>;
+    version: "6";
+    dialect: "mysql";
     schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
 }, {
-    id: string;
-    prevId: string;
-    version: "4";
-    dialect: "mysql";
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
     tables: Record<string, {
         schema?: string | undefined;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -1577,15 +1800,25 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
             tableTo: string;
             columnsTo: string[];
         }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>;
+    version: "6";
+    dialect: "mysql";
     schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
 }>;
-export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
-    version: import("zod").ZodLiteral<"5">;
+export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
+    version: import("zod").ZodLiteral<"3">;
     dialect: import("zod").ZodLiteral<"mysql">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
-        schema: import("zod").ZodOptional<import("zod").ZodString>;
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
@@ -1658,28 +1891,7 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
             tableTo: string;
             columnsTo: string[];
         }>>;
-        compositePrimaryKeys: 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[];
-        }>>;
-        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, {
-        schema?: string | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -1707,20 +1919,7 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
             tableTo: string;
             columnsTo: string[];
         }>;
-        compositePrimaryKeys: Record<string, {
-            name: string;
-            columns: string[];
-        }>;
-        uniqueConstraints: Record<string, {
-            name: string;
-            columns: string[];
-        }>;
     }, {
-        schema?: string | undefined;
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-        }> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -1748,73 +1947,12 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
             tableTo: string;
             columnsTo: string[];
         }>;
-        compositePrimaryKeys: Record<string, {
-            name: string;
-            columns: string[];
-        }>;
-    }>>;
-    schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
-    _meta: import("zod").ZodObject<{
-        schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
-        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>;
-        schemas: Record<string, string>;
-    }, {
-        columns: Record<string, string>;
-        tables: Record<string, string>;
-        schemas: Record<string, string>;
-    }>;
-    internal: import("zod").ZodOptional<import("zod").ZodObject<{
-        tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
-            columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
-                isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            }, "strip", import("zod").ZodTypeAny, {
-                isDefaultAnExpression?: boolean | undefined;
-            }, {
-                isDefaultAnExpression?: boolean | undefined;
-            }>>>;
-        }, "strip", import("zod").ZodTypeAny, {
-            columns: Record<string, {
-                isDefaultAnExpression?: boolean | undefined;
-            } | undefined>;
-        }, {
-            columns: Record<string, {
-                isDefaultAnExpression?: boolean | undefined;
-            } | undefined>;
-        }>>>;
-    }, "strip", import("zod").ZodTypeAny, {
-        tables: Record<string, {
-            columns: Record<string, {
-                isDefaultAnExpression?: boolean | undefined;
-            } | undefined>;
-        } | undefined>;
-    }, {
-        tables: Record<string, {
-            columns: Record<string, {
-                isDefaultAnExpression?: boolean | undefined;
-            } | undefined>;
-        } | undefined>;
     }>>;
 }, {
     id: import("zod").ZodString;
     prevId: import("zod").ZodString;
 }>, "strip", import("zod").ZodTypeAny, {
-    internal?: {
-        tables: Record<string, {
-            columns: Record<string, {
-                isDefaultAnExpression?: boolean | undefined;
-            } | undefined>;
-        } | undefined>;
-    } | undefined;
-    id: string;
-    prevId: string;
-    version: "5";
-    dialect: "mysql";
     tables: Record<string, {
-        schema?: string | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -1842,39 +1980,13 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
             tableTo: string;
             columnsTo: string[];
         }>;
-        compositePrimaryKeys: Record<string, {
-            name: string;
-            columns: string[];
-        }>;
-        uniqueConstraints: Record<string, {
-            name: string;
-            columns: string[];
-        }>;
     }>;
-    schemas: Record<string, string>;
-    _meta: {
-        columns: Record<string, string>;
-        tables: Record<string, string>;
-        schemas: Record<string, string>;
-    };
-}, {
-    internal?: {
-        tables: Record<string, {
-            columns: Record<string, {
-                isDefaultAnExpression?: boolean | undefined;
-            } | undefined>;
-        } | undefined>;
-    } | undefined;
     id: string;
     prevId: string;
-    version: "5";
+    version: "3";
     dialect: "mysql";
+}, {
     tables: Record<string, {
-        schema?: string | undefined;
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-        }> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -1902,20 +2014,14 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
             tableTo: string;
             columnsTo: string[];
         }>;
-        compositePrimaryKeys: Record<string, {
-            name: string;
-            columns: string[];
-        }>;
     }>;
-    schemas: Record<string, string>;
-    _meta: {
-        columns: Record<string, string>;
-        tables: Record<string, string>;
-        schemas: Record<string, string>;
-    };
+    id: string;
+    prevId: string;
+    version: "3";
+    dialect: "mysql";
 }>;
-export declare const schemaSquashed: import("zod").ZodObject<{
-    version: import("zod").ZodLiteral<"5">;
+export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
+    version: import("zod").ZodLiteral<"4">;
     dialect: import("zod").ZodLiteral<"mysql">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -1945,10 +2051,53 @@ export declare const schemaSquashed: import("zod").ZodObject<{
             primaryKey: boolean;
             notNull: boolean;
         }>>;
-        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>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            isUnique: import("zod").ZodBoolean;
+            using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
+            algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
+            lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
+        }, "strict", import("zod").ZodTypeAny, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>>;
+        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, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            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[];
+        }>>;
     }, "strict", import("zod").ZodTypeAny, {
         schema?: string | undefined;
         name: string;
@@ -1961,13 +2110,25 @@ export declare const schemaSquashed: import("zod").ZodObject<{
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, string>;
-        foreignKeys: Record<string, string>;
-        compositePrimaryKeys: Record<string, string>;
-        uniqueConstraints: Record<string, string>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
     }, {
         schema?: string | undefined;
-        uniqueConstraints?: Record<string, string> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -1978,14 +2139,29 @@ export declare const schemaSquashed: import("zod").ZodObject<{
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, string>;
-        foreignKeys: Record<string, string>;
-        compositePrimaryKeys: Record<string, string>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
     }>>;
     schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
-}, "strict", import("zod").ZodTypeAny, {
-    version: "5";
-    dialect: "mysql";
+}, {
+    id: import("zod").ZodString;
+    prevId: import("zod").ZodString;
+}>, "strip", import("zod").ZodTypeAny, {
     tables: Record<string, {
         schema?: string | undefined;
         name: string;
@@ -1998,18 +2174,32 @@ export declare const schemaSquashed: import("zod").ZodObject<{
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, string>;
-        foreignKeys: Record<string, string>;
-        compositePrimaryKeys: Record<string, string>;
-        uniqueConstraints: Record<string, string>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "4";
+    dialect: "mysql";
     schemas: Record<string, string>;
 }, {
-    version: "5";
-    dialect: "mysql";
     tables: Record<string, {
         schema?: string | undefined;
-        uniqueConstraints?: Record<string, string> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -2020,14 +2210,32 @@ export declare const schemaSquashed: import("zod").ZodObject<{
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, string>;
-        foreignKeys: Record<string, string>;
-        compositePrimaryKeys: Record<string, string>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "4";
+    dialect: "mysql";
     schemas: Record<string, string>;
 }>;
-export declare const schemaSquashedV4: import("zod").ZodObject<{
-    version: import("zod").ZodLiteral<"4">;
+export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape<{
+    version: import("zod").ZodLiteral<"5">;
     dialect: import("zod").ZodLiteral<"mysql">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -2057,8 +2265,73 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
             primaryKey: boolean;
             notNull: boolean;
         }>>;
-        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
-        foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            isUnique: import("zod").ZodBoolean;
+            using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
+            algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
+            lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
+        }, "strict", import("zod").ZodTypeAny, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>>;
+        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, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            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[];
+        }>>;
+        compositePrimaryKeys: 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[];
+        }>>;
+        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, {
         schema?: string | undefined;
         name: string;
@@ -2071,27 +2344,125 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, string>;
-        foreignKeys: Record<string, string>;
-    }, {
-        schema?: string | undefined;
-        name: string;
-        columns: Record<string, {
-            default?: any;
-            onUpdate?: any;
-            autoincrement?: boolean | undefined;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
             name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
+            columns: string[];
+            isUnique: boolean;
         }>;
-        indexes: Record<string, string>;
-        foreignKeys: Record<string, string>;
-    }>>;
-    schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
-}, "strict", import("zod").ZodTypeAny, {
-    version: "4";
-    dialect: "mysql";
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }, {
+        schema?: string | undefined;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>>;
+    schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    _meta: import("zod").ZodObject<{
+        schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        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>;
+        schemas: Record<string, string>;
+    }, {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    }>;
+    internal: import("zod").ZodOptional<import("zod").ZodObject<{
+        tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+            columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+                isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, "strip", import("zod").ZodTypeAny, {
+                isDefaultAnExpression?: boolean | undefined;
+            }, {
+                isDefaultAnExpression?: boolean | undefined;
+            }>>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    }, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    }>>;
+}, {
+    id: import("zod").ZodString;
+    prevId: import("zod").ZodString;
+}>, "strip", import("zod").ZodTypeAny, {
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
     tables: Record<string, {
         schema?: string | undefined;
         name: string;
@@ -2104,15 +2475,56 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, string>;
-        foreignKeys: Record<string, string>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "mysql";
     schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
 }, {
-    version: "4";
-    dialect: "mysql";
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
     tables: Record<string, {
         schema?: string | undefined;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -2123,40 +2535,41 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, string>;
-        foreignKeys: Record<string, string>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "mysql";
     schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
 }>;
-export type Dialect = TypeOf<typeof dialect>;
-export type Column = TypeOf<typeof column>;
-export type Table = TypeOf<typeof table>;
-export type TableV4 = TypeOf<typeof tableV4>;
-export type MySqlSchema = TypeOf<typeof schema>;
-export type MySqlSchemaV3 = TypeOf<typeof schemaV3>;
-export type MySqlSchemaV4 = TypeOf<typeof schemaV4>;
-export type MySqlSchemaInternal = TypeOf<typeof schemaInternal>;
-export type MySqlKitInternals = TypeOf<typeof kitInternals>;
-export type MySqlSchemaSquashed = TypeOf<typeof schemaSquashed>;
-export type MySqlSchemaSquashedV4 = TypeOf<typeof schemaSquashedV4>;
-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 MySqlSquasher: {
-    squashIdx: (idx: Index) => string;
-    unsquashIdx: (input: string) => Index;
-    squashPK: (pk: PrimaryKey) => string;
-    unsquashPK: (pk: string) => PrimaryKey;
-    squashUnique: (unq: UniqueConstraint) => string;
-    unsquashUnique: (unq: string) => UniqueConstraint;
-    squashFK: (fk: ForeignKey) => string;
-    unsquashFK: (input: string) => ForeignKey;
-};
-export declare const squashMysqlSchemeV4: (json: MySqlSchemaV4) => MySqlSchemaSquashedV4;
-export declare const squashMysqlScheme: (json: MySqlSchema) => MySqlSchemaSquashed;
-export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendShape<{
-    version: import("zod").ZodLiteral<"5">;
+export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
+    version: import("zod").ZodLiteral<"6">;
     dialect: import("zod").ZodLiteral<"mysql">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -2384,10 +2797,6 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
             } | undefined>;
         } | undefined>;
     } | undefined;
-    id: string;
-    prevId: string;
-    version: "5";
-    dialect: "mysql";
     tables: Record<string, {
         schema?: string | undefined;
         name: string;
@@ -2426,6 +2835,10 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
             columns: string[];
         }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "6";
+    dialect: "mysql";
     schemas: Record<string, string>;
     _meta: {
         columns: Record<string, string>;
@@ -2440,10 +2853,6 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
             } | undefined>;
         } | undefined>;
     } | undefined;
-    id: string;
-    prevId: string;
-    version: "5";
-    dialect: "mysql";
     tables: Record<string, {
         schema?: string | undefined;
         uniqueConstraints?: Record<string, {
@@ -2482,6 +2891,10 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
             columns: string[];
         }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "6";
+    dialect: "mysql";
     schemas: Record<string, string>;
     _meta: {
         columns: Record<string, string>;
@@ -2489,8 +2902,8 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
         schemas: Record<string, string>;
     };
 }>;
-export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
-    version: import("zod").ZodLiteral<"4">;
+export declare const schemaSquashed: import("zod").ZodObject<{
+    version: import("zod").ZodLiteral<"5">;
     dialect: import("zod").ZodLiteral<"mysql">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -2520,53 +2933,10 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
             primaryKey: boolean;
             notNull: boolean;
         }>>;
-        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-            name: import("zod").ZodString;
-            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
-            isUnique: import("zod").ZodBoolean;
-            using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
-            algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
-            lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
-        }, "strict", import("zod").ZodTypeAny, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>>;
-        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, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            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[];
-        }>>;
+        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, {
         schema?: string | undefined;
         name: string;
@@ -2579,25 +2949,13 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints: Record<string, string>;
     }, {
         schema?: string | undefined;
+        uniqueConstraints?: Record<string, string> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -2608,33 +2966,12 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
     }>>;
     schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
-}, {
-    id: import("zod").ZodString;
-    prevId: import("zod").ZodString;
-}>, "strip", import("zod").ZodTypeAny, {
-    id: string;
-    prevId: string;
-    version: "4";
-    dialect: "mysql";
+}, "strict", import("zod").ZodTypeAny, {
     tables: Record<string, {
         schema?: string | undefined;
         name: string;
@@ -2647,32 +2984,18 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints: Record<string, string>;
     }>;
+    version: "5";
+    dialect: "mysql";
     schemas: Record<string, string>;
 }, {
-    id: string;
-    prevId: string;
-    version: "4";
-    dialect: "mysql";
     tables: Record<string, {
         schema?: string | undefined;
+        uniqueConstraints?: Record<string, string> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -2683,31 +3006,20 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
     }>;
+    version: "5";
+    dialect: "mysql";
     schemas: Record<string, string>;
 }>;
-export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
-    version: import("zod").ZodLiteral<"3">;
+export declare const schemaSquashedV4: import("zod").ZodObject<{
+    version: import("zod").ZodLiteral<"4">;
     dialect: import("zod").ZodLiteral<"mysql">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
+        schema: import("zod").ZodOptional<import("zod").ZodString>;
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
@@ -2733,54 +3045,10 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
             primaryKey: boolean;
             notNull: boolean;
         }>>;
-        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-            name: import("zod").ZodString;
-            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
-            isUnique: import("zod").ZodBoolean;
-            using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
-            algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
-            lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
-        }, "strict", import("zod").ZodTypeAny, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>>;
-        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, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            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[];
-        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
     }, "strict", import("zod").ZodTypeAny, {
+        schema?: string | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -2791,24 +3059,10 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
     }, {
+        schema?: string | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -2819,170 +3073,13 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
     }>>;
-}, {
-    id: import("zod").ZodString;
-    prevId: import("zod").ZodString;
-}>, "strip", import("zod").ZodTypeAny, {
-    id: string;
-    prevId: string;
-    version: "3";
-    dialect: "mysql";
+    schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+}, "strict", import("zod").ZodTypeAny, {
     tables: Record<string, {
-        name: string;
-        columns: Record<string, {
-            default?: any;
-            onUpdate?: any;
-            autoincrement?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }>;
-        indexes: Record<string, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }>;
-    }>;
-}, {
-    id: string;
-    prevId: string;
-    version: "3";
-    dialect: "mysql";
-    tables: Record<string, {
-        name: string;
-        columns: Record<string, {
-            default?: any;
-            onUpdate?: any;
-            autoincrement?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }>;
-        indexes: Record<string, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }>;
-    }>;
-}>;
-export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
-    version: import("zod").ZodLiteral<"5">;
-    dialect: import("zod").ZodLiteral<"mysql">;
-    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-        name: import("zod").ZodString;
-        schema: import("zod").ZodOptional<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>;
-            onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
-        }, "strict", import("zod").ZodTypeAny, {
-            default?: any;
-            onUpdate?: any;
-            autoincrement?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }, {
-            default?: any;
-            onUpdate?: any;
-            autoincrement?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }>>;
-        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, {
-        schema?: string | undefined;
-        name: string;
-        columns: Record<string, {
-            default?: any;
-            onUpdate?: any;
-            autoincrement?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }>;
-        indexes: Record<string, string>;
-        foreignKeys: Record<string, string>;
-        compositePrimaryKeys: Record<string, string>;
-        uniqueConstraints: Record<string, string>;
-    }, {
-        schema?: string | undefined;
-        uniqueConstraints?: Record<string, string> | undefined;
-        name: string;
-        columns: Record<string, {
-            default?: any;
-            onUpdate?: any;
-            autoincrement?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }>;
-        indexes: Record<string, string>;
-        foreignKeys: Record<string, string>;
-        compositePrimaryKeys: Record<string, string>;
-    }>>;
-    schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
-}, "strict", import("zod").ZodTypeAny, {
-    version: "5";
-    dialect: "mysql";
-    tables: Record<string, {
-        schema?: string | undefined;
+        schema?: string | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -2995,16 +3092,13 @@ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
         }>;
         indexes: Record<string, string>;
         foreignKeys: Record<string, string>;
-        compositePrimaryKeys: Record<string, string>;
-        uniqueConstraints: Record<string, string>;
     }>;
+    version: "4";
+    dialect: "mysql";
     schemas: Record<string, string>;
 }, {
-    version: "5";
-    dialect: "mysql";
     tables: Record<string, {
         schema?: string | undefined;
-        uniqueConstraints?: Record<string, string> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -3017,15 +3111,45 @@ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
         }>;
         indexes: Record<string, string>;
         foreignKeys: Record<string, string>;
-        compositePrimaryKeys: Record<string, string>;
     }>;
+    version: "4";
+    dialect: "mysql";
     schemas: Record<string, string>;
 }>;
-export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
-    version: import("zod").ZodLiteral<"3">;
+export type Dialect = TypeOf<typeof dialect>;
+export type Column = TypeOf<typeof column>;
+export type Table = TypeOf<typeof table>;
+export type TableV4 = TypeOf<typeof tableV4>;
+export type MySqlSchema = TypeOf<typeof schema>;
+export type MySqlSchemaV3 = TypeOf<typeof schemaV3>;
+export type MySqlSchemaV4 = TypeOf<typeof schemaV4>;
+export type MySqlSchemaV5 = TypeOf<typeof schemaV5>;
+export type MySqlSchemaInternal = TypeOf<typeof schemaInternal>;
+export type MySqlKitInternals = TypeOf<typeof kitInternals>;
+export type MySqlSchemaSquashed = TypeOf<typeof schemaSquashed>;
+export type MySqlSchemaSquashedV4 = TypeOf<typeof schemaSquashedV4>;
+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 MySqlSquasher: {
+    squashIdx: (idx: Index) => string;
+    unsquashIdx: (input: string) => Index;
+    squashPK: (pk: PrimaryKey) => string;
+    unsquashPK: (pk: string) => PrimaryKey;
+    squashUnique: (unq: UniqueConstraint) => string;
+    unsquashUnique: (unq: string) => UniqueConstraint;
+    squashFK: (fk: ForeignKey) => string;
+    unsquashFK: (input: string) => ForeignKey;
+};
+export declare const squashMysqlSchemeV4: (json: MySqlSchemaV4) => MySqlSchemaSquashedV4;
+export declare const squashMysqlScheme: (json: MySqlSchema) => MySqlSchemaSquashed;
+export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendShape<{
+    version: import("zod").ZodLiteral<"6">;
     dialect: import("zod").ZodLiteral<"mysql">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
+        schema: import("zod").ZodOptional<import("zod").ZodString>;
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
@@ -3098,7 +3222,69 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
             tableTo: string;
             columnsTo: string[];
         }>>;
+        compositePrimaryKeys: 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[];
+        }>>;
+        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, {
+        schema?: string | undefined;
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }, {
+        schema?: string | undefined;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -3126,7 +3312,980 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
             tableTo: string;
             columnsTo: string[];
         }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>>;
+    schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    _meta: import("zod").ZodObject<{
+        schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        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>;
+        schemas: Record<string, string>;
+    }, {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    }>;
+    internal: import("zod").ZodOptional<import("zod").ZodObject<{
+        tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+            columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+                isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, "strip", import("zod").ZodTypeAny, {
+                isDefaultAnExpression?: boolean | undefined;
+            }, {
+                isDefaultAnExpression?: boolean | undefined;
+            }>>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    }, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    }>>;
+}, {
+    id: import("zod").ZodString;
+    prevId: import("zod").ZodString;
+}>, "strip", import("zod").ZodTypeAny, {
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
+    tables: Record<string, {
+        schema?: string | undefined;
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "6";
+    dialect: "mysql";
+    schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
+}, {
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
+    tables: Record<string, {
+        schema?: string | undefined;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "6";
+    dialect: "mysql";
+    schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
+}>;
+export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
+    version: import("zod").ZodLiteral<"3">;
+    dialect: import("zod").ZodLiteral<"mysql">;
+    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>;
+            onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            isUnique: import("zod").ZodBoolean;
+            using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
+            algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
+            lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
+        }, "strict", import("zod").ZodTypeAny, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>>;
+        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, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            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[];
+        }>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+    }>>;
+}, {
+    id: import("zod").ZodString;
+    prevId: import("zod").ZodString;
+}>, "strip", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "3";
+    dialect: "mysql";
+}, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "3";
+    dialect: "mysql";
+}>;
+export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
+    version: import("zod").ZodLiteral<"4">;
+    dialect: import("zod").ZodLiteral<"mysql">;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        schema: import("zod").ZodOptional<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>;
+            onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            isUnique: import("zod").ZodBoolean;
+            using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
+            algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
+            lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
+        }, "strict", import("zod").ZodTypeAny, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>>;
+        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, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            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[];
+        }>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        schema?: string | undefined;
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+    }, {
+        schema?: string | undefined;
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+    }>>;
+    schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+}, {
+    id: import("zod").ZodString;
+    prevId: import("zod").ZodString;
+}>, "strip", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        schema?: string | undefined;
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "4";
+    dialect: "mysql";
+    schemas: Record<string, string>;
+}, {
+    tables: Record<string, {
+        schema?: string | undefined;
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "4";
+    dialect: "mysql";
+    schemas: Record<string, string>;
+}>;
+export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extendShape<{
+    version: import("zod").ZodLiteral<"5">;
+    dialect: import("zod").ZodLiteral<"mysql">;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        schema: import("zod").ZodOptional<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>;
+            onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>>;
+        indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            columns: import("zod").ZodArray<import("zod").ZodString, "many">;
+            isUnique: import("zod").ZodBoolean;
+            using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
+            algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
+            lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
+        }, "strict", import("zod").ZodTypeAny, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>>;
+        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, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            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[];
+        }>>;
+        compositePrimaryKeys: 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[];
+        }>>;
+        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, {
+        schema?: string | undefined;
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }, {
+        schema?: string | undefined;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>>;
+    schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    _meta: import("zod").ZodObject<{
+        schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        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>;
+        schemas: Record<string, string>;
+    }, {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    }>;
+    internal: import("zod").ZodOptional<import("zod").ZodObject<{
+        tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+            columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+                isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, "strip", import("zod").ZodTypeAny, {
+                isDefaultAnExpression?: boolean | undefined;
+            }, {
+                isDefaultAnExpression?: boolean | undefined;
+            }>>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    }, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    }>>;
+}, {
+    id: import("zod").ZodString;
+    prevId: import("zod").ZodString;
+}>, "strip", import("zod").ZodTypeAny, {
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
+    tables: Record<string, {
+        schema?: string | undefined;
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "mysql";
+    schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
+}, {
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
+    tables: Record<string, {
+        schema?: string | undefined;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            using?: "btree" | "hash" | undefined;
+            algorithm?: "default" | "inplace" | "copy" | undefined;
+            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "mysql";
+    schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
+}>;
+export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
+    version: import("zod").ZodLiteral<"5">;
+    dialect: import("zod").ZodLiteral<"mysql">;
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        schema: import("zod").ZodOptional<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>;
+            onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
+        }, "strict", import("zod").ZodTypeAny, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>>;
+        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, {
+        schema?: string | undefined;
+        name: string;
+        columns: Record<string, {
+            default?: any;
+            onUpdate?: any;
+            autoincrement?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints: Record<string, string>;
     }, {
+        schema?: string | undefined;
+        uniqueConstraints?: Record<string, string> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -3137,33 +4296,14 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
     }>>;
-}, {
-    id: import("zod").ZodString;
-    prevId: import("zod").ZodString;
-}>, "strip", import("zod").ZodTypeAny, {
-    id: string;
-    prevId: string;
-    version: "3";
-    dialect: "mysql";
+    schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+}, "strict", import("zod").ZodTypeAny, {
     tables: Record<string, {
+        schema?: string | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -3174,30 +4314,18 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints: Record<string, string>;
     }>;
-}, {
-    id: string;
-    prevId: string;
-    version: "3";
+    version: "5";
     dialect: "mysql";
+    schemas: Record<string, string>;
+}, {
     tables: Record<string, {
+        schema?: string | undefined;
+        uniqueConstraints?: Record<string, string> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -3208,26 +4336,16 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, {
-            using?: "btree" | "hash" | undefined;
-            algorithm?: "default" | "inplace" | "copy" | undefined;
-            lock?: "default" | "none" | "shared" | "exclusive" | undefined;
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        compositePrimaryKeys: Record<string, string>;
     }>;
-}>, import("zod").ZodObject<import("zod").extendShape<{
-    version: import("zod").ZodLiteral<"4">;
+    version: "5";
+    dialect: "mysql";
+    schemas: Record<string, string>;
+}>;
+export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
+    version: import("zod").ZodLiteral<"5">;
     dialect: import("zod").ZodLiteral<"mysql">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -3304,6 +4422,26 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
             tableTo: string;
             columnsTo: string[];
         }>>;
+        compositePrimaryKeys: 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[];
+        }>>;
+        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, {
         schema?: string | undefined;
         name: string;
@@ -3333,8 +4471,20 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
             tableTo: string;
             columnsTo: string[];
         }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }, {
         schema?: string | undefined;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -3362,16 +4512,67 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
             tableTo: string;
             columnsTo: string[];
         }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>>;
     schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    _meta: import("zod").ZodObject<{
+        schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        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>;
+        schemas: Record<string, string>;
+    }, {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    }>;
+    internal: import("zod").ZodOptional<import("zod").ZodObject<{
+        tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+            columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
+                isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, "strip", import("zod").ZodTypeAny, {
+                isDefaultAnExpression?: boolean | undefined;
+            }, {
+                isDefaultAnExpression?: boolean | undefined;
+            }>>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    }, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    }>>;
 }, {
     id: import("zod").ZodString;
     prevId: import("zod").ZodString;
 }>, "strip", import("zod").ZodTypeAny, {
-    id: string;
-    prevId: string;
-    version: "4";
-    dialect: "mysql";
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
     tables: Record<string, {
         schema?: string | undefined;
         name: string;
@@ -3401,15 +4602,39 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
             tableTo: string;
             columnsTo: string[];
         }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>;
-    schemas: Record<string, string>;
-}, {
     id: string;
     prevId: string;
-    version: "4";
+    version: "5";
     dialect: "mysql";
+    schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
+}, {
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isDefaultAnExpression?: boolean | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
     tables: Record<string, {
         schema?: string | undefined;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+        }> | undefined;
         name: string;
         columns: Record<string, {
             default?: any;
@@ -3437,10 +4662,23 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
             tableTo: string;
             columnsTo: string[];
         }>;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "mysql";
     schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
 }>, import("zod").ZodObject<import("zod").extendShape<{
-    version: import("zod").ZodLiteral<"5">;
+    version: import("zod").ZodLiteral<"6">;
     dialect: import("zod").ZodLiteral<"mysql">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -3668,10 +4906,6 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
             } | undefined>;
         } | undefined>;
     } | undefined;
-    id: string;
-    prevId: string;
-    version: "5";
-    dialect: "mysql";
     tables: Record<string, {
         schema?: string | undefined;
         name: string;
@@ -3710,6 +4944,10 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
             columns: string[];
         }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "6";
+    dialect: "mysql";
     schemas: Record<string, string>;
     _meta: {
         columns: Record<string, string>;
@@ -3724,10 +4962,6 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
             } | undefined>;
         } | undefined>;
     } | undefined;
-    id: string;
-    prevId: string;
-    version: "5";
-    dialect: "mysql";
     tables: Record<string, {
         schema?: string | undefined;
         uniqueConstraints?: Record<string, {
@@ -3766,6 +5000,10 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
             columns: string[];
         }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "6";
+    dialect: "mysql";
     schemas: Record<string, string>;
     _meta: {
         columns: Record<string, string>;
@@ -3781,10 +5019,6 @@ export declare const dryMySql: {
             } | undefined>;
         } | undefined>;
     } | undefined;
-    id: string;
-    prevId: string;
-    version: "5";
-    dialect: "mysql";
     tables: Record<string, {
         schema?: string | undefined;
         name: string;
@@ -3823,6 +5057,10 @@ export declare const dryMySql: {
             columns: string[];
         }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "6";
+    dialect: "mysql";
     schemas: Record<string, string>;
     _meta: {
         columns: Record<string, string>;