drizzle-kit 0.20.17-151701 → 0.20.17-2923a0f

Sign up to get free protection for your applications and to get access to all the features.
Files changed (28) hide show
  1. package/bin.cjs +16137 -15013
  2. package/cli/commands/migrate.d.ts +39 -39
  3. package/cli/commands/mysqlIntrospect.d.ts +8 -8
  4. package/cli/commands/pgIntrospect.d.ts +7 -7
  5. package/cli/commands/sqliteIntrospect.d.ts +12 -12
  6. package/cli/commands/utils.d.ts +123 -1
  7. package/cli/connections.d.ts +7 -2
  8. package/cli/validations/cli.d.ts +45 -45
  9. package/cli/validations/common.d.ts +27 -27
  10. package/cli/validations/mysql.d.ts +4 -4
  11. package/cli/validations/pg.d.ts +4 -4
  12. package/cli/validations/studio.d.ts +92 -0
  13. package/cli/views.d.ts +6 -0
  14. package/index.d.mts +4 -1
  15. package/index.d.ts +4 -1
  16. package/package.json +2 -2
  17. package/payload.js +1096 -430
  18. package/payload.mjs +899 -233
  19. package/schemaValidator.d.ts +215 -215
  20. package/serializer/mysqlSchema.d.ts +892 -892
  21. package/serializer/pgSchema.d.ts +734 -734
  22. package/serializer/sqliteSchema.d.ts +457 -457
  23. package/serializer/studio.d.ts +3 -1
  24. package/snapshotsDiffer.d.ts +314 -314
  25. package/utils-studio.js +943 -835
  26. package/utils-studio.mjs +916 -808
  27. package/utils.js +839 -214
  28. package/utils.mjs +814 -189
package/serializer/pgSchema.d.ts CHANGED
@@ -24,19 +24,19 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
24
24
  default: import("zod").ZodOptional<import("zod").ZodAny>;
25
25
  references: import("zod").ZodOptional<import("zod").ZodString>;
26
26
  }, "strict", import("zod").ZodTypeAny, {
27
- default?: any;
28
- references?: string | undefined;
29
27
  name: string;
30
28
  type: string;
31
29
  primaryKey: boolean;
32
30
  notNull: boolean;
33
- }, {
34
31
  default?: any;
35
32
  references?: string | undefined;
33
+ }, {
36
34
  name: string;
37
35
  type: string;
38
36
  primaryKey: boolean;
39
37
  notNull: boolean;
38
+ default?: any;
39
+ references?: string | undefined;
40
40
  }>>;
41
41
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
42
42
  name: import("zod").ZodString;
@@ -64,12 +64,12 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
64
64
  }, "strict", import("zod").ZodTypeAny, {
65
65
  name: string;
66
66
  columns: Record<string, {
67
- default?: any;
68
- references?: string | undefined;
69
67
  name: string;
70
68
  type: string;
71
69
  primaryKey: boolean;
72
70
  notNull: boolean;
71
+ default?: any;
72
+ references?: string | undefined;
73
73
  }>;
74
74
  indexes: Record<string, {
75
75
  name: string;
@@ -81,12 +81,12 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
81
81
  }, {
82
82
  name: string;
83
83
  columns: Record<string, {
84
- default?: any;
85
- references?: string | undefined;
86
84
  name: string;
87
85
  type: string;
88
86
  primaryKey: boolean;
89
87
  notNull: boolean;
88
+ default?: any;
89
+ references?: string | undefined;
90
90
  }>;
91
91
  indexes: Record<string, {
92
92
  name: string;
@@ -110,12 +110,12 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
110
110
  tables: Record<string, {
111
111
  name: string;
112
112
  columns: Record<string, {
113
- default?: any;
114
- references?: string | undefined;
115
113
  name: string;
116
114
  type: string;
117
115
  primaryKey: boolean;
118
116
  notNull: boolean;
117
+ default?: any;
118
+ references?: string | undefined;
119
119
  }>;
120
120
  indexes: Record<string, {
121
121
  name: string;
@@ -134,12 +134,12 @@ export declare const pgSchemaV2: import("zod").ZodObject<{
134
134
  tables: Record<string, {
135
135
  name: string;
136
136
  columns: Record<string, {
137
- default?: any;
138
- references?: string | undefined;
139
137
  name: string;
140
138
  type: string;
141
139
  primaryKey: boolean;
142
140
  notNull: boolean;
141
+ default?: any;
142
+ references?: string | undefined;
143
143
  }>;
144
144
  indexes: Record<string, {
145
145
  name: string;
@@ -172,44 +172,44 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
172
172
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
173
173
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
174
174
  }, "strict", import("zod").ZodTypeAny, {
175
- onUpdate?: string | undefined;
176
- onDelete?: string | undefined;
177
175
  foreignKeyName: string;
178
176
  table: string;
179
177
  column: string;
180
- }, {
181
178
  onUpdate?: string | undefined;
182
179
  onDelete?: string | undefined;
180
+ }, {
183
181
  foreignKeyName: string;
184
182
  table: string;
185
183
  column: string;
184
+ onUpdate?: string | undefined;
185
+ onDelete?: string | undefined;
186
186
  }>>;
187
187
  }, "strict", import("zod").ZodTypeAny, {
188
+ name: string;
189
+ type: string;
190
+ primaryKey: boolean;
191
+ notNull: boolean;
188
192
  default?: any;
189
193
  references?: {
190
- onUpdate?: string | undefined;
191
- onDelete?: string | undefined;
192
194
  foreignKeyName: string;
193
195
  table: string;
194
196
  column: string;
197
+ onUpdate?: string | undefined;
198
+ onDelete?: string | undefined;
195
199
  } | undefined;
200
+ }, {
196
201
  name: string;
197
202
  type: string;
198
203
  primaryKey: boolean;
199
204
  notNull: boolean;
200
- }, {
201
205
  default?: any;
202
206
  references?: {
203
- onUpdate?: string | undefined;
204
- onDelete?: string | undefined;
205
207
  foreignKeyName: string;
206
208
  table: string;
207
209
  column: string;
210
+ onUpdate?: string | undefined;
211
+ onDelete?: string | undefined;
208
212
  } | undefined;
209
- name: string;
210
- type: string;
211
- primaryKey: boolean;
212
- notNull: boolean;
213
213
  }>>;
214
214
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
215
215
  name: import("zod").ZodString;
@@ -237,18 +237,18 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
237
237
  }, "strict", import("zod").ZodTypeAny, {
238
238
  name: string;
239
239
  columns: Record<string, {
240
+ name: string;
241
+ type: string;
242
+ primaryKey: boolean;
243
+ notNull: boolean;
240
244
  default?: any;
241
245
  references?: {
242
- onUpdate?: string | undefined;
243
- onDelete?: string | undefined;
244
246
  foreignKeyName: string;
245
247
  table: string;
246
248
  column: string;
249
+ onUpdate?: string | undefined;
250
+ onDelete?: string | undefined;
247
251
  } | undefined;
248
- name: string;
249
- type: string;
250
- primaryKey: boolean;
251
- notNull: boolean;
252
252
  }>;
253
253
  indexes: Record<string, {
254
254
  name: string;
@@ -260,18 +260,18 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
260
260
  }, {
261
261
  name: string;
262
262
  columns: Record<string, {
263
+ name: string;
264
+ type: string;
265
+ primaryKey: boolean;
266
+ notNull: boolean;
263
267
  default?: any;
264
268
  references?: {
265
- onUpdate?: string | undefined;
266
- onDelete?: string | undefined;
267
269
  foreignKeyName: string;
268
270
  table: string;
269
271
  column: string;
272
+ onUpdate?: string | undefined;
273
+ onDelete?: string | undefined;
270
274
  } | undefined;
271
- name: string;
272
- type: string;
273
- primaryKey: boolean;
274
- notNull: boolean;
275
275
  }>;
276
276
  indexes: Record<string, {
277
277
  name: string;
@@ -295,18 +295,18 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
295
295
  tables: Record<string, {
296
296
  name: string;
297
297
  columns: Record<string, {
298
+ name: string;
299
+ type: string;
300
+ primaryKey: boolean;
301
+ notNull: boolean;
298
302
  default?: any;
299
303
  references?: {
300
- onUpdate?: string | undefined;
301
- onDelete?: string | undefined;
302
304
  foreignKeyName: string;
303
305
  table: string;
304
306
  column: string;
307
+ onUpdate?: string | undefined;
308
+ onDelete?: string | undefined;
305
309
  } | undefined;
306
- name: string;
307
- type: string;
308
- primaryKey: boolean;
309
- notNull: boolean;
310
310
  }>;
311
311
  indexes: Record<string, {
312
312
  name: string;
@@ -325,18 +325,18 @@ export declare const pgSchemaV1: import("zod").ZodObject<{
325
325
  tables: Record<string, {
326
326
  name: string;
327
327
  columns: Record<string, {
328
+ name: string;
329
+ type: string;
330
+ primaryKey: boolean;
331
+ notNull: boolean;
328
332
  default?: any;
329
333
  references?: {
330
- onUpdate?: string | undefined;
331
- onDelete?: string | undefined;
332
334
  foreignKeyName: string;
333
335
  table: string;
334
336
  column: string;
337
+ onUpdate?: string | undefined;
338
+ onDelete?: string | undefined;
335
339
  } | undefined;
336
- name: string;
337
- type: string;
338
- primaryKey: boolean;
339
- notNull: boolean;
340
340
  }>;
341
341
  indexes: Record<string, {
342
342
  name: string;
@@ -375,23 +375,23 @@ declare const fk: import("zod").ZodObject<{
375
375
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
376
376
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
377
377
  }, "strict", import("zod").ZodTypeAny, {
378
- onUpdate?: string | undefined;
379
- onDelete?: string | undefined;
380
- schemaTo?: string | undefined;
381
378
  name: string;
382
379
  tableFrom: string;
383
380
  columnsFrom: string[];
384
381
  tableTo: string;
385
382
  columnsTo: string[];
386
- }, {
387
383
  onUpdate?: string | undefined;
388
384
  onDelete?: string | undefined;
389
385
  schemaTo?: string | undefined;
386
+ }, {
390
387
  name: string;
391
388
  tableFrom: string;
392
389
  columnsFrom: string[];
393
390
  tableTo: string;
394
391
  columnsTo: string[];
392
+ onUpdate?: string | undefined;
393
+ onDelete?: string | undefined;
394
+ schemaTo?: string | undefined;
395
395
  }>;
396
396
  declare const column: import("zod").ZodObject<{
397
397
  name: import("zod").ZodString;
@@ -404,25 +404,25 @@ declare const column: import("zod").ZodObject<{
404
404
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
405
405
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
406
406
  }, "strict", import("zod").ZodTypeAny, {
407
+ name: string;
408
+ type: string;
409
+ primaryKey: boolean;
410
+ notNull: boolean;
407
411
  isUnique?: any;
408
412
  default?: any;
409
413
  typeSchema?: string | undefined;
410
414
  uniqueName?: string | undefined;
411
415
  nullsNotDistinct?: boolean | undefined;
416
+ }, {
412
417
  name: string;
413
418
  type: string;
414
419
  primaryKey: boolean;
415
420
  notNull: boolean;
416
- }, {
417
421
  isUnique?: any;
418
422
  default?: any;
419
423
  typeSchema?: string | undefined;
420
424
  uniqueName?: string | undefined;
421
425
  nullsNotDistinct?: boolean | undefined;
422
- name: string;
423
- type: string;
424
- primaryKey: boolean;
425
- notNull: boolean;
426
426
  }>;
427
427
  declare const tableV3: import("zod").ZodObject<{
428
428
  name: import("zod").ZodString;
@@ -437,25 +437,25 @@ declare const tableV3: import("zod").ZodObject<{
437
437
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
438
438
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
439
439
  }, "strict", import("zod").ZodTypeAny, {
440
+ name: string;
441
+ type: string;
442
+ primaryKey: boolean;
443
+ notNull: boolean;
440
444
  isUnique?: any;
441
445
  default?: any;
442
446
  typeSchema?: string | undefined;
443
447
  uniqueName?: string | undefined;
444
448
  nullsNotDistinct?: boolean | undefined;
449
+ }, {
445
450
  name: string;
446
451
  type: string;
447
452
  primaryKey: boolean;
448
453
  notNull: boolean;
449
- }, {
450
454
  isUnique?: any;
451
455
  default?: any;
452
456
  typeSchema?: string | undefined;
453
457
  uniqueName?: string | undefined;
454
458
  nullsNotDistinct?: boolean | undefined;
455
- name: string;
456
- type: string;
457
- primaryKey: boolean;
458
- notNull: boolean;
459
459
  }>>;
460
460
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
461
461
  name: import("zod").ZodString;
@@ -480,36 +480,36 @@ declare const tableV3: import("zod").ZodObject<{
480
480
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
481
481
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
482
482
  }, "strict", import("zod").ZodTypeAny, {
483
- onUpdate?: string | undefined;
484
- onDelete?: string | undefined;
485
- schemaTo?: string | undefined;
486
483
  name: string;
487
484
  tableFrom: string;
488
485
  columnsFrom: string[];
489
486
  tableTo: string;
490
487
  columnsTo: string[];
491
- }, {
492
488
  onUpdate?: string | undefined;
493
489
  onDelete?: string | undefined;
494
490
  schemaTo?: string | undefined;
491
+ }, {
495
492
  name: string;
496
493
  tableFrom: string;
497
494
  columnsFrom: string[];
498
495
  tableTo: string;
499
496
  columnsTo: string[];
497
+ onUpdate?: string | undefined;
498
+ onDelete?: string | undefined;
499
+ schemaTo?: string | undefined;
500
500
  }>>;
501
501
  }, "strict", import("zod").ZodTypeAny, {
502
502
  name: string;
503
503
  columns: Record<string, {
504
+ name: string;
505
+ type: string;
506
+ primaryKey: boolean;
507
+ notNull: boolean;
504
508
  isUnique?: any;
505
509
  default?: any;
506
510
  typeSchema?: string | undefined;
507
511
  uniqueName?: string | undefined;
508
512
  nullsNotDistinct?: boolean | undefined;
509
- name: string;
510
- type: string;
511
- primaryKey: boolean;
512
- notNull: boolean;
513
513
  }>;
514
514
  indexes: Record<string, {
515
515
  name: string;
@@ -517,27 +517,27 @@ declare const tableV3: import("zod").ZodObject<{
517
517
  isUnique: boolean;
518
518
  }>;
519
519
  foreignKeys: Record<string, {
520
- onUpdate?: string | undefined;
521
- onDelete?: string | undefined;
522
- schemaTo?: string | undefined;
523
520
  name: string;
524
521
  tableFrom: string;
525
522
  columnsFrom: string[];
526
523
  tableTo: string;
527
524
  columnsTo: string[];
525
+ onUpdate?: string | undefined;
526
+ onDelete?: string | undefined;
527
+ schemaTo?: string | undefined;
528
528
  }>;
529
529
  }, {
530
530
  name: string;
531
531
  columns: Record<string, {
532
+ name: string;
533
+ type: string;
534
+ primaryKey: boolean;
535
+ notNull: boolean;
532
536
  isUnique?: any;
533
537
  default?: any;
534
538
  typeSchema?: string | undefined;
535
539
  uniqueName?: string | undefined;
536
540
  nullsNotDistinct?: boolean | undefined;
537
- name: string;
538
- type: string;
539
- primaryKey: boolean;
540
- notNull: boolean;
541
541
  }>;
542
542
  indexes: Record<string, {
543
543
  name: string;
@@ -545,14 +545,14 @@ declare const tableV3: import("zod").ZodObject<{
545
545
  isUnique: boolean;
546
546
  }>;
547
547
  foreignKeys: Record<string, {
548
- onUpdate?: string | undefined;
549
- onDelete?: string | undefined;
550
- schemaTo?: string | undefined;
551
548
  name: string;
552
549
  tableFrom: string;
553
550
  columnsFrom: string[];
554
551
  tableTo: string;
555
552
  columnsTo: string[];
553
+ onUpdate?: string | undefined;
554
+ onDelete?: string | undefined;
555
+ schemaTo?: string | undefined;
556
556
  }>;
557
557
  }>;
558
558
  declare const compositePK: import("zod").ZodObject<{
@@ -592,25 +592,25 @@ declare const tableV4: import("zod").ZodObject<{
592
592
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
593
593
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
594
594
  }, "strict", import("zod").ZodTypeAny, {
595
+ name: string;
596
+ type: string;
597
+ primaryKey: boolean;
598
+ notNull: boolean;
595
599
  isUnique?: any;
596
600
  default?: any;
597
601
  typeSchema?: string | undefined;
598
602
  uniqueName?: string | undefined;
599
603
  nullsNotDistinct?: boolean | undefined;
604
+ }, {
600
605
  name: string;
601
606
  type: string;
602
607
  primaryKey: boolean;
603
608
  notNull: boolean;
604
- }, {
605
609
  isUnique?: any;
606
610
  default?: any;
607
611
  typeSchema?: string | undefined;
608
612
  uniqueName?: string | undefined;
609
613
  nullsNotDistinct?: boolean | undefined;
610
- name: string;
611
- type: string;
612
- primaryKey: boolean;
613
- notNull: boolean;
614
614
  }>>;
615
615
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
616
616
  name: import("zod").ZodString;
@@ -635,36 +635,36 @@ declare const tableV4: import("zod").ZodObject<{
635
635
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
636
636
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
637
637
  }, "strict", import("zod").ZodTypeAny, {
638
- onUpdate?: string | undefined;
639
- onDelete?: string | undefined;
640
- schemaTo?: string | undefined;
641
638
  name: string;
642
639
  tableFrom: string;
643
640
  columnsFrom: string[];
644
641
  tableTo: string;
645
642
  columnsTo: string[];
646
- }, {
647
643
  onUpdate?: string | undefined;
648
644
  onDelete?: string | undefined;
649
645
  schemaTo?: string | undefined;
646
+ }, {
650
647
  name: string;
651
648
  tableFrom: string;
652
649
  columnsFrom: string[];
653
650
  tableTo: string;
654
651
  columnsTo: string[];
652
+ onUpdate?: string | undefined;
653
+ onDelete?: string | undefined;
654
+ schemaTo?: string | undefined;
655
655
  }>>;
656
656
  }, "strict", import("zod").ZodTypeAny, {
657
657
  name: string;
658
658
  columns: Record<string, {
659
+ name: string;
660
+ type: string;
661
+ primaryKey: boolean;
662
+ notNull: boolean;
659
663
  isUnique?: any;
660
664
  default?: any;
661
665
  typeSchema?: string | undefined;
662
666
  uniqueName?: string | undefined;
663
667
  nullsNotDistinct?: boolean | undefined;
664
- name: string;
665
- type: string;
666
- primaryKey: boolean;
667
- notNull: boolean;
668
668
  }>;
669
669
  indexes: Record<string, {
670
670
  name: string;
@@ -672,28 +672,28 @@ declare const tableV4: import("zod").ZodObject<{
672
672
  isUnique: boolean;
673
673
  }>;
674
674
  foreignKeys: Record<string, {
675
- onUpdate?: string | undefined;
676
- onDelete?: string | undefined;
677
- schemaTo?: string | undefined;
678
675
  name: string;
679
676
  tableFrom: string;
680
677
  columnsFrom: string[];
681
678
  tableTo: string;
682
679
  columnsTo: string[];
680
+ onUpdate?: string | undefined;
681
+ onDelete?: string | undefined;
682
+ schemaTo?: string | undefined;
683
683
  }>;
684
684
  schema: string;
685
685
  }, {
686
686
  name: string;
687
687
  columns: Record<string, {
688
+ name: string;
689
+ type: string;
690
+ primaryKey: boolean;
691
+ notNull: boolean;
688
692
  isUnique?: any;
689
693
  default?: any;
690
694
  typeSchema?: string | undefined;
691
695
  uniqueName?: string | undefined;
692
696
  nullsNotDistinct?: boolean | undefined;
693
- name: string;
694
- type: string;
695
- primaryKey: boolean;
696
- notNull: boolean;
697
697
  }>;
698
698
  indexes: Record<string, {
699
699
  name: string;
@@ -701,14 +701,14 @@ declare const tableV4: import("zod").ZodObject<{
701
701
  isUnique: boolean;
702
702
  }>;
703
703
  foreignKeys: Record<string, {
704
- onUpdate?: string | undefined;
705
- onDelete?: string | undefined;
706
- schemaTo?: string | undefined;
707
704
  name: string;
708
705
  tableFrom: string;
709
706
  columnsFrom: string[];
710
707
  tableTo: string;
711
708
  columnsTo: string[];
709
+ onUpdate?: string | undefined;
710
+ onDelete?: string | undefined;
711
+ schemaTo?: string | undefined;
712
712
  }>;
713
713
  schema: string;
714
714
  }>;
@@ -726,25 +726,25 @@ declare const table: import("zod").ZodObject<{
726
726
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
727
727
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
728
728
  }, "strict", import("zod").ZodTypeAny, {
729
+ name: string;
730
+ type: string;
731
+ primaryKey: boolean;
732
+ notNull: boolean;
729
733
  isUnique?: any;
730
734
  default?: any;
731
735
  typeSchema?: string | undefined;
732
736
  uniqueName?: string | undefined;
733
737
  nullsNotDistinct?: boolean | undefined;
738
+ }, {
734
739
  name: string;
735
740
  type: string;
736
741
  primaryKey: boolean;
737
742
  notNull: boolean;
738
- }, {
739
743
  isUnique?: any;
740
744
  default?: any;
741
745
  typeSchema?: string | undefined;
742
746
  uniqueName?: string | undefined;
743
747
  nullsNotDistinct?: boolean | undefined;
744
- name: string;
745
- type: string;
746
- primaryKey: boolean;
747
- notNull: boolean;
748
748
  }>>;
749
749
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
750
750
  name: import("zod").ZodString;
@@ -769,23 +769,23 @@ declare const table: import("zod").ZodObject<{
769
769
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
770
770
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
771
771
  }, "strict", import("zod").ZodTypeAny, {
772
- onUpdate?: string | undefined;
773
- onDelete?: string | undefined;
774
- schemaTo?: string | undefined;
775
772
  name: string;
776
773
  tableFrom: string;
777
774
  columnsFrom: string[];
778
775
  tableTo: string;
779
776
  columnsTo: string[];
780
- }, {
781
777
  onUpdate?: string | undefined;
782
778
  onDelete?: string | undefined;
783
779
  schemaTo?: string | undefined;
780
+ }, {
784
781
  name: string;
785
782
  tableFrom: string;
786
783
  columnsFrom: string[];
787
784
  tableTo: string;
788
785
  columnsTo: string[];
786
+ onUpdate?: string | undefined;
787
+ onDelete?: string | undefined;
788
+ schemaTo?: string | undefined;
789
789
  }>>;
790
790
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
791
791
  name: import("zod").ZodString;
@@ -813,15 +813,15 @@ declare const table: import("zod").ZodObject<{
813
813
  }, "strict", import("zod").ZodTypeAny, {
814
814
  name: string;
815
815
  columns: Record<string, {
816
+ name: string;
817
+ type: string;
818
+ primaryKey: boolean;
819
+ notNull: boolean;
816
820
  isUnique?: any;
817
821
  default?: any;
818
822
  typeSchema?: string | undefined;
819
823
  uniqueName?: string | undefined;
820
824
  nullsNotDistinct?: boolean | undefined;
821
- name: string;
822
- type: string;
823
- primaryKey: boolean;
824
- notNull: boolean;
825
825
  }>;
826
826
  indexes: Record<string, {
827
827
  name: string;
@@ -829,14 +829,14 @@ declare const table: import("zod").ZodObject<{
829
829
  isUnique: boolean;
830
830
  }>;
831
831
  foreignKeys: Record<string, {
832
- onUpdate?: string | undefined;
833
- onDelete?: string | undefined;
834
- schemaTo?: string | undefined;
835
832
  name: string;
836
833
  tableFrom: string;
837
834
  columnsFrom: string[];
838
835
  tableTo: string;
839
836
  columnsTo: string[];
837
+ onUpdate?: string | undefined;
838
+ onDelete?: string | undefined;
839
+ schemaTo?: string | undefined;
840
840
  }>;
841
841
  schema: string;
842
842
  compositePrimaryKeys: Record<string, {
@@ -849,22 +849,17 @@ declare const table: import("zod").ZodObject<{
849
849
  nullsNotDistinct: boolean;
850
850
  }>;
851
851
  }, {
852
- uniqueConstraints?: Record<string, {
853
- name: string;
854
- columns: string[];
855
- nullsNotDistinct: boolean;
856
- }> | undefined;
857
852
  name: string;
858
853
  columns: Record<string, {
854
+ name: string;
855
+ type: string;
856
+ primaryKey: boolean;
857
+ notNull: boolean;
859
858
  isUnique?: any;
860
859
  default?: any;
861
860
  typeSchema?: string | undefined;
862
861
  uniqueName?: string | undefined;
863
862
  nullsNotDistinct?: boolean | undefined;
864
- name: string;
865
- type: string;
866
- primaryKey: boolean;
867
- notNull: boolean;
868
863
  }>;
869
864
  indexes: Record<string, {
870
865
  name: string;
@@ -872,21 +867,26 @@ declare const table: import("zod").ZodObject<{
872
867
  isUnique: boolean;
873
868
  }>;
874
869
  foreignKeys: Record<string, {
875
- onUpdate?: string | undefined;
876
- onDelete?: string | undefined;
877
- schemaTo?: string | undefined;
878
870
  name: string;
879
871
  tableFrom: string;
880
872
  columnsFrom: string[];
881
873
  tableTo: string;
882
874
  columnsTo: string[];
875
+ onUpdate?: string | undefined;
876
+ onDelete?: string | undefined;
877
+ schemaTo?: string | undefined;
883
878
  }>;
884
879
  schema: string;
885
880
  compositePrimaryKeys: Record<string, {
886
881
  name: string;
887
882
  columns: string[];
888
883
  }>;
889
- }>;
884
+ uniqueConstraints?: Record<string, {
885
+ name: string;
886
+ columns: string[];
887
+ nullsNotDistinct: boolean;
888
+ }> | undefined;
889
+ }>;
890
890
  export declare const kitInternals: import("zod").ZodOptional<import("zod").ZodObject<{
891
891
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
892
892
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
@@ -948,25 +948,25 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
948
948
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
949
949
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
950
950
  }, "strict", import("zod").ZodTypeAny, {
951
+ name: string;
952
+ type: string;
953
+ primaryKey: boolean;
954
+ notNull: boolean;
951
955
  isUnique?: any;
952
956
  default?: any;
953
957
  typeSchema?: string | undefined;
954
958
  uniqueName?: string | undefined;
955
959
  nullsNotDistinct?: boolean | undefined;
960
+ }, {
956
961
  name: string;
957
962
  type: string;
958
963
  primaryKey: boolean;
959
964
  notNull: boolean;
960
- }, {
961
965
  isUnique?: any;
962
966
  default?: any;
963
967
  typeSchema?: string | undefined;
964
968
  uniqueName?: string | undefined;
965
969
  nullsNotDistinct?: boolean | undefined;
966
- name: string;
967
- type: string;
968
- primaryKey: boolean;
969
- notNull: boolean;
970
970
  }>>;
971
971
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
972
972
  name: import("zod").ZodString;
@@ -991,36 +991,36 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
991
991
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
992
992
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
993
993
  }, "strict", import("zod").ZodTypeAny, {
994
- onUpdate?: string | undefined;
995
- onDelete?: string | undefined;
996
- schemaTo?: string | undefined;
997
994
  name: string;
998
995
  tableFrom: string;
999
996
  columnsFrom: string[];
1000
997
  tableTo: string;
1001
998
  columnsTo: string[];
1002
- }, {
1003
999
  onUpdate?: string | undefined;
1004
1000
  onDelete?: string | undefined;
1005
1001
  schemaTo?: string | undefined;
1002
+ }, {
1006
1003
  name: string;
1007
1004
  tableFrom: string;
1008
1005
  columnsFrom: string[];
1009
1006
  tableTo: string;
1010
1007
  columnsTo: string[];
1008
+ onUpdate?: string | undefined;
1009
+ onDelete?: string | undefined;
1010
+ schemaTo?: string | undefined;
1011
1011
  }>>;
1012
1012
  }, "strict", import("zod").ZodTypeAny, {
1013
1013
  name: string;
1014
1014
  columns: Record<string, {
1015
+ name: string;
1016
+ type: string;
1017
+ primaryKey: boolean;
1018
+ notNull: boolean;
1015
1019
  isUnique?: any;
1016
1020
  default?: any;
1017
1021
  typeSchema?: string | undefined;
1018
1022
  uniqueName?: string | undefined;
1019
1023
  nullsNotDistinct?: boolean | undefined;
1020
- name: string;
1021
- type: string;
1022
- primaryKey: boolean;
1023
- notNull: boolean;
1024
1024
  }>;
1025
1025
  indexes: Record<string, {
1026
1026
  name: string;
@@ -1028,27 +1028,27 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
1028
1028
  isUnique: boolean;
1029
1029
  }>;
1030
1030
  foreignKeys: Record<string, {
1031
- onUpdate?: string | undefined;
1032
- onDelete?: string | undefined;
1033
- schemaTo?: string | undefined;
1034
1031
  name: string;
1035
1032
  tableFrom: string;
1036
1033
  columnsFrom: string[];
1037
1034
  tableTo: string;
1038
1035
  columnsTo: string[];
1036
+ onUpdate?: string | undefined;
1037
+ onDelete?: string | undefined;
1038
+ schemaTo?: string | undefined;
1039
1039
  }>;
1040
1040
  }, {
1041
1041
  name: string;
1042
1042
  columns: Record<string, {
1043
+ name: string;
1044
+ type: string;
1045
+ primaryKey: boolean;
1046
+ notNull: boolean;
1043
1047
  isUnique?: any;
1044
1048
  default?: any;
1045
1049
  typeSchema?: string | undefined;
1046
1050
  uniqueName?: string | undefined;
1047
1051
  nullsNotDistinct?: boolean | undefined;
1048
- name: string;
1049
- type: string;
1050
- primaryKey: boolean;
1051
- notNull: boolean;
1052
1052
  }>;
1053
1053
  indexes: Record<string, {
1054
1054
  name: string;
@@ -1056,14 +1056,14 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
1056
1056
  isUnique: boolean;
1057
1057
  }>;
1058
1058
  foreignKeys: Record<string, {
1059
- onUpdate?: string | undefined;
1060
- onDelete?: string | undefined;
1061
- schemaTo?: string | undefined;
1062
1059
  name: string;
1063
1060
  tableFrom: string;
1064
1061
  columnsFrom: string[];
1065
1062
  tableTo: string;
1066
1063
  columnsTo: string[];
1064
+ onUpdate?: string | undefined;
1065
+ onDelete?: string | undefined;
1066
+ schemaTo?: string | undefined;
1067
1067
  }>;
1068
1068
  }>>;
1069
1069
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1080,15 +1080,15 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
1080
1080
  tables: Record<string, {
1081
1081
  name: string;
1082
1082
  columns: Record<string, {
1083
+ name: string;
1084
+ type: string;
1085
+ primaryKey: boolean;
1086
+ notNull: boolean;
1083
1087
  isUnique?: any;
1084
1088
  default?: any;
1085
1089
  typeSchema?: string | undefined;
1086
1090
  uniqueName?: string | undefined;
1087
1091
  nullsNotDistinct?: boolean | undefined;
1088
- name: string;
1089
- type: string;
1090
- primaryKey: boolean;
1091
- notNull: boolean;
1092
1092
  }>;
1093
1093
  indexes: Record<string, {
1094
1094
  name: string;
@@ -1096,14 +1096,14 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
1096
1096
  isUnique: boolean;
1097
1097
  }>;
1098
1098
  foreignKeys: Record<string, {
1099
- onUpdate?: string | undefined;
1100
- onDelete?: string | undefined;
1101
- schemaTo?: string | undefined;
1102
1099
  name: string;
1103
1100
  tableFrom: string;
1104
1101
  columnsFrom: string[];
1105
1102
  tableTo: string;
1106
1103
  columnsTo: string[];
1104
+ onUpdate?: string | undefined;
1105
+ onDelete?: string | undefined;
1106
+ schemaTo?: string | undefined;
1107
1107
  }>;
1108
1108
  }>;
1109
1109
  version: "3";
@@ -1116,15 +1116,15 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
1116
1116
  tables: Record<string, {
1117
1117
  name: string;
1118
1118
  columns: Record<string, {
1119
+ name: string;
1120
+ type: string;
1121
+ primaryKey: boolean;
1122
+ notNull: boolean;
1119
1123
  isUnique?: any;
1120
1124
  default?: any;
1121
1125
  typeSchema?: string | undefined;
1122
1126
  uniqueName?: string | undefined;
1123
1127
  nullsNotDistinct?: boolean | undefined;
1124
- name: string;
1125
- type: string;
1126
- primaryKey: boolean;
1127
- notNull: boolean;
1128
1128
  }>;
1129
1129
  indexes: Record<string, {
1130
1130
  name: string;
@@ -1132,14 +1132,14 @@ export declare const pgSchemaInternalV3: import("zod").ZodObject<{
1132
1132
  isUnique: boolean;
1133
1133
  }>;
1134
1134
  foreignKeys: Record<string, {
1135
- onUpdate?: string | undefined;
1136
- onDelete?: string | undefined;
1137
- schemaTo?: string | undefined;
1138
1135
  name: string;
1139
1136
  tableFrom: string;
1140
1137
  columnsFrom: string[];
1141
1138
  tableTo: string;
1142
1139
  columnsTo: string[];
1140
+ onUpdate?: string | undefined;
1141
+ onDelete?: string | undefined;
1142
+ schemaTo?: string | undefined;
1143
1143
  }>;
1144
1144
  }>;
1145
1145
  version: "3";
@@ -1166,25 +1166,25 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1166
1166
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
1167
1167
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
1168
1168
  }, "strict", import("zod").ZodTypeAny, {
1169
+ name: string;
1170
+ type: string;
1171
+ primaryKey: boolean;
1172
+ notNull: boolean;
1169
1173
  isUnique?: any;
1170
1174
  default?: any;
1171
1175
  typeSchema?: string | undefined;
1172
1176
  uniqueName?: string | undefined;
1173
1177
  nullsNotDistinct?: boolean | undefined;
1178
+ }, {
1174
1179
  name: string;
1175
1180
  type: string;
1176
1181
  primaryKey: boolean;
1177
1182
  notNull: boolean;
1178
- }, {
1179
1183
  isUnique?: any;
1180
1184
  default?: any;
1181
1185
  typeSchema?: string | undefined;
1182
1186
  uniqueName?: string | undefined;
1183
1187
  nullsNotDistinct?: boolean | undefined;
1184
- name: string;
1185
- type: string;
1186
- primaryKey: boolean;
1187
- notNull: boolean;
1188
1188
  }>>;
1189
1189
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1190
1190
  name: import("zod").ZodString;
@@ -1209,36 +1209,36 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1209
1209
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1210
1210
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1211
1211
  }, "strict", import("zod").ZodTypeAny, {
1212
- onUpdate?: string | undefined;
1213
- onDelete?: string | undefined;
1214
- schemaTo?: string | undefined;
1215
1212
  name: string;
1216
1213
  tableFrom: string;
1217
1214
  columnsFrom: string[];
1218
1215
  tableTo: string;
1219
1216
  columnsTo: string[];
1220
- }, {
1221
1217
  onUpdate?: string | undefined;
1222
1218
  onDelete?: string | undefined;
1223
1219
  schemaTo?: string | undefined;
1220
+ }, {
1224
1221
  name: string;
1225
1222
  tableFrom: string;
1226
1223
  columnsFrom: string[];
1227
1224
  tableTo: string;
1228
1225
  columnsTo: string[];
1226
+ onUpdate?: string | undefined;
1227
+ onDelete?: string | undefined;
1228
+ schemaTo?: string | undefined;
1229
1229
  }>>;
1230
1230
  }, "strict", import("zod").ZodTypeAny, {
1231
1231
  name: string;
1232
1232
  columns: Record<string, {
1233
+ name: string;
1234
+ type: string;
1235
+ primaryKey: boolean;
1236
+ notNull: boolean;
1233
1237
  isUnique?: any;
1234
1238
  default?: any;
1235
1239
  typeSchema?: string | undefined;
1236
1240
  uniqueName?: string | undefined;
1237
1241
  nullsNotDistinct?: boolean | undefined;
1238
- name: string;
1239
- type: string;
1240
- primaryKey: boolean;
1241
- notNull: boolean;
1242
1242
  }>;
1243
1243
  indexes: Record<string, {
1244
1244
  name: string;
@@ -1246,28 +1246,28 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1246
1246
  isUnique: boolean;
1247
1247
  }>;
1248
1248
  foreignKeys: Record<string, {
1249
- onUpdate?: string | undefined;
1250
- onDelete?: string | undefined;
1251
- schemaTo?: string | undefined;
1252
1249
  name: string;
1253
1250
  tableFrom: string;
1254
1251
  columnsFrom: string[];
1255
1252
  tableTo: string;
1256
1253
  columnsTo: string[];
1254
+ onUpdate?: string | undefined;
1255
+ onDelete?: string | undefined;
1256
+ schemaTo?: string | undefined;
1257
1257
  }>;
1258
1258
  schema: string;
1259
1259
  }, {
1260
1260
  name: string;
1261
1261
  columns: Record<string, {
1262
+ name: string;
1263
+ type: string;
1264
+ primaryKey: boolean;
1265
+ notNull: boolean;
1262
1266
  isUnique?: any;
1263
1267
  default?: any;
1264
1268
  typeSchema?: string | undefined;
1265
1269
  uniqueName?: string | undefined;
1266
1270
  nullsNotDistinct?: boolean | undefined;
1267
- name: string;
1268
- type: string;
1269
- primaryKey: boolean;
1270
- notNull: boolean;
1271
1271
  }>;
1272
1272
  indexes: Record<string, {
1273
1273
  name: string;
@@ -1275,14 +1275,14 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1275
1275
  isUnique: boolean;
1276
1276
  }>;
1277
1277
  foreignKeys: Record<string, {
1278
- onUpdate?: string | undefined;
1279
- onDelete?: string | undefined;
1280
- schemaTo?: string | undefined;
1281
1278
  name: string;
1282
1279
  tableFrom: string;
1283
1280
  columnsFrom: string[];
1284
1281
  tableTo: string;
1285
1282
  columnsTo: string[];
1283
+ onUpdate?: string | undefined;
1284
+ onDelete?: string | undefined;
1285
+ schemaTo?: string | undefined;
1286
1286
  }>;
1287
1287
  schema: string;
1288
1288
  }>>;
@@ -1301,15 +1301,15 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1301
1301
  tables: Record<string, {
1302
1302
  name: string;
1303
1303
  columns: Record<string, {
1304
+ name: string;
1305
+ type: string;
1306
+ primaryKey: boolean;
1307
+ notNull: boolean;
1304
1308
  isUnique?: any;
1305
1309
  default?: any;
1306
1310
  typeSchema?: string | undefined;
1307
1311
  uniqueName?: string | undefined;
1308
1312
  nullsNotDistinct?: boolean | undefined;
1309
- name: string;
1310
- type: string;
1311
- primaryKey: boolean;
1312
- notNull: boolean;
1313
1313
  }>;
1314
1314
  indexes: Record<string, {
1315
1315
  name: string;
@@ -1317,14 +1317,14 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1317
1317
  isUnique: boolean;
1318
1318
  }>;
1319
1319
  foreignKeys: Record<string, {
1320
- onUpdate?: string | undefined;
1321
- onDelete?: string | undefined;
1322
- schemaTo?: string | undefined;
1323
1320
  name: string;
1324
1321
  tableFrom: string;
1325
1322
  columnsFrom: string[];
1326
1323
  tableTo: string;
1327
1324
  columnsTo: string[];
1325
+ onUpdate?: string | undefined;
1326
+ onDelete?: string | undefined;
1327
+ schemaTo?: string | undefined;
1328
1328
  }>;
1329
1329
  schema: string;
1330
1330
  }>;
@@ -1339,15 +1339,15 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1339
1339
  tables: Record<string, {
1340
1340
  name: string;
1341
1341
  columns: Record<string, {
1342
+ name: string;
1343
+ type: string;
1344
+ primaryKey: boolean;
1345
+ notNull: boolean;
1342
1346
  isUnique?: any;
1343
1347
  default?: any;
1344
1348
  typeSchema?: string | undefined;
1345
1349
  uniqueName?: string | undefined;
1346
1350
  nullsNotDistinct?: boolean | undefined;
1347
- name: string;
1348
- type: string;
1349
- primaryKey: boolean;
1350
- notNull: boolean;
1351
1351
  }>;
1352
1352
  indexes: Record<string, {
1353
1353
  name: string;
@@ -1355,14 +1355,14 @@ export declare const pgSchemaInternalV4: import("zod").ZodObject<{
1355
1355
  isUnique: boolean;
1356
1356
  }>;
1357
1357
  foreignKeys: Record<string, {
1358
- onUpdate?: string | undefined;
1359
- onDelete?: string | undefined;
1360
- schemaTo?: string | undefined;
1361
1358
  name: string;
1362
1359
  tableFrom: string;
1363
1360
  columnsFrom: string[];
1364
1361
  tableTo: string;
1365
1362
  columnsTo: string[];
1363
+ onUpdate?: string | undefined;
1364
+ onDelete?: string | undefined;
1365
+ schemaTo?: string | undefined;
1366
1366
  }>;
1367
1367
  schema: string;
1368
1368
  }>;
@@ -1391,25 +1391,25 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1391
1391
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
1392
1392
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
1393
1393
  }, "strict", import("zod").ZodTypeAny, {
1394
+ name: string;
1395
+ type: string;
1396
+ primaryKey: boolean;
1397
+ notNull: boolean;
1394
1398
  isUnique?: any;
1395
1399
  default?: any;
1396
1400
  typeSchema?: string | undefined;
1397
1401
  uniqueName?: string | undefined;
1398
1402
  nullsNotDistinct?: boolean | undefined;
1403
+ }, {
1399
1404
  name: string;
1400
1405
  type: string;
1401
1406
  primaryKey: boolean;
1402
1407
  notNull: boolean;
1403
- }, {
1404
1408
  isUnique?: any;
1405
1409
  default?: any;
1406
1410
  typeSchema?: string | undefined;
1407
1411
  uniqueName?: string | undefined;
1408
1412
  nullsNotDistinct?: boolean | undefined;
1409
- name: string;
1410
- type: string;
1411
- primaryKey: boolean;
1412
- notNull: boolean;
1413
1413
  }>>;
1414
1414
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1415
1415
  name: import("zod").ZodString;
@@ -1434,23 +1434,23 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1434
1434
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1435
1435
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1436
1436
  }, "strict", import("zod").ZodTypeAny, {
1437
- onUpdate?: string | undefined;
1438
- onDelete?: string | undefined;
1439
- schemaTo?: string | undefined;
1440
1437
  name: string;
1441
1438
  tableFrom: string;
1442
1439
  columnsFrom: string[];
1443
1440
  tableTo: string;
1444
1441
  columnsTo: string[];
1445
- }, {
1446
1442
  onUpdate?: string | undefined;
1447
1443
  onDelete?: string | undefined;
1448
1444
  schemaTo?: string | undefined;
1445
+ }, {
1449
1446
  name: string;
1450
1447
  tableFrom: string;
1451
1448
  columnsFrom: string[];
1452
1449
  tableTo: string;
1453
1450
  columnsTo: string[];
1451
+ onUpdate?: string | undefined;
1452
+ onDelete?: string | undefined;
1453
+ schemaTo?: string | undefined;
1454
1454
  }>>;
1455
1455
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1456
1456
  name: import("zod").ZodString;
@@ -1478,15 +1478,15 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1478
1478
  }, "strict", import("zod").ZodTypeAny, {
1479
1479
  name: string;
1480
1480
  columns: Record<string, {
1481
+ name: string;
1482
+ type: string;
1483
+ primaryKey: boolean;
1484
+ notNull: boolean;
1481
1485
  isUnique?: any;
1482
1486
  default?: any;
1483
1487
  typeSchema?: string | undefined;
1484
1488
  uniqueName?: string | undefined;
1485
1489
  nullsNotDistinct?: boolean | undefined;
1486
- name: string;
1487
- type: string;
1488
- primaryKey: boolean;
1489
- notNull: boolean;
1490
1490
  }>;
1491
1491
  indexes: Record<string, {
1492
1492
  name: string;
@@ -1494,14 +1494,14 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1494
1494
  isUnique: boolean;
1495
1495
  }>;
1496
1496
  foreignKeys: Record<string, {
1497
- onUpdate?: string | undefined;
1498
- onDelete?: string | undefined;
1499
- schemaTo?: string | undefined;
1500
1497
  name: string;
1501
1498
  tableFrom: string;
1502
1499
  columnsFrom: string[];
1503
1500
  tableTo: string;
1504
1501
  columnsTo: string[];
1502
+ onUpdate?: string | undefined;
1503
+ onDelete?: string | undefined;
1504
+ schemaTo?: string | undefined;
1505
1505
  }>;
1506
1506
  schema: string;
1507
1507
  compositePrimaryKeys: Record<string, {
@@ -1514,22 +1514,17 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1514
1514
  nullsNotDistinct: boolean;
1515
1515
  }>;
1516
1516
  }, {
1517
- uniqueConstraints?: Record<string, {
1518
- name: string;
1519
- columns: string[];
1520
- nullsNotDistinct: boolean;
1521
- }> | undefined;
1522
1517
  name: string;
1523
1518
  columns: Record<string, {
1519
+ name: string;
1520
+ type: string;
1521
+ primaryKey: boolean;
1522
+ notNull: boolean;
1524
1523
  isUnique?: any;
1525
1524
  default?: any;
1526
1525
  typeSchema?: string | undefined;
1527
1526
  uniqueName?: string | undefined;
1528
1527
  nullsNotDistinct?: boolean | undefined;
1529
- name: string;
1530
- type: string;
1531
- primaryKey: boolean;
1532
- notNull: boolean;
1533
1528
  }>;
1534
1529
  indexes: Record<string, {
1535
1530
  name: string;
@@ -1537,20 +1532,25 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1537
1532
  isUnique: boolean;
1538
1533
  }>;
1539
1534
  foreignKeys: Record<string, {
1540
- onUpdate?: string | undefined;
1541
- onDelete?: string | undefined;
1542
- schemaTo?: string | undefined;
1543
1535
  name: string;
1544
1536
  tableFrom: string;
1545
1537
  columnsFrom: string[];
1546
1538
  tableTo: string;
1547
1539
  columnsTo: string[];
1540
+ onUpdate?: string | undefined;
1541
+ onDelete?: string | undefined;
1542
+ schemaTo?: string | undefined;
1548
1543
  }>;
1549
1544
  schema: string;
1550
1545
  compositePrimaryKeys: Record<string, {
1551
1546
  name: string;
1552
1547
  columns: string[];
1553
1548
  }>;
1549
+ uniqueConstraints?: Record<string, {
1550
+ name: string;
1551
+ columns: string[];
1552
+ nullsNotDistinct: boolean;
1553
+ }> | undefined;
1554
1554
  }>>;
1555
1555
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1556
1556
  name: import("zod").ZodString;
@@ -1622,27 +1622,18 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1622
1622
  } | undefined>;
1623
1623
  }>>;
1624
1624
  }, "strict", import("zod").ZodTypeAny, {
1625
- internal?: {
1626
- tables: Record<string, {
1627
- columns: Record<string, {
1628
- isArray?: boolean | undefined;
1629
- dimensions?: number | undefined;
1630
- rawType?: string | undefined;
1631
- } | undefined>;
1632
- } | undefined>;
1633
- } | undefined;
1634
1625
  tables: Record<string, {
1635
1626
  name: string;
1636
1627
  columns: Record<string, {
1628
+ name: string;
1629
+ type: string;
1630
+ primaryKey: boolean;
1631
+ notNull: boolean;
1637
1632
  isUnique?: any;
1638
1633
  default?: any;
1639
1634
  typeSchema?: string | undefined;
1640
1635
  uniqueName?: string | undefined;
1641
1636
  nullsNotDistinct?: boolean | undefined;
1642
- name: string;
1643
- type: string;
1644
- primaryKey: boolean;
1645
- notNull: boolean;
1646
1637
  }>;
1647
1638
  indexes: Record<string, {
1648
1639
  name: string;
@@ -1650,14 +1641,14 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1650
1641
  isUnique: boolean;
1651
1642
  }>;
1652
1643
  foreignKeys: Record<string, {
1653
- onUpdate?: string | undefined;
1654
- onDelete?: string | undefined;
1655
- schemaTo?: string | undefined;
1656
1644
  name: string;
1657
1645
  tableFrom: string;
1658
1646
  columnsFrom: string[];
1659
1647
  tableTo: string;
1660
1648
  columnsTo: string[];
1649
+ onUpdate?: string | undefined;
1650
+ onDelete?: string | undefined;
1651
+ schemaTo?: string | undefined;
1661
1652
  }>;
1662
1653
  schema: string;
1663
1654
  compositePrimaryKeys: Record<string, {
@@ -1682,7 +1673,6 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1682
1673
  name: string;
1683
1674
  values: Record<string, string>;
1684
1675
  }>;
1685
- }, {
1686
1676
  internal?: {
1687
1677
  tables: Record<string, {
1688
1678
  columns: Record<string, {
@@ -1692,23 +1682,19 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1692
1682
  } | undefined>;
1693
1683
  } | undefined>;
1694
1684
  } | undefined;
1685
+ }, {
1695
1686
  tables: Record<string, {
1696
- uniqueConstraints?: Record<string, {
1697
- name: string;
1698
- columns: string[];
1699
- nullsNotDistinct: boolean;
1700
- }> | undefined;
1701
1687
  name: string;
1702
1688
  columns: Record<string, {
1689
+ name: string;
1690
+ type: string;
1691
+ primaryKey: boolean;
1692
+ notNull: boolean;
1703
1693
  isUnique?: any;
1704
1694
  default?: any;
1705
1695
  typeSchema?: string | undefined;
1706
1696
  uniqueName?: string | undefined;
1707
1697
  nullsNotDistinct?: boolean | undefined;
1708
- name: string;
1709
- type: string;
1710
- primaryKey: boolean;
1711
- notNull: boolean;
1712
1698
  }>;
1713
1699
  indexes: Record<string, {
1714
1700
  name: string;
@@ -1716,22 +1702,27 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1716
1702
  isUnique: boolean;
1717
1703
  }>;
1718
1704
  foreignKeys: Record<string, {
1719
- onUpdate?: string | undefined;
1720
- onDelete?: string | undefined;
1721
- schemaTo?: string | undefined;
1722
1705
  name: string;
1723
1706
  tableFrom: string;
1724
1707
  columnsFrom: string[];
1725
1708
  tableTo: string;
1726
1709
  columnsTo: string[];
1710
+ onUpdate?: string | undefined;
1711
+ onDelete?: string | undefined;
1712
+ schemaTo?: string | undefined;
1727
1713
  }>;
1728
1714
  schema: string;
1729
1715
  compositePrimaryKeys: Record<string, {
1730
1716
  name: string;
1731
1717
  columns: string[];
1732
1718
  }>;
1733
- }>;
1734
- version: "5";
1719
+ uniqueConstraints?: Record<string, {
1720
+ name: string;
1721
+ columns: string[];
1722
+ nullsNotDistinct: boolean;
1723
+ }> | undefined;
1724
+ }>;
1725
+ version: "5";
1735
1726
  dialect: "pg";
1736
1727
  schemas: Record<string, string>;
1737
1728
  _meta: {
@@ -1743,6 +1734,15 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1743
1734
  name: string;
1744
1735
  values: Record<string, string>;
1745
1736
  }>;
1737
+ internal?: {
1738
+ tables: Record<string, {
1739
+ columns: Record<string, {
1740
+ isArray?: boolean | undefined;
1741
+ dimensions?: number | undefined;
1742
+ rawType?: string | undefined;
1743
+ } | undefined>;
1744
+ } | undefined>;
1745
+ } | undefined;
1746
1746
  }>;
1747
1747
  export declare const pgSchemaExternal: import("zod").ZodObject<{
1748
1748
  version: import("zod").ZodLiteral<"5">;
@@ -1761,25 +1761,25 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1761
1761
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
1762
1762
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
1763
1763
  }, "strict", import("zod").ZodTypeAny, {
1764
+ name: string;
1765
+ type: string;
1766
+ primaryKey: boolean;
1767
+ notNull: boolean;
1764
1768
  isUnique?: any;
1765
1769
  default?: any;
1766
1770
  typeSchema?: string | undefined;
1767
1771
  uniqueName?: string | undefined;
1768
1772
  nullsNotDistinct?: boolean | undefined;
1773
+ }, {
1769
1774
  name: string;
1770
1775
  type: string;
1771
1776
  primaryKey: boolean;
1772
1777
  notNull: boolean;
1773
- }, {
1774
1778
  isUnique?: any;
1775
1779
  default?: any;
1776
1780
  typeSchema?: string | undefined;
1777
1781
  uniqueName?: string | undefined;
1778
1782
  nullsNotDistinct?: boolean | undefined;
1779
- name: string;
1780
- type: string;
1781
- primaryKey: boolean;
1782
- notNull: boolean;
1783
1783
  }>>;
1784
1784
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1785
1785
  name: import("zod").ZodString;
@@ -1804,23 +1804,23 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1804
1804
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1805
1805
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1806
1806
  }, "strict", import("zod").ZodTypeAny, {
1807
- onUpdate?: string | undefined;
1808
- onDelete?: string | undefined;
1809
- schemaTo?: string | undefined;
1810
1807
  name: string;
1811
1808
  tableFrom: string;
1812
1809
  columnsFrom: string[];
1813
1810
  tableTo: string;
1814
1811
  columnsTo: string[];
1815
- }, {
1816
1812
  onUpdate?: string | undefined;
1817
1813
  onDelete?: string | undefined;
1818
1814
  schemaTo?: string | undefined;
1815
+ }, {
1819
1816
  name: string;
1820
1817
  tableFrom: string;
1821
1818
  columnsFrom: string[];
1822
1819
  tableTo: string;
1823
1820
  columnsTo: string[];
1821
+ onUpdate?: string | undefined;
1822
+ onDelete?: string | undefined;
1823
+ schemaTo?: string | undefined;
1824
1824
  }>>;
1825
1825
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1826
1826
  name: import("zod").ZodString;
@@ -1848,15 +1848,15 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1848
1848
  }, "strict", import("zod").ZodTypeAny, {
1849
1849
  name: string;
1850
1850
  columns: Record<string, {
1851
+ name: string;
1852
+ type: string;
1853
+ primaryKey: boolean;
1854
+ notNull: boolean;
1851
1855
  isUnique?: any;
1852
1856
  default?: any;
1853
1857
  typeSchema?: string | undefined;
1854
1858
  uniqueName?: string | undefined;
1855
1859
  nullsNotDistinct?: boolean | undefined;
1856
- name: string;
1857
- type: string;
1858
- primaryKey: boolean;
1859
- notNull: boolean;
1860
1860
  }>;
1861
1861
  indexes: Record<string, {
1862
1862
  name: string;
@@ -1864,14 +1864,14 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1864
1864
  isUnique: boolean;
1865
1865
  }>;
1866
1866
  foreignKeys: Record<string, {
1867
- onUpdate?: string | undefined;
1868
- onDelete?: string | undefined;
1869
- schemaTo?: string | undefined;
1870
1867
  name: string;
1871
1868
  tableFrom: string;
1872
1869
  columnsFrom: string[];
1873
1870
  tableTo: string;
1874
1871
  columnsTo: string[];
1872
+ onUpdate?: string | undefined;
1873
+ onDelete?: string | undefined;
1874
+ schemaTo?: string | undefined;
1875
1875
  }>;
1876
1876
  schema: string;
1877
1877
  compositePrimaryKeys: Record<string, {
@@ -1884,22 +1884,17 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1884
1884
  nullsNotDistinct: boolean;
1885
1885
  }>;
1886
1886
  }, {
1887
- uniqueConstraints?: Record<string, {
1888
- name: string;
1889
- columns: string[];
1890
- nullsNotDistinct: boolean;
1891
- }> | undefined;
1892
1887
  name: string;
1893
1888
  columns: Record<string, {
1889
+ name: string;
1890
+ type: string;
1891
+ primaryKey: boolean;
1892
+ notNull: boolean;
1894
1893
  isUnique?: any;
1895
1894
  default?: any;
1896
1895
  typeSchema?: string | undefined;
1897
1896
  uniqueName?: string | undefined;
1898
1897
  nullsNotDistinct?: boolean | undefined;
1899
- name: string;
1900
- type: string;
1901
- primaryKey: boolean;
1902
- notNull: boolean;
1903
1898
  }>;
1904
1899
  indexes: Record<string, {
1905
1900
  name: string;
@@ -1907,20 +1902,25 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1907
1902
  isUnique: boolean;
1908
1903
  }>;
1909
1904
  foreignKeys: Record<string, {
1910
- onUpdate?: string | undefined;
1911
- onDelete?: string | undefined;
1912
- schemaTo?: string | undefined;
1913
1905
  name: string;
1914
1906
  tableFrom: string;
1915
1907
  columnsFrom: string[];
1916
1908
  tableTo: string;
1917
1909
  columnsTo: string[];
1910
+ onUpdate?: string | undefined;
1911
+ onDelete?: string | undefined;
1912
+ schemaTo?: string | undefined;
1918
1913
  }>;
1919
1914
  schema: string;
1920
1915
  compositePrimaryKeys: Record<string, {
1921
1916
  name: string;
1922
1917
  columns: string[];
1923
1918
  }>;
1919
+ uniqueConstraints?: Record<string, {
1920
+ name: string;
1921
+ columns: string[];
1922
+ nullsNotDistinct: boolean;
1923
+ }> | undefined;
1924
1924
  }>, "many">;
1925
1925
  enums: import("zod").ZodArray<import("zod").ZodObject<{
1926
1926
  name: import("zod").ZodString;
@@ -1956,15 +1956,15 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1956
1956
  tables: {
1957
1957
  name: string;
1958
1958
  columns: Record<string, {
1959
+ name: string;
1960
+ type: string;
1961
+ primaryKey: boolean;
1962
+ notNull: boolean;
1959
1963
  isUnique?: any;
1960
1964
  default?: any;
1961
1965
  typeSchema?: string | undefined;
1962
1966
  uniqueName?: string | undefined;
1963
1967
  nullsNotDistinct?: boolean | undefined;
1964
- name: string;
1965
- type: string;
1966
- primaryKey: boolean;
1967
- notNull: boolean;
1968
1968
  }>;
1969
1969
  indexes: Record<string, {
1970
1970
  name: string;
@@ -1972,14 +1972,14 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1972
1972
  isUnique: boolean;
1973
1973
  }>;
1974
1974
  foreignKeys: Record<string, {
1975
- onUpdate?: string | undefined;
1976
- onDelete?: string | undefined;
1977
- schemaTo?: string | undefined;
1978
1975
  name: string;
1979
1976
  tableFrom: string;
1980
1977
  columnsFrom: string[];
1981
1978
  tableTo: string;
1982
1979
  columnsTo: string[];
1980
+ onUpdate?: string | undefined;
1981
+ onDelete?: string | undefined;
1982
+ schemaTo?: string | undefined;
1983
1983
  }>;
1984
1984
  schema: string;
1985
1985
  compositePrimaryKeys: Record<string, {
@@ -2008,22 +2008,17 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
2008
2008
  }[];
2009
2009
  }, {
2010
2010
  tables: {
2011
- uniqueConstraints?: Record<string, {
2012
- name: string;
2013
- columns: string[];
2014
- nullsNotDistinct: boolean;
2015
- }> | undefined;
2016
2011
  name: string;
2017
2012
  columns: Record<string, {
2013
+ name: string;
2014
+ type: string;
2015
+ primaryKey: boolean;
2016
+ notNull: boolean;
2018
2017
  isUnique?: any;
2019
2018
  default?: any;
2020
2019
  typeSchema?: string | undefined;
2021
2020
  uniqueName?: string | undefined;
2022
2021
  nullsNotDistinct?: boolean | undefined;
2023
- name: string;
2024
- type: string;
2025
- primaryKey: boolean;
2026
- notNull: boolean;
2027
2022
  }>;
2028
2023
  indexes: Record<string, {
2029
2024
  name: string;
@@ -2031,20 +2026,25 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
2031
2026
  isUnique: boolean;
2032
2027
  }>;
2033
2028
  foreignKeys: Record<string, {
2034
- onUpdate?: string | undefined;
2035
- onDelete?: string | undefined;
2036
- schemaTo?: string | undefined;
2037
2029
  name: string;
2038
2030
  tableFrom: string;
2039
2031
  columnsFrom: string[];
2040
2032
  tableTo: string;
2041
2033
  columnsTo: string[];
2034
+ onUpdate?: string | undefined;
2035
+ onDelete?: string | undefined;
2036
+ schemaTo?: string | undefined;
2042
2037
  }>;
2043
2038
  schema: string;
2044
2039
  compositePrimaryKeys: Record<string, {
2045
2040
  name: string;
2046
2041
  columns: string[];
2047
2042
  }>;
2043
+ uniqueConstraints?: Record<string, {
2044
+ name: string;
2045
+ columns: string[];
2046
+ nullsNotDistinct: boolean;
2047
+ }> | undefined;
2048
2048
  }[];
2049
2049
  version: "5";
2050
2050
  dialect: "pg";
@@ -2078,25 +2078,25 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2078
2078
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
2079
2079
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
2080
2080
  }, "strict", import("zod").ZodTypeAny, {
2081
+ name: string;
2082
+ type: string;
2083
+ primaryKey: boolean;
2084
+ notNull: boolean;
2081
2085
  isUnique?: any;
2082
2086
  default?: any;
2083
2087
  typeSchema?: string | undefined;
2084
2088
  uniqueName?: string | undefined;
2085
2089
  nullsNotDistinct?: boolean | undefined;
2090
+ }, {
2086
2091
  name: string;
2087
2092
  type: string;
2088
2093
  primaryKey: boolean;
2089
2094
  notNull: boolean;
2090
- }, {
2091
2095
  isUnique?: any;
2092
2096
  default?: any;
2093
2097
  typeSchema?: string | undefined;
2094
2098
  uniqueName?: string | undefined;
2095
2099
  nullsNotDistinct?: boolean | undefined;
2096
- name: string;
2097
- type: string;
2098
- primaryKey: boolean;
2099
- notNull: boolean;
2100
2100
  }>>;
2101
2101
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2102
2102
  name: import("zod").ZodString;
@@ -2121,23 +2121,23 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2121
2121
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2122
2122
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2123
2123
  }, "strict", import("zod").ZodTypeAny, {
2124
- onUpdate?: string | undefined;
2125
- onDelete?: string | undefined;
2126
- schemaTo?: string | undefined;
2127
2124
  name: string;
2128
2125
  tableFrom: string;
2129
2126
  columnsFrom: string[];
2130
2127
  tableTo: string;
2131
2128
  columnsTo: string[];
2132
- }, {
2133
2129
  onUpdate?: string | undefined;
2134
2130
  onDelete?: string | undefined;
2135
2131
  schemaTo?: string | undefined;
2132
+ }, {
2136
2133
  name: string;
2137
2134
  tableFrom: string;
2138
2135
  columnsFrom: string[];
2139
2136
  tableTo: string;
2140
2137
  columnsTo: string[];
2138
+ onUpdate?: string | undefined;
2139
+ onDelete?: string | undefined;
2140
+ schemaTo?: string | undefined;
2141
2141
  }>>;
2142
2142
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2143
2143
  name: import("zod").ZodString;
@@ -2165,15 +2165,15 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2165
2165
  }, "strict", import("zod").ZodTypeAny, {
2166
2166
  name: string;
2167
2167
  columns: Record<string, {
2168
+ name: string;
2169
+ type: string;
2170
+ primaryKey: boolean;
2171
+ notNull: boolean;
2168
2172
  isUnique?: any;
2169
2173
  default?: any;
2170
2174
  typeSchema?: string | undefined;
2171
2175
  uniqueName?: string | undefined;
2172
2176
  nullsNotDistinct?: boolean | undefined;
2173
- name: string;
2174
- type: string;
2175
- primaryKey: boolean;
2176
- notNull: boolean;
2177
2177
  }>;
2178
2178
  indexes: Record<string, {
2179
2179
  name: string;
@@ -2181,14 +2181,14 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2181
2181
  isUnique: boolean;
2182
2182
  }>;
2183
2183
  foreignKeys: Record<string, {
2184
- onUpdate?: string | undefined;
2185
- onDelete?: string | undefined;
2186
- schemaTo?: string | undefined;
2187
2184
  name: string;
2188
2185
  tableFrom: string;
2189
2186
  columnsFrom: string[];
2190
2187
  tableTo: string;
2191
2188
  columnsTo: string[];
2189
+ onUpdate?: string | undefined;
2190
+ onDelete?: string | undefined;
2191
+ schemaTo?: string | undefined;
2192
2192
  }>;
2193
2193
  schema: string;
2194
2194
  compositePrimaryKeys: Record<string, {
@@ -2201,22 +2201,17 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2201
2201
  nullsNotDistinct: boolean;
2202
2202
  }>;
2203
2203
  }, {
2204
- uniqueConstraints?: Record<string, {
2205
- name: string;
2206
- columns: string[];
2207
- nullsNotDistinct: boolean;
2208
- }> | undefined;
2209
2204
  name: string;
2210
2205
  columns: Record<string, {
2206
+ name: string;
2207
+ type: string;
2208
+ primaryKey: boolean;
2209
+ notNull: boolean;
2211
2210
  isUnique?: any;
2212
2211
  default?: any;
2213
2212
  typeSchema?: string | undefined;
2214
2213
  uniqueName?: string | undefined;
2215
2214
  nullsNotDistinct?: boolean | undefined;
2216
- name: string;
2217
- type: string;
2218
- primaryKey: boolean;
2219
- notNull: boolean;
2220
2215
  }>;
2221
2216
  indexes: Record<string, {
2222
2217
  name: string;
@@ -2224,20 +2219,25 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2224
2219
  isUnique: boolean;
2225
2220
  }>;
2226
2221
  foreignKeys: Record<string, {
2227
- onUpdate?: string | undefined;
2228
- onDelete?: string | undefined;
2229
- schemaTo?: string | undefined;
2230
2222
  name: string;
2231
2223
  tableFrom: string;
2232
2224
  columnsFrom: string[];
2233
2225
  tableTo: string;
2234
2226
  columnsTo: string[];
2227
+ onUpdate?: string | undefined;
2228
+ onDelete?: string | undefined;
2229
+ schemaTo?: string | undefined;
2235
2230
  }>;
2236
2231
  schema: string;
2237
2232
  compositePrimaryKeys: Record<string, {
2238
2233
  name: string;
2239
2234
  columns: string[];
2240
2235
  }>;
2236
+ uniqueConstraints?: Record<string, {
2237
+ name: string;
2238
+ columns: string[];
2239
+ nullsNotDistinct: boolean;
2240
+ }> | undefined;
2241
2241
  }>>;
2242
2242
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2243
2243
  name: import("zod").ZodString;
@@ -2312,27 +2312,18 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2312
2312
  } | undefined>;
2313
2313
  }>>;
2314
2314
  }, "strict", import("zod").ZodTypeAny, {
2315
- internal?: {
2316
- tables: Record<string, {
2317
- columns: Record<string, {
2318
- isArray?: boolean | undefined;
2319
- dimensions?: number | undefined;
2320
- rawType?: string | undefined;
2321
- } | undefined>;
2322
- } | undefined>;
2323
- } | undefined;
2324
2315
  tables: Record<string, {
2325
2316
  name: string;
2326
2317
  columns: Record<string, {
2318
+ name: string;
2319
+ type: string;
2320
+ primaryKey: boolean;
2321
+ notNull: boolean;
2327
2322
  isUnique?: any;
2328
2323
  default?: any;
2329
2324
  typeSchema?: string | undefined;
2330
2325
  uniqueName?: string | undefined;
2331
2326
  nullsNotDistinct?: boolean | undefined;
2332
- name: string;
2333
- type: string;
2334
- primaryKey: boolean;
2335
- notNull: boolean;
2336
2327
  }>;
2337
2328
  indexes: Record<string, {
2338
2329
  name: string;
@@ -2340,14 +2331,14 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2340
2331
  isUnique: boolean;
2341
2332
  }>;
2342
2333
  foreignKeys: Record<string, {
2343
- onUpdate?: string | undefined;
2344
- onDelete?: string | undefined;
2345
- schemaTo?: string | undefined;
2346
2334
  name: string;
2347
2335
  tableFrom: string;
2348
2336
  columnsFrom: string[];
2349
2337
  tableTo: string;
2350
2338
  columnsTo: string[];
2339
+ onUpdate?: string | undefined;
2340
+ onDelete?: string | undefined;
2341
+ schemaTo?: string | undefined;
2351
2342
  }>;
2352
2343
  schema: string;
2353
2344
  compositePrimaryKeys: Record<string, {
@@ -2373,7 +2364,6 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2373
2364
  values: string[];
2374
2365
  schema: string;
2375
2366
  }>;
2376
- }, {
2377
2367
  internal?: {
2378
2368
  tables: Record<string, {
2379
2369
  columns: Record<string, {
@@ -2383,23 +2373,19 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2383
2373
  } | undefined>;
2384
2374
  } | undefined>;
2385
2375
  } | undefined;
2376
+ }, {
2386
2377
  tables: Record<string, {
2387
- uniqueConstraints?: Record<string, {
2388
- name: string;
2389
- columns: string[];
2390
- nullsNotDistinct: boolean;
2391
- }> | undefined;
2392
2378
  name: string;
2393
2379
  columns: Record<string, {
2380
+ name: string;
2381
+ type: string;
2382
+ primaryKey: boolean;
2383
+ notNull: boolean;
2394
2384
  isUnique?: any;
2395
2385
  default?: any;
2396
2386
  typeSchema?: string | undefined;
2397
2387
  uniqueName?: string | undefined;
2398
2388
  nullsNotDistinct?: boolean | undefined;
2399
- name: string;
2400
- type: string;
2401
- primaryKey: boolean;
2402
- notNull: boolean;
2403
2389
  }>;
2404
2390
  indexes: Record<string, {
2405
2391
  name: string;
@@ -2407,20 +2393,25 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2407
2393
  isUnique: boolean;
2408
2394
  }>;
2409
2395
  foreignKeys: Record<string, {
2410
- onUpdate?: string | undefined;
2411
- onDelete?: string | undefined;
2412
- schemaTo?: string | undefined;
2413
2396
  name: string;
2414
2397
  tableFrom: string;
2415
2398
  columnsFrom: string[];
2416
2399
  tableTo: string;
2417
2400
  columnsTo: string[];
2401
+ onUpdate?: string | undefined;
2402
+ onDelete?: string | undefined;
2403
+ schemaTo?: string | undefined;
2418
2404
  }>;
2419
2405
  schema: string;
2420
2406
  compositePrimaryKeys: Record<string, {
2421
2407
  name: string;
2422
2408
  columns: string[];
2423
2409
  }>;
2410
+ uniqueConstraints?: Record<string, {
2411
+ name: string;
2412
+ columns: string[];
2413
+ nullsNotDistinct: boolean;
2414
+ }> | undefined;
2424
2415
  }>;
2425
2416
  version: "6";
2426
2417
  dialect: "postgresql";
@@ -2435,6 +2426,15 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2435
2426
  values: string[];
2436
2427
  schema: string;
2437
2428
  }>;
2429
+ internal?: {
2430
+ tables: Record<string, {
2431
+ columns: Record<string, {
2432
+ isArray?: boolean | undefined;
2433
+ dimensions?: number | undefined;
2434
+ rawType?: string | undefined;
2435
+ } | undefined>;
2436
+ } | undefined>;
2437
+ } | undefined;
2438
2438
  }>;
2439
2439
  export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2440
2440
  version: import("zod").ZodLiteral<"4">;
@@ -2453,40 +2453,40 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2453
2453
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
2454
2454
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
2455
2455
  }, "strict", import("zod").ZodTypeAny, {
2456
+ name: string;
2457
+ type: string;
2458
+ primaryKey: boolean;
2459
+ notNull: boolean;
2456
2460
  isUnique?: any;
2457
2461
  default?: any;
2458
2462
  typeSchema?: string | undefined;
2459
2463
  uniqueName?: string | undefined;
2460
2464
  nullsNotDistinct?: boolean | undefined;
2465
+ }, {
2461
2466
  name: string;
2462
2467
  type: string;
2463
2468
  primaryKey: boolean;
2464
2469
  notNull: boolean;
2465
- }, {
2466
2470
  isUnique?: any;
2467
2471
  default?: any;
2468
2472
  typeSchema?: string | undefined;
2469
2473
  uniqueName?: string | undefined;
2470
2474
  nullsNotDistinct?: boolean | undefined;
2471
- name: string;
2472
- type: string;
2473
- primaryKey: boolean;
2474
- notNull: boolean;
2475
2475
  }>>;
2476
2476
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2477
2477
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2478
2478
  }, "strict", import("zod").ZodTypeAny, {
2479
2479
  name: string;
2480
2480
  columns: Record<string, {
2481
+ name: string;
2482
+ type: string;
2483
+ primaryKey: boolean;
2484
+ notNull: boolean;
2481
2485
  isUnique?: any;
2482
2486
  default?: any;
2483
2487
  typeSchema?: string | undefined;
2484
2488
  uniqueName?: string | undefined;
2485
2489
  nullsNotDistinct?: boolean | undefined;
2486
- name: string;
2487
- type: string;
2488
- primaryKey: boolean;
2489
- notNull: boolean;
2490
2490
  }>;
2491
2491
  indexes: Record<string, string>;
2492
2492
  foreignKeys: Record<string, string>;
@@ -2494,15 +2494,15 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2494
2494
  }, {
2495
2495
  name: string;
2496
2496
  columns: Record<string, {
2497
+ name: string;
2498
+ type: string;
2499
+ primaryKey: boolean;
2500
+ notNull: boolean;
2497
2501
  isUnique?: any;
2498
2502
  default?: any;
2499
2503
  typeSchema?: string | undefined;
2500
2504
  uniqueName?: string | undefined;
2501
2505
  nullsNotDistinct?: boolean | undefined;
2502
- name: string;
2503
- type: string;
2504
- primaryKey: boolean;
2505
- notNull: boolean;
2506
2506
  }>;
2507
2507
  indexes: Record<string, string>;
2508
2508
  foreignKeys: Record<string, string>;
@@ -2523,15 +2523,15 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2523
2523
  tables: Record<string, {
2524
2524
  name: string;
2525
2525
  columns: Record<string, {
2526
+ name: string;
2527
+ type: string;
2528
+ primaryKey: boolean;
2529
+ notNull: boolean;
2526
2530
  isUnique?: any;
2527
2531
  default?: any;
2528
2532
  typeSchema?: string | undefined;
2529
2533
  uniqueName?: string | undefined;
2530
2534
  nullsNotDistinct?: boolean | undefined;
2531
- name: string;
2532
- type: string;
2533
- primaryKey: boolean;
2534
- notNull: boolean;
2535
2535
  }>;
2536
2536
  indexes: Record<string, string>;
2537
2537
  foreignKeys: Record<string, string>;
@@ -2548,15 +2548,15 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2548
2548
  tables: Record<string, {
2549
2549
  name: string;
2550
2550
  columns: Record<string, {
2551
+ name: string;
2552
+ type: string;
2553
+ primaryKey: boolean;
2554
+ notNull: boolean;
2551
2555
  isUnique?: any;
2552
2556
  default?: any;
2553
2557
  typeSchema?: string | undefined;
2554
2558
  uniqueName?: string | undefined;
2555
2559
  nullsNotDistinct?: boolean | undefined;
2556
- name: string;
2557
- type: string;
2558
- primaryKey: boolean;
2559
- notNull: boolean;
2560
2560
  }>;
2561
2561
  indexes: Record<string, string>;
2562
2562
  foreignKeys: Record<string, string>;
@@ -2587,25 +2587,25 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2587
2587
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
2588
2588
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
2589
2589
  }, "strict", import("zod").ZodTypeAny, {
2590
+ name: string;
2591
+ type: string;
2592
+ primaryKey: boolean;
2593
+ notNull: boolean;
2590
2594
  isUnique?: any;
2591
2595
  default?: any;
2592
2596
  typeSchema?: string | undefined;
2593
2597
  uniqueName?: string | undefined;
2594
2598
  nullsNotDistinct?: boolean | undefined;
2599
+ }, {
2595
2600
  name: string;
2596
2601
  type: string;
2597
2602
  primaryKey: boolean;
2598
2603
  notNull: boolean;
2599
- }, {
2600
2604
  isUnique?: any;
2601
2605
  default?: any;
2602
2606
  typeSchema?: string | undefined;
2603
2607
  uniqueName?: string | undefined;
2604
2608
  nullsNotDistinct?: boolean | undefined;
2605
- name: string;
2606
- type: string;
2607
- primaryKey: boolean;
2608
- notNull: boolean;
2609
2609
  }>>;
2610
2610
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2611
2611
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -2614,15 +2614,15 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2614
2614
  }, "strict", import("zod").ZodTypeAny, {
2615
2615
  name: string;
2616
2616
  columns: Record<string, {
2617
+ name: string;
2618
+ type: string;
2619
+ primaryKey: boolean;
2620
+ notNull: boolean;
2617
2621
  isUnique?: any;
2618
2622
  default?: any;
2619
2623
  typeSchema?: string | undefined;
2620
2624
  uniqueName?: string | undefined;
2621
2625
  nullsNotDistinct?: boolean | undefined;
2622
- name: string;
2623
- type: string;
2624
- primaryKey: boolean;
2625
- notNull: boolean;
2626
2626
  }>;
2627
2627
  indexes: Record<string, string>;
2628
2628
  foreignKeys: Record<string, string>;
@@ -2632,15 +2632,15 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2632
2632
  }, {
2633
2633
  name: string;
2634
2634
  columns: Record<string, {
2635
+ name: string;
2636
+ type: string;
2637
+ primaryKey: boolean;
2638
+ notNull: boolean;
2635
2639
  isUnique?: any;
2636
2640
  default?: any;
2637
2641
  typeSchema?: string | undefined;
2638
2642
  uniqueName?: string | undefined;
2639
2643
  nullsNotDistinct?: boolean | undefined;
2640
- name: string;
2641
- type: string;
2642
- primaryKey: boolean;
2643
- notNull: boolean;
2644
2644
  }>;
2645
2645
  indexes: Record<string, string>;
2646
2646
  foreignKeys: Record<string, string>;
@@ -2666,15 +2666,15 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2666
2666
  tables: Record<string, {
2667
2667
  name: string;
2668
2668
  columns: Record<string, {
2669
+ name: string;
2670
+ type: string;
2671
+ primaryKey: boolean;
2672
+ notNull: boolean;
2669
2673
  isUnique?: any;
2670
2674
  default?: any;
2671
2675
  typeSchema?: string | undefined;
2672
2676
  uniqueName?: string | undefined;
2673
2677
  nullsNotDistinct?: boolean | undefined;
2674
- name: string;
2675
- type: string;
2676
- primaryKey: boolean;
2677
- notNull: boolean;
2678
2678
  }>;
2679
2679
  indexes: Record<string, string>;
2680
2680
  foreignKeys: Record<string, string>;
@@ -2694,15 +2694,15 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2694
2694
  tables: Record<string, {
2695
2695
  name: string;
2696
2696
  columns: Record<string, {
2697
+ name: string;
2698
+ type: string;
2699
+ primaryKey: boolean;
2700
+ notNull: boolean;
2697
2701
  isUnique?: any;
2698
2702
  default?: any;
2699
2703
  typeSchema?: string | undefined;
2700
2704
  uniqueName?: string | undefined;
2701
2705
  nullsNotDistinct?: boolean | undefined;
2702
- name: string;
2703
- type: string;
2704
- primaryKey: boolean;
2705
- notNull: boolean;
2706
2706
  }>;
2707
2707
  indexes: Record<string, string>;
2708
2708
  foreignKeys: Record<string, string>;
@@ -2719,7 +2719,7 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2719
2719
  schema: string;
2720
2720
  }>;
2721
2721
  }>;
2722
- export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
2722
+ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
2723
2723
  version: import("zod").ZodLiteral<"3">;
2724
2724
  dialect: import("zod").ZodLiteral<"pg">;
2725
2725
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -2735,25 +2735,25 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2735
2735
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
2736
2736
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
2737
2737
  }, "strict", import("zod").ZodTypeAny, {
2738
+ name: string;
2739
+ type: string;
2740
+ primaryKey: boolean;
2741
+ notNull: boolean;
2738
2742
  isUnique?: any;
2739
2743
  default?: any;
2740
2744
  typeSchema?: string | undefined;
2741
2745
  uniqueName?: string | undefined;
2742
2746
  nullsNotDistinct?: boolean | undefined;
2747
+ }, {
2743
2748
  name: string;
2744
2749
  type: string;
2745
2750
  primaryKey: boolean;
2746
2751
  notNull: boolean;
2747
- }, {
2748
2752
  isUnique?: any;
2749
2753
  default?: any;
2750
2754
  typeSchema?: string | undefined;
2751
2755
  uniqueName?: string | undefined;
2752
2756
  nullsNotDistinct?: boolean | undefined;
2753
- name: string;
2754
- type: string;
2755
- primaryKey: boolean;
2756
- notNull: boolean;
2757
2757
  }>>;
2758
2758
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2759
2759
  name: import("zod").ZodString;
@@ -2778,36 +2778,36 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2778
2778
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2779
2779
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2780
2780
  }, "strict", import("zod").ZodTypeAny, {
2781
- onUpdate?: string | undefined;
2782
- onDelete?: string | undefined;
2783
- schemaTo?: string | undefined;
2784
2781
  name: string;
2785
2782
  tableFrom: string;
2786
2783
  columnsFrom: string[];
2787
2784
  tableTo: string;
2788
2785
  columnsTo: string[];
2789
- }, {
2790
2786
  onUpdate?: string | undefined;
2791
2787
  onDelete?: string | undefined;
2792
2788
  schemaTo?: string | undefined;
2789
+ }, {
2793
2790
  name: string;
2794
2791
  tableFrom: string;
2795
2792
  columnsFrom: string[];
2796
2793
  tableTo: string;
2797
2794
  columnsTo: string[];
2795
+ onUpdate?: string | undefined;
2796
+ onDelete?: string | undefined;
2797
+ schemaTo?: string | undefined;
2798
2798
  }>>;
2799
2799
  }, "strict", import("zod").ZodTypeAny, {
2800
2800
  name: string;
2801
2801
  columns: Record<string, {
2802
+ name: string;
2803
+ type: string;
2804
+ primaryKey: boolean;
2805
+ notNull: boolean;
2802
2806
  isUnique?: any;
2803
2807
  default?: any;
2804
2808
  typeSchema?: string | undefined;
2805
2809
  uniqueName?: string | undefined;
2806
2810
  nullsNotDistinct?: boolean | undefined;
2807
- name: string;
2808
- type: string;
2809
- primaryKey: boolean;
2810
- notNull: boolean;
2811
2811
  }>;
2812
2812
  indexes: Record<string, {
2813
2813
  name: string;
@@ -2815,27 +2815,27 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2815
2815
  isUnique: boolean;
2816
2816
  }>;
2817
2817
  foreignKeys: Record<string, {
2818
- onUpdate?: string | undefined;
2819
- onDelete?: string | undefined;
2820
- schemaTo?: string | undefined;
2821
2818
  name: string;
2822
2819
  tableFrom: string;
2823
2820
  columnsFrom: string[];
2824
2821
  tableTo: string;
2825
2822
  columnsTo: string[];
2823
+ onUpdate?: string | undefined;
2824
+ onDelete?: string | undefined;
2825
+ schemaTo?: string | undefined;
2826
2826
  }>;
2827
2827
  }, {
2828
2828
  name: string;
2829
2829
  columns: Record<string, {
2830
+ name: string;
2831
+ type: string;
2832
+ primaryKey: boolean;
2833
+ notNull: boolean;
2830
2834
  isUnique?: any;
2831
2835
  default?: any;
2832
2836
  typeSchema?: string | undefined;
2833
2837
  uniqueName?: string | undefined;
2834
2838
  nullsNotDistinct?: boolean | undefined;
2835
- name: string;
2836
- type: string;
2837
- primaryKey: boolean;
2838
- notNull: boolean;
2839
2839
  }>;
2840
2840
  indexes: Record<string, {
2841
2841
  name: string;
@@ -2843,14 +2843,14 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2843
2843
  isUnique: boolean;
2844
2844
  }>;
2845
2845
  foreignKeys: Record<string, {
2846
- onUpdate?: string | undefined;
2847
- onDelete?: string | undefined;
2848
- schemaTo?: string | undefined;
2849
2846
  name: string;
2850
2847
  tableFrom: string;
2851
2848
  columnsFrom: string[];
2852
2849
  tableTo: string;
2853
2850
  columnsTo: string[];
2851
+ onUpdate?: string | undefined;
2852
+ onDelete?: string | undefined;
2853
+ schemaTo?: string | undefined;
2854
2854
  }>;
2855
2855
  }>>;
2856
2856
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -2870,15 +2870,15 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2870
2870
  tables: Record<string, {
2871
2871
  name: string;
2872
2872
  columns: Record<string, {
2873
+ name: string;
2874
+ type: string;
2875
+ primaryKey: boolean;
2876
+ notNull: boolean;
2873
2877
  isUnique?: any;
2874
2878
  default?: any;
2875
2879
  typeSchema?: string | undefined;
2876
2880
  uniqueName?: string | undefined;
2877
2881
  nullsNotDistinct?: boolean | undefined;
2878
- name: string;
2879
- type: string;
2880
- primaryKey: boolean;
2881
- notNull: boolean;
2882
2882
  }>;
2883
2883
  indexes: Record<string, {
2884
2884
  name: string;
@@ -2886,14 +2886,14 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2886
2886
  isUnique: boolean;
2887
2887
  }>;
2888
2888
  foreignKeys: Record<string, {
2889
- onUpdate?: string | undefined;
2890
- onDelete?: string | undefined;
2891
- schemaTo?: string | undefined;
2892
2889
  name: string;
2893
2890
  tableFrom: string;
2894
2891
  columnsFrom: string[];
2895
2892
  tableTo: string;
2896
2893
  columnsTo: string[];
2894
+ onUpdate?: string | undefined;
2895
+ onDelete?: string | undefined;
2896
+ schemaTo?: string | undefined;
2897
2897
  }>;
2898
2898
  }>;
2899
2899
  id: string;
@@ -2908,15 +2908,15 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2908
2908
  tables: Record<string, {
2909
2909
  name: string;
2910
2910
  columns: Record<string, {
2911
+ name: string;
2912
+ type: string;
2913
+ primaryKey: boolean;
2914
+ notNull: boolean;
2911
2915
  isUnique?: any;
2912
2916
  default?: any;
2913
2917
  typeSchema?: string | undefined;
2914
2918
  uniqueName?: string | undefined;
2915
2919
  nullsNotDistinct?: boolean | undefined;
2916
- name: string;
2917
- type: string;
2918
- primaryKey: boolean;
2919
- notNull: boolean;
2920
2920
  }>;
2921
2921
  indexes: Record<string, {
2922
2922
  name: string;
@@ -2924,14 +2924,14 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2924
2924
  isUnique: boolean;
2925
2925
  }>;
2926
2926
  foreignKeys: Record<string, {
2927
- onUpdate?: string | undefined;
2928
- onDelete?: string | undefined;
2929
- schemaTo?: string | undefined;
2930
2927
  name: string;
2931
2928
  tableFrom: string;
2932
2929
  columnsFrom: string[];
2933
2930
  tableTo: string;
2934
2931
  columnsTo: string[];
2932
+ onUpdate?: string | undefined;
2933
+ onDelete?: string | undefined;
2934
+ schemaTo?: string | undefined;
2935
2935
  }>;
2936
2936
  }>;
2937
2937
  id: string;
@@ -2943,7 +2943,7 @@ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").extendSha
2943
2943
  values: Record<string, string>;
2944
2944
  }>;
2945
2945
  }>;
2946
- export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
2946
+ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
2947
2947
  version: import("zod").ZodLiteral<"4">;
2948
2948
  dialect: import("zod").ZodLiteral<"pg">;
2949
2949
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -2960,25 +2960,25 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
2960
2960
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
2961
2961
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
2962
2962
  }, "strict", import("zod").ZodTypeAny, {
2963
+ name: string;
2964
+ type: string;
2965
+ primaryKey: boolean;
2966
+ notNull: boolean;
2963
2967
  isUnique?: any;
2964
2968
  default?: any;
2965
2969
  typeSchema?: string | undefined;
2966
2970
  uniqueName?: string | undefined;
2967
2971
  nullsNotDistinct?: boolean | undefined;
2972
+ }, {
2968
2973
  name: string;
2969
2974
  type: string;
2970
2975
  primaryKey: boolean;
2971
2976
  notNull: boolean;
2972
- }, {
2973
2977
  isUnique?: any;
2974
2978
  default?: any;
2975
2979
  typeSchema?: string | undefined;
2976
2980
  uniqueName?: string | undefined;
2977
2981
  nullsNotDistinct?: boolean | undefined;
2978
- name: string;
2979
- type: string;
2980
- primaryKey: boolean;
2981
- notNull: boolean;
2982
2982
  }>>;
2983
2983
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2984
2984
  name: import("zod").ZodString;
@@ -3003,36 +3003,36 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
3003
3003
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3004
3004
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3005
3005
  }, "strict", import("zod").ZodTypeAny, {
3006
- onUpdate?: string | undefined;
3007
- onDelete?: string | undefined;
3008
- schemaTo?: string | undefined;
3009
3006
  name: string;
3010
3007
  tableFrom: string;
3011
3008
  columnsFrom: string[];
3012
3009
  tableTo: string;
3013
3010
  columnsTo: string[];
3014
- }, {
3015
3011
  onUpdate?: string | undefined;
3016
3012
  onDelete?: string | undefined;
3017
3013
  schemaTo?: string | undefined;
3014
+ }, {
3018
3015
  name: string;
3019
3016
  tableFrom: string;
3020
3017
  columnsFrom: string[];
3021
3018
  tableTo: string;
3022
3019
  columnsTo: string[];
3020
+ onUpdate?: string | undefined;
3021
+ onDelete?: string | undefined;
3022
+ schemaTo?: string | undefined;
3023
3023
  }>>;
3024
3024
  }, "strict", import("zod").ZodTypeAny, {
3025
3025
  name: string;
3026
3026
  columns: Record<string, {
3027
+ name: string;
3028
+ type: string;
3029
+ primaryKey: boolean;
3030
+ notNull: boolean;
3027
3031
  isUnique?: any;
3028
3032
  default?: any;
3029
3033
  typeSchema?: string | undefined;
3030
3034
  uniqueName?: string | undefined;
3031
3035
  nullsNotDistinct?: boolean | undefined;
3032
- name: string;
3033
- type: string;
3034
- primaryKey: boolean;
3035
- notNull: boolean;
3036
3036
  }>;
3037
3037
  indexes: Record<string, {
3038
3038
  name: string;
@@ -3040,28 +3040,28 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
3040
3040
  isUnique: boolean;
3041
3041
  }>;
3042
3042
  foreignKeys: Record<string, {
3043
- onUpdate?: string | undefined;
3044
- onDelete?: string | undefined;
3045
- schemaTo?: string | undefined;
3046
3043
  name: string;
3047
3044
  tableFrom: string;
3048
3045
  columnsFrom: string[];
3049
3046
  tableTo: string;
3050
3047
  columnsTo: string[];
3048
+ onUpdate?: string | undefined;
3049
+ onDelete?: string | undefined;
3050
+ schemaTo?: string | undefined;
3051
3051
  }>;
3052
3052
  schema: string;
3053
3053
  }, {
3054
3054
  name: string;
3055
3055
  columns: Record<string, {
3056
+ name: string;
3057
+ type: string;
3058
+ primaryKey: boolean;
3059
+ notNull: boolean;
3056
3060
  isUnique?: any;
3057
3061
  default?: any;
3058
3062
  typeSchema?: string | undefined;
3059
3063
  uniqueName?: string | undefined;
3060
3064
  nullsNotDistinct?: boolean | undefined;
3061
- name: string;
3062
- type: string;
3063
- primaryKey: boolean;
3064
- notNull: boolean;
3065
3065
  }>;
3066
3066
  indexes: Record<string, {
3067
3067
  name: string;
@@ -3069,14 +3069,14 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
3069
3069
  isUnique: boolean;
3070
3070
  }>;
3071
3071
  foreignKeys: Record<string, {
3072
- onUpdate?: string | undefined;
3073
- onDelete?: string | undefined;
3074
- schemaTo?: string | undefined;
3075
3072
  name: string;
3076
3073
  tableFrom: string;
3077
3074
  columnsFrom: string[];
3078
3075
  tableTo: string;
3079
3076
  columnsTo: string[];
3077
+ onUpdate?: string | undefined;
3078
+ onDelete?: string | undefined;
3079
+ schemaTo?: string | undefined;
3080
3080
  }>;
3081
3081
  schema: string;
3082
3082
  }>>;
@@ -3098,15 +3098,15 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
3098
3098
  tables: Record<string, {
3099
3099
  name: string;
3100
3100
  columns: Record<string, {
3101
+ name: string;
3102
+ type: string;
3103
+ primaryKey: boolean;
3104
+ notNull: boolean;
3101
3105
  isUnique?: any;
3102
3106
  default?: any;
3103
3107
  typeSchema?: string | undefined;
3104
3108
  uniqueName?: string | undefined;
3105
3109
  nullsNotDistinct?: boolean | undefined;
3106
- name: string;
3107
- type: string;
3108
- primaryKey: boolean;
3109
- notNull: boolean;
3110
3110
  }>;
3111
3111
  indexes: Record<string, {
3112
3112
  name: string;
@@ -3114,14 +3114,14 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
3114
3114
  isUnique: boolean;
3115
3115
  }>;
3116
3116
  foreignKeys: Record<string, {
3117
- onUpdate?: string | undefined;
3118
- onDelete?: string | undefined;
3119
- schemaTo?: string | undefined;
3120
3117
  name: string;
3121
3118
  tableFrom: string;
3122
3119
  columnsFrom: string[];
3123
3120
  tableTo: string;
3124
3121
  columnsTo: string[];
3122
+ onUpdate?: string | undefined;
3123
+ onDelete?: string | undefined;
3124
+ schemaTo?: string | undefined;
3125
3125
  }>;
3126
3126
  schema: string;
3127
3127
  }>;
@@ -3138,15 +3138,15 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
3138
3138
  tables: Record<string, {
3139
3139
  name: string;
3140
3140
  columns: Record<string, {
3141
+ name: string;
3142
+ type: string;
3143
+ primaryKey: boolean;
3144
+ notNull: boolean;
3141
3145
  isUnique?: any;
3142
3146
  default?: any;
3143
3147
  typeSchema?: string | undefined;
3144
3148
  uniqueName?: string | undefined;
3145
3149
  nullsNotDistinct?: boolean | undefined;
3146
- name: string;
3147
- type: string;
3148
- primaryKey: boolean;
3149
- notNull: boolean;
3150
3150
  }>;
3151
3151
  indexes: Record<string, {
3152
3152
  name: string;
@@ -3154,14 +3154,14 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
3154
3154
  isUnique: boolean;
3155
3155
  }>;
3156
3156
  foreignKeys: Record<string, {
3157
- onUpdate?: string | undefined;
3158
- onDelete?: string | undefined;
3159
- schemaTo?: string | undefined;
3160
3157
  name: string;
3161
3158
  tableFrom: string;
3162
3159
  columnsFrom: string[];
3163
3160
  tableTo: string;
3164
3161
  columnsTo: string[];
3162
+ onUpdate?: string | undefined;
3163
+ onDelete?: string | undefined;
3164
+ schemaTo?: string | undefined;
3165
3165
  }>;
3166
3166
  schema: string;
3167
3167
  }>;
@@ -3175,7 +3175,7 @@ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").extendSha
3175
3175
  values: Record<string, string>;
3176
3176
  }>;
3177
3177
  }>;
3178
- export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendShape<{
3178
+ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
3179
3179
  version: import("zod").ZodLiteral<"5">;
3180
3180
  dialect: import("zod").ZodLiteral<"pg">;
3181
3181
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -3192,25 +3192,25 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3192
3192
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
3193
3193
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
3194
3194
  }, "strict", import("zod").ZodTypeAny, {
3195
+ name: string;
3196
+ type: string;
3197
+ primaryKey: boolean;
3198
+ notNull: boolean;
3195
3199
  isUnique?: any;
3196
3200
  default?: any;
3197
3201
  typeSchema?: string | undefined;
3198
3202
  uniqueName?: string | undefined;
3199
3203
  nullsNotDistinct?: boolean | undefined;
3204
+ }, {
3200
3205
  name: string;
3201
3206
  type: string;
3202
3207
  primaryKey: boolean;
3203
3208
  notNull: boolean;
3204
- }, {
3205
3209
  isUnique?: any;
3206
3210
  default?: any;
3207
3211
  typeSchema?: string | undefined;
3208
3212
  uniqueName?: string | undefined;
3209
3213
  nullsNotDistinct?: boolean | undefined;
3210
- name: string;
3211
- type: string;
3212
- primaryKey: boolean;
3213
- notNull: boolean;
3214
3214
  }>>;
3215
3215
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3216
3216
  name: import("zod").ZodString;
@@ -3235,23 +3235,23 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3235
3235
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3236
3236
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3237
3237
  }, "strict", import("zod").ZodTypeAny, {
3238
- onUpdate?: string | undefined;
3239
- onDelete?: string | undefined;
3240
- schemaTo?: string | undefined;
3241
3238
  name: string;
3242
3239
  tableFrom: string;
3243
3240
  columnsFrom: string[];
3244
3241
  tableTo: string;
3245
3242
  columnsTo: string[];
3246
- }, {
3247
3243
  onUpdate?: string | undefined;
3248
3244
  onDelete?: string | undefined;
3249
3245
  schemaTo?: string | undefined;
3246
+ }, {
3250
3247
  name: string;
3251
3248
  tableFrom: string;
3252
3249
  columnsFrom: string[];
3253
3250
  tableTo: string;
3254
3251
  columnsTo: string[];
3252
+ onUpdate?: string | undefined;
3253
+ onDelete?: string | undefined;
3254
+ schemaTo?: string | undefined;
3255
3255
  }>>;
3256
3256
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3257
3257
  name: import("zod").ZodString;
@@ -3279,15 +3279,15 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3279
3279
  }, "strict", import("zod").ZodTypeAny, {
3280
3280
  name: string;
3281
3281
  columns: Record<string, {
3282
+ name: string;
3283
+ type: string;
3284
+ primaryKey: boolean;
3285
+ notNull: boolean;
3282
3286
  isUnique?: any;
3283
3287
  default?: any;
3284
3288
  typeSchema?: string | undefined;
3285
3289
  uniqueName?: string | undefined;
3286
3290
  nullsNotDistinct?: boolean | undefined;
3287
- name: string;
3288
- type: string;
3289
- primaryKey: boolean;
3290
- notNull: boolean;
3291
3291
  }>;
3292
3292
  indexes: Record<string, {
3293
3293
  name: string;
@@ -3295,14 +3295,14 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3295
3295
  isUnique: boolean;
3296
3296
  }>;
3297
3297
  foreignKeys: Record<string, {
3298
- onUpdate?: string | undefined;
3299
- onDelete?: string | undefined;
3300
- schemaTo?: string | undefined;
3301
3298
  name: string;
3302
3299
  tableFrom: string;
3303
3300
  columnsFrom: string[];
3304
3301
  tableTo: string;
3305
3302
  columnsTo: string[];
3303
+ onUpdate?: string | undefined;
3304
+ onDelete?: string | undefined;
3305
+ schemaTo?: string | undefined;
3306
3306
  }>;
3307
3307
  schema: string;
3308
3308
  compositePrimaryKeys: Record<string, {
@@ -3315,22 +3315,17 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3315
3315
  nullsNotDistinct: boolean;
3316
3316
  }>;
3317
3317
  }, {
3318
- uniqueConstraints?: Record<string, {
3319
- name: string;
3320
- columns: string[];
3321
- nullsNotDistinct: boolean;
3322
- }> | undefined;
3323
3318
  name: string;
3324
3319
  columns: Record<string, {
3320
+ name: string;
3321
+ type: string;
3322
+ primaryKey: boolean;
3323
+ notNull: boolean;
3325
3324
  isUnique?: any;
3326
3325
  default?: any;
3327
3326
  typeSchema?: string | undefined;
3328
3327
  uniqueName?: string | undefined;
3329
3328
  nullsNotDistinct?: boolean | undefined;
3330
- name: string;
3331
- type: string;
3332
- primaryKey: boolean;
3333
- notNull: boolean;
3334
3329
  }>;
3335
3330
  indexes: Record<string, {
3336
3331
  name: string;
@@ -3338,20 +3333,25 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3338
3333
  isUnique: boolean;
3339
3334
  }>;
3340
3335
  foreignKeys: Record<string, {
3341
- onUpdate?: string | undefined;
3342
- onDelete?: string | undefined;
3343
- schemaTo?: string | undefined;
3344
3336
  name: string;
3345
3337
  tableFrom: string;
3346
3338
  columnsFrom: string[];
3347
3339
  tableTo: string;
3348
3340
  columnsTo: string[];
3341
+ onUpdate?: string | undefined;
3342
+ onDelete?: string | undefined;
3343
+ schemaTo?: string | undefined;
3349
3344
  }>;
3350
3345
  schema: string;
3351
3346
  compositePrimaryKeys: Record<string, {
3352
3347
  name: string;
3353
3348
  columns: string[];
3354
3349
  }>;
3350
+ uniqueConstraints?: Record<string, {
3351
+ name: string;
3352
+ columns: string[];
3353
+ nullsNotDistinct: boolean;
3354
+ }> | undefined;
3355
3355
  }>>;
3356
3356
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3357
3357
  name: import("zod").ZodString;
@@ -3426,27 +3426,18 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3426
3426
  id: import("zod").ZodString;
3427
3427
  prevId: import("zod").ZodString;
3428
3428
  }>, "strip", import("zod").ZodTypeAny, {
3429
- internal?: {
3430
- tables: Record<string, {
3431
- columns: Record<string, {
3432
- isArray?: boolean | undefined;
3433
- dimensions?: number | undefined;
3434
- rawType?: string | undefined;
3435
- } | undefined>;
3436
- } | undefined>;
3437
- } | undefined;
3438
3429
  tables: Record<string, {
3439
3430
  name: string;
3440
3431
  columns: Record<string, {
3432
+ name: string;
3433
+ type: string;
3434
+ primaryKey: boolean;
3435
+ notNull: boolean;
3441
3436
  isUnique?: any;
3442
3437
  default?: any;
3443
3438
  typeSchema?: string | undefined;
3444
3439
  uniqueName?: string | undefined;
3445
3440
  nullsNotDistinct?: boolean | undefined;
3446
- name: string;
3447
- type: string;
3448
- primaryKey: boolean;
3449
- notNull: boolean;
3450
3441
  }>;
3451
3442
  indexes: Record<string, {
3452
3443
  name: string;
@@ -3454,14 +3445,14 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3454
3445
  isUnique: boolean;
3455
3446
  }>;
3456
3447
  foreignKeys: Record<string, {
3457
- onUpdate?: string | undefined;
3458
- onDelete?: string | undefined;
3459
- schemaTo?: string | undefined;
3460
3448
  name: string;
3461
3449
  tableFrom: string;
3462
3450
  columnsFrom: string[];
3463
3451
  tableTo: string;
3464
3452
  columnsTo: string[];
3453
+ onUpdate?: string | undefined;
3454
+ onDelete?: string | undefined;
3455
+ schemaTo?: string | undefined;
3465
3456
  }>;
3466
3457
  schema: string;
3467
3458
  compositePrimaryKeys: Record<string, {
@@ -3488,7 +3479,6 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3488
3479
  name: string;
3489
3480
  values: Record<string, string>;
3490
3481
  }>;
3491
- }, {
3492
3482
  internal?: {
3493
3483
  tables: Record<string, {
3494
3484
  columns: Record<string, {
@@ -3498,23 +3488,19 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3498
3488
  } | undefined>;
3499
3489
  } | undefined>;
3500
3490
  } | undefined;
3491
+ }, {
3501
3492
  tables: Record<string, {
3502
- uniqueConstraints?: Record<string, {
3503
- name: string;
3504
- columns: string[];
3505
- nullsNotDistinct: boolean;
3506
- }> | undefined;
3507
3493
  name: string;
3508
3494
  columns: Record<string, {
3495
+ name: string;
3496
+ type: string;
3497
+ primaryKey: boolean;
3498
+ notNull: boolean;
3509
3499
  isUnique?: any;
3510
3500
  default?: any;
3511
3501
  typeSchema?: string | undefined;
3512
3502
  uniqueName?: string | undefined;
3513
3503
  nullsNotDistinct?: boolean | undefined;
3514
- name: string;
3515
- type: string;
3516
- primaryKey: boolean;
3517
- notNull: boolean;
3518
3504
  }>;
3519
3505
  indexes: Record<string, {
3520
3506
  name: string;
@@ -3522,20 +3508,25 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3522
3508
  isUnique: boolean;
3523
3509
  }>;
3524
3510
  foreignKeys: Record<string, {
3525
- onUpdate?: string | undefined;
3526
- onDelete?: string | undefined;
3527
- schemaTo?: string | undefined;
3528
3511
  name: string;
3529
3512
  tableFrom: string;
3530
3513
  columnsFrom: string[];
3531
3514
  tableTo: string;
3532
3515
  columnsTo: string[];
3516
+ onUpdate?: string | undefined;
3517
+ onDelete?: string | undefined;
3518
+ schemaTo?: string | undefined;
3533
3519
  }>;
3534
3520
  schema: string;
3535
3521
  compositePrimaryKeys: Record<string, {
3536
3522
  name: string;
3537
3523
  columns: string[];
3538
3524
  }>;
3525
+ uniqueConstraints?: Record<string, {
3526
+ name: string;
3527
+ columns: string[];
3528
+ nullsNotDistinct: boolean;
3529
+ }> | undefined;
3539
3530
  }>;
3540
3531
  id: string;
3541
3532
  prevId: string;
@@ -3551,8 +3542,17 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").extendSha
3551
3542
  name: string;
3552
3543
  values: Record<string, string>;
3553
3544
  }>;
3545
+ internal?: {
3546
+ tables: Record<string, {
3547
+ columns: Record<string, {
3548
+ isArray?: boolean | undefined;
3549
+ dimensions?: number | undefined;
3550
+ rawType?: string | undefined;
3551
+ } | undefined>;
3552
+ } | undefined>;
3553
+ } | undefined;
3554
3554
  }>;
3555
- export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape<{
3555
+ export declare const pgSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
3556
3556
  version: import("zod").ZodLiteral<"6">;
3557
3557
  dialect: import("zod").ZodLiteral<"postgresql">;
3558
3558
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -3569,25 +3569,25 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3569
3569
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
3570
3570
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
3571
3571
  }, "strict", import("zod").ZodTypeAny, {
3572
+ name: string;
3573
+ type: string;
3574
+ primaryKey: boolean;
3575
+ notNull: boolean;
3572
3576
  isUnique?: any;
3573
3577
  default?: any;
3574
3578
  typeSchema?: string | undefined;
3575
3579
  uniqueName?: string | undefined;
3576
3580
  nullsNotDistinct?: boolean | undefined;
3581
+ }, {
3577
3582
  name: string;
3578
3583
  type: string;
3579
3584
  primaryKey: boolean;
3580
3585
  notNull: boolean;
3581
- }, {
3582
3586
  isUnique?: any;
3583
3587
  default?: any;
3584
3588
  typeSchema?: string | undefined;
3585
3589
  uniqueName?: string | undefined;
3586
3590
  nullsNotDistinct?: boolean | undefined;
3587
- name: string;
3588
- type: string;
3589
- primaryKey: boolean;
3590
- notNull: boolean;
3591
3591
  }>>;
3592
3592
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3593
3593
  name: import("zod").ZodString;
@@ -3612,23 +3612,23 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3612
3612
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3613
3613
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3614
3614
  }, "strict", import("zod").ZodTypeAny, {
3615
- onUpdate?: string | undefined;
3616
- onDelete?: string | undefined;
3617
- schemaTo?: string | undefined;
3618
3615
  name: string;
3619
3616
  tableFrom: string;
3620
3617
  columnsFrom: string[];
3621
3618
  tableTo: string;
3622
3619
  columnsTo: string[];
3623
- }, {
3624
3620
  onUpdate?: string | undefined;
3625
3621
  onDelete?: string | undefined;
3626
3622
  schemaTo?: string | undefined;
3623
+ }, {
3627
3624
  name: string;
3628
3625
  tableFrom: string;
3629
3626
  columnsFrom: string[];
3630
3627
  tableTo: string;
3631
3628
  columnsTo: string[];
3629
+ onUpdate?: string | undefined;
3630
+ onDelete?: string | undefined;
3631
+ schemaTo?: string | undefined;
3632
3632
  }>>;
3633
3633
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3634
3634
  name: import("zod").ZodString;
@@ -3656,15 +3656,15 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3656
3656
  }, "strict", import("zod").ZodTypeAny, {
3657
3657
  name: string;
3658
3658
  columns: Record<string, {
3659
+ name: string;
3660
+ type: string;
3661
+ primaryKey: boolean;
3662
+ notNull: boolean;
3659
3663
  isUnique?: any;
3660
3664
  default?: any;
3661
3665
  typeSchema?: string | undefined;
3662
3666
  uniqueName?: string | undefined;
3663
3667
  nullsNotDistinct?: boolean | undefined;
3664
- name: string;
3665
- type: string;
3666
- primaryKey: boolean;
3667
- notNull: boolean;
3668
3668
  }>;
3669
3669
  indexes: Record<string, {
3670
3670
  name: string;
@@ -3672,14 +3672,14 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3672
3672
  isUnique: boolean;
3673
3673
  }>;
3674
3674
  foreignKeys: Record<string, {
3675
- onUpdate?: string | undefined;
3676
- onDelete?: string | undefined;
3677
- schemaTo?: string | undefined;
3678
3675
  name: string;
3679
3676
  tableFrom: string;
3680
3677
  columnsFrom: string[];
3681
3678
  tableTo: string;
3682
3679
  columnsTo: string[];
3680
+ onUpdate?: string | undefined;
3681
+ onDelete?: string | undefined;
3682
+ schemaTo?: string | undefined;
3683
3683
  }>;
3684
3684
  schema: string;
3685
3685
  compositePrimaryKeys: Record<string, {
@@ -3692,22 +3692,17 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3692
3692
  nullsNotDistinct: boolean;
3693
3693
  }>;
3694
3694
  }, {
3695
- uniqueConstraints?: Record<string, {
3696
- name: string;
3697
- columns: string[];
3698
- nullsNotDistinct: boolean;
3699
- }> | undefined;
3700
3695
  name: string;
3701
3696
  columns: Record<string, {
3697
+ name: string;
3698
+ type: string;
3699
+ primaryKey: boolean;
3700
+ notNull: boolean;
3702
3701
  isUnique?: any;
3703
3702
  default?: any;
3704
3703
  typeSchema?: string | undefined;
3705
3704
  uniqueName?: string | undefined;
3706
3705
  nullsNotDistinct?: boolean | undefined;
3707
- name: string;
3708
- type: string;
3709
- primaryKey: boolean;
3710
- notNull: boolean;
3711
3706
  }>;
3712
3707
  indexes: Record<string, {
3713
3708
  name: string;
@@ -3715,20 +3710,25 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3715
3710
  isUnique: boolean;
3716
3711
  }>;
3717
3712
  foreignKeys: Record<string, {
3718
- onUpdate?: string | undefined;
3719
- onDelete?: string | undefined;
3720
- schemaTo?: string | undefined;
3721
3713
  name: string;
3722
3714
  tableFrom: string;
3723
3715
  columnsFrom: string[];
3724
3716
  tableTo: string;
3725
3717
  columnsTo: string[];
3718
+ onUpdate?: string | undefined;
3719
+ onDelete?: string | undefined;
3720
+ schemaTo?: string | undefined;
3726
3721
  }>;
3727
3722
  schema: string;
3728
3723
  compositePrimaryKeys: Record<string, {
3729
3724
  name: string;
3730
3725
  columns: string[];
3731
3726
  }>;
3727
+ uniqueConstraints?: Record<string, {
3728
+ name: string;
3729
+ columns: string[];
3730
+ nullsNotDistinct: boolean;
3731
+ }> | undefined;
3732
3732
  }>>;
3733
3733
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3734
3734
  name: import("zod").ZodString;
@@ -3806,27 +3806,18 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3806
3806
  id: import("zod").ZodString;
3807
3807
  prevId: import("zod").ZodString;
3808
3808
  }>, "strip", import("zod").ZodTypeAny, {
3809
- internal?: {
3810
- tables: Record<string, {
3811
- columns: Record<string, {
3812
- isArray?: boolean | undefined;
3813
- dimensions?: number | undefined;
3814
- rawType?: string | undefined;
3815
- } | undefined>;
3816
- } | undefined>;
3817
- } | undefined;
3818
3809
  tables: Record<string, {
3819
3810
  name: string;
3820
3811
  columns: Record<string, {
3812
+ name: string;
3813
+ type: string;
3814
+ primaryKey: boolean;
3815
+ notNull: boolean;
3821
3816
  isUnique?: any;
3822
3817
  default?: any;
3823
3818
  typeSchema?: string | undefined;
3824
3819
  uniqueName?: string | undefined;
3825
3820
  nullsNotDistinct?: boolean | undefined;
3826
- name: string;
3827
- type: string;
3828
- primaryKey: boolean;
3829
- notNull: boolean;
3830
3821
  }>;
3831
3822
  indexes: Record<string, {
3832
3823
  name: string;
@@ -3834,14 +3825,14 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3834
3825
  isUnique: boolean;
3835
3826
  }>;
3836
3827
  foreignKeys: Record<string, {
3837
- onUpdate?: string | undefined;
3838
- onDelete?: string | undefined;
3839
- schemaTo?: string | undefined;
3840
3828
  name: string;
3841
3829
  tableFrom: string;
3842
3830
  columnsFrom: string[];
3843
3831
  tableTo: string;
3844
3832
  columnsTo: string[];
3833
+ onUpdate?: string | undefined;
3834
+ onDelete?: string | undefined;
3835
+ schemaTo?: string | undefined;
3845
3836
  }>;
3846
3837
  schema: string;
3847
3838
  compositePrimaryKeys: Record<string, {
@@ -3869,7 +3860,6 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3869
3860
  values: string[];
3870
3861
  schema: string;
3871
3862
  }>;
3872
- }, {
3873
3863
  internal?: {
3874
3864
  tables: Record<string, {
3875
3865
  columns: Record<string, {
@@ -3879,23 +3869,19 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3879
3869
  } | undefined>;
3880
3870
  } | undefined>;
3881
3871
  } | undefined;
3872
+ }, {
3882
3873
  tables: Record<string, {
3883
- uniqueConstraints?: Record<string, {
3884
- name: string;
3885
- columns: string[];
3886
- nullsNotDistinct: boolean;
3887
- }> | undefined;
3888
3874
  name: string;
3889
3875
  columns: Record<string, {
3876
+ name: string;
3877
+ type: string;
3878
+ primaryKey: boolean;
3879
+ notNull: boolean;
3890
3880
  isUnique?: any;
3891
3881
  default?: any;
3892
3882
  typeSchema?: string | undefined;
3893
3883
  uniqueName?: string | undefined;
3894
3884
  nullsNotDistinct?: boolean | undefined;
3895
- name: string;
3896
- type: string;
3897
- primaryKey: boolean;
3898
- notNull: boolean;
3899
3885
  }>;
3900
3886
  indexes: Record<string, {
3901
3887
  name: string;
@@ -3903,20 +3889,25 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3903
3889
  isUnique: boolean;
3904
3890
  }>;
3905
3891
  foreignKeys: Record<string, {
3906
- onUpdate?: string | undefined;
3907
- onDelete?: string | undefined;
3908
- schemaTo?: string | undefined;
3909
3892
  name: string;
3910
3893
  tableFrom: string;
3911
3894
  columnsFrom: string[];
3912
3895
  tableTo: string;
3913
3896
  columnsTo: string[];
3897
+ onUpdate?: string | undefined;
3898
+ onDelete?: string | undefined;
3899
+ schemaTo?: string | undefined;
3914
3900
  }>;
3915
3901
  schema: string;
3916
3902
  compositePrimaryKeys: Record<string, {
3917
3903
  name: string;
3918
3904
  columns: string[];
3919
3905
  }>;
3906
+ uniqueConstraints?: Record<string, {
3907
+ name: string;
3908
+ columns: string[];
3909
+ nullsNotDistinct: boolean;
3910
+ }> | undefined;
3920
3911
  }>;
3921
3912
  id: string;
3922
3913
  prevId: string;
@@ -3933,6 +3924,15 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape
3933
3924
  values: string[];
3934
3925
  schema: string;
3935
3926
  }>;
3927
+ internal?: {
3928
+ tables: Record<string, {
3929
+ columns: Record<string, {
3930
+ isArray?: boolean | undefined;
3931
+ dimensions?: number | undefined;
3932
+ rawType?: string | undefined;
3933
+ } | undefined>;
3934
+ } | undefined>;
3935
+ } | undefined;
3936
3936
  }>;
3937
3937
  export type Enum = TypeOf<typeof enumSchema>;
3938
3938
  export type Column = TypeOf<typeof column>;
@@ -3954,7 +3954,7 @@ export type PgSchemaV2 = TypeOf<typeof pgSchemaV2>;
3954
3954
  export type PgSchemaV3 = TypeOf<typeof pgSchemaV3>;
3955
3955
  export type PgSchemaV4 = TypeOf<typeof pgSchemaV4>;
3956
3956
  export type PgSchemaV5 = TypeOf<typeof pgSchemaV5>;
3957
- export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
3957
+ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
3958
3958
  version: import("zod").ZodLiteral<"5">;
3959
3959
  dialect: import("zod").ZodLiteral<"pg">;
3960
3960
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -3971,25 +3971,25 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
3971
3971
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
3972
3972
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
3973
3973
  }, "strict", import("zod").ZodTypeAny, {
3974
+ name: string;
3975
+ type: string;
3976
+ primaryKey: boolean;
3977
+ notNull: boolean;
3974
3978
  isUnique?: any;
3975
3979
  default?: any;
3976
3980
  typeSchema?: string | undefined;
3977
3981
  uniqueName?: string | undefined;
3978
3982
  nullsNotDistinct?: boolean | undefined;
3983
+ }, {
3979
3984
  name: string;
3980
3985
  type: string;
3981
3986
  primaryKey: boolean;
3982
3987
  notNull: boolean;
3983
- }, {
3984
3988
  isUnique?: any;
3985
3989
  default?: any;
3986
3990
  typeSchema?: string | undefined;
3987
3991
  uniqueName?: string | undefined;
3988
3992
  nullsNotDistinct?: boolean | undefined;
3989
- name: string;
3990
- type: string;
3991
- primaryKey: boolean;
3992
- notNull: boolean;
3993
3993
  }>>;
3994
3994
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3995
3995
  name: import("zod").ZodString;
@@ -4014,23 +4014,23 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4014
4014
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
4015
4015
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
4016
4016
  }, "strict", import("zod").ZodTypeAny, {
4017
- onUpdate?: string | undefined;
4018
- onDelete?: string | undefined;
4019
- schemaTo?: string | undefined;
4020
4017
  name: string;
4021
4018
  tableFrom: string;
4022
4019
  columnsFrom: string[];
4023
4020
  tableTo: string;
4024
4021
  columnsTo: string[];
4025
- }, {
4026
4022
  onUpdate?: string | undefined;
4027
4023
  onDelete?: string | undefined;
4028
4024
  schemaTo?: string | undefined;
4025
+ }, {
4029
4026
  name: string;
4030
4027
  tableFrom: string;
4031
4028
  columnsFrom: string[];
4032
4029
  tableTo: string;
4033
4030
  columnsTo: string[];
4031
+ onUpdate?: string | undefined;
4032
+ onDelete?: string | undefined;
4033
+ schemaTo?: string | undefined;
4034
4034
  }>>;
4035
4035
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4036
4036
  name: import("zod").ZodString;
@@ -4058,15 +4058,15 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4058
4058
  }, "strict", import("zod").ZodTypeAny, {
4059
4059
  name: string;
4060
4060
  columns: Record<string, {
4061
+ name: string;
4062
+ type: string;
4063
+ primaryKey: boolean;
4064
+ notNull: boolean;
4061
4065
  isUnique?: any;
4062
4066
  default?: any;
4063
4067
  typeSchema?: string | undefined;
4064
4068
  uniqueName?: string | undefined;
4065
4069
  nullsNotDistinct?: boolean | undefined;
4066
- name: string;
4067
- type: string;
4068
- primaryKey: boolean;
4069
- notNull: boolean;
4070
4070
  }>;
4071
4071
  indexes: Record<string, {
4072
4072
  name: string;
@@ -4074,14 +4074,14 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4074
4074
  isUnique: boolean;
4075
4075
  }>;
4076
4076
  foreignKeys: Record<string, {
4077
- onUpdate?: string | undefined;
4078
- onDelete?: string | undefined;
4079
- schemaTo?: string | undefined;
4080
4077
  name: string;
4081
4078
  tableFrom: string;
4082
4079
  columnsFrom: string[];
4083
4080
  tableTo: string;
4084
4081
  columnsTo: string[];
4082
+ onUpdate?: string | undefined;
4083
+ onDelete?: string | undefined;
4084
+ schemaTo?: string | undefined;
4085
4085
  }>;
4086
4086
  schema: string;
4087
4087
  compositePrimaryKeys: Record<string, {
@@ -4094,22 +4094,17 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4094
4094
  nullsNotDistinct: boolean;
4095
4095
  }>;
4096
4096
  }, {
4097
- uniqueConstraints?: Record<string, {
4098
- name: string;
4099
- columns: string[];
4100
- nullsNotDistinct: boolean;
4101
- }> | undefined;
4102
4097
  name: string;
4103
4098
  columns: Record<string, {
4099
+ name: string;
4100
+ type: string;
4101
+ primaryKey: boolean;
4102
+ notNull: boolean;
4104
4103
  isUnique?: any;
4105
4104
  default?: any;
4106
4105
  typeSchema?: string | undefined;
4107
4106
  uniqueName?: string | undefined;
4108
4107
  nullsNotDistinct?: boolean | undefined;
4109
- name: string;
4110
- type: string;
4111
- primaryKey: boolean;
4112
- notNull: boolean;
4113
4108
  }>;
4114
4109
  indexes: Record<string, {
4115
4110
  name: string;
@@ -4117,20 +4112,25 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4117
4112
  isUnique: boolean;
4118
4113
  }>;
4119
4114
  foreignKeys: Record<string, {
4120
- onUpdate?: string | undefined;
4121
- onDelete?: string | undefined;
4122
- schemaTo?: string | undefined;
4123
4115
  name: string;
4124
4116
  tableFrom: string;
4125
4117
  columnsFrom: string[];
4126
4118
  tableTo: string;
4127
4119
  columnsTo: string[];
4120
+ onUpdate?: string | undefined;
4121
+ onDelete?: string | undefined;
4122
+ schemaTo?: string | undefined;
4128
4123
  }>;
4129
4124
  schema: string;
4130
4125
  compositePrimaryKeys: Record<string, {
4131
4126
  name: string;
4132
4127
  columns: string[];
4133
4128
  }>;
4129
+ uniqueConstraints?: Record<string, {
4130
+ name: string;
4131
+ columns: string[];
4132
+ nullsNotDistinct: boolean;
4133
+ }> | undefined;
4134
4134
  }>>;
4135
4135
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4136
4136
  name: import("zod").ZodString;
@@ -4205,27 +4205,18 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4205
4205
  id: import("zod").ZodString;
4206
4206
  prevId: import("zod").ZodString;
4207
4207
  }>, "strip", import("zod").ZodTypeAny, {
4208
- internal?: {
4209
- tables: Record<string, {
4210
- columns: Record<string, {
4211
- isArray?: boolean | undefined;
4212
- dimensions?: number | undefined;
4213
- rawType?: string | undefined;
4214
- } | undefined>;
4215
- } | undefined>;
4216
- } | undefined;
4217
4208
  tables: Record<string, {
4218
4209
  name: string;
4219
4210
  columns: Record<string, {
4211
+ name: string;
4212
+ type: string;
4213
+ primaryKey: boolean;
4214
+ notNull: boolean;
4220
4215
  isUnique?: any;
4221
4216
  default?: any;
4222
4217
  typeSchema?: string | undefined;
4223
4218
  uniqueName?: string | undefined;
4224
4219
  nullsNotDistinct?: boolean | undefined;
4225
- name: string;
4226
- type: string;
4227
- primaryKey: boolean;
4228
- notNull: boolean;
4229
4220
  }>;
4230
4221
  indexes: Record<string, {
4231
4222
  name: string;
@@ -4233,14 +4224,14 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4233
4224
  isUnique: boolean;
4234
4225
  }>;
4235
4226
  foreignKeys: Record<string, {
4236
- onUpdate?: string | undefined;
4237
- onDelete?: string | undefined;
4238
- schemaTo?: string | undefined;
4239
4227
  name: string;
4240
4228
  tableFrom: string;
4241
4229
  columnsFrom: string[];
4242
4230
  tableTo: string;
4243
4231
  columnsTo: string[];
4232
+ onUpdate?: string | undefined;
4233
+ onDelete?: string | undefined;
4234
+ schemaTo?: string | undefined;
4244
4235
  }>;
4245
4236
  schema: string;
4246
4237
  compositePrimaryKeys: Record<string, {
@@ -4267,7 +4258,6 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4267
4258
  name: string;
4268
4259
  values: Record<string, string>;
4269
4260
  }>;
4270
- }, {
4271
4261
  internal?: {
4272
4262
  tables: Record<string, {
4273
4263
  columns: Record<string, {
@@ -4277,23 +4267,19 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4277
4267
  } | undefined>;
4278
4268
  } | undefined>;
4279
4269
  } | undefined;
4270
+ }, {
4280
4271
  tables: Record<string, {
4281
- uniqueConstraints?: Record<string, {
4282
- name: string;
4283
- columns: string[];
4284
- nullsNotDistinct: boolean;
4285
- }> | undefined;
4286
4272
  name: string;
4287
4273
  columns: Record<string, {
4274
+ name: string;
4275
+ type: string;
4276
+ primaryKey: boolean;
4277
+ notNull: boolean;
4288
4278
  isUnique?: any;
4289
4279
  default?: any;
4290
4280
  typeSchema?: string | undefined;
4291
4281
  uniqueName?: string | undefined;
4292
4282
  nullsNotDistinct?: boolean | undefined;
4293
- name: string;
4294
- type: string;
4295
- primaryKey: boolean;
4296
- notNull: boolean;
4297
4283
  }>;
4298
4284
  indexes: Record<string, {
4299
4285
  name: string;
@@ -4301,20 +4287,25 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4301
4287
  isUnique: boolean;
4302
4288
  }>;
4303
4289
  foreignKeys: Record<string, {
4304
- onUpdate?: string | undefined;
4305
- onDelete?: string | undefined;
4306
- schemaTo?: string | undefined;
4307
4290
  name: string;
4308
4291
  tableFrom: string;
4309
4292
  columnsFrom: string[];
4310
4293
  tableTo: string;
4311
4294
  columnsTo: string[];
4295
+ onUpdate?: string | undefined;
4296
+ onDelete?: string | undefined;
4297
+ schemaTo?: string | undefined;
4312
4298
  }>;
4313
4299
  schema: string;
4314
4300
  compositePrimaryKeys: Record<string, {
4315
4301
  name: string;
4316
4302
  columns: string[];
4317
4303
  }>;
4304
+ uniqueConstraints?: Record<string, {
4305
+ name: string;
4306
+ columns: string[];
4307
+ nullsNotDistinct: boolean;
4308
+ }> | undefined;
4318
4309
  }>;
4319
4310
  id: string;
4320
4311
  prevId: string;
@@ -4330,7 +4321,16 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4330
4321
  name: string;
4331
4322
  values: Record<string, string>;
4332
4323
  }>;
4333
- }>, import("zod").ZodObject<import("zod").extendShape<{
4324
+ internal?: {
4325
+ tables: Record<string, {
4326
+ columns: Record<string, {
4327
+ isArray?: boolean | undefined;
4328
+ dimensions?: number | undefined;
4329
+ rawType?: string | undefined;
4330
+ } | undefined>;
4331
+ } | undefined>;
4332
+ } | undefined;
4333
+ }>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
4334
4334
  version: import("zod").ZodLiteral<"6">;
4335
4335
  dialect: import("zod").ZodLiteral<"postgresql">;
4336
4336
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -4347,25 +4347,25 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4347
4347
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
4348
4348
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
4349
4349
  }, "strict", import("zod").ZodTypeAny, {
4350
+ name: string;
4351
+ type: string;
4352
+ primaryKey: boolean;
4353
+ notNull: boolean;
4350
4354
  isUnique?: any;
4351
4355
  default?: any;
4352
4356
  typeSchema?: string | undefined;
4353
4357
  uniqueName?: string | undefined;
4354
4358
  nullsNotDistinct?: boolean | undefined;
4359
+ }, {
4355
4360
  name: string;
4356
4361
  type: string;
4357
4362
  primaryKey: boolean;
4358
4363
  notNull: boolean;
4359
- }, {
4360
4364
  isUnique?: any;
4361
4365
  default?: any;
4362
4366
  typeSchema?: string | undefined;
4363
4367
  uniqueName?: string | undefined;
4364
4368
  nullsNotDistinct?: boolean | undefined;
4365
- name: string;
4366
- type: string;
4367
- primaryKey: boolean;
4368
- notNull: boolean;
4369
4369
  }>>;
4370
4370
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4371
4371
  name: import("zod").ZodString;
@@ -4390,23 +4390,23 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4390
4390
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
4391
4391
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
4392
4392
  }, "strict", import("zod").ZodTypeAny, {
4393
- onUpdate?: string | undefined;
4394
- onDelete?: string | undefined;
4395
- schemaTo?: string | undefined;
4396
4393
  name: string;
4397
4394
  tableFrom: string;
4398
4395
  columnsFrom: string[];
4399
4396
  tableTo: string;
4400
4397
  columnsTo: string[];
4401
- }, {
4402
4398
  onUpdate?: string | undefined;
4403
4399
  onDelete?: string | undefined;
4404
4400
  schemaTo?: string | undefined;
4401
+ }, {
4405
4402
  name: string;
4406
4403
  tableFrom: string;
4407
4404
  columnsFrom: string[];
4408
4405
  tableTo: string;
4409
4406
  columnsTo: string[];
4407
+ onUpdate?: string | undefined;
4408
+ onDelete?: string | undefined;
4409
+ schemaTo?: string | undefined;
4410
4410
  }>>;
4411
4411
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4412
4412
  name: import("zod").ZodString;
@@ -4434,15 +4434,15 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4434
4434
  }, "strict", import("zod").ZodTypeAny, {
4435
4435
  name: string;
4436
4436
  columns: Record<string, {
4437
+ name: string;
4438
+ type: string;
4439
+ primaryKey: boolean;
4440
+ notNull: boolean;
4437
4441
  isUnique?: any;
4438
4442
  default?: any;
4439
4443
  typeSchema?: string | undefined;
4440
4444
  uniqueName?: string | undefined;
4441
4445
  nullsNotDistinct?: boolean | undefined;
4442
- name: string;
4443
- type: string;
4444
- primaryKey: boolean;
4445
- notNull: boolean;
4446
4446
  }>;
4447
4447
  indexes: Record<string, {
4448
4448
  name: string;
@@ -4450,14 +4450,14 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4450
4450
  isUnique: boolean;
4451
4451
  }>;
4452
4452
  foreignKeys: Record<string, {
4453
- onUpdate?: string | undefined;
4454
- onDelete?: string | undefined;
4455
- schemaTo?: string | undefined;
4456
4453
  name: string;
4457
4454
  tableFrom: string;
4458
4455
  columnsFrom: string[];
4459
4456
  tableTo: string;
4460
4457
  columnsTo: string[];
4458
+ onUpdate?: string | undefined;
4459
+ onDelete?: string | undefined;
4460
+ schemaTo?: string | undefined;
4461
4461
  }>;
4462
4462
  schema: string;
4463
4463
  compositePrimaryKeys: Record<string, {
@@ -4470,22 +4470,17 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4470
4470
  nullsNotDistinct: boolean;
4471
4471
  }>;
4472
4472
  }, {
4473
- uniqueConstraints?: Record<string, {
4474
- name: string;
4475
- columns: string[];
4476
- nullsNotDistinct: boolean;
4477
- }> | undefined;
4478
4473
  name: string;
4479
4474
  columns: Record<string, {
4475
+ name: string;
4476
+ type: string;
4477
+ primaryKey: boolean;
4478
+ notNull: boolean;
4480
4479
  isUnique?: any;
4481
4480
  default?: any;
4482
4481
  typeSchema?: string | undefined;
4483
4482
  uniqueName?: string | undefined;
4484
4483
  nullsNotDistinct?: boolean | undefined;
4485
- name: string;
4486
- type: string;
4487
- primaryKey: boolean;
4488
- notNull: boolean;
4489
4484
  }>;
4490
4485
  indexes: Record<string, {
4491
4486
  name: string;
@@ -4493,20 +4488,25 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4493
4488
  isUnique: boolean;
4494
4489
  }>;
4495
4490
  foreignKeys: Record<string, {
4496
- onUpdate?: string | undefined;
4497
- onDelete?: string | undefined;
4498
- schemaTo?: string | undefined;
4499
4491
  name: string;
4500
4492
  tableFrom: string;
4501
4493
  columnsFrom: string[];
4502
4494
  tableTo: string;
4503
4495
  columnsTo: string[];
4496
+ onUpdate?: string | undefined;
4497
+ onDelete?: string | undefined;
4498
+ schemaTo?: string | undefined;
4504
4499
  }>;
4505
4500
  schema: string;
4506
4501
  compositePrimaryKeys: Record<string, {
4507
4502
  name: string;
4508
4503
  columns: string[];
4509
4504
  }>;
4505
+ uniqueConstraints?: Record<string, {
4506
+ name: string;
4507
+ columns: string[];
4508
+ nullsNotDistinct: boolean;
4509
+ }> | undefined;
4510
4510
  }>>;
4511
4511
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4512
4512
  name: import("zod").ZodString;
@@ -4584,27 +4584,18 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4584
4584
  id: import("zod").ZodString;
4585
4585
  prevId: import("zod").ZodString;
4586
4586
  }>, "strip", import("zod").ZodTypeAny, {
4587
- internal?: {
4588
- tables: Record<string, {
4589
- columns: Record<string, {
4590
- isArray?: boolean | undefined;
4591
- dimensions?: number | undefined;
4592
- rawType?: string | undefined;
4593
- } | undefined>;
4594
- } | undefined>;
4595
- } | undefined;
4596
4587
  tables: Record<string, {
4597
4588
  name: string;
4598
4589
  columns: Record<string, {
4590
+ name: string;
4591
+ type: string;
4592
+ primaryKey: boolean;
4593
+ notNull: boolean;
4599
4594
  isUnique?: any;
4600
4595
  default?: any;
4601
4596
  typeSchema?: string | undefined;
4602
4597
  uniqueName?: string | undefined;
4603
4598
  nullsNotDistinct?: boolean | undefined;
4604
- name: string;
4605
- type: string;
4606
- primaryKey: boolean;
4607
- notNull: boolean;
4608
4599
  }>;
4609
4600
  indexes: Record<string, {
4610
4601
  name: string;
@@ -4612,14 +4603,14 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4612
4603
  isUnique: boolean;
4613
4604
  }>;
4614
4605
  foreignKeys: Record<string, {
4615
- onUpdate?: string | undefined;
4616
- onDelete?: string | undefined;
4617
- schemaTo?: string | undefined;
4618
4606
  name: string;
4619
4607
  tableFrom: string;
4620
4608
  columnsFrom: string[];
4621
4609
  tableTo: string;
4622
4610
  columnsTo: string[];
4611
+ onUpdate?: string | undefined;
4612
+ onDelete?: string | undefined;
4613
+ schemaTo?: string | undefined;
4623
4614
  }>;
4624
4615
  schema: string;
4625
4616
  compositePrimaryKeys: Record<string, {
@@ -4647,7 +4638,6 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4647
4638
  values: string[];
4648
4639
  schema: string;
4649
4640
  }>;
4650
- }, {
4651
4641
  internal?: {
4652
4642
  tables: Record<string, {
4653
4643
  columns: Record<string, {
@@ -4657,23 +4647,19 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4657
4647
  } | undefined>;
4658
4648
  } | undefined>;
4659
4649
  } | undefined;
4650
+ }, {
4660
4651
  tables: Record<string, {
4661
- uniqueConstraints?: Record<string, {
4662
- name: string;
4663
- columns: string[];
4664
- nullsNotDistinct: boolean;
4665
- }> | undefined;
4666
4652
  name: string;
4667
4653
  columns: Record<string, {
4654
+ name: string;
4655
+ type: string;
4656
+ primaryKey: boolean;
4657
+ notNull: boolean;
4668
4658
  isUnique?: any;
4669
4659
  default?: any;
4670
4660
  typeSchema?: string | undefined;
4671
4661
  uniqueName?: string | undefined;
4672
4662
  nullsNotDistinct?: boolean | undefined;
4673
- name: string;
4674
- type: string;
4675
- primaryKey: boolean;
4676
- notNull: boolean;
4677
4663
  }>;
4678
4664
  indexes: Record<string, {
4679
4665
  name: string;
@@ -4681,20 +4667,25 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4681
4667
  isUnique: boolean;
4682
4668
  }>;
4683
4669
  foreignKeys: Record<string, {
4684
- onUpdate?: string | undefined;
4685
- onDelete?: string | undefined;
4686
- schemaTo?: string | undefined;
4687
4670
  name: string;
4688
4671
  tableFrom: string;
4689
4672
  columnsFrom: string[];
4690
4673
  tableTo: string;
4691
4674
  columnsTo: string[];
4675
+ onUpdate?: string | undefined;
4676
+ onDelete?: string | undefined;
4677
+ schemaTo?: string | undefined;
4692
4678
  }>;
4693
4679
  schema: string;
4694
4680
  compositePrimaryKeys: Record<string, {
4695
4681
  name: string;
4696
4682
  columns: string[];
4697
4683
  }>;
4684
+ uniqueConstraints?: Record<string, {
4685
+ name: string;
4686
+ columns: string[];
4687
+ nullsNotDistinct: boolean;
4688
+ }> | undefined;
4698
4689
  }>;
4699
4690
  id: string;
4700
4691
  prevId: string;
@@ -4711,6 +4702,15 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4711
4702
  values: string[];
4712
4703
  schema: string;
4713
4704
  }>;
4705
+ internal?: {
4706
+ tables: Record<string, {
4707
+ columns: Record<string, {
4708
+ isArray?: boolean | undefined;
4709
+ dimensions?: number | undefined;
4710
+ rawType?: string | undefined;
4711
+ } | undefined>;
4712
+ } | undefined>;
4713
+ } | undefined;
4714
4714
  }>]>;
4715
4715
  export declare const PgSquasher: {
4716
4716
  squashIdx: (idx: Index) => string;
@@ -4725,27 +4725,18 @@ export declare const PgSquasher: {
4725
4725
  export declare const squashPgSchemeV4: (json: PgSchemaV4) => PgSchemaSquashedV4;
4726
4726
  export declare const squashPgScheme: (json: PgSchema) => PgSchemaSquashed;
4727
4727
  export declare const dryPg: {
4728
- internal?: {
4729
- tables: Record<string, {
4730
- columns: Record<string, {
4731
- isArray?: boolean | undefined;
4732
- dimensions?: number | undefined;
4733
- rawType?: string | undefined;
4734
- } | undefined>;
4735
- } | undefined>;
4736
- } | undefined;
4737
4728
  tables: Record<string, {
4738
4729
  name: string;
4739
4730
  columns: Record<string, {
4731
+ name: string;
4732
+ type: string;
4733
+ primaryKey: boolean;
4734
+ notNull: boolean;
4740
4735
  isUnique?: any;
4741
4736
  default?: any;
4742
4737
  typeSchema?: string | undefined;
4743
4738
  uniqueName?: string | undefined;
4744
4739
  nullsNotDistinct?: boolean | undefined;
4745
- name: string;
4746
- type: string;
4747
- primaryKey: boolean;
4748
- notNull: boolean;
4749
4740
  }>;
4750
4741
  indexes: Record<string, {
4751
4742
  name: string;
@@ -4753,14 +4744,14 @@ export declare const dryPg: {
4753
4744
  isUnique: boolean;
4754
4745
  }>;
4755
4746
  foreignKeys: Record<string, {
4756
- onUpdate?: string | undefined;
4757
- onDelete?: string | undefined;
4758
- schemaTo?: string | undefined;
4759
4747
  name: string;
4760
4748
  tableFrom: string;
4761
4749
  columnsFrom: string[];
4762
4750
  tableTo: string;
4763
4751
  columnsTo: string[];
4752
+ onUpdate?: string | undefined;
4753
+ onDelete?: string | undefined;
4754
+ schemaTo?: string | undefined;
4764
4755
  }>;
4765
4756
  schema: string;
4766
4757
  compositePrimaryKeys: Record<string, {
@@ -4788,5 +4779,14 @@ export declare const dryPg: {
4788
4779
  values: string[];
4789
4780
  schema: string;
4790
4781
  }>;
4782
+ internal?: {
4783
+ tables: Record<string, {
4784
+ columns: Record<string, {
4785
+ isArray?: boolean | undefined;
4786
+ dimensions?: number | undefined;
4787
+ rawType?: string | undefined;
4788
+ } | undefined>;
4789
+ } | undefined>;
4790
+ } | undefined;
4791
4791
  };
4792
4792
  export {};