drizzle-kit 0.20.17-a2979a1 → 0.20.17-b08243d

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (26) hide show
  1. package/bin.cjs +25462 -26322
  2. package/cli/commands/migrate.d.ts +41 -41
  3. package/cli/commands/mysqlIntrospect.d.ts +8 -8
  4. package/cli/commands/pgIntrospect.d.ts +8 -8
  5. package/cli/commands/sqliteIntrospect.d.ts +12 -12
  6. package/cli/commands/utils.d.ts +2 -2
  7. package/cli/validations/cli.d.ts +29 -29
  8. package/cli/validations/common.d.ts +35 -35
  9. package/cli/validations/mysql.d.ts +4 -4
  10. package/cli/validations/outputs.d.ts +1 -2
  11. package/cli/validations/pg.d.ts +4 -4
  12. package/index.d.mts +2 -48
  13. package/index.d.ts +2 -48
  14. package/package.json +1 -1
  15. package/payload.js +476 -1080
  16. package/payload.mjs +283 -887
  17. package/schemaValidator.d.ts +222 -222
  18. package/serializer/mysqlSchema.d.ts +890 -890
  19. package/serializer/pgSchema.d.ts +745 -745
  20. package/serializer/sqliteSchema.d.ts +457 -457
  21. package/serializer/studio.d.ts +1 -1
  22. package/snapshotsDiffer.d.ts +315 -316
  23. package/utils-studio.js +841 -947
  24. package/utils-studio.mjs +814 -920
  25. package/utils.js +219 -844
  26. package/utils.mjs +194 -819
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;
27
29
  name: string;
28
30
  type: string;
29
31
  primaryKey: boolean;
30
32
  notNull: boolean;
33
+ }, {
31
34
  default?: any;
32
35
  references?: string | undefined;
33
- }, {
34
36
  name: string;
35
37
  type: string;
36
38
  primaryKey: boolean;
37
39
  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;
67
69
  name: string;
68
70
  type: string;
69
71
  primaryKey: boolean;
70
72
  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;
84
86
  name: string;
85
87
  type: string;
86
88
  primaryKey: boolean;
87
89
  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;
113
115
  name: string;
114
116
  type: string;
115
117
  primaryKey: boolean;
116
118
  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;
137
139
  name: string;
138
140
  type: string;
139
141
  primaryKey: boolean;
140
142
  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;
175
177
  foreignKeyName: string;
176
178
  table: string;
177
179
  column: string;
180
+ }, {
178
181
  onUpdate?: string | undefined;
179
182
  onDelete?: string | undefined;
180
- }, {
181
183
  foreignKeyName: string;
182
184
  table: string;
183
185
  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;
192
188
  default?: any;
193
189
  references?: {
190
+ onUpdate?: string | undefined;
191
+ onDelete?: string | undefined;
194
192
  foreignKeyName: string;
195
193
  table: string;
196
194
  column: string;
197
- onUpdate?: string | undefined;
198
- onDelete?: string | undefined;
199
195
  } | undefined;
200
- }, {
201
196
  name: string;
202
197
  type: string;
203
198
  primaryKey: boolean;
204
199
  notNull: boolean;
200
+ }, {
205
201
  default?: any;
206
202
  references?: {
203
+ onUpdate?: string | undefined;
204
+ onDelete?: string | undefined;
207
205
  foreignKeyName: string;
208
206
  table: string;
209
207
  column: string;
210
- onUpdate?: string | undefined;
211
- onDelete?: string | undefined;
212
208
  } | 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;
244
240
  default?: any;
245
241
  references?: {
242
+ onUpdate?: string | undefined;
243
+ onDelete?: string | undefined;
246
244
  foreignKeyName: string;
247
245
  table: string;
248
246
  column: string;
249
- onUpdate?: string | undefined;
250
- onDelete?: string | undefined;
251
247
  } | 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;
267
263
  default?: any;
268
264
  references?: {
265
+ onUpdate?: string | undefined;
266
+ onDelete?: string | undefined;
269
267
  foreignKeyName: string;
270
268
  table: string;
271
269
  column: string;
272
- onUpdate?: string | undefined;
273
- onDelete?: string | undefined;
274
270
  } | 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;
302
298
  default?: any;
303
299
  references?: {
300
+ onUpdate?: string | undefined;
301
+ onDelete?: string | undefined;
304
302
  foreignKeyName: string;
305
303
  table: string;
306
304
  column: string;
307
- onUpdate?: string | undefined;
308
- onDelete?: string | undefined;
309
305
  } | 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;
332
328
  default?: any;
333
329
  references?: {
330
+ onUpdate?: string | undefined;
331
+ onDelete?: string | undefined;
334
332
  foreignKeyName: string;
335
333
  table: string;
336
334
  column: string;
337
- onUpdate?: string | undefined;
338
- onDelete?: string | undefined;
339
335
  } | 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;
378
381
  name: string;
379
382
  tableFrom: string;
380
383
  columnsFrom: string[];
381
384
  tableTo: string;
382
385
  columnsTo: string[];
386
+ }, {
383
387
  onUpdate?: string | undefined;
384
388
  onDelete?: string | undefined;
385
389
  schemaTo?: string | undefined;
386
- }, {
387
390
  name: string;
388
391
  tableFrom: string;
389
392
  columnsFrom: string[];
390
393
  tableTo: string;
391
394
  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;
411
407
  isUnique?: any;
412
408
  default?: any;
413
409
  typeSchema?: string | undefined;
414
410
  uniqueName?: string | undefined;
415
411
  nullsNotDistinct?: boolean | undefined;
416
- }, {
417
412
  name: string;
418
413
  type: string;
419
414
  primaryKey: boolean;
420
415
  notNull: boolean;
416
+ }, {
421
417
  isUnique?: any;
422
418
  default?: any;
423
419
  typeSchema?: string | undefined;
424
420
  uniqueName?: string | undefined;
425
421
  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;
444
440
  isUnique?: any;
445
441
  default?: any;
446
442
  typeSchema?: string | undefined;
447
443
  uniqueName?: string | undefined;
448
444
  nullsNotDistinct?: boolean | undefined;
449
- }, {
450
445
  name: string;
451
446
  type: string;
452
447
  primaryKey: boolean;
453
448
  notNull: boolean;
449
+ }, {
454
450
  isUnique?: any;
455
451
  default?: any;
456
452
  typeSchema?: string | undefined;
457
453
  uniqueName?: string | undefined;
458
454
  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;
483
486
  name: string;
484
487
  tableFrom: string;
485
488
  columnsFrom: string[];
486
489
  tableTo: string;
487
490
  columnsTo: string[];
491
+ }, {
488
492
  onUpdate?: string | undefined;
489
493
  onDelete?: string | undefined;
490
494
  schemaTo?: string | undefined;
491
- }, {
492
495
  name: string;
493
496
  tableFrom: string;
494
497
  columnsFrom: string[];
495
498
  tableTo: string;
496
499
  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;
508
504
  isUnique?: any;
509
505
  default?: any;
510
506
  typeSchema?: string | undefined;
511
507
  uniqueName?: string | undefined;
512
508
  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;
520
523
  name: string;
521
524
  tableFrom: string;
522
525
  columnsFrom: string[];
523
526
  tableTo: string;
524
527
  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;
536
532
  isUnique?: any;
537
533
  default?: any;
538
534
  typeSchema?: string | undefined;
539
535
  uniqueName?: string | undefined;
540
536
  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;
548
551
  name: string;
549
552
  tableFrom: string;
550
553
  columnsFrom: string[];
551
554
  tableTo: string;
552
555
  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;
599
595
  isUnique?: any;
600
596
  default?: any;
601
597
  typeSchema?: string | undefined;
602
598
  uniqueName?: string | undefined;
603
599
  nullsNotDistinct?: boolean | undefined;
604
- }, {
605
600
  name: string;
606
601
  type: string;
607
602
  primaryKey: boolean;
608
603
  notNull: boolean;
604
+ }, {
609
605
  isUnique?: any;
610
606
  default?: any;
611
607
  typeSchema?: string | undefined;
612
608
  uniqueName?: string | undefined;
613
609
  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;
638
641
  name: string;
639
642
  tableFrom: string;
640
643
  columnsFrom: string[];
641
644
  tableTo: string;
642
645
  columnsTo: string[];
646
+ }, {
643
647
  onUpdate?: string | undefined;
644
648
  onDelete?: string | undefined;
645
649
  schemaTo?: string | undefined;
646
- }, {
647
650
  name: string;
648
651
  tableFrom: string;
649
652
  columnsFrom: string[];
650
653
  tableTo: string;
651
654
  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;
663
659
  isUnique?: any;
664
660
  default?: any;
665
661
  typeSchema?: string | undefined;
666
662
  uniqueName?: string | undefined;
667
663
  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;
675
678
  name: string;
676
679
  tableFrom: string;
677
680
  columnsFrom: string[];
678
681
  tableTo: string;
679
682
  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;
692
688
  isUnique?: any;
693
689
  default?: any;
694
690
  typeSchema?: string | undefined;
695
691
  uniqueName?: string | undefined;
696
692
  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;
704
707
  name: string;
705
708
  tableFrom: string;
706
709
  columnsFrom: string[];
707
710
  tableTo: string;
708
711
  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;
733
729
  isUnique?: any;
734
730
  default?: any;
735
731
  typeSchema?: string | undefined;
736
732
  uniqueName?: string | undefined;
737
733
  nullsNotDistinct?: boolean | undefined;
738
- }, {
739
734
  name: string;
740
735
  type: string;
741
736
  primaryKey: boolean;
742
737
  notNull: boolean;
738
+ }, {
743
739
  isUnique?: any;
744
740
  default?: any;
745
741
  typeSchema?: string | undefined;
746
742
  uniqueName?: string | undefined;
747
743
  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;
772
775
  name: string;
773
776
  tableFrom: string;
774
777
  columnsFrom: string[];
775
778
  tableTo: string;
776
779
  columnsTo: string[];
780
+ }, {
777
781
  onUpdate?: string | undefined;
778
782
  onDelete?: string | undefined;
779
783
  schemaTo?: string | undefined;
780
- }, {
781
784
  name: string;
782
785
  tableFrom: string;
783
786
  columnsFrom: string[];
784
787
  tableTo: string;
785
788
  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;
820
816
  isUnique?: any;
821
817
  default?: any;
822
818
  typeSchema?: string | undefined;
823
819
  uniqueName?: string | undefined;
824
820
  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;
832
835
  name: string;
833
836
  tableFrom: string;
834
837
  columnsFrom: string[];
835
838
  tableTo: string;
836
839
  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,17 +849,22 @@ 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;
852
857
  name: string;
853
858
  columns: Record<string, {
854
- name: string;
855
- type: string;
856
- primaryKey: boolean;
857
- notNull: boolean;
858
859
  isUnique?: any;
859
860
  default?: any;
860
861
  typeSchema?: string | undefined;
861
862
  uniqueName?: string | undefined;
862
863
  nullsNotDistinct?: boolean | undefined;
864
+ name: string;
865
+ type: string;
866
+ primaryKey: boolean;
867
+ notNull: boolean;
863
868
  }>;
864
869
  indexes: Record<string, {
865
870
  name: string;
@@ -867,25 +872,20 @@ declare const table: import("zod").ZodObject<{
867
872
  isUnique: boolean;
868
873
  }>;
869
874
  foreignKeys: Record<string, {
875
+ onUpdate?: string | undefined;
876
+ onDelete?: string | undefined;
877
+ schemaTo?: string | undefined;
870
878
  name: string;
871
879
  tableFrom: string;
872
880
  columnsFrom: string[];
873
881
  tableTo: string;
874
882
  columnsTo: string[];
875
- onUpdate?: string | undefined;
876
- onDelete?: string | undefined;
877
- schemaTo?: string | undefined;
878
883
  }>;
879
884
  schema: string;
880
885
  compositePrimaryKeys: Record<string, {
881
886
  name: string;
882
887
  columns: string[];
883
888
  }>;
884
- uniqueConstraints?: Record<string, {
885
- name: string;
886
- columns: string[];
887
- nullsNotDistinct: boolean;
888
- }> | undefined;
889
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<{
@@ -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;
955
951
  isUnique?: any;
956
952
  default?: any;
957
953
  typeSchema?: string | undefined;
958
954
  uniqueName?: string | undefined;
959
955
  nullsNotDistinct?: boolean | undefined;
960
- }, {
961
956
  name: string;
962
957
  type: string;
963
958
  primaryKey: boolean;
964
959
  notNull: boolean;
960
+ }, {
965
961
  isUnique?: any;
966
962
  default?: any;
967
963
  typeSchema?: string | undefined;
968
964
  uniqueName?: string | undefined;
969
965
  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;
994
997
  name: string;
995
998
  tableFrom: string;
996
999
  columnsFrom: string[];
997
1000
  tableTo: string;
998
1001
  columnsTo: string[];
1002
+ }, {
999
1003
  onUpdate?: string | undefined;
1000
1004
  onDelete?: string | undefined;
1001
1005
  schemaTo?: string | undefined;
1002
- }, {
1003
1006
  name: string;
1004
1007
  tableFrom: string;
1005
1008
  columnsFrom: string[];
1006
1009
  tableTo: string;
1007
1010
  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;
1019
1015
  isUnique?: any;
1020
1016
  default?: any;
1021
1017
  typeSchema?: string | undefined;
1022
1018
  uniqueName?: string | undefined;
1023
1019
  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;
1031
1034
  name: string;
1032
1035
  tableFrom: string;
1033
1036
  columnsFrom: string[];
1034
1037
  tableTo: string;
1035
1038
  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;
1047
1043
  isUnique?: any;
1048
1044
  default?: any;
1049
1045
  typeSchema?: string | undefined;
1050
1046
  uniqueName?: string | undefined;
1051
1047
  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;
1059
1062
  name: string;
1060
1063
  tableFrom: string;
1061
1064
  columnsFrom: string[];
1062
1065
  tableTo: string;
1063
1066
  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;
1087
1083
  isUnique?: any;
1088
1084
  default?: any;
1089
1085
  typeSchema?: string | undefined;
1090
1086
  uniqueName?: string | undefined;
1091
1087
  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;
1099
1102
  name: string;
1100
1103
  tableFrom: string;
1101
1104
  columnsFrom: string[];
1102
1105
  tableTo: string;
1103
1106
  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;
1123
1119
  isUnique?: any;
1124
1120
  default?: any;
1125
1121
  typeSchema?: string | undefined;
1126
1122
  uniqueName?: string | undefined;
1127
1123
  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;
1135
1138
  name: string;
1136
1139
  tableFrom: string;
1137
1140
  columnsFrom: string[];
1138
1141
  tableTo: string;
1139
1142
  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;
1173
1169
  isUnique?: any;
1174
1170
  default?: any;
1175
1171
  typeSchema?: string | undefined;
1176
1172
  uniqueName?: string | undefined;
1177
1173
  nullsNotDistinct?: boolean | undefined;
1178
- }, {
1179
1174
  name: string;
1180
1175
  type: string;
1181
1176
  primaryKey: boolean;
1182
1177
  notNull: boolean;
1178
+ }, {
1183
1179
  isUnique?: any;
1184
1180
  default?: any;
1185
1181
  typeSchema?: string | undefined;
1186
1182
  uniqueName?: string | undefined;
1187
1183
  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;
1212
1215
  name: string;
1213
1216
  tableFrom: string;
1214
1217
  columnsFrom: string[];
1215
1218
  tableTo: string;
1216
1219
  columnsTo: string[];
1220
+ }, {
1217
1221
  onUpdate?: string | undefined;
1218
1222
  onDelete?: string | undefined;
1219
1223
  schemaTo?: string | undefined;
1220
- }, {
1221
1224
  name: string;
1222
1225
  tableFrom: string;
1223
1226
  columnsFrom: string[];
1224
1227
  tableTo: string;
1225
1228
  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;
1237
1233
  isUnique?: any;
1238
1234
  default?: any;
1239
1235
  typeSchema?: string | undefined;
1240
1236
  uniqueName?: string | undefined;
1241
1237
  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;
1249
1252
  name: string;
1250
1253
  tableFrom: string;
1251
1254
  columnsFrom: string[];
1252
1255
  tableTo: string;
1253
1256
  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;
1266
1262
  isUnique?: any;
1267
1263
  default?: any;
1268
1264
  typeSchema?: string | undefined;
1269
1265
  uniqueName?: string | undefined;
1270
1266
  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;
1278
1281
  name: string;
1279
1282
  tableFrom: string;
1280
1283
  columnsFrom: string[];
1281
1284
  tableTo: string;
1282
1285
  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;
1308
1304
  isUnique?: any;
1309
1305
  default?: any;
1310
1306
  typeSchema?: string | undefined;
1311
1307
  uniqueName?: string | undefined;
1312
1308
  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;
1320
1323
  name: string;
1321
1324
  tableFrom: string;
1322
1325
  columnsFrom: string[];
1323
1326
  tableTo: string;
1324
1327
  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;
1346
1342
  isUnique?: any;
1347
1343
  default?: any;
1348
1344
  typeSchema?: string | undefined;
1349
1345
  uniqueName?: string | undefined;
1350
1346
  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;
1358
1361
  name: string;
1359
1362
  tableFrom: string;
1360
1363
  columnsFrom: string[];
1361
1364
  tableTo: string;
1362
1365
  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;
1398
1394
  isUnique?: any;
1399
1395
  default?: any;
1400
1396
  typeSchema?: string | undefined;
1401
1397
  uniqueName?: string | undefined;
1402
1398
  nullsNotDistinct?: boolean | undefined;
1403
- }, {
1404
1399
  name: string;
1405
1400
  type: string;
1406
1401
  primaryKey: boolean;
1407
1402
  notNull: boolean;
1403
+ }, {
1408
1404
  isUnique?: any;
1409
1405
  default?: any;
1410
1406
  typeSchema?: string | undefined;
1411
1407
  uniqueName?: string | undefined;
1412
1408
  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;
1437
1440
  name: string;
1438
1441
  tableFrom: string;
1439
1442
  columnsFrom: string[];
1440
1443
  tableTo: string;
1441
1444
  columnsTo: string[];
1445
+ }, {
1442
1446
  onUpdate?: string | undefined;
1443
1447
  onDelete?: string | undefined;
1444
1448
  schemaTo?: string | undefined;
1445
- }, {
1446
1449
  name: string;
1447
1450
  tableFrom: string;
1448
1451
  columnsFrom: string[];
1449
1452
  tableTo: string;
1450
1453
  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;
1485
1481
  isUnique?: any;
1486
1482
  default?: any;
1487
1483
  typeSchema?: string | undefined;
1488
1484
  uniqueName?: string | undefined;
1489
1485
  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;
1497
1500
  name: string;
1498
1501
  tableFrom: string;
1499
1502
  columnsFrom: string[];
1500
1503
  tableTo: string;
1501
1504
  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,17 +1514,22 @@ 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;
1517
1522
  name: string;
1518
1523
  columns: Record<string, {
1519
- name: string;
1520
- type: string;
1521
- primaryKey: boolean;
1522
- notNull: boolean;
1523
1524
  isUnique?: any;
1524
1525
  default?: any;
1525
1526
  typeSchema?: string | undefined;
1526
1527
  uniqueName?: string | undefined;
1527
1528
  nullsNotDistinct?: boolean | undefined;
1529
+ name: string;
1530
+ type: string;
1531
+ primaryKey: boolean;
1532
+ notNull: boolean;
1528
1533
  }>;
1529
1534
  indexes: Record<string, {
1530
1535
  name: string;
@@ -1532,25 +1537,20 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1532
1537
  isUnique: boolean;
1533
1538
  }>;
1534
1539
  foreignKeys: Record<string, {
1540
+ onUpdate?: string | undefined;
1541
+ onDelete?: string | undefined;
1542
+ schemaTo?: string | undefined;
1535
1543
  name: string;
1536
1544
  tableFrom: string;
1537
1545
  columnsFrom: string[];
1538
1546
  tableTo: string;
1539
1547
  columnsTo: string[];
1540
- onUpdate?: string | undefined;
1541
- onDelete?: string | undefined;
1542
- schemaTo?: string | undefined;
1543
1548
  }>;
1544
1549
  schema: string;
1545
1550
  compositePrimaryKeys: Record<string, {
1546
1551
  name: string;
1547
1552
  columns: string[];
1548
1553
  }>;
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,18 +1622,27 @@ 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;
1625
1634
  tables: Record<string, {
1626
1635
  name: string;
1627
1636
  columns: Record<string, {
1628
- name: string;
1629
- type: string;
1630
- primaryKey: boolean;
1631
- notNull: boolean;
1632
1637
  isUnique?: any;
1633
1638
  default?: any;
1634
1639
  typeSchema?: string | undefined;
1635
1640
  uniqueName?: string | undefined;
1636
1641
  nullsNotDistinct?: boolean | undefined;
1642
+ name: string;
1643
+ type: string;
1644
+ primaryKey: boolean;
1645
+ notNull: boolean;
1637
1646
  }>;
1638
1647
  indexes: Record<string, {
1639
1648
  name: string;
@@ -1641,14 +1650,14 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1641
1650
  isUnique: boolean;
1642
1651
  }>;
1643
1652
  foreignKeys: Record<string, {
1653
+ onUpdate?: string | undefined;
1654
+ onDelete?: string | undefined;
1655
+ schemaTo?: string | undefined;
1644
1656
  name: string;
1645
1657
  tableFrom: string;
1646
1658
  columnsFrom: string[];
1647
1659
  tableTo: string;
1648
1660
  columnsTo: string[];
1649
- onUpdate?: string | undefined;
1650
- onDelete?: string | undefined;
1651
- schemaTo?: string | undefined;
1652
1661
  }>;
1653
1662
  schema: string;
1654
1663
  compositePrimaryKeys: Record<string, {
@@ -1673,6 +1682,7 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1673
1682
  name: string;
1674
1683
  values: Record<string, string>;
1675
1684
  }>;
1685
+ }, {
1676
1686
  internal?: {
1677
1687
  tables: Record<string, {
1678
1688
  columns: Record<string, {
@@ -1682,19 +1692,23 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1682
1692
  } | undefined>;
1683
1693
  } | undefined>;
1684
1694
  } | undefined;
1685
- }, {
1686
1695
  tables: Record<string, {
1696
+ uniqueConstraints?: Record<string, {
1697
+ name: string;
1698
+ columns: string[];
1699
+ nullsNotDistinct: boolean;
1700
+ }> | undefined;
1687
1701
  name: string;
1688
1702
  columns: Record<string, {
1689
- name: string;
1690
- type: string;
1691
- primaryKey: boolean;
1692
- notNull: boolean;
1693
1703
  isUnique?: any;
1694
1704
  default?: any;
1695
1705
  typeSchema?: string | undefined;
1696
1706
  uniqueName?: string | undefined;
1697
1707
  nullsNotDistinct?: boolean | undefined;
1708
+ name: string;
1709
+ type: string;
1710
+ primaryKey: boolean;
1711
+ notNull: boolean;
1698
1712
  }>;
1699
1713
  indexes: Record<string, {
1700
1714
  name: string;
@@ -1702,25 +1716,20 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1702
1716
  isUnique: boolean;
1703
1717
  }>;
1704
1718
  foreignKeys: Record<string, {
1719
+ onUpdate?: string | undefined;
1720
+ onDelete?: string | undefined;
1721
+ schemaTo?: string | undefined;
1705
1722
  name: string;
1706
1723
  tableFrom: string;
1707
1724
  columnsFrom: string[];
1708
1725
  tableTo: string;
1709
1726
  columnsTo: string[];
1710
- onUpdate?: string | undefined;
1711
- onDelete?: string | undefined;
1712
- schemaTo?: string | undefined;
1713
1727
  }>;
1714
1728
  schema: string;
1715
1729
  compositePrimaryKeys: Record<string, {
1716
1730
  name: string;
1717
1731
  columns: string[];
1718
1732
  }>;
1719
- uniqueConstraints?: Record<string, {
1720
- name: string;
1721
- columns: string[];
1722
- nullsNotDistinct: boolean;
1723
- }> | undefined;
1724
1733
  }>;
1725
1734
  version: "5";
1726
1735
  dialect: "pg";
@@ -1734,15 +1743,6 @@ export declare const pgSchemaInternalV5: import("zod").ZodObject<{
1734
1743
  name: string;
1735
1744
  values: Record<string, string>;
1736
1745
  }>;
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;
1768
1764
  isUnique?: any;
1769
1765
  default?: any;
1770
1766
  typeSchema?: string | undefined;
1771
1767
  uniqueName?: string | undefined;
1772
1768
  nullsNotDistinct?: boolean | undefined;
1773
- }, {
1774
1769
  name: string;
1775
1770
  type: string;
1776
1771
  primaryKey: boolean;
1777
1772
  notNull: boolean;
1773
+ }, {
1778
1774
  isUnique?: any;
1779
1775
  default?: any;
1780
1776
  typeSchema?: string | undefined;
1781
1777
  uniqueName?: string | undefined;
1782
1778
  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;
1807
1810
  name: string;
1808
1811
  tableFrom: string;
1809
1812
  columnsFrom: string[];
1810
1813
  tableTo: string;
1811
1814
  columnsTo: string[];
1815
+ }, {
1812
1816
  onUpdate?: string | undefined;
1813
1817
  onDelete?: string | undefined;
1814
1818
  schemaTo?: string | undefined;
1815
- }, {
1816
1819
  name: string;
1817
1820
  tableFrom: string;
1818
1821
  columnsFrom: string[];
1819
1822
  tableTo: string;
1820
1823
  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;
1855
1851
  isUnique?: any;
1856
1852
  default?: any;
1857
1853
  typeSchema?: string | undefined;
1858
1854
  uniqueName?: string | undefined;
1859
1855
  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;
1867
1870
  name: string;
1868
1871
  tableFrom: string;
1869
1872
  columnsFrom: string[];
1870
1873
  tableTo: string;
1871
1874
  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,17 +1884,22 @@ 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;
1887
1892
  name: string;
1888
1893
  columns: Record<string, {
1889
- name: string;
1890
- type: string;
1891
- primaryKey: boolean;
1892
- notNull: boolean;
1893
1894
  isUnique?: any;
1894
1895
  default?: any;
1895
1896
  typeSchema?: string | undefined;
1896
1897
  uniqueName?: string | undefined;
1897
1898
  nullsNotDistinct?: boolean | undefined;
1899
+ name: string;
1900
+ type: string;
1901
+ primaryKey: boolean;
1902
+ notNull: boolean;
1898
1903
  }>;
1899
1904
  indexes: Record<string, {
1900
1905
  name: string;
@@ -1902,25 +1907,20 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
1902
1907
  isUnique: boolean;
1903
1908
  }>;
1904
1909
  foreignKeys: Record<string, {
1910
+ onUpdate?: string | undefined;
1911
+ onDelete?: string | undefined;
1912
+ schemaTo?: string | undefined;
1905
1913
  name: string;
1906
1914
  tableFrom: string;
1907
1915
  columnsFrom: string[];
1908
1916
  tableTo: string;
1909
1917
  columnsTo: string[];
1910
- onUpdate?: string | undefined;
1911
- onDelete?: string | undefined;
1912
- schemaTo?: string | undefined;
1913
1918
  }>;
1914
1919
  schema: string;
1915
1920
  compositePrimaryKeys: Record<string, {
1916
1921
  name: string;
1917
1922
  columns: string[];
1918
1923
  }>;
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;
1963
1959
  isUnique?: any;
1964
1960
  default?: any;
1965
1961
  typeSchema?: string | undefined;
1966
1962
  uniqueName?: string | undefined;
1967
1963
  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;
1975
1978
  name: string;
1976
1979
  tableFrom: string;
1977
1980
  columnsFrom: string[];
1978
1981
  tableTo: string;
1979
1982
  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,17 +2008,22 @@ 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;
2011
2016
  name: string;
2012
2017
  columns: Record<string, {
2013
- name: string;
2014
- type: string;
2015
- primaryKey: boolean;
2016
- notNull: boolean;
2017
2018
  isUnique?: any;
2018
2019
  default?: any;
2019
2020
  typeSchema?: string | undefined;
2020
2021
  uniqueName?: string | undefined;
2021
2022
  nullsNotDistinct?: boolean | undefined;
2023
+ name: string;
2024
+ type: string;
2025
+ primaryKey: boolean;
2026
+ notNull: boolean;
2022
2027
  }>;
2023
2028
  indexes: Record<string, {
2024
2029
  name: string;
@@ -2026,25 +2031,20 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
2026
2031
  isUnique: boolean;
2027
2032
  }>;
2028
2033
  foreignKeys: Record<string, {
2034
+ onUpdate?: string | undefined;
2035
+ onDelete?: string | undefined;
2036
+ schemaTo?: string | undefined;
2029
2037
  name: string;
2030
2038
  tableFrom: string;
2031
2039
  columnsFrom: string[];
2032
2040
  tableTo: string;
2033
2041
  columnsTo: string[];
2034
- onUpdate?: string | undefined;
2035
- onDelete?: string | undefined;
2036
- schemaTo?: string | undefined;
2037
2042
  }>;
2038
2043
  schema: string;
2039
2044
  compositePrimaryKeys: Record<string, {
2040
2045
  name: string;
2041
2046
  columns: string[];
2042
2047
  }>;
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";
@@ -2063,7 +2063,7 @@ export declare const pgSchemaExternal: import("zod").ZodObject<{
2063
2063
  }>;
2064
2064
  export declare const pgSchemaInternal: import("zod").ZodObject<{
2065
2065
  version: import("zod").ZodLiteral<"6">;
2066
- dialect: import("zod").ZodLiteral<"pg">;
2066
+ dialect: import("zod").ZodLiteral<"postgresql">;
2067
2067
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2068
2068
  name: import("zod").ZodString;
2069
2069
  schema: import("zod").ZodString;
@@ -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;
2085
2081
  isUnique?: any;
2086
2082
  default?: any;
2087
2083
  typeSchema?: string | undefined;
2088
2084
  uniqueName?: string | undefined;
2089
2085
  nullsNotDistinct?: boolean | undefined;
2090
- }, {
2091
2086
  name: string;
2092
2087
  type: string;
2093
2088
  primaryKey: boolean;
2094
2089
  notNull: boolean;
2090
+ }, {
2095
2091
  isUnique?: any;
2096
2092
  default?: any;
2097
2093
  typeSchema?: string | undefined;
2098
2094
  uniqueName?: string | undefined;
2099
2095
  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;
2124
2127
  name: string;
2125
2128
  tableFrom: string;
2126
2129
  columnsFrom: string[];
2127
2130
  tableTo: string;
2128
2131
  columnsTo: string[];
2132
+ }, {
2129
2133
  onUpdate?: string | undefined;
2130
2134
  onDelete?: string | undefined;
2131
2135
  schemaTo?: string | undefined;
2132
- }, {
2133
2136
  name: string;
2134
2137
  tableFrom: string;
2135
2138
  columnsFrom: string[];
2136
2139
  tableTo: string;
2137
2140
  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;
2172
2168
  isUnique?: any;
2173
2169
  default?: any;
2174
2170
  typeSchema?: string | undefined;
2175
2171
  uniqueName?: string | undefined;
2176
2172
  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;
2184
2187
  name: string;
2185
2188
  tableFrom: string;
2186
2189
  columnsFrom: string[];
2187
2190
  tableTo: string;
2188
2191
  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,17 +2201,22 @@ 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;
2204
2209
  name: string;
2205
2210
  columns: Record<string, {
2206
- name: string;
2207
- type: string;
2208
- primaryKey: boolean;
2209
- notNull: boolean;
2210
2211
  isUnique?: any;
2211
2212
  default?: any;
2212
2213
  typeSchema?: string | undefined;
2213
2214
  uniqueName?: string | undefined;
2214
2215
  nullsNotDistinct?: boolean | undefined;
2216
+ name: string;
2217
+ type: string;
2218
+ primaryKey: boolean;
2219
+ notNull: boolean;
2215
2220
  }>;
2216
2221
  indexes: Record<string, {
2217
2222
  name: string;
@@ -2219,25 +2224,20 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2219
2224
  isUnique: boolean;
2220
2225
  }>;
2221
2226
  foreignKeys: Record<string, {
2227
+ onUpdate?: string | undefined;
2228
+ onDelete?: string | undefined;
2229
+ schemaTo?: string | undefined;
2222
2230
  name: string;
2223
2231
  tableFrom: string;
2224
2232
  columnsFrom: string[];
2225
2233
  tableTo: string;
2226
2234
  columnsTo: string[];
2227
- onUpdate?: string | undefined;
2228
- onDelete?: string | undefined;
2229
- schemaTo?: string | undefined;
2230
2235
  }>;
2231
2236
  schema: string;
2232
2237
  compositePrimaryKeys: Record<string, {
2233
2238
  name: string;
2234
2239
  columns: string[];
2235
2240
  }>;
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,18 +2312,27 @@ 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;
2315
2324
  tables: Record<string, {
2316
2325
  name: string;
2317
2326
  columns: Record<string, {
2318
- name: string;
2319
- type: string;
2320
- primaryKey: boolean;
2321
- notNull: boolean;
2322
2327
  isUnique?: any;
2323
2328
  default?: any;
2324
2329
  typeSchema?: string | undefined;
2325
2330
  uniqueName?: string | undefined;
2326
2331
  nullsNotDistinct?: boolean | undefined;
2332
+ name: string;
2333
+ type: string;
2334
+ primaryKey: boolean;
2335
+ notNull: boolean;
2327
2336
  }>;
2328
2337
  indexes: Record<string, {
2329
2338
  name: string;
@@ -2331,14 +2340,14 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2331
2340
  isUnique: boolean;
2332
2341
  }>;
2333
2342
  foreignKeys: Record<string, {
2343
+ onUpdate?: string | undefined;
2344
+ onDelete?: string | undefined;
2345
+ schemaTo?: string | undefined;
2334
2346
  name: string;
2335
2347
  tableFrom: string;
2336
2348
  columnsFrom: string[];
2337
2349
  tableTo: string;
2338
2350
  columnsTo: string[];
2339
- onUpdate?: string | undefined;
2340
- onDelete?: string | undefined;
2341
- schemaTo?: string | undefined;
2342
2351
  }>;
2343
2352
  schema: string;
2344
2353
  compositePrimaryKeys: Record<string, {
@@ -2352,7 +2361,7 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2352
2361
  }>;
2353
2362
  }>;
2354
2363
  version: "6";
2355
- dialect: "pg";
2364
+ dialect: "postgresql";
2356
2365
  schemas: Record<string, string>;
2357
2366
  _meta: {
2358
2367
  columns: Record<string, string>;
@@ -2364,6 +2373,7 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2364
2373
  values: string[];
2365
2374
  schema: string;
2366
2375
  }>;
2376
+ }, {
2367
2377
  internal?: {
2368
2378
  tables: Record<string, {
2369
2379
  columns: Record<string, {
@@ -2373,19 +2383,23 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2373
2383
  } | undefined>;
2374
2384
  } | undefined>;
2375
2385
  } | undefined;
2376
- }, {
2377
2386
  tables: Record<string, {
2387
+ uniqueConstraints?: Record<string, {
2388
+ name: string;
2389
+ columns: string[];
2390
+ nullsNotDistinct: boolean;
2391
+ }> | undefined;
2378
2392
  name: string;
2379
2393
  columns: Record<string, {
2380
- name: string;
2381
- type: string;
2382
- primaryKey: boolean;
2383
- notNull: boolean;
2384
2394
  isUnique?: any;
2385
2395
  default?: any;
2386
2396
  typeSchema?: string | undefined;
2387
2397
  uniqueName?: string | undefined;
2388
2398
  nullsNotDistinct?: boolean | undefined;
2399
+ name: string;
2400
+ type: string;
2401
+ primaryKey: boolean;
2402
+ notNull: boolean;
2389
2403
  }>;
2390
2404
  indexes: Record<string, {
2391
2405
  name: string;
@@ -2393,28 +2407,23 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2393
2407
  isUnique: boolean;
2394
2408
  }>;
2395
2409
  foreignKeys: Record<string, {
2410
+ onUpdate?: string | undefined;
2411
+ onDelete?: string | undefined;
2412
+ schemaTo?: string | undefined;
2396
2413
  name: string;
2397
2414
  tableFrom: string;
2398
2415
  columnsFrom: string[];
2399
2416
  tableTo: string;
2400
2417
  columnsTo: string[];
2401
- onUpdate?: string | undefined;
2402
- onDelete?: string | undefined;
2403
- schemaTo?: string | undefined;
2404
2418
  }>;
2405
2419
  schema: string;
2406
2420
  compositePrimaryKeys: Record<string, {
2407
2421
  name: string;
2408
2422
  columns: string[];
2409
2423
  }>;
2410
- uniqueConstraints?: Record<string, {
2411
- name: string;
2412
- columns: string[];
2413
- nullsNotDistinct: boolean;
2414
- }> | undefined;
2415
2424
  }>;
2416
2425
  version: "6";
2417
- dialect: "pg";
2426
+ dialect: "postgresql";
2418
2427
  schemas: Record<string, string>;
2419
2428
  _meta: {
2420
2429
  columns: Record<string, string>;
@@ -2426,19 +2435,10 @@ export declare const pgSchemaInternal: import("zod").ZodObject<{
2426
2435
  values: string[];
2427
2436
  schema: string;
2428
2437
  }>;
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">;
2441
- dialect: import("zod").ZodEnum<["pg"]>;
2441
+ dialect: import("zod").ZodLiteral<"pg">;
2442
2442
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2443
2443
  name: import("zod").ZodString;
2444
2444
  schema: import("zod").ZodString;
@@ -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;
2460
2456
  isUnique?: any;
2461
2457
  default?: any;
2462
2458
  typeSchema?: string | undefined;
2463
2459
  uniqueName?: string | undefined;
2464
2460
  nullsNotDistinct?: boolean | undefined;
2465
- }, {
2466
2461
  name: string;
2467
2462
  type: string;
2468
2463
  primaryKey: boolean;
2469
2464
  notNull: boolean;
2465
+ }, {
2470
2466
  isUnique?: any;
2471
2467
  default?: any;
2472
2468
  typeSchema?: string | undefined;
2473
2469
  uniqueName?: string | undefined;
2474
2470
  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;
2485
2481
  isUnique?: any;
2486
2482
  default?: any;
2487
2483
  typeSchema?: string | undefined;
2488
2484
  uniqueName?: string | undefined;
2489
2485
  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;
2501
2497
  isUnique?: any;
2502
2498
  default?: any;
2503
2499
  typeSchema?: string | undefined;
2504
2500
  uniqueName?: string | undefined;
2505
2501
  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;
2530
2526
  isUnique?: any;
2531
2527
  default?: any;
2532
2528
  typeSchema?: string | undefined;
2533
2529
  uniqueName?: string | undefined;
2534
2530
  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;
2555
2551
  isUnique?: any;
2556
2552
  default?: any;
2557
2553
  typeSchema?: string | undefined;
2558
2554
  uniqueName?: string | undefined;
2559
2555
  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>;
@@ -2572,7 +2572,7 @@ export declare const pgSchemaSquashedV4: import("zod").ZodObject<{
2572
2572
  }>;
2573
2573
  export declare const pgSchemaSquashed: import("zod").ZodObject<{
2574
2574
  version: import("zod").ZodLiteral<"6">;
2575
- dialect: import("zod").ZodEnum<["pg"]>;
2575
+ dialect: import("zod").ZodLiteral<"postgresql">;
2576
2576
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2577
2577
  name: import("zod").ZodString;
2578
2578
  schema: import("zod").ZodString;
@@ -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;
2594
2590
  isUnique?: any;
2595
2591
  default?: any;
2596
2592
  typeSchema?: string | undefined;
2597
2593
  uniqueName?: string | undefined;
2598
2594
  nullsNotDistinct?: boolean | undefined;
2599
- }, {
2600
2595
  name: string;
2601
2596
  type: string;
2602
2597
  primaryKey: boolean;
2603
2598
  notNull: boolean;
2599
+ }, {
2604
2600
  isUnique?: any;
2605
2601
  default?: any;
2606
2602
  typeSchema?: string | undefined;
2607
2603
  uniqueName?: string | undefined;
2608
2604
  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;
2621
2617
  isUnique?: any;
2622
2618
  default?: any;
2623
2619
  typeSchema?: string | undefined;
2624
2620
  uniqueName?: string | undefined;
2625
2621
  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;
2639
2635
  isUnique?: any;
2640
2636
  default?: any;
2641
2637
  typeSchema?: string | undefined;
2642
2638
  uniqueName?: string | undefined;
2643
2639
  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;
2673
2669
  isUnique?: any;
2674
2670
  default?: any;
2675
2671
  typeSchema?: string | undefined;
2676
2672
  uniqueName?: string | undefined;
2677
2673
  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>;
@@ -2683,7 +2683,7 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2683
2683
  uniqueConstraints: Record<string, string>;
2684
2684
  }>;
2685
2685
  version: "6";
2686
- dialect: "pg";
2686
+ dialect: "postgresql";
2687
2687
  schemas: Record<string, string>;
2688
2688
  enums: Record<string, {
2689
2689
  name: 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;
2701
2697
  isUnique?: any;
2702
2698
  default?: any;
2703
2699
  typeSchema?: string | undefined;
2704
2700
  uniqueName?: string | undefined;
2705
2701
  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>;
@@ -2711,7 +2711,7 @@ export declare const pgSchemaSquashed: import("zod").ZodObject<{
2711
2711
  uniqueConstraints: Record<string, string>;
2712
2712
  }>;
2713
2713
  version: "6";
2714
- dialect: "pg";
2714
+ dialect: "postgresql";
2715
2715
  schemas: Record<string, string>;
2716
2716
  enums: Record<string, {
2717
2717
  name: 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").objectUtil.extendShape<{
2722
+ export declare const pgSchemaV3: import("zod").ZodObject<import("zod").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").objectUti
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;
2742
2738
  isUnique?: any;
2743
2739
  default?: any;
2744
2740
  typeSchema?: string | undefined;
2745
2741
  uniqueName?: string | undefined;
2746
2742
  nullsNotDistinct?: boolean | undefined;
2747
- }, {
2748
2743
  name: string;
2749
2744
  type: string;
2750
2745
  primaryKey: boolean;
2751
2746
  notNull: boolean;
2747
+ }, {
2752
2748
  isUnique?: any;
2753
2749
  default?: any;
2754
2750
  typeSchema?: string | undefined;
2755
2751
  uniqueName?: string | undefined;
2756
2752
  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").objectUti
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;
2781
2784
  name: string;
2782
2785
  tableFrom: string;
2783
2786
  columnsFrom: string[];
2784
2787
  tableTo: string;
2785
2788
  columnsTo: string[];
2789
+ }, {
2786
2790
  onUpdate?: string | undefined;
2787
2791
  onDelete?: string | undefined;
2788
2792
  schemaTo?: string | undefined;
2789
- }, {
2790
2793
  name: string;
2791
2794
  tableFrom: string;
2792
2795
  columnsFrom: string[];
2793
2796
  tableTo: string;
2794
2797
  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;
2806
2802
  isUnique?: any;
2807
2803
  default?: any;
2808
2804
  typeSchema?: string | undefined;
2809
2805
  uniqueName?: string | undefined;
2810
2806
  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").objectUti
2815
2815
  isUnique: boolean;
2816
2816
  }>;
2817
2817
  foreignKeys: Record<string, {
2818
+ onUpdate?: string | undefined;
2819
+ onDelete?: string | undefined;
2820
+ schemaTo?: string | undefined;
2818
2821
  name: string;
2819
2822
  tableFrom: string;
2820
2823
  columnsFrom: string[];
2821
2824
  tableTo: string;
2822
2825
  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;
2834
2830
  isUnique?: any;
2835
2831
  default?: any;
2836
2832
  typeSchema?: string | undefined;
2837
2833
  uniqueName?: string | undefined;
2838
2834
  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").objectUti
2843
2843
  isUnique: boolean;
2844
2844
  }>;
2845
2845
  foreignKeys: Record<string, {
2846
+ onUpdate?: string | undefined;
2847
+ onDelete?: string | undefined;
2848
+ schemaTo?: string | undefined;
2846
2849
  name: string;
2847
2850
  tableFrom: string;
2848
2851
  columnsFrom: string[];
2849
2852
  tableTo: string;
2850
2853
  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").objectUti
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;
2877
2873
  isUnique?: any;
2878
2874
  default?: any;
2879
2875
  typeSchema?: string | undefined;
2880
2876
  uniqueName?: string | undefined;
2881
2877
  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").objectUti
2886
2886
  isUnique: boolean;
2887
2887
  }>;
2888
2888
  foreignKeys: Record<string, {
2889
+ onUpdate?: string | undefined;
2890
+ onDelete?: string | undefined;
2891
+ schemaTo?: string | undefined;
2889
2892
  name: string;
2890
2893
  tableFrom: string;
2891
2894
  columnsFrom: string[];
2892
2895
  tableTo: string;
2893
2896
  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").objectUti
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;
2915
2911
  isUnique?: any;
2916
2912
  default?: any;
2917
2913
  typeSchema?: string | undefined;
2918
2914
  uniqueName?: string | undefined;
2919
2915
  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").objectUti
2924
2924
  isUnique: boolean;
2925
2925
  }>;
2926
2926
  foreignKeys: Record<string, {
2927
+ onUpdate?: string | undefined;
2928
+ onDelete?: string | undefined;
2929
+ schemaTo?: string | undefined;
2927
2930
  name: string;
2928
2931
  tableFrom: string;
2929
2932
  columnsFrom: string[];
2930
2933
  tableTo: string;
2931
2934
  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").objectUti
2943
2943
  values: Record<string, string>;
2944
2944
  }>;
2945
2945
  }>;
2946
- export declare const pgSchemaV4: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
2946
+ export declare const pgSchemaV4: import("zod").ZodObject<import("zod").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").objectUti
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;
2967
2963
  isUnique?: any;
2968
2964
  default?: any;
2969
2965
  typeSchema?: string | undefined;
2970
2966
  uniqueName?: string | undefined;
2971
2967
  nullsNotDistinct?: boolean | undefined;
2972
- }, {
2973
2968
  name: string;
2974
2969
  type: string;
2975
2970
  primaryKey: boolean;
2976
2971
  notNull: boolean;
2972
+ }, {
2977
2973
  isUnique?: any;
2978
2974
  default?: any;
2979
2975
  typeSchema?: string | undefined;
2980
2976
  uniqueName?: string | undefined;
2981
2977
  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").objectUti
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;
3006
3009
  name: string;
3007
3010
  tableFrom: string;
3008
3011
  columnsFrom: string[];
3009
3012
  tableTo: string;
3010
3013
  columnsTo: string[];
3014
+ }, {
3011
3015
  onUpdate?: string | undefined;
3012
3016
  onDelete?: string | undefined;
3013
3017
  schemaTo?: string | undefined;
3014
- }, {
3015
3018
  name: string;
3016
3019
  tableFrom: string;
3017
3020
  columnsFrom: string[];
3018
3021
  tableTo: string;
3019
3022
  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;
3031
3027
  isUnique?: any;
3032
3028
  default?: any;
3033
3029
  typeSchema?: string | undefined;
3034
3030
  uniqueName?: string | undefined;
3035
3031
  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").objectUti
3040
3040
  isUnique: boolean;
3041
3041
  }>;
3042
3042
  foreignKeys: Record<string, {
3043
+ onUpdate?: string | undefined;
3044
+ onDelete?: string | undefined;
3045
+ schemaTo?: string | undefined;
3043
3046
  name: string;
3044
3047
  tableFrom: string;
3045
3048
  columnsFrom: string[];
3046
3049
  tableTo: string;
3047
3050
  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;
3060
3056
  isUnique?: any;
3061
3057
  default?: any;
3062
3058
  typeSchema?: string | undefined;
3063
3059
  uniqueName?: string | undefined;
3064
3060
  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").objectUti
3069
3069
  isUnique: boolean;
3070
3070
  }>;
3071
3071
  foreignKeys: Record<string, {
3072
+ onUpdate?: string | undefined;
3073
+ onDelete?: string | undefined;
3074
+ schemaTo?: string | undefined;
3072
3075
  name: string;
3073
3076
  tableFrom: string;
3074
3077
  columnsFrom: string[];
3075
3078
  tableTo: string;
3076
3079
  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").objectUti
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;
3105
3101
  isUnique?: any;
3106
3102
  default?: any;
3107
3103
  typeSchema?: string | undefined;
3108
3104
  uniqueName?: string | undefined;
3109
3105
  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").objectUti
3114
3114
  isUnique: boolean;
3115
3115
  }>;
3116
3116
  foreignKeys: Record<string, {
3117
+ onUpdate?: string | undefined;
3118
+ onDelete?: string | undefined;
3119
+ schemaTo?: string | undefined;
3117
3120
  name: string;
3118
3121
  tableFrom: string;
3119
3122
  columnsFrom: string[];
3120
3123
  tableTo: string;
3121
3124
  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").objectUti
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;
3145
3141
  isUnique?: any;
3146
3142
  default?: any;
3147
3143
  typeSchema?: string | undefined;
3148
3144
  uniqueName?: string | undefined;
3149
3145
  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").objectUti
3154
3154
  isUnique: boolean;
3155
3155
  }>;
3156
3156
  foreignKeys: Record<string, {
3157
+ onUpdate?: string | undefined;
3158
+ onDelete?: string | undefined;
3159
+ schemaTo?: string | undefined;
3157
3160
  name: string;
3158
3161
  tableFrom: string;
3159
3162
  columnsFrom: string[];
3160
3163
  tableTo: string;
3161
3164
  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").objectUti
3175
3175
  values: Record<string, string>;
3176
3176
  }>;
3177
3177
  }>;
3178
- export declare const pgSchemaV5: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
3178
+ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").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").objectUti
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;
3199
3195
  isUnique?: any;
3200
3196
  default?: any;
3201
3197
  typeSchema?: string | undefined;
3202
3198
  uniqueName?: string | undefined;
3203
3199
  nullsNotDistinct?: boolean | undefined;
3204
- }, {
3205
3200
  name: string;
3206
3201
  type: string;
3207
3202
  primaryKey: boolean;
3208
3203
  notNull: boolean;
3204
+ }, {
3209
3205
  isUnique?: any;
3210
3206
  default?: any;
3211
3207
  typeSchema?: string | undefined;
3212
3208
  uniqueName?: string | undefined;
3213
3209
  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").objectUti
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;
3238
3241
  name: string;
3239
3242
  tableFrom: string;
3240
3243
  columnsFrom: string[];
3241
3244
  tableTo: string;
3242
3245
  columnsTo: string[];
3246
+ }, {
3243
3247
  onUpdate?: string | undefined;
3244
3248
  onDelete?: string | undefined;
3245
3249
  schemaTo?: string | undefined;
3246
- }, {
3247
3250
  name: string;
3248
3251
  tableFrom: string;
3249
3252
  columnsFrom: string[];
3250
3253
  tableTo: string;
3251
3254
  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").objectUti
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;
3286
3282
  isUnique?: any;
3287
3283
  default?: any;
3288
3284
  typeSchema?: string | undefined;
3289
3285
  uniqueName?: string | undefined;
3290
3286
  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").objectUti
3295
3295
  isUnique: boolean;
3296
3296
  }>;
3297
3297
  foreignKeys: Record<string, {
3298
+ onUpdate?: string | undefined;
3299
+ onDelete?: string | undefined;
3300
+ schemaTo?: string | undefined;
3298
3301
  name: string;
3299
3302
  tableFrom: string;
3300
3303
  columnsFrom: string[];
3301
3304
  tableTo: string;
3302
3305
  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,17 +3315,22 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").objectUti
3315
3315
  nullsNotDistinct: boolean;
3316
3316
  }>;
3317
3317
  }, {
3318
+ uniqueConstraints?: Record<string, {
3319
+ name: string;
3320
+ columns: string[];
3321
+ nullsNotDistinct: boolean;
3322
+ }> | undefined;
3318
3323
  name: string;
3319
3324
  columns: Record<string, {
3320
- name: string;
3321
- type: string;
3322
- primaryKey: boolean;
3323
- notNull: boolean;
3324
3325
  isUnique?: any;
3325
3326
  default?: any;
3326
3327
  typeSchema?: string | undefined;
3327
3328
  uniqueName?: string | undefined;
3328
3329
  nullsNotDistinct?: boolean | undefined;
3330
+ name: string;
3331
+ type: string;
3332
+ primaryKey: boolean;
3333
+ notNull: boolean;
3329
3334
  }>;
3330
3335
  indexes: Record<string, {
3331
3336
  name: string;
@@ -3333,25 +3338,20 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").objectUti
3333
3338
  isUnique: boolean;
3334
3339
  }>;
3335
3340
  foreignKeys: Record<string, {
3341
+ onUpdate?: string | undefined;
3342
+ onDelete?: string | undefined;
3343
+ schemaTo?: string | undefined;
3336
3344
  name: string;
3337
3345
  tableFrom: string;
3338
3346
  columnsFrom: string[];
3339
3347
  tableTo: string;
3340
3348
  columnsTo: string[];
3341
- onUpdate?: string | undefined;
3342
- onDelete?: string | undefined;
3343
- schemaTo?: string | undefined;
3344
3349
  }>;
3345
3350
  schema: string;
3346
3351
  compositePrimaryKeys: Record<string, {
3347
3352
  name: string;
3348
3353
  columns: string[];
3349
3354
  }>;
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,18 +3426,27 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").objectUti
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;
3429
3438
  tables: Record<string, {
3430
3439
  name: string;
3431
3440
  columns: Record<string, {
3432
- name: string;
3433
- type: string;
3434
- primaryKey: boolean;
3435
- notNull: boolean;
3436
3441
  isUnique?: any;
3437
3442
  default?: any;
3438
3443
  typeSchema?: string | undefined;
3439
3444
  uniqueName?: string | undefined;
3440
3445
  nullsNotDistinct?: boolean | undefined;
3446
+ name: string;
3447
+ type: string;
3448
+ primaryKey: boolean;
3449
+ notNull: boolean;
3441
3450
  }>;
3442
3451
  indexes: Record<string, {
3443
3452
  name: string;
@@ -3445,14 +3454,14 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").objectUti
3445
3454
  isUnique: boolean;
3446
3455
  }>;
3447
3456
  foreignKeys: Record<string, {
3457
+ onUpdate?: string | undefined;
3458
+ onDelete?: string | undefined;
3459
+ schemaTo?: string | undefined;
3448
3460
  name: string;
3449
3461
  tableFrom: string;
3450
3462
  columnsFrom: string[];
3451
3463
  tableTo: string;
3452
3464
  columnsTo: string[];
3453
- onUpdate?: string | undefined;
3454
- onDelete?: string | undefined;
3455
- schemaTo?: string | undefined;
3456
3465
  }>;
3457
3466
  schema: string;
3458
3467
  compositePrimaryKeys: Record<string, {
@@ -3479,6 +3488,7 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").objectUti
3479
3488
  name: string;
3480
3489
  values: Record<string, string>;
3481
3490
  }>;
3491
+ }, {
3482
3492
  internal?: {
3483
3493
  tables: Record<string, {
3484
3494
  columns: Record<string, {
@@ -3488,19 +3498,23 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").objectUti
3488
3498
  } | undefined>;
3489
3499
  } | undefined>;
3490
3500
  } | undefined;
3491
- }, {
3492
3501
  tables: Record<string, {
3502
+ uniqueConstraints?: Record<string, {
3503
+ name: string;
3504
+ columns: string[];
3505
+ nullsNotDistinct: boolean;
3506
+ }> | undefined;
3493
3507
  name: string;
3494
3508
  columns: Record<string, {
3495
- name: string;
3496
- type: string;
3497
- primaryKey: boolean;
3498
- notNull: boolean;
3499
3509
  isUnique?: any;
3500
3510
  default?: any;
3501
3511
  typeSchema?: string | undefined;
3502
3512
  uniqueName?: string | undefined;
3503
3513
  nullsNotDistinct?: boolean | undefined;
3514
+ name: string;
3515
+ type: string;
3516
+ primaryKey: boolean;
3517
+ notNull: boolean;
3504
3518
  }>;
3505
3519
  indexes: Record<string, {
3506
3520
  name: string;
@@ -3508,25 +3522,20 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").objectUti
3508
3522
  isUnique: boolean;
3509
3523
  }>;
3510
3524
  foreignKeys: Record<string, {
3525
+ onUpdate?: string | undefined;
3526
+ onDelete?: string | undefined;
3527
+ schemaTo?: string | undefined;
3511
3528
  name: string;
3512
3529
  tableFrom: string;
3513
3530
  columnsFrom: string[];
3514
3531
  tableTo: string;
3515
3532
  columnsTo: string[];
3516
- onUpdate?: string | undefined;
3517
- onDelete?: string | undefined;
3518
- schemaTo?: string | undefined;
3519
3533
  }>;
3520
3534
  schema: string;
3521
3535
  compositePrimaryKeys: Record<string, {
3522
3536
  name: string;
3523
3537
  columns: string[];
3524
3538
  }>;
3525
- uniqueConstraints?: Record<string, {
3526
- name: string;
3527
- columns: string[];
3528
- nullsNotDistinct: boolean;
3529
- }> | undefined;
3530
3539
  }>;
3531
3540
  id: string;
3532
3541
  prevId: string;
@@ -3542,19 +3551,10 @@ export declare const pgSchemaV5: import("zod").ZodObject<import("zod").objectUti
3542
3551
  name: string;
3543
3552
  values: Record<string, string>;
3544
3553
  }>;
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").objectUtil.extendShape<{
3555
+ export declare const pgSchema: import("zod").ZodObject<import("zod").extendShape<{
3556
3556
  version: import("zod").ZodLiteral<"6">;
3557
- dialect: import("zod").ZodLiteral<"pg">;
3557
+ dialect: import("zod").ZodLiteral<"postgresql">;
3558
3558
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3559
3559
  name: import("zod").ZodString;
3560
3560
  schema: import("zod").ZodString;
@@ -3569,25 +3569,25 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").objectUtil.
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;
3576
3572
  isUnique?: any;
3577
3573
  default?: any;
3578
3574
  typeSchema?: string | undefined;
3579
3575
  uniqueName?: string | undefined;
3580
3576
  nullsNotDistinct?: boolean | undefined;
3581
- }, {
3582
3577
  name: string;
3583
3578
  type: string;
3584
3579
  primaryKey: boolean;
3585
3580
  notNull: boolean;
3581
+ }, {
3586
3582
  isUnique?: any;
3587
3583
  default?: any;
3588
3584
  typeSchema?: string | undefined;
3589
3585
  uniqueName?: string | undefined;
3590
3586
  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").objectUtil.
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;
3615
3618
  name: string;
3616
3619
  tableFrom: string;
3617
3620
  columnsFrom: string[];
3618
3621
  tableTo: string;
3619
3622
  columnsTo: string[];
3623
+ }, {
3620
3624
  onUpdate?: string | undefined;
3621
3625
  onDelete?: string | undefined;
3622
3626
  schemaTo?: string | undefined;
3623
- }, {
3624
3627
  name: string;
3625
3628
  tableFrom: string;
3626
3629
  columnsFrom: string[];
3627
3630
  tableTo: string;
3628
3631
  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").objectUtil.
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;
3663
3659
  isUnique?: any;
3664
3660
  default?: any;
3665
3661
  typeSchema?: string | undefined;
3666
3662
  uniqueName?: string | undefined;
3667
3663
  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").objectUtil.
3672
3672
  isUnique: boolean;
3673
3673
  }>;
3674
3674
  foreignKeys: Record<string, {
3675
+ onUpdate?: string | undefined;
3676
+ onDelete?: string | undefined;
3677
+ schemaTo?: string | undefined;
3675
3678
  name: string;
3676
3679
  tableFrom: string;
3677
3680
  columnsFrom: string[];
3678
3681
  tableTo: string;
3679
3682
  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,17 +3692,22 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").objectUtil.
3692
3692
  nullsNotDistinct: boolean;
3693
3693
  }>;
3694
3694
  }, {
3695
+ uniqueConstraints?: Record<string, {
3696
+ name: string;
3697
+ columns: string[];
3698
+ nullsNotDistinct: boolean;
3699
+ }> | undefined;
3695
3700
  name: string;
3696
3701
  columns: Record<string, {
3697
- name: string;
3698
- type: string;
3699
- primaryKey: boolean;
3700
- notNull: boolean;
3701
3702
  isUnique?: any;
3702
3703
  default?: any;
3703
3704
  typeSchema?: string | undefined;
3704
3705
  uniqueName?: string | undefined;
3705
3706
  nullsNotDistinct?: boolean | undefined;
3707
+ name: string;
3708
+ type: string;
3709
+ primaryKey: boolean;
3710
+ notNull: boolean;
3706
3711
  }>;
3707
3712
  indexes: Record<string, {
3708
3713
  name: string;
@@ -3710,25 +3715,20 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").objectUtil.
3710
3715
  isUnique: boolean;
3711
3716
  }>;
3712
3717
  foreignKeys: Record<string, {
3718
+ onUpdate?: string | undefined;
3719
+ onDelete?: string | undefined;
3720
+ schemaTo?: string | undefined;
3713
3721
  name: string;
3714
3722
  tableFrom: string;
3715
3723
  columnsFrom: string[];
3716
3724
  tableTo: string;
3717
3725
  columnsTo: string[];
3718
- onUpdate?: string | undefined;
3719
- onDelete?: string | undefined;
3720
- schemaTo?: string | undefined;
3721
3726
  }>;
3722
3727
  schema: string;
3723
3728
  compositePrimaryKeys: Record<string, {
3724
3729
  name: string;
3725
3730
  columns: string[];
3726
3731
  }>;
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,18 +3806,27 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").objectUtil.
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;
3809
3818
  tables: Record<string, {
3810
3819
  name: string;
3811
3820
  columns: Record<string, {
3812
- name: string;
3813
- type: string;
3814
- primaryKey: boolean;
3815
- notNull: boolean;
3816
3821
  isUnique?: any;
3817
3822
  default?: any;
3818
3823
  typeSchema?: string | undefined;
3819
3824
  uniqueName?: string | undefined;
3820
3825
  nullsNotDistinct?: boolean | undefined;
3826
+ name: string;
3827
+ type: string;
3828
+ primaryKey: boolean;
3829
+ notNull: boolean;
3821
3830
  }>;
3822
3831
  indexes: Record<string, {
3823
3832
  name: string;
@@ -3825,14 +3834,14 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").objectUtil.
3825
3834
  isUnique: boolean;
3826
3835
  }>;
3827
3836
  foreignKeys: Record<string, {
3837
+ onUpdate?: string | undefined;
3838
+ onDelete?: string | undefined;
3839
+ schemaTo?: string | undefined;
3828
3840
  name: string;
3829
3841
  tableFrom: string;
3830
3842
  columnsFrom: string[];
3831
3843
  tableTo: string;
3832
3844
  columnsTo: string[];
3833
- onUpdate?: string | undefined;
3834
- onDelete?: string | undefined;
3835
- schemaTo?: string | undefined;
3836
3845
  }>;
3837
3846
  schema: string;
3838
3847
  compositePrimaryKeys: Record<string, {
@@ -3848,7 +3857,7 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").objectUtil.
3848
3857
  id: string;
3849
3858
  prevId: string;
3850
3859
  version: "6";
3851
- dialect: "pg";
3860
+ dialect: "postgresql";
3852
3861
  schemas: Record<string, string>;
3853
3862
  _meta: {
3854
3863
  columns: Record<string, string>;
@@ -3860,6 +3869,7 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").objectUtil.
3860
3869
  values: string[];
3861
3870
  schema: string;
3862
3871
  }>;
3872
+ }, {
3863
3873
  internal?: {
3864
3874
  tables: Record<string, {
3865
3875
  columns: Record<string, {
@@ -3869,19 +3879,23 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").objectUtil.
3869
3879
  } | undefined>;
3870
3880
  } | undefined>;
3871
3881
  } | undefined;
3872
- }, {
3873
3882
  tables: Record<string, {
3883
+ uniqueConstraints?: Record<string, {
3884
+ name: string;
3885
+ columns: string[];
3886
+ nullsNotDistinct: boolean;
3887
+ }> | undefined;
3874
3888
  name: string;
3875
3889
  columns: Record<string, {
3876
- name: string;
3877
- type: string;
3878
- primaryKey: boolean;
3879
- notNull: boolean;
3880
3890
  isUnique?: any;
3881
3891
  default?: any;
3882
3892
  typeSchema?: string | undefined;
3883
3893
  uniqueName?: string | undefined;
3884
3894
  nullsNotDistinct?: boolean | undefined;
3895
+ name: string;
3896
+ type: string;
3897
+ primaryKey: boolean;
3898
+ notNull: boolean;
3885
3899
  }>;
3886
3900
  indexes: Record<string, {
3887
3901
  name: string;
@@ -3889,30 +3903,25 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").objectUtil.
3889
3903
  isUnique: boolean;
3890
3904
  }>;
3891
3905
  foreignKeys: Record<string, {
3906
+ onUpdate?: string | undefined;
3907
+ onDelete?: string | undefined;
3908
+ schemaTo?: string | undefined;
3892
3909
  name: string;
3893
3910
  tableFrom: string;
3894
3911
  columnsFrom: string[];
3895
3912
  tableTo: string;
3896
3913
  columnsTo: string[];
3897
- onUpdate?: string | undefined;
3898
- onDelete?: string | undefined;
3899
- schemaTo?: string | undefined;
3900
3914
  }>;
3901
3915
  schema: string;
3902
3916
  compositePrimaryKeys: Record<string, {
3903
3917
  name: string;
3904
3918
  columns: string[];
3905
3919
  }>;
3906
- uniqueConstraints?: Record<string, {
3907
- name: string;
3908
- columns: string[];
3909
- nullsNotDistinct: boolean;
3910
- }> | undefined;
3911
3920
  }>;
3912
3921
  id: string;
3913
3922
  prevId: string;
3914
3923
  version: "6";
3915
- dialect: "pg";
3924
+ dialect: "postgresql";
3916
3925
  schemas: Record<string, string>;
3917
3926
  _meta: {
3918
3927
  columns: Record<string, string>;
@@ -3924,15 +3933,6 @@ export declare const pgSchema: import("zod").ZodObject<import("zod").objectUtil.
3924
3933
  values: string[];
3925
3934
  schema: string;
3926
3935
  }>;
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").objectUtil.extendShape<{
3957
+ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").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;
3978
3974
  isUnique?: any;
3979
3975
  default?: any;
3980
3976
  typeSchema?: string | undefined;
3981
3977
  uniqueName?: string | undefined;
3982
3978
  nullsNotDistinct?: boolean | undefined;
3983
- }, {
3984
3979
  name: string;
3985
3980
  type: string;
3986
3981
  primaryKey: boolean;
3987
3982
  notNull: boolean;
3983
+ }, {
3988
3984
  isUnique?: any;
3989
3985
  default?: any;
3990
3986
  typeSchema?: string | undefined;
3991
3987
  uniqueName?: string | undefined;
3992
3988
  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;
4017
4020
  name: string;
4018
4021
  tableFrom: string;
4019
4022
  columnsFrom: string[];
4020
4023
  tableTo: string;
4021
4024
  columnsTo: string[];
4025
+ }, {
4022
4026
  onUpdate?: string | undefined;
4023
4027
  onDelete?: string | undefined;
4024
4028
  schemaTo?: string | undefined;
4025
- }, {
4026
4029
  name: string;
4027
4030
  tableFrom: string;
4028
4031
  columnsFrom: string[];
4029
4032
  tableTo: string;
4030
4033
  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;
4065
4061
  isUnique?: any;
4066
4062
  default?: any;
4067
4063
  typeSchema?: string | undefined;
4068
4064
  uniqueName?: string | undefined;
4069
4065
  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;
4077
4080
  name: string;
4078
4081
  tableFrom: string;
4079
4082
  columnsFrom: string[];
4080
4083
  tableTo: string;
4081
4084
  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,17 +4094,22 @@ 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;
4097
4102
  name: string;
4098
4103
  columns: Record<string, {
4099
- name: string;
4100
- type: string;
4101
- primaryKey: boolean;
4102
- notNull: boolean;
4103
4104
  isUnique?: any;
4104
4105
  default?: any;
4105
4106
  typeSchema?: string | undefined;
4106
4107
  uniqueName?: string | undefined;
4107
4108
  nullsNotDistinct?: boolean | undefined;
4109
+ name: string;
4110
+ type: string;
4111
+ primaryKey: boolean;
4112
+ notNull: boolean;
4108
4113
  }>;
4109
4114
  indexes: Record<string, {
4110
4115
  name: string;
@@ -4112,25 +4117,20 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4112
4117
  isUnique: boolean;
4113
4118
  }>;
4114
4119
  foreignKeys: Record<string, {
4120
+ onUpdate?: string | undefined;
4121
+ onDelete?: string | undefined;
4122
+ schemaTo?: string | undefined;
4115
4123
  name: string;
4116
4124
  tableFrom: string;
4117
4125
  columnsFrom: string[];
4118
4126
  tableTo: string;
4119
4127
  columnsTo: string[];
4120
- onUpdate?: string | undefined;
4121
- onDelete?: string | undefined;
4122
- schemaTo?: string | undefined;
4123
4128
  }>;
4124
4129
  schema: string;
4125
4130
  compositePrimaryKeys: Record<string, {
4126
4131
  name: string;
4127
4132
  columns: string[];
4128
4133
  }>;
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,18 +4205,27 @@ 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;
4208
4217
  tables: Record<string, {
4209
4218
  name: string;
4210
4219
  columns: Record<string, {
4211
- name: string;
4212
- type: string;
4213
- primaryKey: boolean;
4214
- notNull: boolean;
4215
4220
  isUnique?: any;
4216
4221
  default?: any;
4217
4222
  typeSchema?: string | undefined;
4218
4223
  uniqueName?: string | undefined;
4219
4224
  nullsNotDistinct?: boolean | undefined;
4225
+ name: string;
4226
+ type: string;
4227
+ primaryKey: boolean;
4228
+ notNull: boolean;
4220
4229
  }>;
4221
4230
  indexes: Record<string, {
4222
4231
  name: string;
@@ -4224,14 +4233,14 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4224
4233
  isUnique: boolean;
4225
4234
  }>;
4226
4235
  foreignKeys: Record<string, {
4236
+ onUpdate?: string | undefined;
4237
+ onDelete?: string | undefined;
4238
+ schemaTo?: string | undefined;
4227
4239
  name: string;
4228
4240
  tableFrom: string;
4229
4241
  columnsFrom: string[];
4230
4242
  tableTo: string;
4231
4243
  columnsTo: string[];
4232
- onUpdate?: string | undefined;
4233
- onDelete?: string | undefined;
4234
- schemaTo?: string | undefined;
4235
4244
  }>;
4236
4245
  schema: string;
4237
4246
  compositePrimaryKeys: Record<string, {
@@ -4258,6 +4267,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4258
4267
  name: string;
4259
4268
  values: Record<string, string>;
4260
4269
  }>;
4270
+ }, {
4261
4271
  internal?: {
4262
4272
  tables: Record<string, {
4263
4273
  columns: Record<string, {
@@ -4267,19 +4277,23 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4267
4277
  } | undefined>;
4268
4278
  } | undefined>;
4269
4279
  } | undefined;
4270
- }, {
4271
4280
  tables: Record<string, {
4281
+ uniqueConstraints?: Record<string, {
4282
+ name: string;
4283
+ columns: string[];
4284
+ nullsNotDistinct: boolean;
4285
+ }> | undefined;
4272
4286
  name: string;
4273
4287
  columns: Record<string, {
4274
- name: string;
4275
- type: string;
4276
- primaryKey: boolean;
4277
- notNull: boolean;
4278
4288
  isUnique?: any;
4279
4289
  default?: any;
4280
4290
  typeSchema?: string | undefined;
4281
4291
  uniqueName?: string | undefined;
4282
4292
  nullsNotDistinct?: boolean | undefined;
4293
+ name: string;
4294
+ type: string;
4295
+ primaryKey: boolean;
4296
+ notNull: boolean;
4283
4297
  }>;
4284
4298
  indexes: Record<string, {
4285
4299
  name: string;
@@ -4287,25 +4301,20 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4287
4301
  isUnique: boolean;
4288
4302
  }>;
4289
4303
  foreignKeys: Record<string, {
4304
+ onUpdate?: string | undefined;
4305
+ onDelete?: string | undefined;
4306
+ schemaTo?: string | undefined;
4290
4307
  name: string;
4291
4308
  tableFrom: string;
4292
4309
  columnsFrom: string[];
4293
4310
  tableTo: string;
4294
4311
  columnsTo: string[];
4295
- onUpdate?: string | undefined;
4296
- onDelete?: string | undefined;
4297
- schemaTo?: string | undefined;
4298
4312
  }>;
4299
4313
  schema: string;
4300
4314
  compositePrimaryKeys: Record<string, {
4301
4315
  name: string;
4302
4316
  columns: string[];
4303
4317
  }>;
4304
- uniqueConstraints?: Record<string, {
4305
- name: string;
4306
- columns: string[];
4307
- nullsNotDistinct: boolean;
4308
- }> | undefined;
4309
4318
  }>;
4310
4319
  id: string;
4311
4320
  prevId: string;
@@ -4321,18 +4330,9 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4321
4330
  name: string;
4322
4331
  values: Record<string, string>;
4323
4332
  }>;
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<{
4333
+ }>, import("zod").ZodObject<import("zod").extendShape<{
4334
4334
  version: import("zod").ZodLiteral<"6">;
4335
- dialect: import("zod").ZodLiteral<"pg">;
4335
+ dialect: import("zod").ZodLiteral<"postgresql">;
4336
4336
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4337
4337
  name: import("zod").ZodString;
4338
4338
  schema: import("zod").ZodString;
@@ -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;
4354
4350
  isUnique?: any;
4355
4351
  default?: any;
4356
4352
  typeSchema?: string | undefined;
4357
4353
  uniqueName?: string | undefined;
4358
4354
  nullsNotDistinct?: boolean | undefined;
4359
- }, {
4360
4355
  name: string;
4361
4356
  type: string;
4362
4357
  primaryKey: boolean;
4363
4358
  notNull: boolean;
4359
+ }, {
4364
4360
  isUnique?: any;
4365
4361
  default?: any;
4366
4362
  typeSchema?: string | undefined;
4367
4363
  uniqueName?: string | undefined;
4368
4364
  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;
4393
4396
  name: string;
4394
4397
  tableFrom: string;
4395
4398
  columnsFrom: string[];
4396
4399
  tableTo: string;
4397
4400
  columnsTo: string[];
4401
+ }, {
4398
4402
  onUpdate?: string | undefined;
4399
4403
  onDelete?: string | undefined;
4400
4404
  schemaTo?: string | undefined;
4401
- }, {
4402
4405
  name: string;
4403
4406
  tableFrom: string;
4404
4407
  columnsFrom: string[];
4405
4408
  tableTo: string;
4406
4409
  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;
4441
4437
  isUnique?: any;
4442
4438
  default?: any;
4443
4439
  typeSchema?: string | undefined;
4444
4440
  uniqueName?: string | undefined;
4445
4441
  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;
4453
4456
  name: string;
4454
4457
  tableFrom: string;
4455
4458
  columnsFrom: string[];
4456
4459
  tableTo: string;
4457
4460
  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,17 +4470,22 @@ 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;
4473
4478
  name: string;
4474
4479
  columns: Record<string, {
4475
- name: string;
4476
- type: string;
4477
- primaryKey: boolean;
4478
- notNull: boolean;
4479
4480
  isUnique?: any;
4480
4481
  default?: any;
4481
4482
  typeSchema?: string | undefined;
4482
4483
  uniqueName?: string | undefined;
4483
4484
  nullsNotDistinct?: boolean | undefined;
4485
+ name: string;
4486
+ type: string;
4487
+ primaryKey: boolean;
4488
+ notNull: boolean;
4484
4489
  }>;
4485
4490
  indexes: Record<string, {
4486
4491
  name: string;
@@ -4488,25 +4493,20 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4488
4493
  isUnique: boolean;
4489
4494
  }>;
4490
4495
  foreignKeys: Record<string, {
4496
+ onUpdate?: string | undefined;
4497
+ onDelete?: string | undefined;
4498
+ schemaTo?: string | undefined;
4491
4499
  name: string;
4492
4500
  tableFrom: string;
4493
4501
  columnsFrom: string[];
4494
4502
  tableTo: string;
4495
4503
  columnsTo: string[];
4496
- onUpdate?: string | undefined;
4497
- onDelete?: string | undefined;
4498
- schemaTo?: string | undefined;
4499
4504
  }>;
4500
4505
  schema: string;
4501
4506
  compositePrimaryKeys: Record<string, {
4502
4507
  name: string;
4503
4508
  columns: string[];
4504
4509
  }>;
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,18 +4584,27 @@ 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;
4587
4596
  tables: Record<string, {
4588
4597
  name: string;
4589
4598
  columns: Record<string, {
4590
- name: string;
4591
- type: string;
4592
- primaryKey: boolean;
4593
- notNull: boolean;
4594
4599
  isUnique?: any;
4595
4600
  default?: any;
4596
4601
  typeSchema?: string | undefined;
4597
4602
  uniqueName?: string | undefined;
4598
4603
  nullsNotDistinct?: boolean | undefined;
4604
+ name: string;
4605
+ type: string;
4606
+ primaryKey: boolean;
4607
+ notNull: boolean;
4599
4608
  }>;
4600
4609
  indexes: Record<string, {
4601
4610
  name: string;
@@ -4603,14 +4612,14 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4603
4612
  isUnique: boolean;
4604
4613
  }>;
4605
4614
  foreignKeys: Record<string, {
4615
+ onUpdate?: string | undefined;
4616
+ onDelete?: string | undefined;
4617
+ schemaTo?: string | undefined;
4606
4618
  name: string;
4607
4619
  tableFrom: string;
4608
4620
  columnsFrom: string[];
4609
4621
  tableTo: string;
4610
4622
  columnsTo: string[];
4611
- onUpdate?: string | undefined;
4612
- onDelete?: string | undefined;
4613
- schemaTo?: string | undefined;
4614
4623
  }>;
4615
4624
  schema: string;
4616
4625
  compositePrimaryKeys: Record<string, {
@@ -4626,7 +4635,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4626
4635
  id: string;
4627
4636
  prevId: string;
4628
4637
  version: "6";
4629
- dialect: "pg";
4638
+ dialect: "postgresql";
4630
4639
  schemas: Record<string, string>;
4631
4640
  _meta: {
4632
4641
  columns: Record<string, string>;
@@ -4638,6 +4647,7 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4638
4647
  values: string[];
4639
4648
  schema: string;
4640
4649
  }>;
4650
+ }, {
4641
4651
  internal?: {
4642
4652
  tables: Record<string, {
4643
4653
  columns: Record<string, {
@@ -4647,19 +4657,23 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4647
4657
  } | undefined>;
4648
4658
  } | undefined>;
4649
4659
  } | undefined;
4650
- }, {
4651
4660
  tables: Record<string, {
4661
+ uniqueConstraints?: Record<string, {
4662
+ name: string;
4663
+ columns: string[];
4664
+ nullsNotDistinct: boolean;
4665
+ }> | undefined;
4652
4666
  name: string;
4653
4667
  columns: Record<string, {
4654
- name: string;
4655
- type: string;
4656
- primaryKey: boolean;
4657
- notNull: boolean;
4658
4668
  isUnique?: any;
4659
4669
  default?: any;
4660
4670
  typeSchema?: string | undefined;
4661
4671
  uniqueName?: string | undefined;
4662
4672
  nullsNotDistinct?: boolean | undefined;
4673
+ name: string;
4674
+ type: string;
4675
+ primaryKey: boolean;
4676
+ notNull: boolean;
4663
4677
  }>;
4664
4678
  indexes: Record<string, {
4665
4679
  name: string;
@@ -4667,30 +4681,25 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4667
4681
  isUnique: boolean;
4668
4682
  }>;
4669
4683
  foreignKeys: Record<string, {
4684
+ onUpdate?: string | undefined;
4685
+ onDelete?: string | undefined;
4686
+ schemaTo?: string | undefined;
4670
4687
  name: string;
4671
4688
  tableFrom: string;
4672
4689
  columnsFrom: string[];
4673
4690
  tableTo: string;
4674
4691
  columnsTo: string[];
4675
- onUpdate?: string | undefined;
4676
- onDelete?: string | undefined;
4677
- schemaTo?: string | undefined;
4678
4692
  }>;
4679
4693
  schema: string;
4680
4694
  compositePrimaryKeys: Record<string, {
4681
4695
  name: string;
4682
4696
  columns: string[];
4683
4697
  }>;
4684
- uniqueConstraints?: Record<string, {
4685
- name: string;
4686
- columns: string[];
4687
- nullsNotDistinct: boolean;
4688
- }> | undefined;
4689
4698
  }>;
4690
4699
  id: string;
4691
4700
  prevId: string;
4692
4701
  version: "6";
4693
- dialect: "pg";
4702
+ dialect: "postgresql";
4694
4703
  schemas: Record<string, string>;
4695
4704
  _meta: {
4696
4705
  columns: Record<string, string>;
@@ -4702,15 +4711,6 @@ export declare const backwardCompatiblePgSchema: import("zod").ZodUnion<[import(
4702
4711
  values: string[];
4703
4712
  schema: string;
4704
4713
  }>;
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,18 +4725,27 @@ 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;
4728
4737
  tables: Record<string, {
4729
4738
  name: string;
4730
4739
  columns: Record<string, {
4731
- name: string;
4732
- type: string;
4733
- primaryKey: boolean;
4734
- notNull: boolean;
4735
4740
  isUnique?: any;
4736
4741
  default?: any;
4737
4742
  typeSchema?: string | undefined;
4738
4743
  uniqueName?: string | undefined;
4739
4744
  nullsNotDistinct?: boolean | undefined;
4745
+ name: string;
4746
+ type: string;
4747
+ primaryKey: boolean;
4748
+ notNull: boolean;
4740
4749
  }>;
4741
4750
  indexes: Record<string, {
4742
4751
  name: string;
@@ -4744,14 +4753,14 @@ export declare const dryPg: {
4744
4753
  isUnique: boolean;
4745
4754
  }>;
4746
4755
  foreignKeys: Record<string, {
4756
+ onUpdate?: string | undefined;
4757
+ onDelete?: string | undefined;
4758
+ schemaTo?: string | undefined;
4747
4759
  name: string;
4748
4760
  tableFrom: string;
4749
4761
  columnsFrom: string[];
4750
4762
  tableTo: string;
4751
4763
  columnsTo: string[];
4752
- onUpdate?: string | undefined;
4753
- onDelete?: string | undefined;
4754
- schemaTo?: string | undefined;
4755
4764
  }>;
4756
4765
  schema: string;
4757
4766
  compositePrimaryKeys: Record<string, {
@@ -4767,7 +4776,7 @@ export declare const dryPg: {
4767
4776
  id: string;
4768
4777
  prevId: string;
4769
4778
  version: "6";
4770
- dialect: "pg";
4779
+ dialect: "postgresql";
4771
4780
  schemas: Record<string, string>;
4772
4781
  _meta: {
4773
4782
  columns: Record<string, string>;
@@ -4779,14 +4788,5 @@ export declare const dryPg: {
4779
4788
  values: string[];
4780
4789
  schema: string;
4781
4790
  }>;
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 {};