drizzle-kit 0.20.14-a77266f → 0.20.14-c82ab68

package/serializer/pgSchema.d.ts

@@ -104,7 +104,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 +122,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 +146,7 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
     }>;
+    version: "2";
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
@@ -289,7 +289,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 +313,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 +343,7 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
     }>;
+    version: "1";
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
@@ -866,6 +866,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">;
@@ -1006,8 +1051,6 @@ 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, {
@@ -1036,13 +1079,13 @@ 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, {
@@ -1071,6 +1114,8 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
             columnsTo: string[];
         }>;
     }>;
+    version: "3";
+    dialect: "pg";
     enums: Record<string, {
         name: string;
         values: Record<string, string>;
@@ -1220,8 +1265,6 @@ 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, {
@@ -1251,14 +1294,14 @@ 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, {
@@ -1288,16 +1331,18 @@ 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<{
@@ -1466,8 +1511,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 +1521,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,10 +1536,62 @@ 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;
@@ -1537,23 +1628,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[];
@@ -1590,69 +1688,24 @@ 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<{
@@ -1821,8 +1874,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 +1884,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,64 +1905,8 @@ 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;
@@ -1940,30 +1943,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[];
@@ -2000,21 +1996,25 @@ 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;
@@ -2046,8 +2046,70 @@ 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, {
@@ -2060,10 +2122,37 @@ 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;
@@ -2075,9 +2164,26 @@ 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;
@@ -2090,57 +2196,187 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
         values: Record<string, 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, {
-            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>;
+    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;
+            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;
+        }>;
+    }>;
+    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>;
+    }>;
+}, {
+    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;
+            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: Record<string, 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;
@@ -2175,8 +2411,6 @@ 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, {
@@ -2192,8 +2426,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>;
     }, {
         name: string;
         columns: Record<string, {
@@ -2209,8 +2441,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,8 +2454,6 @@ 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, {
@@ -2241,17 +2469,15 @@ 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, {
@@ -2267,20 +2493,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>;
     }>;
 }>;
-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;
@@ -2309,47 +2536,10 @@ 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, {
@@ -2362,21 +2552,11 @@ 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, {
@@ -2389,11 +2569,194 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
             primaryKey: boolean;
             notNull: boolean;
         }>;
-        indexes: Record<string, {
-            name: string;
-            columns: string[];
-            isUnique: boolean;
-        }>;
+        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;
+        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>;
+    }>>;
+    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;
+            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: Record<string, string>;
+    }>;
+}, {
+    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;
+        compositePrimaryKeys: Record<string, string>;
+        uniqueConstraints: Record<string, string>;
+    }>;
+    version: "6";
+    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">;
+    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>;
+            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;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
+        }, {
+            isUnique?: any;
+            default?: any;
+            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;
+            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;
+            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;
@@ -2419,10 +2782,6 @@ 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, {
@@ -2451,15 +2810,15 @@ 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, {
@@ -2488,6 +2847,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>;
@@ -2640,10 +3003,6 @@ 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, {
@@ -2673,16 +3032,16 @@ 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, {
@@ -2712,13 +3071,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<{
@@ -2968,395 +3331,18 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
         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, {
-        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, {
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
+    tables: Record<string, {
         name: string;
         columns: Record<string, {
+            isUnique?: any;
             default?: any;
-            references?: string | undefined;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
             name: string;
             type: string;
             primaryKey: boolean;
@@ -3364,70 +3350,66 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         }>;
         indexes: Record<string, {
             name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
+            columns: string[];
             isUnique: boolean;
         }>;
-    }, {
-        name: string;
-        columns: Record<string, {
-            default?: any;
-            references?: string | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
-        }>;
-        indexes: Record<string, {
+        foreignKeys: Record<string, {
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
             name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
-            isUnique: boolean;
+            tableFrom: string;
+            columnsFrom: string[];
+            tableTo: string;
+            columnsTo: 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>;
-    }, "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;
+        schema: string;
+        compositePrimaryKeys: Record<string, {
             name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
+            columns: string[];
         }>;
-        indexes: Record<string, {
+        uniqueConstraints: Record<string, {
             name: string;
-            columns: Record<string, {
-                name: string;
-            }>;
-            isUnique: boolean;
+            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;
+            uniqueName?: string | undefined;
+            nullsNotDistinct?: boolean | undefined;
             name: string;
             type: string;
             primaryKey: boolean;
@@ -3435,21 +3417,46 @@ 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;
@@ -3519,6 +3526,29 @@ 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, {
@@ -3546,7 +3576,22 @@ 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;
@@ -3573,6 +3618,11 @@ 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;
@@ -3584,14 +3634,78 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         name: string;
         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: "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, {
@@ -3614,22 +3728,52 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             onDelete?: string | undefined;
             schemaTo?: string | undefined;
             name: string;
-            tableFrom: string;
-            columnsFrom: string[];
-            tableTo: string;
-            columnsTo: 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;
         }>;
     }>;
+    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>;
     }>;
 }, {
-    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;
@@ -3656,13 +3800,49 @@ 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>;
     }>;
-}>, 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;
@@ -3736,6 +3916,29 @@ 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, {
@@ -3764,7 +3967,21 @@ 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;
@@ -3792,6 +4009,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,14 +4025,77 @@ 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, {
@@ -3840,18 +4124,46 @@ 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;
@@ -3879,14 +4191,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;
@@ -4140,10 +4465,6 @@ 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, {
@@ -4182,6 +4503,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>;
@@ -4202,10 +4527,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;
@@ -4244,6 +4565,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>;
@@ -4277,10 +4602,6 @@ export declare const dryPg: {
             } | undefined>;
         } | undefined>;
     } | undefined;
-    id: string;
-    prevId: string;
-    version: "5";
-    dialect: "pg";
     tables: Record<string, {
         name: string;
         columns: Record<string, {
@@ -4319,6 +4640,10 @@ export declare const dryPg: {
             nullsNotDistinct: boolean;
         }>;
     }>;
+    id: string;
+    prevId: string;
+    version: "6";
+    dialect: "pg";
     schemas: Record<string, string>;
     _meta: {
         columns: Record<string, string>;