drizzle-kit 0.20.14-d8f1e46 → 0.20.14-e8e7ed6

package/serializer/pgSchema.d.ts

@@ -1,13 +1,16 @@
 import { TypeOf } from "zod";
 declare const enumSchema: import("zod").ZodObject<{
     name: import("zod").ZodString;
-    values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    schema: import("zod").ZodString;
+    values: import("zod").ZodArray<import("zod").ZodString, "many">;
 }, "strict", import("zod").ZodTypeAny, {
     name: string;
-    values: Record<string, string>;
+    values: string[];
+    schema: string;
 }, {
     name: string;
-    values: Record<string, string>;
+    values: string[];
+    schema: string;
 }>;
 export declare const pgSchemaV2: import("zod").ZodObject<{
     version: import("zod").ZodLiteral<"2">;
@@ -104,7 +107,6 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
         values: Record<string, string>;
     }>>;
 }, "strict", import("zod").ZodTypeAny, {
-    version: "2";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
@@ -123,12 +125,12 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
     }>;
+    version: "2";
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
     }>;
 }, {
-    version: "2";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
@@ -147,6 +149,7 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
     }>;
+    version: "2";
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
@@ -289,7 +292,6 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
         values: Record<string, string>;
     }>>;
 }, "strict", import("zod").ZodTypeAny, {
-    version: "1";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
@@ -314,12 +316,12 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
     }>;
+    version: "1";
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
     }>;
 }, {
-    version: "1";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
@@ -344,6 +346,7 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
     }>;
+    version: "1";
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
@@ -393,6 +396,7 @@ declare const fk: import("zod").ZodObject<{
 declare const column: import("zod").ZodObject<{
     name: import("zod").ZodString;
     type: import("zod").ZodString;
+    typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
     primaryKey: import("zod").ZodBoolean;
     notNull: import("zod").ZodBoolean;
     default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -402,6 +406,7 @@ declare const column: import("zod").ZodObject<{
 }, "strict", import("zod").ZodTypeAny, {
     isUnique?: any;
     default?: any;
+    typeSchema?: string | undefined;
     uniqueName?: string | undefined;
     nullsNotDistinct?: boolean | undefined;
     name: string;
@@ -411,6 +416,7 @@ declare const column: import("zod").ZodObject<{
 }, {
     isUnique?: any;
     default?: any;
+    typeSchema?: string | undefined;
     uniqueName?: string | undefined;
     nullsNotDistinct?: boolean | undefined;
     name: string;
@@ -423,6 +429,7 @@ declare const tableV3: import("zod").ZodObject<{
     columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
         type: import("zod").ZodString;
+        typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
         primaryKey: import("zod").ZodBoolean;
         notNull: import("zod").ZodBoolean;
         default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -432,6 +439,7 @@ declare const tableV3: import("zod").ZodObject<{
     }, "strict", import("zod").ZodTypeAny, {
         isUnique?: any;
         default?: any;
+        typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
         name: string;
@@ -441,6 +449,7 @@ declare const tableV3: import("zod").ZodObject<{
     }, {
         isUnique?: any;
         default?: any;
+        typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
         name: string;
@@ -494,6 +503,7 @@ declare const tableV3: import("zod").ZodObject<{
     columns: Record<string, {
         isUnique?: any;
         default?: any;
+        typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
         name: string;
@@ -521,6 +531,7 @@ declare const tableV3: import("zod").ZodObject<{
     columns: Record<string, {
         isUnique?: any;
         default?: any;
+        typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
         name: string;
@@ -573,6 +584,7 @@ declare const tableV4: import("zod").ZodObject<{
     columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
         type: import("zod").ZodString;
+        typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
         primaryKey: import("zod").ZodBoolean;
         notNull: import("zod").ZodBoolean;
         default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -582,6 +594,7 @@ declare const tableV4: import("zod").ZodObject<{
     }, "strict", import("zod").ZodTypeAny, {
         isUnique?: any;
         default?: any;
+        typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
         name: string;
@@ -591,6 +604,7 @@ declare const tableV4: import("zod").ZodObject<{
     }, {
         isUnique?: any;
         default?: any;
+        typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
         name: string;
@@ -644,6 +658,7 @@ declare const tableV4: import("zod").ZodObject<{
     columns: Record<string, {
         isUnique?: any;
         default?: any;
+        typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
         name: string;
@@ -672,6 +687,7 @@ declare const tableV4: import("zod").ZodObject<{
     columns: Record<string, {
         isUnique?: any;
         default?: any;
+        typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
         name: string;
@@ -702,6 +718,7 @@ declare const table: import("zod").ZodObject<{
     columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
         type: import("zod").ZodString;
+        typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
         primaryKey: import("zod").ZodBoolean;
         notNull: import("zod").ZodBoolean;
         default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -711,6 +728,7 @@ declare const table: import("zod").ZodObject<{
     }, "strict", import("zod").ZodTypeAny, {
         isUnique?: any;
         default?: any;
+        typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
         name: string;
@@ -720,6 +738,7 @@ declare const table: import("zod").ZodObject<{
     }, {
         isUnique?: any;
         default?: any;
+        typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
         name: string;
@@ -796,6 +815,7 @@ declare const table: import("zod").ZodObject<{
     columns: Record<string, {
         isUnique?: any;
         default?: any;
+        typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
         name: string;
@@ -838,6 +858,7 @@ declare const table: import("zod").ZodObject<{
     columns: Record<string, {
         isUnique?: any;
         default?: any;
+        typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
         name: string;
@@ -866,6 +887,51 @@ 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<{
+            isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
+            rawType: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            isArray?: boolean | undefined;
+            dimensions?: number | undefined;
+            rawType?: string | undefined;
+        }, {
+            isArray?: boolean | undefined;
+            dimensions?: number | undefined;
+            rawType?: string | undefined;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        columns: Record<string, {
+            isArray?: boolean | undefined;
+            dimensions?: number | undefined;
+            rawType?: string | undefined;
+        } | undefined>;
+    }, {
+        columns: Record<string, {
+            isArray?: boolean | undefined;
+            dimensions?: number | undefined;
+            rawType?: string | undefined;
+        } | undefined>;
+    }>>>;
+}, "strip", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        columns: Record<string, {
+            isArray?: boolean | undefined;
+            dimensions?: number | undefined;
+            rawType?: string | undefined;
+        } | undefined>;
+    } | undefined>;
+}, {
+    tables: Record<string, {
+        columns: Record<string, {
+            isArray?: boolean | undefined;
+            dimensions?: number | undefined;
+            rawType?: string | undefined;
+        } | undefined>;
+    } | undefined>;
+}>>;
 export declare const pgSchemaInternalV3: import("zod").ZodObject<{
     version: import("zod").ZodLiteral<"3">;
     dialect: import("zod").ZodLiteral<"pg">;
@@ -874,6 +940,7 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
+            typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
             primaryKey: import("zod").ZodBoolean;
             notNull: import("zod").ZodBoolean;
             default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -883,6 +950,7 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
         }, "strict", import("zod").ZodTypeAny, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -892,6 +960,7 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
         }, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -945,6 +1014,7 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -972,6 +1042,7 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1006,13 +1077,12 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
         values: Record<string, string>;
     }>>;
 }, "strict", import("zod").ZodTypeAny, {
-    version: "3";
-    dialect: "pg";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1036,18 +1106,19 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
             columnsTo: string[];
         }>;
     }>;
+    version: "3";
+    dialect: "pg";
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
     }>;
 }, {
-    version: "3";
-    dialect: "pg";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1071,6 +1142,8 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
             columnsTo: string[];
         }>;
     }>;
+    version: "3";
+    dialect: "pg";
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
@@ -1085,6 +1158,7 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
+            typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
             primaryKey: import("zod").ZodBoolean;
             notNull: import("zod").ZodBoolean;
             default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -1094,6 +1168,7 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
         }, "strict", import("zod").ZodTypeAny, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1103,6 +1178,7 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
         }, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1156,6 +1232,7 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1184,6 +1261,7 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1220,13 +1298,12 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
     }>>;
     schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
 }, "strict", import("zod").ZodTypeAny, {
-    version: "4";
-    dialect: "pg";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1251,19 +1328,20 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
         }>;
         schema: string;
     }>;
+    version: "4";
+    dialect: "pg";
     schemas: Record<string, string>;
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
     }>;
 }, {
-    version: "4";
-    dialect: "pg";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1288,21 +1366,24 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
         }>;
         schema: string;
     }>;
+    version: "4";
+    dialect: "pg";
     schemas: Record<string, string>;
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
     }>;
 }>;
-export declare const pgSchemaExternal: import("zod").ZodObject<{
+export declare const pgSchemaInternalV5: import("zod").ZodObject<{
     version: import("zod").ZodLiteral<"5">;
     dialect: import("zod").ZodLiteral<"pg">;
-    tables: import("zod").ZodArray<import("zod").ZodObject<{
+    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
         schema: import("zod").ZodString;
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
+            typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
             primaryKey: import("zod").ZodBoolean;
             notNull: import("zod").ZodBoolean;
             default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -1312,6 +1393,7 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
         }, "strict", import("zod").ZodTypeAny, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1321,6 +1403,7 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
         }, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1397,6 +1480,7 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1439,6 +1523,7 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1466,8 +1551,8 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
             name: string;
             columns: string[];
         }>;
-    }>, "many">;
-    enums: import("zod").ZodArray<import("zod").ZodObject<{
+    }>>;
+    enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
         values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
     }, "strict", import("zod").ZodTypeAny, {
@@ -1476,14 +1561,8 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
     }, {
         name: string;
         values: Record<string, string>;
-    }>, "many">;
-    schemas: import("zod").ZodArray<import("zod").ZodObject<{
-        name: import("zod").ZodString;
-    }, "strip", import("zod").ZodTypeAny, {
-        name: string;
-    }, {
-        name: string;
-    }>, "many">;
+    }>>;
+    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>;
@@ -1497,14 +1576,67 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
         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<{
+                isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
+                rawType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "strip", import("zod").ZodTypeAny, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            }, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            }>>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    }, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    }>>;
 }, "strict", import("zod").ZodTypeAny, {
-    version: "5";
-    dialect: "pg";
-    tables: {
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
+    tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1537,23 +1669,30 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
             columns: string[];
             nullsNotDistinct: boolean;
         }>;
-    }[];
-    schemas: {
-        name: string;
-    }[];
+    }>;
+    version: "5";
+    dialect: "pg";
+    schemas: Record<string, string>;
     _meta: {
         columns: Record<string, string>;
         tables: Record<string, string>;
         schemas: Record<string, string>;
     };
-    enums: {
+    enums: Record<string, {
         name: string;
         values: Record<string, string>;
-    }[];
+    }>;
 }, {
-    version: "5";
-    dialect: "pg";
-    tables: {
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
+    tables: Record<string, {
         uniqueConstraints?: Record<string, {
             name: string;
             columns: string[];
@@ -1563,6 +1702,7 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1590,74 +1730,30 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
             name: string;
             columns: string[];
         }>;
-    }[];
-    schemas: {
-        name: string;
-    }[];
+    }>;
+    version: "5";
+    dialect: "pg";
+    schemas: Record<string, string>;
     _meta: {
         columns: Record<string, string>;
         tables: Record<string, string>;
         schemas: Record<string, string>;
     };
-    enums: {
+    enums: Record<string, {
         name: string;
         values: 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<{
-            isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
-            dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
-            rawType: import("zod").ZodOptional<import("zod").ZodString>;
-        }, "strip", import("zod").ZodTypeAny, {
-            isArray?: boolean | undefined;
-            dimensions?: number | undefined;
-            rawType?: string | undefined;
-        }, {
-            isArray?: boolean | undefined;
-            dimensions?: number | undefined;
-            rawType?: string | undefined;
-        }>>>;
-    }, "strip", import("zod").ZodTypeAny, {
-        columns: Record<string, {
-            isArray?: boolean | undefined;
-            dimensions?: number | undefined;
-            rawType?: string | undefined;
-        } | undefined>;
-    }, {
-        columns: Record<string, {
-            isArray?: boolean | undefined;
-            dimensions?: number | undefined;
-            rawType?: string | undefined;
-        } | undefined>;
-    }>>>;
-}, "strip", import("zod").ZodTypeAny, {
-    tables: Record<string, {
-        columns: Record<string, {
-            isArray?: boolean | undefined;
-            dimensions?: number | undefined;
-            rawType?: string | undefined;
-        } | undefined>;
-    } | undefined>;
-}, {
-    tables: Record<string, {
-        columns: Record<string, {
-            isArray?: boolean | undefined;
-            dimensions?: number | undefined;
-            rawType?: string | undefined;
-        } | undefined>;
-    } | undefined>;
-}>>;
-export declare const pgSchemaInternal: import("zod").ZodObject<{
+export declare const pgSchemaExternal: import("zod").ZodObject<{
     version: import("zod").ZodLiteral<"5">;
     dialect: import("zod").ZodLiteral<"pg">;
-    tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+    tables: import("zod").ZodArray<import("zod").ZodObject<{
         name: import("zod").ZodString;
         schema: import("zod").ZodString;
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
+            typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
             primaryKey: import("zod").ZodBoolean;
             notNull: import("zod").ZodBoolean;
             default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -1667,6 +1763,7 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
         }, "strict", import("zod").ZodTypeAny, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1676,6 +1773,7 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
         }, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1752,6 +1850,7 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1794,6 +1893,7 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1821,8 +1921,8 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
             name: string;
             columns: string[];
         }>;
-    }>>;
-    enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+    }>, "many">;
+    enums: import("zod").ZodArray<import("zod").ZodObject<{
         name: import("zod").ZodString;
         values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
     }, "strict", import("zod").ZodTypeAny, {
@@ -1831,8 +1931,14 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
     }, {
         name: string;
         values: Record<string, string>;
-    }>>;
-    schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    }>, "many">;
+    schemas: import("zod").ZodArray<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        name: string;
+    }, {
+        name: string;
+    }>, "many">;
     _meta: import("zod").ZodObject<{
         schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
         tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -1846,68 +1952,13 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
         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<{
-                isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
-                rawType: import("zod").ZodOptional<import("zod").ZodString>;
-            }, "strip", import("zod").ZodTypeAny, {
-                isArray?: boolean | undefined;
-                dimensions?: number | undefined;
-                rawType?: string | undefined;
-            }, {
-                isArray?: boolean | undefined;
-                dimensions?: number | undefined;
-                rawType?: string | undefined;
-            }>>>;
-        }, "strip", import("zod").ZodTypeAny, {
-            columns: Record<string, {
-                isArray?: boolean | undefined;
-                dimensions?: number | undefined;
-                rawType?: string | undefined;
-            } | undefined>;
-        }, {
-            columns: Record<string, {
-                isArray?: boolean | undefined;
-                dimensions?: number | undefined;
-                rawType?: string | undefined;
-            } | undefined>;
-        }>>>;
-    }, "strip", import("zod").ZodTypeAny, {
-        tables: Record<string, {
-            columns: Record<string, {
-                isArray?: boolean | undefined;
-                dimensions?: number | undefined;
-                rawType?: string | undefined;
-            } | undefined>;
-        } | undefined>;
-    }, {
-        tables: Record<string, {
-            columns: Record<string, {
-                isArray?: boolean | undefined;
-                dimensions?: number | undefined;
-                rawType?: string | undefined;
-            } | undefined>;
-        } | undefined>;
-    }>>;
 }, "strict", import("zod").ZodTypeAny, {
-    internal?: {
-        tables: Record<string, {
-            columns: Record<string, {
-                isArray?: boolean | undefined;
-                dimensions?: number | undefined;
-                rawType?: string | undefined;
-            } | undefined>;
-        } | undefined>;
-    } | undefined;
-    version: "5";
-    dialect: "pg";
-    tables: Record<string, {
+    tables: {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -1940,30 +1991,23 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
             columns: string[];
             nullsNotDistinct: boolean;
         }>;
-    }>;
-    schemas: Record<string, string>;
+    }[];
+    version: "5";
+    dialect: "pg";
+    schemas: {
+        name: string;
+    }[];
     _meta: {
         columns: Record<string, string>;
         tables: Record<string, string>;
         schemas: Record<string, string>;
     };
-    enums: Record<string, {
+    enums: {
         name: string;
         values: Record<string, string>;
-    }>;
+    }[];
 }, {
-    internal?: {
-        tables: Record<string, {
-            columns: Record<string, {
-                isArray?: boolean | undefined;
-                dimensions?: number | undefined;
-                rawType?: string | undefined;
-            } | undefined>;
-        } | undefined>;
-    } | undefined;
-    version: "5";
-    dialect: "pg";
-    tables: Record<string, {
+    tables: {
         uniqueConstraints?: Record<string, {
             name: string;
             columns: string[];
@@ -1973,6 +2017,7 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2000,27 +2045,32 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
             name: string;
             columns: string[];
         }>;
-    }>;
-    schemas: Record<string, string>;
+    }[];
+    version: "5";
+    dialect: "pg";
+    schemas: {
+        name: string;
+    }[];
     _meta: {
         columns: Record<string, string>;
         tables: Record<string, string>;
         schemas: Record<string, string>;
     };
-    enums: Record<string, {
+    enums: {
         name: string;
         values: Record<string, string>;
-    }>;
+    }[];
 }>;
-export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
-    version: import("zod").ZodLiteral<"4">;
-    dialect: import("zod").ZodEnum<["pg"]>;
+export declare const pgSchemaInternal: import("zod").ZodObject<{
+    version: import("zod").ZodLiteral<"6">;
+    dialect: import("zod").ZodLiteral<"pg">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
         schema: import("zod").ZodString;
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
+            typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
             primaryKey: import("zod").ZodBoolean;
             notNull: import("zod").ZodBoolean;
             default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -2030,6 +2080,7 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
         }, "strict", import("zod").ZodTypeAny, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2039,6 +2090,7 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
         }, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2046,13 +2098,76 @@ export declare const pgSchemaSquashedV4: 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;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }, {
+            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;
+            schemaTo: import("zod").ZodOptional<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;
+            schemaTo?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: 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">;
+            nullsNotDistinct: import("zod").ZodBoolean;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }>>>;
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2060,14 +2175,42 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, string>;
-        foreignKeys: Record<string, string>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
         schema: string;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }>;
     }, {
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2075,53 +2218,115 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, string>;
-        foreignKeys: Record<string, string>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
         schema: string;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>>;
     enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
-        values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        schema: import("zod").ZodString;
+        values: import("zod").ZodArray<import("zod").ZodString, "many">;
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
-        values: Record<string, string>;
+        values: string[];
+        schema: string;
     }, {
         name: string;
-        values: Record<string, string>;
+        values: string[];
+        schema: string;
     }>>;
     schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
-}, "strict", import("zod").ZodTypeAny, {
-    version: "4";
-    dialect: "pg";
-    tables: Record<string, {
-        name: string;
-        columns: Record<string, {
-            isUnique?: any;
-            default?: any;
-            uniqueName?: string | undefined;
-            nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }>;
-        indexes: Record<string, string>;
-        foreignKeys: Record<string, string>;
-        schema: string;
-    }>;
-    schemas: Record<string, string>;
-    enums: Record<string, {
-        name: string;
-        values: Record<string, string>;
+    _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>;
     }>;
-}, {
-    version: "4";
-    dialect: "pg";
-    tables: Record<string, {
-        name: string;
-        columns: Record<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<{
+                isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
+                rawType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "strip", import("zod").ZodTypeAny, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            }, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            }>>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    }, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    }>>;
+}, "strict", import("zod").ZodTypeAny, {
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2129,18 +2334,110 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, string>;
-        foreignKeys: Record<string, string>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
         schema: string;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }>;
     }>;
+    version: "6";
+    dialect: "pg";
     schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
     enums: Record<string, {
         name: string;
-        values: Record<string, string>;
+        values: string[];
+        schema: string;
+    }>;
+}, {
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
+    tables: Record<string, {
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
+        name: string;
+        columns: Record<string, {
+            isUnique?: any;
+            default?: any;
+            typeSchema?: string | undefined;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+        schema: string;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+    }>;
+    version: "6";
+    dialect: "pg";
+    schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
+    enums: Record<string, {
+        name: string;
+        values: string[];
+        schema: string;
     }>;
 }>;
-export declare const pgSchemaSquashed: import("zod").ZodObject<{
-    version: import("zod").ZodLiteral<"5">;
+export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
+    version: import("zod").ZodLiteral<"4">;
     dialect: import("zod").ZodEnum<["pg"]>;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -2148,6 +2445,7 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
+            typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
             primaryKey: import("zod").ZodBoolean;
             notNull: import("zod").ZodBoolean;
             default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -2157,6 +2455,7 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
         }, "strict", import("zod").ZodTypeAny, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2166,6 +2465,7 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
         }, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2175,13 +2475,12 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
         }>>;
         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").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2192,13 +2491,12 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
         indexes: Record<string, string>;
         foreignKeys: Record<string, string>;
         schema: string;
-        compositePrimaryKeys: Record<string, string>;
-        uniqueConstraints: Record<string, string>;
     }, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2209,8 +2507,6 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
         indexes: Record<string, string>;
         foreignKeys: Record<string, string>;
         schema: string;
-        compositePrimaryKeys: Record<string, string>;
-        uniqueConstraints: Record<string, string>;
     }>>;
     enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -2224,13 +2520,12 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
     }>>;
     schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
 }, "strict", import("zod").ZodTypeAny, {
-    version: "5";
-    dialect: "pg";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2241,22 +2536,21 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
         indexes: Record<string, string>;
         foreignKeys: Record<string, string>;
         schema: string;
-        compositePrimaryKeys: Record<string, string>;
-        uniqueConstraints: Record<string, string>;
     }>;
+    version: "4";
+    dialect: "pg";
     schemas: Record<string, string>;
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
     }>;
 }, {
-    version: "5";
-    dialect: "pg";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2267,23 +2561,25 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
         indexes: Record<string, string>;
         foreignKeys: Record<string, string>;
         schema: string;
-        compositePrimaryKeys: Record<string, string>;
-        uniqueConstraints: Record<string, string>;
     }>;
+    version: "4";
+    dialect: "pg";
     schemas: Record<string, string>;
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
     }>;
 }>;
-export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
-    version: import("zod").ZodLiteral<"3">;
-    dialect: import("zod").ZodLiteral<"pg">;
+export declare const pgSchemaSquashed: import("zod").ZodObject<{
+    version: import("zod").ZodLiteral<"6">;
+    dialect: import("zod").ZodEnum<["pg"]>;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
+        schema: import("zod").ZodString;
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
+            typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
             primaryKey: import("zod").ZodBoolean;
             notNull: import("zod").ZodBoolean;
             default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -2293,6 +2589,7 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
         }, "strict", import("zod").ZodTypeAny, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2302,6 +2599,7 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
         }, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2309,52 +2607,16 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
             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;
-        }, "strict", import("zod").ZodTypeAny, {
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }, {
-            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;
-            schemaTo: import("zod").ZodOptional<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;
-            schemaTo?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            schemaTo?: 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").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2362,26 +2624,17 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, {
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            schemaTo?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        schema: string;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints: Record<string, string>;
     }, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2389,18 +2642,213 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, {
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            schemaTo?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        schema: string;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints: Record<string, string>;
+    }>>;
+    enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        schema: import("zod").ZodString;
+        values: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        values: string[];
+        schema: string;
+    }, {
+        name: string;
+        values: string[];
+        schema: string;
+    }>>;
+    schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+}, "strict", import("zod").ZodTypeAny, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            isUnique?: any;
+            default?: any;
+            typeSchema?: string | undefined;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        schema: string;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints: Record<string, string>;
+    }>;
+    version: "6";
+    dialect: "pg";
+    schemas: Record<string, string>;
+    enums: Record<string, {
+        name: string;
+        values: string[];
+        schema: string;
+    }>;
+}, {
+    tables: Record<string, {
+        name: string;
+        columns: Record<string, {
+            isUnique?: any;
+            default?: any;
+            typeSchema?: string | undefined;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, string>;
+        foreignKeys: Record<string, string>;
+        schema: string;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints: Record<string, string>;
+    }>;
+    version: "6";
+    dialect: "pg";
+    schemas: Record<string, string>;
+    enums: Record<string, {
+        name: string;
+        values: string[];
+        schema: string;
+    }>;
+}>;
+export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
+    version: import("zod").ZodLiteral<"3">;
+    dialect: import("zod").ZodLiteral<"pg">;
+    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;
+            typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
+            primaryKey: import("zod").ZodBoolean;
+            notNull: import("zod").ZodBoolean;
+            default: import("zod").ZodOptional<import("zod").ZodAny>;
+            isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
+            uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
+            nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, "strict", import("zod").ZodTypeAny, {
+            isUnique?: any;
+            default?: any;
+            typeSchema?: string | undefined;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }, {
+            isUnique?: any;
+            default?: any;
+            typeSchema?: string | undefined;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: 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;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }, {
+            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;
+            schemaTo: import("zod").ZodOptional<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;
+            schemaTo?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        columns: Record<string, {
+            isUnique?: any;
+            default?: any;
+            typeSchema?: string | undefined;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+    }, {
+        name: string;
+        columns: Record<string, {
+            isUnique?: any;
+            default?: any;
+            typeSchema?: string | undefined;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }>;
+        indexes: Record<string, {
+            name: string;
+            columns: string[];
+            isUnique: boolean;
+        }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
             tableTo: string;
             columnsTo: string[];
         }>;
@@ -2419,15 +2867,12 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
     id: import("zod").ZodString;
     prevId: import("zod").ZodString;
 }>, "strip", import("zod").ZodTypeAny, {
-    id: string;
-    prevId: string;
-    version: "3";
-    dialect: "pg";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2451,20 +2896,21 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
             columnsTo: string[];
         }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "3";
+    dialect: "pg";
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
     }>;
 }, {
-    id: string;
-    prevId: string;
-    version: "3";
-    dialect: "pg";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2488,6 +2934,10 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
             columnsTo: string[];
         }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "3";
+    dialect: "pg";
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
@@ -2502,6 +2952,7 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
+            typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
             primaryKey: import("zod").ZodBoolean;
             notNull: import("zod").ZodBoolean;
             default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -2511,6 +2962,7 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
         }, "strict", import("zod").ZodTypeAny, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2520,6 +2972,7 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
         }, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2573,6 +3026,7 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2601,6 +3055,7 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2640,15 +3095,12 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
     id: import("zod").ZodString;
     prevId: import("zod").ZodString;
 }>, "strip", import("zod").ZodTypeAny, {
-    id: string;
-    prevId: string;
-    version: "4";
-    dialect: "pg";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2673,21 +3125,22 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
         }>;
         schema: string;
     }>;
+    id: string;
+    prevId: string;
+    version: "4";
+    dialect: "pg";
     schemas: Record<string, string>;
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
     }>;
 }, {
-    id: string;
-    prevId: string;
-    version: "4";
-    dialect: "pg";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2712,13 +3165,17 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
         }>;
         schema: string;
     }>;
+    id: string;
+    prevId: string;
+    version: "4";
+    dialect: "pg";
     schemas: Record<string, string>;
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
     }>;
 }>;
-export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape<{
+export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendShape<{
     version: import("zod").ZodLiteral<"5">;
     dialect: import("zod").ZodLiteral<"pg">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -2727,6 +3184,7 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
+            typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
             primaryKey: import("zod").ZodBoolean;
             notNull: import("zod").ZodBoolean;
             default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -2736,6 +3194,7 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
         }, "strict", import("zod").ZodTypeAny, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2745,6 +3204,7 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
         }, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2821,6 +3281,7 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2863,6 +3324,7 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -2969,411 +3431,18 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
             columns: Record<string, {
                 isArray?: boolean | undefined;
                 dimensions?: number | undefined;
-                rawType?: string | undefined;
-            } | undefined>;
-        } | undefined>;
-    } | undefined;
-    id: string;
-    prevId: string;
-    version: "5";
-    dialect: "pg";
-    tables: Record<string, {
-        name: string;
-        columns: Record<string, {
-            isUnique?: any;
-            default?: any;
-            uniqueName?: string | undefined;
-            nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }>;
-        indexes: Record<string, {
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            schemaTo?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }>;
-        schema: string;
-        compositePrimaryKeys: Record<string, {
-            name: string;
-            columns: string[];
-        }>;
-        uniqueConstraints: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }>;
-    }>;
-    schemas: Record<string, string>;
-    _meta: {
-        columns: Record<string, string>;
-        tables: Record<string, string>;
-        schemas: Record<string, string>;
-    };
-    enums: Record<string, {
-        name: string;
-        values: Record<string, string>;
-    }>;
-}, {
-    internal?: {
-        tables: Record<string, {
-            columns: Record<string, {
-                isArray?: boolean | undefined;
-                dimensions?: number | undefined;
-                rawType?: string | undefined;
-            } | undefined>;
-        } | undefined>;
-    } | undefined;
-    id: string;
-    prevId: string;
-    version: "5";
-    dialect: "pg";
-    tables: Record<string, {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
-        name: string;
-        columns: Record<string, {
-            isUnique?: any;
-            default?: any;
-            uniqueName?: string | undefined;
-            nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }>;
-        indexes: Record<string, {
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
-        foreignKeys: Record<string, {
-            onUpdate?: string | undefined;
-            onDelete?: string | undefined;
-            schemaTo?: string | undefined;
-            name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: string[];
-        }>;
-        schema: 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>;
-    };
-    enums: Record<string, {
-        name: string;
-        values: Record<string, string>;
-    }>;
-}>;
-export type Enum = TypeOf<typeof enumSchema>;
-export type Column = TypeOf<typeof column>;
-export type TableV3 = TypeOf<typeof tableV3>;
-export type TableV4 = TypeOf<typeof tableV4>;
-export type Table = TypeOf<typeof table>;
-export type PgSchema = TypeOf<typeof pgSchema>;
-export type PgSchemaInternal = TypeOf<typeof pgSchemaInternal>;
-export type PgSchemaExternal = TypeOf<typeof pgSchemaExternal>;
-export type PgSchemaSquashed = TypeOf<typeof pgSchemaSquashed>;
-export type PgSchemaSquashedV4 = TypeOf<typeof pgSchemaSquashedV4>;
-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 type PgKitInternals = TypeOf<typeof kitInternals>;
-export type PgSchemaV1 = TypeOf<typeof pgSchemaV1>;
-export type PgSchemaV2 = TypeOf<typeof pgSchemaV2>;
-export type PgSchemaV3 = TypeOf<typeof pgSchemaV3>;
-export type PgSchemaV4 = TypeOf<typeof pgSchemaV4>;
-export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import("zod").ZodObject<{
-    version: import("zod").ZodLiteral<"1">;
-    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;
-            default: import("zod").ZodOptional<import("zod").ZodAny>;
-            references: import("zod").ZodOptional<import("zod").ZodObject<{
-                foreignKeyName: import("zod").ZodString;
-                table: import("zod").ZodString;
-                column: import("zod").ZodString;
-                onDelete: import("zod").ZodOptional<import("zod").ZodString>;
-                onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
-            }, "strict", import("zod").ZodTypeAny, {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
-                foreignKeyName: string;
-                table: string;
-                column: string;
-            }, {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
-                foreignKeyName: string;
-                table: string;
-                column: string;
-            }>>;
-        }, "strict", import("zod").ZodTypeAny, {
-            default?: any;
-            references?: {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
-                foreignKeyName: string;
-                table: string;
-                column: string;
-            } | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }, {
-            default?: any;
-            references?: {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
-                foreignKeyName: string;
-                table: string;
-                column: string;
-            } | 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").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-                name: import("zod").ZodString;
-            }, "strip", import("zod").ZodTypeAny, {
-                name: string;
-            }, {
-                name: string;
-            }>>;
-            isUnique: import("zod").ZodBoolean;
-        }, "strict", import("zod").ZodTypeAny, {
-            name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
-            isUnique: boolean;
-        }, {
-            name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
-            isUnique: boolean;
-        }>>;
-    }, "strict", import("zod").ZodTypeAny, {
-        name: string;
-        columns: Record<string, {
-            default?: any;
-            references?: {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
-                foreignKeyName: string;
-                table: string;
-                column: string;
-            } | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }>;
-        indexes: Record<string, {
-            name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
-            isUnique: boolean;
-        }>;
-    }, {
-        name: string;
-        columns: Record<string, {
-            default?: any;
-            references?: {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
-                foreignKeyName: string;
-                table: string;
-                column: string;
-            } | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }>;
-        indexes: Record<string, {
-            name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
-            isUnique: boolean;
-        }>;
-    }>>;
-    enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-        name: import("zod").ZodString;
-        values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
-    }, "strict", import("zod").ZodTypeAny, {
-        name: string;
-        values: Record<string, string>;
-    }, {
-        name: string;
-        values: Record<string, string>;
-    }>>;
-}, "strict", import("zod").ZodTypeAny, {
-    version: "1";
-    tables: Record<string, {
-        name: string;
-        columns: Record<string, {
-            default?: any;
-            references?: {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
-                foreignKeyName: string;
-                table: string;
-                column: string;
-            } | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }>;
-        indexes: Record<string, {
-            name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
-            isUnique: boolean;
-        }>;
-    }>;
-    enums: Record<string, {
-        name: string;
-        values: Record<string, string>;
-    }>;
-}, {
-    version: "1";
-    tables: Record<string, {
-        name: string;
-        columns: Record<string, {
-            default?: any;
-            references?: {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
-                foreignKeyName: string;
-                table: string;
-                column: string;
-            } | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }>;
-        indexes: Record<string, {
-            name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
-            isUnique: boolean;
-        }>;
-    }>;
-    enums: Record<string, {
-        name: string;
-        values: Record<string, string>;
-    }>;
-}>, import("zod").ZodObject<{
-    version: import("zod").ZodLiteral<"2">;
-    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;
-            default: import("zod").ZodOptional<import("zod").ZodAny>;
-            references: import("zod").ZodOptional<import("zod").ZodString>;
-        }, "strict", import("zod").ZodTypeAny, {
-            default?: any;
-            references?: string | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }, {
-            default?: any;
-            references?: string | 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").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-                name: import("zod").ZodString;
-            }, "strip", import("zod").ZodTypeAny, {
-                name: string;
-            }, {
-                name: string;
-            }>>;
-            isUnique: import("zod").ZodBoolean;
-        }, "strict", import("zod").ZodTypeAny, {
-            name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
-            isUnique: boolean;
-        }, {
-            name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
-            isUnique: boolean;
-        }>>;
-    }, "strict", import("zod").ZodTypeAny, {
-        name: string;
-        columns: Record<string, {
-            default?: any;
-            references?: string | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }>;
-        indexes: Record<string, {
-            name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
-            isUnique: boolean;
-        }>;
-    }, {
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
+    tables: Record<string, {
         name: string;
         columns: Record<string, {
+            isUnique?: any;
             default?: any;
-            references?: string | undefined;
+            typeSchema?: string | undefined;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
             name: string;
             type: string;
             primaryKey: boolean;
@@ -3381,53 +3450,67 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         }>;
         indexes: Record<string, {
             name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
+            columns: string[];
             isUnique: boolean;
         }>;
-    }>>;
-    enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-        name: import("zod").ZodString;
-        values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
-    }, "strict", import("zod").ZodTypeAny, {
-        name: string;
-        values: Record<string, string>;
-    }, {
-        name: string;
-        values: Record<string, string>;
-    }>>;
-}, "strict", import("zod").ZodTypeAny, {
-    version: "2";
-    tables: Record<string, {
-        name: string;
-        columns: Record<string, {
-            default?: any;
-            references?: string | undefined;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
             name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
         }>;
-        indexes: Record<string, {
+        schema: string;
+        compositePrimaryKeys: Record<string, {
             name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
-            isUnique: boolean;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
         }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "pg";
+    schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
     }>;
 }, {
-    version: "2";
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
     tables: Record<string, {
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
         name: string;
         columns: Record<string, {
+            isUnique?: any;
             default?: any;
-            references?: string | undefined;
+            typeSchema?: string | undefined;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
             name: string;
             type: string;
             primaryKey: boolean;
@@ -3435,24 +3518,50 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         }>;
         indexes: Record<string, {
             name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
+            columns: string[];
             isUnique: boolean;
         }>;
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
+            name: string;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: string[];
+        }>;
+        schema: string;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "pg";
+    schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
     }>;
-}>, import("zod").ZodObject<import("zod").extendShape<{
-    version: import("zod").ZodLiteral<"3">;
+}>;
+export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape<{
+    version: import("zod").ZodLiteral<"6">;
     dialect: import("zod").ZodLiteral<"pg">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
+        schema: import("zod").ZodString;
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
+            typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
             primaryKey: import("zod").ZodBoolean;
             notNull: import("zod").ZodBoolean;
             default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -3462,6 +3571,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         }, "strict", import("zod").ZodTypeAny, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -3471,6 +3581,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         }, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -3519,11 +3630,35 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             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">;
+            nullsNotDistinct: import("zod").ZodBoolean;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }>>>;
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -3546,11 +3681,27 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             tableTo: string;
             columnsTo: string[];
         }>;
+        schema: string;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }>;
     }, {
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -3573,30 +3724,103 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             tableTo: string;
             columnsTo: string[];
         }>;
+        schema: string;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>>;
     enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
-        values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        schema: import("zod").ZodString;
+        values: import("zod").ZodArray<import("zod").ZodString, "many">;
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
-        values: Record<string, string>;
+        values: string[];
+        schema: string;
     }, {
         name: string;
-        values: Record<string, string>;
+        values: string[];
+        schema: 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<{
+                isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
+                rawType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "strip", import("zod").ZodTypeAny, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            }, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            }>>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    }, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
     }>>;
 }, {
     id: import("zod").ZodString;
     prevId: import("zod").ZodString;
 }>, "strip", import("zod").ZodTypeAny, {
-    id: string;
-    prevId: string;
-    version: "3";
-    dialect: "pg";
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
     tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -3619,21 +3843,53 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             tableTo: string;
             columnsTo: string[];
         }>;
+        schema: string;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "6";
+    dialect: "pg";
+    schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
     enums: Record<string, {
         name: string;
-        values: Record<string, string>;
+        values: string[];
+        schema: string;
     }>;
 }, {
-    id: string;
-    prevId: string;
-    version: "3";
-    dialect: "pg";
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
     tables: Record<string, {
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -3656,13 +3912,50 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             tableTo: string;
             columnsTo: string[];
         }>;
+        schema: string;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "6";
+    dialect: "pg";
+    schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
     enums: Record<string, {
         name: string;
-        values: Record<string, string>;
+        values: string[];
+        schema: string;
     }>;
-}>, import("zod").ZodObject<import("zod").extendShape<{
-    version: import("zod").ZodLiteral<"4">;
+}>;
+export type Enum = TypeOf<typeof enumSchema>;
+export type Column = TypeOf<typeof column>;
+export type TableV3 = TypeOf<typeof tableV3>;
+export type TableV4 = TypeOf<typeof tableV4>;
+export type Table = TypeOf<typeof table>;
+export type PgSchema = TypeOf<typeof pgSchema>;
+export type PgSchemaInternal = TypeOf<typeof pgSchemaInternal>;
+export type PgSchemaExternal = TypeOf<typeof pgSchemaExternal>;
+export type PgSchemaSquashed = TypeOf<typeof pgSchemaSquashed>;
+export type PgSchemaSquashedV4 = TypeOf<typeof pgSchemaSquashedV4>;
+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 type PgKitInternals = TypeOf<typeof kitInternals>;
+export type PgSchemaV1 = TypeOf<typeof pgSchemaV1>;
+export type PgSchemaV2 = TypeOf<typeof pgSchemaV2>;
+export type PgSchemaV3 = TypeOf<typeof pgSchemaV3>;
+export type PgSchemaV4 = TypeOf<typeof pgSchemaV4>;
+export type PgSchemaV5 = TypeOf<typeof pgSchemaV5>;
+export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
+    version: import("zod").ZodLiteral<"5">;
     dialect: import("zod").ZodLiteral<"pg">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -3670,6 +3963,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
+            typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
             primaryKey: import("zod").ZodBoolean;
             notNull: import("zod").ZodBoolean;
             default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -3679,6 +3973,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         }, "strict", import("zod").ZodTypeAny, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -3688,6 +3983,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         }, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -3736,11 +4032,35 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             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">;
+            nullsNotDistinct: import("zod").ZodBoolean;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }>>>;
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -3764,11 +4084,26 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             columnsTo: string[];
         }>;
         schema: string;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }>;
     }, {
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -3792,6 +4127,10 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             columnsTo: string[];
         }>;
         schema: string;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>>;
     enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -3804,19 +4143,83 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         values: Record<string, 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<{
+                isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
+                rawType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "strip", import("zod").ZodTypeAny, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            }, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            }>>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        }, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        }>>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    }, {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    }>>;
 }, {
     id: import("zod").ZodString;
     prevId: import("zod").ZodString;
 }>, "strip", import("zod").ZodTypeAny, {
-    id: string;
-    prevId: string;
-    version: "4";
-    dialect: "pg";
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
     tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -3840,22 +4243,51 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             columnsTo: string[];
         }>;
         schema: string;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
+        uniqueConstraints: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "pg";
     schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
     }>;
 }, {
-    id: string;
-    prevId: string;
-    version: "4";
-    dialect: "pg";
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
     tables: Record<string, {
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -3879,14 +4311,27 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             columnsTo: string[];
         }>;
         schema: string;
+        compositePrimaryKeys: Record<string, {
+            name: string;
+            columns: string[];
+        }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "5";
+    dialect: "pg";
     schemas: Record<string, string>;
+    _meta: {
+        columns: Record<string, string>;
+        tables: Record<string, string>;
+        schemas: Record<string, string>;
+    };
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
     }>;
 }>, import("zod").ZodObject<import("zod").extendShape<{
-    version: import("zod").ZodLiteral<"5">;
+    version: import("zod").ZodLiteral<"6">;
     dialect: import("zod").ZodLiteral<"pg">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -3894,6 +4339,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
             type: import("zod").ZodString;
+            typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
             primaryKey: import("zod").ZodBoolean;
             notNull: import("zod").ZodBoolean;
             default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -3903,6 +4349,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         }, "strict", import("zod").ZodTypeAny, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -3912,6 +4359,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         }, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -3988,6 +4436,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -4030,6 +4479,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -4060,13 +4510,16 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
     }>>;
     enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
-        values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+        schema: import("zod").ZodString;
+        values: import("zod").ZodArray<import("zod").ZodString, "many">;
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
-        values: Record<string, string>;
+        values: string[];
+        schema: string;
     }, {
         name: string;
-        values: Record<string, string>;
+        values: string[];
+        schema: string;
     }>>;
     schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
     _meta: import("zod").ZodObject<{
@@ -4140,15 +4593,12 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             } | undefined>;
         } | undefined>;
     } | undefined;
-    id: string;
-    prevId: string;
-    version: "5";
-    dialect: "pg";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -4182,6 +4632,10 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             nullsNotDistinct: boolean;
         }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "6";
+    dialect: "pg";
     schemas: Record<string, string>;
     _meta: {
         columns: Record<string, string>;
@@ -4190,7 +4644,8 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
     };
     enums: Record<string, {
         name: string;
-        values: Record<string, string>;
+        values: string[];
+        schema: string;
     }>;
 }, {
     internal?: {
@@ -4202,10 +4657,6 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             } | undefined>;
         } | undefined>;
     } | undefined;
-    id: string;
-    prevId: string;
-    version: "5";
-    dialect: "pg";
     tables: Record<string, {
         uniqueConstraints?: Record<string, {
             name: string;
@@ -4216,6 +4667,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -4244,6 +4696,10 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             columns: string[];
         }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "6";
+    dialect: "pg";
     schemas: Record<string, string>;
     _meta: {
         columns: Record<string, string>;
@@ -4252,7 +4708,8 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
     };
     enums: Record<string, {
         name: string;
-        values: Record<string, string>;
+        values: string[];
+        schema: string;
     }>;
 }>]>;
 export declare const PgSquasher: {
@@ -4277,15 +4734,12 @@ export declare const dryPg: {
             } | undefined>;
         } | undefined>;
     } | undefined;
-    id: string;
-    prevId: string;
-    version: "5";
-    dialect: "pg";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
             isUnique?: any;
             default?: any;
+            typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
             name: string;
@@ -4319,6 +4773,10 @@ export declare const dryPg: {
             nullsNotDistinct: boolean;
         }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "6";
+    dialect: "pg";
     schemas: Record<string, string>;
     _meta: {
         columns: Record<string, string>;
@@ -4327,7 +4785,8 @@ export declare const dryPg: {
     };
     enums: Record<string, {
         name: string;
-        values: Record<string, string>;
+        values: string[];
+        schema: string;
     }>;
 };
 export {};