npm - drizzle-kit - Versions diffs - 0.20.17-b08243d → 0.20.17-b4f119e - Mend

drizzle-kit 0.20.17-b08243d → 0.20.17-b4f119e

Files changed (22) hide show

package/bin.cjs +26342 -25481
package/cli/commands/migrate.d.ts +39 -39
package/cli/commands/mysqlIntrospect.d.ts +8 -8
package/cli/commands/pgIntrospect.d.ts +7 -7
package/cli/commands/sqliteIntrospect.d.ts +12 -12
package/cli/validations/cli.d.ts +13 -13
package/cli/validations/common.d.ts +27 -27
package/cli/validations/mysql.d.ts +4 -4
package/cli/validations/outputs.d.ts +0 -1
package/cli/validations/pg.d.ts +4 -4
package/package.json +1 -1
package/payload.js +1037 -433
package/payload.mjs +844 -240
package/schemaValidator.d.ts +215 -215
package/serializer/mysqlSchema.d.ts +892 -892
package/serializer/pgSchema.d.ts +734 -734
package/serializer/sqliteSchema.d.ts +457 -457
package/snapshotsDiffer.d.ts +314 -314
package/utils-studio.js +939 -833
package/utils-studio.mjs +912 -806
package/utils.js +839 -214
package/utils.mjs +814 -189

package/serializer/pgSchema.d.ts CHANGED Viewed

@@ -24,19 +24,19 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
             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;
+            default?: any;
+            references?: string | undefined;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -64,12 +64,12 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
-            default?: any;
-            references?: string | undefined;
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
+            default?: any;
+            references?: string | undefined;
         }>;
         indexes: Record<string, {
             name: string;
@@ -81,12 +81,12 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
     }, {
         name: string;
         columns: Record<string, {
-            default?: any;
-            references?: string | undefined;
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
+            default?: any;
+            references?: string | undefined;
         }>;
         indexes: Record<string, {
             name: string;
@@ -110,12 +110,12 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
     tables: Record<string, {
         name: string;
         columns: Record<string, {
-            default?: any;
-            references?: string | undefined;
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
+            default?: any;
+            references?: string | undefined;
         }>;
         indexes: Record<string, {
             name: string;
@@ -134,12 +134,12 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
     tables: Record<string, {
         name: string;
         columns: Record<string, {
-            default?: any;
-            references?: string | undefined;
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
+            default?: any;
+            references?: string | undefined;
         }>;
         indexes: Record<string, {
             name: string;
@@ -172,44 +172,44 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
                 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;
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
             }>>;
         }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             default?: any;
             references?: {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
                 foreignKeyName: string;
                 table: string;
                 column: string;
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
             } | undefined;
+        }, {
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
-        }, {
             default?: any;
             references?: {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
                 foreignKeyName: string;
                 table: string;
                 column: string;
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
             } | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -237,18 +237,18 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             default?: any;
             references?: {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
                 foreignKeyName: string;
                 table: string;
                 column: string;
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
             } | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -260,18 +260,18 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
     }, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             default?: any;
             references?: {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
                 foreignKeyName: string;
                 table: string;
                 column: string;
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
             } | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -295,18 +295,18 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
     tables: Record<string, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             default?: any;
             references?: {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
                 foreignKeyName: string;
                 table: string;
                 column: string;
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
             } | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -325,18 +325,18 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
     tables: Record<string, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             default?: any;
             references?: {
-                onUpdate?: string | undefined;
-                onDelete?: string | undefined;
                 foreignKeyName: string;
                 table: string;
                 column: string;
+                onUpdate?: string | undefined;
+                onDelete?: string | undefined;
             } | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -375,23 +375,23 @@ declare const fk: import("zod").ZodObject<{
     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[];
+    onUpdate?: string | undefined;
+    onDelete?: string | undefined;
+    schemaTo?: string | undefined;
 }>;
 declare const column: import("zod").ZodObject<{
     name: import("zod").ZodString;
@@ -404,25 +404,25 @@ declare const column: import("zod").ZodObject<{
     uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
     nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
 }, "strict", import("zod").ZodTypeAny, {
+    name: string;
+    type: string;
+    primaryKey: boolean;
+    notNull: boolean;
     isUnique?: any;
     default?: any;
     typeSchema?: string | undefined;
     uniqueName?: string | undefined;
     nullsNotDistinct?: boolean | undefined;
+}, {
     name: string;
     type: string;
     primaryKey: boolean;
     notNull: boolean;
-}, {
     isUnique?: any;
     default?: any;
     typeSchema?: string | undefined;
     uniqueName?: string | undefined;
     nullsNotDistinct?: boolean | undefined;
-    name: string;
-    type: string;
-    primaryKey: boolean;
-    notNull: boolean;
 }>;
 declare const tableV3: import("zod").ZodObject<{
     name: import("zod").ZodString;
@@ -437,25 +437,25 @@ declare const tableV3: import("zod").ZodObject<{
         uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
         nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
     }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        type: string;
+        primaryKey: boolean;
+        notNull: boolean;
         isUnique?: any;
         default?: any;
         typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
+    }, {
         name: string;
         type: string;
         primaryKey: boolean;
         notNull: boolean;
-    }, {
         isUnique?: any;
         default?: any;
         typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
-        name: string;
-        type: string;
-        primaryKey: boolean;
-        notNull: boolean;
     }>>;
     indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -480,36 +480,36 @@ declare const tableV3: import("zod").ZodObject<{
         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[];
+        onUpdate?: string | undefined;
+        onDelete?: string | undefined;
+        schemaTo?: string | undefined;
     }>>;
 }, "strict", import("zod").ZodTypeAny, {
     name: string;
     columns: Record<string, {
+        name: string;
+        type: string;
+        primaryKey: boolean;
+        notNull: boolean;
         isUnique?: any;
         default?: any;
         typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
-        name: string;
-        type: string;
-        primaryKey: boolean;
-        notNull: boolean;
     }>;
     indexes: Record<string, {
         name: string;
@@ -517,27 +517,27 @@ declare const tableV3: import("zod").ZodObject<{
         isUnique: boolean;
     }>;
     foreignKeys: Record<string, {
-        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;
     columns: Record<string, {
+        name: string;
+        type: string;
+        primaryKey: boolean;
+        notNull: boolean;
         isUnique?: any;
         default?: any;
         typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
-        name: string;
-        type: string;
-        primaryKey: boolean;
-        notNull: boolean;
     }>;
     indexes: Record<string, {
         name: string;
@@ -545,14 +545,14 @@ declare const tableV3: import("zod").ZodObject<{
         isUnique: boolean;
     }>;
     foreignKeys: Record<string, {
-        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;
     }>;
 }>;
 declare const compositePK: import("zod").ZodObject<{
@@ -592,25 +592,25 @@ declare const tableV4: import("zod").ZodObject<{
         uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
         nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
     }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        type: string;
+        primaryKey: boolean;
+        notNull: boolean;
         isUnique?: any;
         default?: any;
         typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
+    }, {
         name: string;
         type: string;
         primaryKey: boolean;
         notNull: boolean;
-    }, {
         isUnique?: any;
         default?: any;
         typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
-        name: string;
-        type: string;
-        primaryKey: boolean;
-        notNull: boolean;
     }>>;
     indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -635,36 +635,36 @@ declare const tableV4: import("zod").ZodObject<{
         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[];
+        onUpdate?: string | undefined;
+        onDelete?: string | undefined;
+        schemaTo?: string | undefined;
     }>>;
 }, "strict", import("zod").ZodTypeAny, {
     name: string;
     columns: Record<string, {
+        name: string;
+        type: string;
+        primaryKey: boolean;
+        notNull: boolean;
         isUnique?: any;
         default?: any;
         typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
-        name: string;
-        type: string;
-        primaryKey: boolean;
-        notNull: boolean;
     }>;
     indexes: Record<string, {
         name: string;
@@ -672,28 +672,28 @@ declare const tableV4: import("zod").ZodObject<{
         isUnique: boolean;
     }>;
     foreignKeys: Record<string, {
-        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;
     }>;
     schema: string;
 }, {
     name: string;
     columns: Record<string, {
+        name: string;
+        type: string;
+        primaryKey: boolean;
+        notNull: boolean;
         isUnique?: any;
         default?: any;
         typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
-        name: string;
-        type: string;
-        primaryKey: boolean;
-        notNull: boolean;
     }>;
     indexes: Record<string, {
         name: string;
@@ -701,14 +701,14 @@ declare const tableV4: import("zod").ZodObject<{
         isUnique: boolean;
     }>;
     foreignKeys: Record<string, {
-        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;
     }>;
     schema: string;
 }>;
@@ -726,25 +726,25 @@ declare const table: import("zod").ZodObject<{
         uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
         nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
     }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        type: string;
+        primaryKey: boolean;
+        notNull: boolean;
         isUnique?: any;
         default?: any;
         typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
+    }, {
         name: string;
         type: string;
         primaryKey: boolean;
         notNull: boolean;
-    }, {
         isUnique?: any;
         default?: any;
         typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
-        name: string;
-        type: string;
-        primaryKey: boolean;
-        notNull: boolean;
     }>>;
     indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -769,23 +769,23 @@ declare const table: import("zod").ZodObject<{
         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[];
+        onUpdate?: string | undefined;
+        onDelete?: string | undefined;
+        schemaTo?: string | undefined;
     }>>;
     compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -813,15 +813,15 @@ declare const table: import("zod").ZodObject<{
 }, "strict", import("zod").ZodTypeAny, {
     name: string;
     columns: Record<string, {
+        name: string;
+        type: string;
+        primaryKey: boolean;
+        notNull: boolean;
         isUnique?: any;
         default?: any;
         typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
-        name: string;
-        type: string;
-        primaryKey: boolean;
-        notNull: boolean;
     }>;
     indexes: Record<string, {
         name: string;
@@ -829,14 +829,14 @@ declare const table: import("zod").ZodObject<{
         isUnique: boolean;
     }>;
     foreignKeys: Record<string, {
-        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;
     }>;
     schema: string;
     compositePrimaryKeys: Record<string, {
@@ -849,22 +849,17 @@ declare const table: import("zod").ZodObject<{
         nullsNotDistinct: boolean;
     }>;
 }, {
-    uniqueConstraints?: Record<string, {
-        name: string;
-        columns: string[];
-        nullsNotDistinct: boolean;
-    }> | undefined;
     name: string;
     columns: Record<string, {
+        name: string;
+        type: string;
+        primaryKey: boolean;
+        notNull: boolean;
         isUnique?: any;
         default?: any;
         typeSchema?: string | undefined;
         uniqueName?: string | undefined;
         nullsNotDistinct?: boolean | undefined;
-        name: string;
-        type: string;
-        primaryKey: boolean;
-        notNull: boolean;
     }>;
     indexes: Record<string, {
         name: string;
@@ -872,21 +867,26 @@ declare const table: import("zod").ZodObject<{
         isUnique: boolean;
     }>;
     foreignKeys: Record<string, {
-        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;
     }>;
     schema: string;
     compositePrimaryKeys: Record<string, {
         name: string;
         columns: string[];
     }>;
-}>;
+    uniqueConstraints?: Record<string, {
+        name: string;
+        columns: string[];
+        nullsNotDistinct: boolean;
+    }> | undefined;
+}>;
 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<{
@@ -948,25 +948,25 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
             uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
             nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
         }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
+        }, {
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
-        }, {
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -991,36 +991,36 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
             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[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
         }>>;
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1028,27 +1028,27 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1056,14 +1056,14 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
     }>>;
     enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1080,15 +1080,15 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
     tables: Record<string, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1096,14 +1096,14 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
     }>;
     version: "3";
@@ -1116,15 +1116,15 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
     tables: Record<string, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1132,14 +1132,14 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
     }>;
     version: "3";
@@ -1166,25 +1166,25 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
             uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
             nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
         }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
+        }, {
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
-        }, {
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -1209,36 +1209,36 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
             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[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
         }>>;
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1246,28 +1246,28 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
     }, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1275,14 +1275,14 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
     }>>;
@@ -1301,15 +1301,15 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
     tables: Record<string, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1317,14 +1317,14 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
     }>;
@@ -1339,15 +1339,15 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
     tables: Record<string, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1355,14 +1355,14 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
     }>;
@@ -1391,25 +1391,25 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
             uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
             nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
         }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
+        }, {
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
-        }, {
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -1434,23 +1434,23 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
             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[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
         }>>;
         compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -1478,15 +1478,15 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1494,14 +1494,14 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -1514,22 +1514,17 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
             nullsNotDistinct: boolean;
         }>;
     }, {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1537,20 +1532,25 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
             name: string;
             columns: string[];
         }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
     }>>;
     enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -1622,27 +1622,18 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
         } | 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, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1650,14 +1641,14 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -1682,7 +1673,6 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
         name: string;
         values: Record<string, string>;
     }>;
-}, {
     internal?: {
         tables: Record<string, {
             columns: Record<string, {
@@ -1692,23 +1682,19 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
             } | undefined>;
         } | undefined>;
     } | undefined;
+}, {
     tables: Record<string, {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1716,22 +1702,27 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
             name: string;
             columns: string[];
         }>;
-    }>;
-    version: "5";
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
+    }>;
+    version: "5";
     dialect: "pg";
     schemas: Record<string, string>;
     _meta: {
@@ -1743,6 +1734,15 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
         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;
 }>;
 export declare const pgSchemaExternal: import("zod").ZodObject<{
     version: import("zod").ZodLiteral<"5">;
@@ -1761,25 +1761,25 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
             uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
             nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
         }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
+        }, {
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
-        }, {
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -1804,23 +1804,23 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
             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[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
         }>>;
         compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -1848,15 +1848,15 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1864,14 +1864,14 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -1884,22 +1884,17 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
             nullsNotDistinct: boolean;
         }>;
     }, {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1907,20 +1902,25 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
             name: string;
             columns: string[];
         }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
     }>, "many">;
     enums: import("zod").ZodArray<import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -1956,15 +1956,15 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
     tables: {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -1972,14 +1972,14 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -2008,22 +2008,17 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
     }[];
 }, {
     tables: {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -2031,20 +2026,25 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
             name: string;
             columns: string[];
         }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
     }[];
     version: "5";
     dialect: "pg";
@@ -2078,25 +2078,25 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
             uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
             nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
         }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
+        }, {
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
-        }, {
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -2121,23 +2121,23 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
             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[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
         }>>;
         compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -2165,15 +2165,15 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -2181,14 +2181,14 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -2201,22 +2201,17 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
             nullsNotDistinct: boolean;
         }>;
     }, {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -2224,20 +2219,25 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
             name: string;
             columns: string[];
         }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
     }>>;
     enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -2312,27 +2312,18 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
         } | 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, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -2340,14 +2331,14 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -2373,7 +2364,6 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
         values: string[];
         schema: string;
     }>;
-}, {
     internal?: {
         tables: Record<string, {
             columns: Record<string, {
@@ -2383,23 +2373,19 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
             } | undefined>;
         } | undefined>;
     } | undefined;
+}, {
     tables: Record<string, {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -2407,20 +2393,25 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
             name: string;
             columns: string[];
         }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
     }>;
     version: "6";
     dialect: "postgresql";
@@ -2435,6 +2426,15 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
         values: string[];
         schema: string;
     }>;
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
 }>;
 export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
     version: import("zod").ZodLiteral<"4">;
@@ -2453,40 +2453,40 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
             uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
             nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
         }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
+        }, {
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
-        }, {
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
         foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, string>;
         foreignKeys: Record<string, string>;
@@ -2494,15 +2494,15 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
     }, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, string>;
         foreignKeys: Record<string, string>;
@@ -2523,15 +2523,15 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
     tables: Record<string, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, string>;
         foreignKeys: Record<string, string>;
@@ -2548,15 +2548,15 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
     tables: Record<string, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, string>;
         foreignKeys: Record<string, string>;
@@ -2587,25 +2587,25 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
             uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
             nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
         }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
+        }, {
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
-        }, {
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
         foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -2614,15 +2614,15 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, string>;
         foreignKeys: Record<string, string>;
@@ -2632,15 +2632,15 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
     }, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, string>;
         foreignKeys: Record<string, string>;
@@ -2666,15 +2666,15 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
     tables: Record<string, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, string>;
         foreignKeys: Record<string, string>;
@@ -2694,15 +2694,15 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
     tables: Record<string, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, string>;
         foreignKeys: Record<string, string>;
@@ -2719,7 +2719,7 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
         schema: string;
     }>;
 }>;
-export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
+export declare const pgSchemaV3: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
     version: import("zod").ZodLiteral<"3">;
     dialect: import("zod").ZodLiteral<"pg">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -2735,25 +2735,25 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
             uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
             nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
         }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
+        }, {
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
-        }, {
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -2778,36 +2778,36 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
             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[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
         }>>;
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -2815,27 +2815,27 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -2843,14 +2843,14 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
     }>>;
     enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -2870,15 +2870,15 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
     tables: Record<string, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -2886,14 +2886,14 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
     }>;
     id: string;
@@ -2908,15 +2908,15 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
     tables: Record<string, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -2924,14 +2924,14 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
     }>;
     id: string;
@@ -2943,7 +2943,7 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
         values: Record<string, string>;
     }>;
 }>;
-export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
+export declare const pgSchemaV4: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
     version: import("zod").ZodLiteral<"4">;
     dialect: import("zod").ZodLiteral<"pg">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -2960,25 +2960,25 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
             uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
             nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
         }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
+        }, {
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
-        }, {
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -3003,36 +3003,36 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
             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[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
         }>>;
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -3040,28 +3040,28 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
     }, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -3069,14 +3069,14 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
     }>>;
@@ -3098,15 +3098,15 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
     tables: Record<string, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -3114,14 +3114,14 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
     }>;
@@ -3138,15 +3138,15 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
     tables: Record<string, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -3154,14 +3154,14 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
     }>;
@@ -3175,7 +3175,7 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
         values: Record<string, string>;
     }>;
 }>;
-export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendShape<{
+export declare const pgSchemaV5: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
     version: import("zod").ZodLiteral<"5">;
     dialect: import("zod").ZodLiteral<"pg">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -3192,25 +3192,25 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
             uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
             nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
         }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
+        }, {
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
-        }, {
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -3235,23 +3235,23 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
             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[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
         }>>;
         compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -3279,15 +3279,15 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -3295,14 +3295,14 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -3315,22 +3315,17 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
             nullsNotDistinct: boolean;
         }>;
     }, {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -3338,20 +3333,25 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
             name: string;
             columns: string[];
         }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
     }>>;
     enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -3426,27 +3426,18 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
     id: import("zod").ZodString;
     prevId: import("zod").ZodString;
 }>, "strip", 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, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -3454,14 +3445,14 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -3488,7 +3479,6 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
         name: string;
         values: Record<string, string>;
     }>;
-}, {
     internal?: {
         tables: Record<string, {
             columns: Record<string, {
@@ -3498,23 +3488,19 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
             } | undefined>;
         } | undefined>;
     } | undefined;
+}, {
     tables: Record<string, {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -3522,20 +3508,25 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
             name: string;
             columns: string[];
         }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
     }>;
     id: string;
     prevId: string;
@@ -3551,8 +3542,17 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
         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;
 }>;
-export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape<{
+export declare const pgSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
     version: import("zod").ZodLiteral<"6">;
     dialect: import("zod").ZodLiteral<"postgresql">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -3569,25 +3569,25 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
             uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
             nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
         }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
+        }, {
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
-        }, {
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -3612,23 +3612,23 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
             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[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
         }>>;
         compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -3656,15 +3656,15 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -3672,14 +3672,14 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -3692,22 +3692,17 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
             nullsNotDistinct: boolean;
         }>;
     }, {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -3715,20 +3710,25 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
             name: string;
             columns: string[];
         }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
     }>>;
     enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -3806,27 +3806,18 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
     id: import("zod").ZodString;
     prevId: import("zod").ZodString;
 }>, "strip", 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, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -3834,14 +3825,14 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -3869,7 +3860,6 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
         values: string[];
         schema: string;
     }>;
-}, {
     internal?: {
         tables: Record<string, {
             columns: Record<string, {
@@ -3879,23 +3869,19 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
             } | undefined>;
         } | undefined>;
     } | undefined;
+}, {
     tables: Record<string, {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -3903,20 +3889,25 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
             name: string;
             columns: string[];
         }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
     }>;
     id: string;
     prevId: string;
@@ -3933,6 +3924,15 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
         values: string[];
         schema: string;
     }>;
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
 }>;
 export type Enum = TypeOf<typeof enumSchema>;
 export type Column = TypeOf<typeof column>;
@@ -3954,7 +3954,7 @@ 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<{
+export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
     version: import("zod").ZodLiteral<"5">;
     dialect: import("zod").ZodLiteral<"pg">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -3971,25 +3971,25 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
             nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
         }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
+        }, {
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
-        }, {
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -4014,23 +4014,23 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             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[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
         }>>;
         compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -4058,15 +4058,15 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -4074,14 +4074,14 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -4094,22 +4094,17 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             nullsNotDistinct: boolean;
         }>;
     }, {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -4117,20 +4112,25 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
             name: string;
             columns: string[];
         }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
     }>>;
     enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -4205,27 +4205,18 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
     id: import("zod").ZodString;
     prevId: import("zod").ZodString;
 }>, "strip", 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, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -4233,14 +4224,14 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -4267,7 +4258,6 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         name: string;
         values: Record<string, string>;
     }>;
-}, {
     internal?: {
         tables: Record<string, {
             columns: Record<string, {
@@ -4277,23 +4267,19 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             } | undefined>;
         } | undefined>;
     } | undefined;
+}, {
     tables: Record<string, {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -4301,20 +4287,25 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
             name: string;
             columns: string[];
         }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
     }>;
     id: string;
     prevId: string;
@@ -4330,7 +4321,16 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         name: string;
         values: Record<string, string>;
     }>;
-}>, import("zod").ZodObject<import("zod").extendShape<{
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
+}>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
     version: import("zod").ZodLiteral<"6">;
     dialect: import("zod").ZodLiteral<"postgresql">;
     tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -4347,25 +4347,25 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
             nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
         }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
+        }, {
             name: string;
             type: string;
             primaryKey: boolean;
             notNull: boolean;
-        }, {
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>>;
         indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -4390,23 +4390,23 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             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[];
+            onUpdate?: string | undefined;
+            onDelete?: string | undefined;
+            schemaTo?: string | undefined;
         }>>;
         compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
             name: import("zod").ZodString;
@@ -4434,15 +4434,15 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
     }, "strict", import("zod").ZodTypeAny, {
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -4450,14 +4450,14 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -4470,22 +4470,17 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             nullsNotDistinct: boolean;
         }>;
     }, {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -4493,20 +4488,25 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
             name: string;
             columns: string[];
         }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
     }>>;
     enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
         name: import("zod").ZodString;
@@ -4584,27 +4584,18 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
     id: import("zod").ZodString;
     prevId: import("zod").ZodString;
 }>, "strip", 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, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -4612,14 +4603,14 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -4647,7 +4638,6 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         values: string[];
         schema: string;
     }>;
-}, {
     internal?: {
         tables: Record<string, {
             columns: Record<string, {
@@ -4657,23 +4647,19 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             } | undefined>;
         } | undefined>;
     } | undefined;
+}, {
     tables: Record<string, {
-        uniqueConstraints?: Record<string, {
-            name: string;
-            columns: string[];
-            nullsNotDistinct: boolean;
-        }> | undefined;
         name: string;
         columns: Record<string, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -4681,20 +4667,25 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
             name: string;
             columns: string[];
         }>;
+        uniqueConstraints?: Record<string, {
+            name: string;
+            columns: string[];
+            nullsNotDistinct: boolean;
+        }> | undefined;
     }>;
     id: string;
     prevId: string;
@@ -4711,6 +4702,15 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
         values: string[];
         schema: string;
     }>;
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
 }>]>;
 export declare const PgSquasher: {
     squashIdx: (idx: Index) => string;
@@ -4725,27 +4725,18 @@ export declare const PgSquasher: {
 export declare const squashPgSchemeV4: (json: PgSchemaV4) => PgSchemaSquashedV4;
 export declare const squashPgScheme: (json: PgSchema) => PgSchemaSquashed;
 export declare const dryPg: {
-    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, {
+            name: string;
+            type: string;
+            primaryKey: boolean;
+            notNull: boolean;
             isUnique?: any;
             default?: any;
             typeSchema?: string | undefined;
             uniqueName?: string | undefined;
             nullsNotDistinct?: boolean | undefined;
-            name: string;
-            type: string;
-            primaryKey: boolean;
-            notNull: boolean;
         }>;
         indexes: Record<string, {
             name: string;
@@ -4753,14 +4744,14 @@ export declare const dryPg: {
             isUnique: boolean;
         }>;
         foreignKeys: Record<string, {
-            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;
         }>;
         schema: string;
         compositePrimaryKeys: Record<string, {
@@ -4788,5 +4779,14 @@ export declare const dryPg: {
         values: string[];
         schema: string;
     }>;
+    internal?: {
+        tables: Record<string, {
+            columns: Record<string, {
+                isArray?: boolean | undefined;
+                dimensions?: number | undefined;
+                rawType?: string | undefined;
+            } | undefined>;
+        } | undefined>;
+    } | undefined;
 };
 export {};