drizzle-kit 0.21.2 → 0.21.4

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 (12) hide show
  1. package/bin.cjs +34625 -26761
  2. package/index.d.mts +9 -1
  3. package/index.d.ts +9 -1
  4. package/package.json +2 -1
  5. package/payload.d.mts +177 -177
  6. package/payload.d.ts +177 -177
  7. package/payload.js +533 -454
  8. package/payload.mjs +510 -431
  9. package/utils-studio.js +934 -246
  10. package/utils-studio.mjs +908 -220
  11. package/utils.js +842 -215
  12. package/utils.mjs +817 -190
package/payload.d.ts CHANGED
@@ -4,7 +4,7 @@ import { TypeOf } from 'zod';
4
4
  import { MySql2Database } from 'drizzle-orm/mysql2';
5
5
  import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
6
6
 
7
- declare const pgSchema: zod.ZodObject<zod.extendShape<{
7
+ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
8
8
  version: zod.ZodLiteral<"6">;
9
9
  dialect: zod.ZodLiteral<"postgresql">;
10
10
  tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
@@ -21,25 +21,25 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
21
21
  uniqueName: zod.ZodOptional<zod.ZodString>;
22
22
  nullsNotDistinct: zod.ZodOptional<zod.ZodBoolean>;
23
23
  }, "strict", zod.ZodTypeAny, {
24
+ type: string;
25
+ name: string;
26
+ primaryKey: boolean;
27
+ notNull: boolean;
24
28
  isUnique?: any;
25
29
  default?: any;
26
30
  typeSchema?: string | undefined;
27
31
  uniqueName?: string | undefined;
28
32
  nullsNotDistinct?: boolean | undefined;
33
+ }, {
29
34
  type: string;
30
35
  name: string;
31
36
  primaryKey: boolean;
32
37
  notNull: boolean;
33
- }, {
34
38
  isUnique?: any;
35
39
  default?: any;
36
40
  typeSchema?: string | undefined;
37
41
  uniqueName?: string | undefined;
38
42
  nullsNotDistinct?: boolean | undefined;
39
- type: string;
40
- name: string;
41
- primaryKey: boolean;
42
- notNull: boolean;
43
43
  }>>;
44
44
  indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
45
45
  name: zod.ZodString;
@@ -64,23 +64,23 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
64
64
  onUpdate: zod.ZodOptional<zod.ZodString>;
65
65
  onDelete: zod.ZodOptional<zod.ZodString>;
66
66
  }, "strict", zod.ZodTypeAny, {
67
- onUpdate?: string | undefined;
68
- onDelete?: string | undefined;
69
- schemaTo?: string | undefined;
70
67
  name: string;
71
68
  tableFrom: string;
72
69
  columnsFrom: string[];
73
70
  tableTo: string;
74
71
  columnsTo: string[];
75
- }, {
76
72
  onUpdate?: string | undefined;
77
73
  onDelete?: string | undefined;
78
74
  schemaTo?: string | undefined;
75
+ }, {
79
76
  name: string;
80
77
  tableFrom: string;
81
78
  columnsFrom: string[];
82
79
  tableTo: string;
83
80
  columnsTo: string[];
81
+ onUpdate?: string | undefined;
82
+ onDelete?: string | undefined;
83
+ schemaTo?: string | undefined;
84
84
  }>>;
85
85
  compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
86
86
  name: zod.ZodString;
@@ -108,15 +108,15 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
108
108
  }, "strict", zod.ZodTypeAny, {
109
109
  name: string;
110
110
  columns: Record<string, {
111
+ type: string;
112
+ name: string;
113
+ primaryKey: boolean;
114
+ notNull: boolean;
111
115
  isUnique?: any;
112
116
  default?: any;
113
117
  typeSchema?: string | undefined;
114
118
  uniqueName?: string | undefined;
115
119
  nullsNotDistinct?: boolean | undefined;
116
- type: string;
117
- name: string;
118
- primaryKey: boolean;
119
- notNull: boolean;
120
120
  }>;
121
121
  indexes: Record<string, {
122
122
  name: string;
@@ -124,14 +124,14 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
124
124
  isUnique: boolean;
125
125
  }>;
126
126
  foreignKeys: Record<string, {
127
- onUpdate?: string | undefined;
128
- onDelete?: string | undefined;
129
- schemaTo?: string | undefined;
130
127
  name: string;
131
128
  tableFrom: string;
132
129
  columnsFrom: string[];
133
130
  tableTo: string;
134
131
  columnsTo: string[];
132
+ onUpdate?: string | undefined;
133
+ onDelete?: string | undefined;
134
+ schemaTo?: string | undefined;
135
135
  }>;
136
136
  schema: string;
137
137
  compositePrimaryKeys: Record<string, {
@@ -144,22 +144,17 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
144
144
  nullsNotDistinct: boolean;
145
145
  }>;
146
146
  }, {
147
- uniqueConstraints?: Record<string, {
148
- name: string;
149
- columns: string[];
150
- nullsNotDistinct: boolean;
151
- }> | undefined;
152
147
  name: string;
153
148
  columns: Record<string, {
149
+ type: string;
150
+ name: string;
151
+ primaryKey: boolean;
152
+ notNull: boolean;
154
153
  isUnique?: any;
155
154
  default?: any;
156
155
  typeSchema?: string | undefined;
157
156
  uniqueName?: string | undefined;
158
157
  nullsNotDistinct?: boolean | undefined;
159
- type: string;
160
- name: string;
161
- primaryKey: boolean;
162
- notNull: boolean;
163
158
  }>;
164
159
  indexes: Record<string, {
165
160
  name: string;
@@ -167,20 +162,25 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
167
162
  isUnique: boolean;
168
163
  }>;
169
164
  foreignKeys: Record<string, {
170
- onUpdate?: string | undefined;
171
- onDelete?: string | undefined;
172
- schemaTo?: string | undefined;
173
165
  name: string;
174
166
  tableFrom: string;
175
167
  columnsFrom: string[];
176
168
  tableTo: string;
177
169
  columnsTo: string[];
170
+ onUpdate?: string | undefined;
171
+ onDelete?: string | undefined;
172
+ schemaTo?: string | undefined;
178
173
  }>;
179
174
  schema: string;
180
175
  compositePrimaryKeys: Record<string, {
181
176
  name: string;
182
177
  columns: string[];
183
178
  }>;
179
+ uniqueConstraints?: Record<string, {
180
+ name: string;
181
+ columns: string[];
182
+ nullsNotDistinct: boolean;
183
+ }> | undefined;
184
184
  }>>;
185
185
  enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
186
186
  name: zod.ZodString;
@@ -258,27 +258,18 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
258
258
  id: zod.ZodString;
259
259
  prevId: zod.ZodString;
260
260
  }>, "strip", zod.ZodTypeAny, {
261
- internal?: {
262
- tables: Record<string, {
263
- columns: Record<string, {
264
- isArray?: boolean | undefined;
265
- dimensions?: number | undefined;
266
- rawType?: string | undefined;
267
- } | undefined>;
268
- } | undefined>;
269
- } | undefined;
270
261
  tables: Record<string, {
271
262
  name: string;
272
263
  columns: Record<string, {
264
+ type: string;
265
+ name: string;
266
+ primaryKey: boolean;
267
+ notNull: boolean;
273
268
  isUnique?: any;
274
269
  default?: any;
275
270
  typeSchema?: string | undefined;
276
271
  uniqueName?: string | undefined;
277
272
  nullsNotDistinct?: boolean | undefined;
278
- type: string;
279
- name: string;
280
- primaryKey: boolean;
281
- notNull: boolean;
282
273
  }>;
283
274
  indexes: Record<string, {
284
275
  name: string;
@@ -286,14 +277,14 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
286
277
  isUnique: boolean;
287
278
  }>;
288
279
  foreignKeys: Record<string, {
289
- onUpdate?: string | undefined;
290
- onDelete?: string | undefined;
291
- schemaTo?: string | undefined;
292
280
  name: string;
293
281
  tableFrom: string;
294
282
  columnsFrom: string[];
295
283
  tableTo: string;
296
284
  columnsTo: string[];
285
+ onUpdate?: string | undefined;
286
+ onDelete?: string | undefined;
287
+ schemaTo?: string | undefined;
297
288
  }>;
298
289
  schema: string;
299
290
  compositePrimaryKeys: Record<string, {
@@ -321,7 +312,6 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
321
312
  name: string;
322
313
  schema: string;
323
314
  }>;
324
- }, {
325
315
  internal?: {
326
316
  tables: Record<string, {
327
317
  columns: Record<string, {
@@ -331,23 +321,19 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
331
321
  } | undefined>;
332
322
  } | undefined>;
333
323
  } | undefined;
324
+ }, {
334
325
  tables: Record<string, {
335
- uniqueConstraints?: Record<string, {
336
- name: string;
337
- columns: string[];
338
- nullsNotDistinct: boolean;
339
- }> | undefined;
340
326
  name: string;
341
327
  columns: Record<string, {
328
+ type: string;
329
+ name: string;
330
+ primaryKey: boolean;
331
+ notNull: boolean;
342
332
  isUnique?: any;
343
333
  default?: any;
344
334
  typeSchema?: string | undefined;
345
335
  uniqueName?: string | undefined;
346
336
  nullsNotDistinct?: boolean | undefined;
347
- type: string;
348
- name: string;
349
- primaryKey: boolean;
350
- notNull: boolean;
351
337
  }>;
352
338
  indexes: Record<string, {
353
339
  name: string;
@@ -355,20 +341,25 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
355
341
  isUnique: boolean;
356
342
  }>;
357
343
  foreignKeys: Record<string, {
358
- onUpdate?: string | undefined;
359
- onDelete?: string | undefined;
360
- schemaTo?: string | undefined;
361
344
  name: string;
362
345
  tableFrom: string;
363
346
  columnsFrom: string[];
364
347
  tableTo: string;
365
348
  columnsTo: string[];
349
+ onUpdate?: string | undefined;
350
+ onDelete?: string | undefined;
351
+ schemaTo?: string | undefined;
366
352
  }>;
367
353
  schema: string;
368
354
  compositePrimaryKeys: Record<string, {
369
355
  name: string;
370
356
  columns: string[];
371
357
  }>;
358
+ uniqueConstraints?: Record<string, {
359
+ name: string;
360
+ columns: string[];
361
+ nullsNotDistinct: boolean;
362
+ }> | undefined;
372
363
  }>;
373
364
  id: string;
374
365
  prevId: string;
@@ -385,10 +376,19 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
385
376
  name: string;
386
377
  schema: string;
387
378
  }>;
379
+ internal?: {
380
+ tables: Record<string, {
381
+ columns: Record<string, {
382
+ isArray?: boolean | undefined;
383
+ dimensions?: number | undefined;
384
+ rawType?: string | undefined;
385
+ } | undefined>;
386
+ } | undefined>;
387
+ } | undefined;
388
388
  }>;
389
389
  type PgSchema = TypeOf<typeof pgSchema>;
390
390
 
391
- declare const schema$1: zod.ZodObject<zod.extendShape<{
391
+ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
392
392
  version: zod.ZodLiteral<"6">;
393
393
  dialect: zod.ZodEnum<["sqlite"]>;
394
394
  tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
@@ -401,19 +401,19 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
401
401
  autoincrement: zod.ZodOptional<zod.ZodBoolean>;
402
402
  default: zod.ZodOptional<zod.ZodAny>;
403
403
  }, "strict", zod.ZodTypeAny, {
404
- default?: any;
405
- autoincrement?: boolean | undefined;
406
404
  type: string;
407
405
  name: string;
408
406
  primaryKey: boolean;
409
407
  notNull: boolean;
410
- }, {
411
408
  default?: any;
412
409
  autoincrement?: boolean | undefined;
410
+ }, {
413
411
  type: string;
414
412
  name: string;
415
413
  primaryKey: boolean;
416
414
  notNull: boolean;
415
+ default?: any;
416
+ autoincrement?: boolean | undefined;
417
417
  }>>;
418
418
  indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
419
419
  name: zod.ZodString;
@@ -421,15 +421,15 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
421
421
  where: zod.ZodOptional<zod.ZodString>;
422
422
  isUnique: zod.ZodBoolean;
423
423
  }, "strict", zod.ZodTypeAny, {
424
- where?: string | undefined;
425
424
  name: string;
426
425
  columns: string[];
427
426
  isUnique: boolean;
428
- }, {
429
427
  where?: string | undefined;
428
+ }, {
430
429
  name: string;
431
430
  columns: string[];
432
431
  isUnique: boolean;
432
+ where?: string | undefined;
433
433
  }>>;
434
434
  foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
435
435
  name: zod.ZodString;
@@ -440,31 +440,31 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
440
440
  onUpdate: zod.ZodOptional<zod.ZodString>;
441
441
  onDelete: zod.ZodOptional<zod.ZodString>;
442
442
  }, "strict", zod.ZodTypeAny, {
443
- onUpdate?: string | undefined;
444
- onDelete?: string | undefined;
445
443
  name: string;
446
444
  tableFrom: string;
447
445
  columnsFrom: string[];
448
446
  tableTo: string;
449
447
  columnsTo: string[];
450
- }, {
451
448
  onUpdate?: string | undefined;
452
449
  onDelete?: string | undefined;
450
+ }, {
453
451
  name: string;
454
452
  tableFrom: string;
455
453
  columnsFrom: string[];
456
454
  tableTo: string;
457
455
  columnsTo: string[];
456
+ onUpdate?: string | undefined;
457
+ onDelete?: string | undefined;
458
458
  }>>;
459
459
  compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
460
460
  columns: zod.ZodArray<zod.ZodString, "many">;
461
461
  name: zod.ZodOptional<zod.ZodString>;
462
462
  }, "strict", zod.ZodTypeAny, {
463
- name?: string | undefined;
464
463
  columns: string[];
465
- }, {
466
464
  name?: string | undefined;
465
+ }, {
467
466
  columns: string[];
467
+ name?: string | undefined;
468
468
  }>>;
469
469
  uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
470
470
  name: zod.ZodString;
@@ -479,69 +479,69 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
479
479
  }, "strict", zod.ZodTypeAny, {
480
480
  name: string;
481
481
  columns: Record<string, {
482
- default?: any;
483
- autoincrement?: boolean | undefined;
484
482
  type: string;
485
483
  name: string;
486
484
  primaryKey: boolean;
487
485
  notNull: boolean;
486
+ default?: any;
487
+ autoincrement?: boolean | undefined;
488
488
  }>;
489
489
  indexes: Record<string, {
490
- where?: string | undefined;
491
490
  name: string;
492
491
  columns: string[];
493
492
  isUnique: boolean;
493
+ where?: string | undefined;
494
494
  }>;
495
495
  foreignKeys: Record<string, {
496
- onUpdate?: string | undefined;
497
- onDelete?: string | undefined;
498
496
  name: string;
499
497
  tableFrom: string;
500
498
  columnsFrom: string[];
501
499
  tableTo: string;
502
500
  columnsTo: string[];
501
+ onUpdate?: string | undefined;
502
+ onDelete?: string | undefined;
503
503
  }>;
504
504
  compositePrimaryKeys: Record<string, {
505
- name?: string | undefined;
506
505
  columns: string[];
506
+ name?: string | undefined;
507
507
  }>;
508
508
  uniqueConstraints: Record<string, {
509
509
  name: string;
510
510
  columns: string[];
511
511
  }>;
512
512
  }, {
513
- uniqueConstraints?: Record<string, {
514
- name: string;
515
- columns: string[];
516
- }> | undefined;
517
513
  name: string;
518
514
  columns: Record<string, {
519
- default?: any;
520
- autoincrement?: boolean | undefined;
521
515
  type: string;
522
516
  name: string;
523
517
  primaryKey: boolean;
524
518
  notNull: boolean;
519
+ default?: any;
520
+ autoincrement?: boolean | undefined;
525
521
  }>;
526
522
  indexes: Record<string, {
527
- where?: string | undefined;
528
523
  name: string;
529
524
  columns: string[];
530
525
  isUnique: boolean;
526
+ where?: string | undefined;
531
527
  }>;
532
528
  foreignKeys: Record<string, {
533
- onUpdate?: string | undefined;
534
- onDelete?: string | undefined;
535
529
  name: string;
536
530
  tableFrom: string;
537
531
  columnsFrom: string[];
538
532
  tableTo: string;
539
533
  columnsTo: string[];
534
+ onUpdate?: string | undefined;
535
+ onDelete?: string | undefined;
540
536
  }>;
541
537
  compositePrimaryKeys: Record<string, {
542
- name?: string | undefined;
543
538
  columns: string[];
539
+ name?: string | undefined;
544
540
  }>;
541
+ uniqueConstraints?: Record<string, {
542
+ name: string;
543
+ columns: string[];
544
+ }> | undefined;
545
545
  }>>;
546
546
  enums: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
547
547
  _meta: zod.ZodObject<{
@@ -561,31 +561,31 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
561
561
  tables: Record<string, {
562
562
  name: string;
563
563
  columns: Record<string, {
564
- default?: any;
565
- autoincrement?: boolean | undefined;
566
564
  type: string;
567
565
  name: string;
568
566
  primaryKey: boolean;
569
567
  notNull: boolean;
568
+ default?: any;
569
+ autoincrement?: boolean | undefined;
570
570
  }>;
571
571
  indexes: Record<string, {
572
- where?: string | undefined;
573
572
  name: string;
574
573
  columns: string[];
575
574
  isUnique: boolean;
575
+ where?: string | undefined;
576
576
  }>;
577
577
  foreignKeys: Record<string, {
578
- onUpdate?: string | undefined;
579
- onDelete?: string | undefined;
580
578
  name: string;
581
579
  tableFrom: string;
582
580
  columnsFrom: string[];
583
581
  tableTo: string;
584
582
  columnsTo: string[];
583
+ onUpdate?: string | undefined;
584
+ onDelete?: string | undefined;
585
585
  }>;
586
586
  compositePrimaryKeys: Record<string, {
587
- name?: string | undefined;
588
587
  columns: string[];
588
+ name?: string | undefined;
589
589
  }>;
590
590
  uniqueConstraints: Record<string, {
591
591
  name: string;
@@ -603,38 +603,38 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
603
603
  enums: {};
604
604
  }, {
605
605
  tables: Record<string, {
606
- uniqueConstraints?: Record<string, {
607
- name: string;
608
- columns: string[];
609
- }> | undefined;
610
606
  name: string;
611
607
  columns: Record<string, {
612
- default?: any;
613
- autoincrement?: boolean | undefined;
614
608
  type: string;
615
609
  name: string;
616
610
  primaryKey: boolean;
617
611
  notNull: boolean;
612
+ default?: any;
613
+ autoincrement?: boolean | undefined;
618
614
  }>;
619
615
  indexes: Record<string, {
620
- where?: string | undefined;
621
616
  name: string;
622
617
  columns: string[];
623
618
  isUnique: boolean;
619
+ where?: string | undefined;
624
620
  }>;
625
621
  foreignKeys: Record<string, {
626
- onUpdate?: string | undefined;
627
- onDelete?: string | undefined;
628
622
  name: string;
629
623
  tableFrom: string;
630
624
  columnsFrom: string[];
631
625
  tableTo: string;
632
626
  columnsTo: string[];
627
+ onUpdate?: string | undefined;
628
+ onDelete?: string | undefined;
633
629
  }>;
634
630
  compositePrimaryKeys: Record<string, {
635
- name?: string | undefined;
636
631
  columns: string[];
632
+ name?: string | undefined;
637
633
  }>;
634
+ uniqueConstraints?: Record<string, {
635
+ name: string;
636
+ columns: string[];
637
+ }> | undefined;
638
638
  }>;
639
639
  id: string;
640
640
  prevId: string;
@@ -648,7 +648,7 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
648
648
  }>;
649
649
  type SQLiteSchema = TypeOf<typeof schema$1>;
650
650
 
651
- declare const schema: zod.ZodObject<zod.extendShape<{
651
+ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
652
652
  version: zod.ZodLiteral<"5">;
653
653
  dialect: zod.ZodLiteral<"mysql">;
654
654
  tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
@@ -662,21 +662,21 @@ declare const schema: zod.ZodObject<zod.extendShape<{
662
662
  default: zod.ZodOptional<zod.ZodAny>;
663
663
  onUpdate: zod.ZodOptional<zod.ZodAny>;
664
664
  }, "strict", zod.ZodTypeAny, {
665
- default?: any;
666
- onUpdate?: any;
667
- autoincrement?: boolean | undefined;
668
665
  type: string;
669
666
  name: string;
670
667
  primaryKey: boolean;
671
668
  notNull: boolean;
672
- }, {
673
669
  default?: any;
674
670
  onUpdate?: any;
675
671
  autoincrement?: boolean | undefined;
672
+ }, {
676
673
  type: string;
677
674
  name: string;
678
675
  primaryKey: boolean;
679
676
  notNull: boolean;
677
+ default?: any;
678
+ onUpdate?: any;
679
+ autoincrement?: boolean | undefined;
680
680
  }>>;
681
681
  indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
682
682
  name: zod.ZodString;
@@ -686,19 +686,19 @@ declare const schema: zod.ZodObject<zod.extendShape<{
686
686
  algorithm: zod.ZodOptional<zod.ZodEnum<["default", "inplace", "copy"]>>;
687
687
  lock: zod.ZodOptional<zod.ZodEnum<["default", "none", "shared", "exclusive"]>>;
688
688
  }, "strict", zod.ZodTypeAny, {
689
- using?: "btree" | "hash" | undefined;
690
- algorithm?: "default" | "inplace" | "copy" | undefined;
691
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
692
689
  name: string;
693
690
  columns: string[];
694
691
  isUnique: boolean;
695
- }, {
696
692
  using?: "btree" | "hash" | undefined;
697
693
  algorithm?: "default" | "inplace" | "copy" | undefined;
698
694
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
695
+ }, {
699
696
  name: string;
700
697
  columns: string[];
701
698
  isUnique: boolean;
699
+ using?: "btree" | "hash" | undefined;
700
+ algorithm?: "default" | "inplace" | "copy" | undefined;
701
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
702
702
  }>>;
703
703
  foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
704
704
  name: zod.ZodString;
@@ -709,21 +709,21 @@ declare const schema: zod.ZodObject<zod.extendShape<{
709
709
  onUpdate: zod.ZodOptional<zod.ZodString>;
710
710
  onDelete: zod.ZodOptional<zod.ZodString>;
711
711
  }, "strict", zod.ZodTypeAny, {
712
- onUpdate?: string | undefined;
713
- onDelete?: string | undefined;
714
712
  name: string;
715
713
  tableFrom: string;
716
714
  columnsFrom: string[];
717
715
  tableTo: string;
718
716
  columnsTo: string[];
719
- }, {
720
717
  onUpdate?: string | undefined;
721
718
  onDelete?: string | undefined;
719
+ }, {
722
720
  name: string;
723
721
  tableFrom: string;
724
722
  columnsFrom: string[];
725
723
  tableTo: string;
726
724
  columnsTo: string[];
725
+ onUpdate?: string | undefined;
726
+ onDelete?: string | undefined;
727
727
  }>>;
728
728
  compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
729
729
  name: zod.ZodString;
@@ -748,30 +748,30 @@ declare const schema: zod.ZodObject<zod.extendShape<{
748
748
  }, "strict", zod.ZodTypeAny, {
749
749
  name: string;
750
750
  columns: Record<string, {
751
- default?: any;
752
- onUpdate?: any;
753
- autoincrement?: boolean | undefined;
754
751
  type: string;
755
752
  name: string;
756
753
  primaryKey: boolean;
757
754
  notNull: boolean;
755
+ default?: any;
756
+ onUpdate?: any;
757
+ autoincrement?: boolean | undefined;
758
758
  }>;
759
759
  indexes: Record<string, {
760
- using?: "btree" | "hash" | undefined;
761
- algorithm?: "default" | "inplace" | "copy" | undefined;
762
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
763
760
  name: string;
764
761
  columns: string[];
765
762
  isUnique: boolean;
763
+ using?: "btree" | "hash" | undefined;
764
+ algorithm?: "default" | "inplace" | "copy" | undefined;
765
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
766
766
  }>;
767
767
  foreignKeys: Record<string, {
768
- onUpdate?: string | undefined;
769
- onDelete?: string | undefined;
770
768
  name: string;
771
769
  tableFrom: string;
772
770
  columnsFrom: string[];
773
771
  tableTo: string;
774
772
  columnsTo: string[];
773
+ onUpdate?: string | undefined;
774
+ onDelete?: string | undefined;
775
775
  }>;
776
776
  compositePrimaryKeys: Record<string, {
777
777
  name: string;
@@ -782,41 +782,41 @@ declare const schema: zod.ZodObject<zod.extendShape<{
782
782
  columns: string[];
783
783
  }>;
784
784
  }, {
785
- uniqueConstraints?: Record<string, {
786
- name: string;
787
- columns: string[];
788
- }> | undefined;
789
785
  name: string;
790
786
  columns: Record<string, {
791
- default?: any;
792
- onUpdate?: any;
793
- autoincrement?: boolean | undefined;
794
787
  type: string;
795
788
  name: string;
796
789
  primaryKey: boolean;
797
790
  notNull: boolean;
791
+ default?: any;
792
+ onUpdate?: any;
793
+ autoincrement?: boolean | undefined;
798
794
  }>;
799
795
  indexes: Record<string, {
800
- using?: "btree" | "hash" | undefined;
801
- algorithm?: "default" | "inplace" | "copy" | undefined;
802
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
803
796
  name: string;
804
797
  columns: string[];
805
798
  isUnique: boolean;
799
+ using?: "btree" | "hash" | undefined;
800
+ algorithm?: "default" | "inplace" | "copy" | undefined;
801
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
806
802
  }>;
807
803
  foreignKeys: Record<string, {
808
- onUpdate?: string | undefined;
809
- onDelete?: string | undefined;
810
804
  name: string;
811
805
  tableFrom: string;
812
806
  columnsFrom: string[];
813
807
  tableTo: string;
814
808
  columnsTo: string[];
809
+ onUpdate?: string | undefined;
810
+ onDelete?: string | undefined;
815
811
  }>;
816
812
  compositePrimaryKeys: Record<string, {
817
813
  name: string;
818
814
  columns: string[];
819
815
  }>;
816
+ uniqueConstraints?: Record<string, {
817
+ name: string;
818
+ columns: string[];
819
+ }> | undefined;
820
820
  }>>;
821
821
  _meta: zod.ZodObject<{
822
822
  tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
@@ -863,40 +863,33 @@ declare const schema: zod.ZodObject<zod.extendShape<{
863
863
  id: zod.ZodString;
864
864
  prevId: zod.ZodString;
865
865
  }>, "strip", zod.ZodTypeAny, {
866
- internal?: {
867
- tables: Record<string, {
868
- columns: Record<string, {
869
- isDefaultAnExpression?: boolean | undefined;
870
- } | undefined>;
871
- } | undefined>;
872
- } | undefined;
873
866
  tables: Record<string, {
874
867
  name: string;
875
868
  columns: Record<string, {
876
- default?: any;
877
- onUpdate?: any;
878
- autoincrement?: boolean | undefined;
879
869
  type: string;
880
870
  name: string;
881
871
  primaryKey: boolean;
882
872
  notNull: boolean;
873
+ default?: any;
874
+ onUpdate?: any;
875
+ autoincrement?: boolean | undefined;
883
876
  }>;
884
877
  indexes: Record<string, {
885
- using?: "btree" | "hash" | undefined;
886
- algorithm?: "default" | "inplace" | "copy" | undefined;
887
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
888
878
  name: string;
889
879
  columns: string[];
890
880
  isUnique: boolean;
881
+ using?: "btree" | "hash" | undefined;
882
+ algorithm?: "default" | "inplace" | "copy" | undefined;
883
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
891
884
  }>;
892
885
  foreignKeys: Record<string, {
893
- onUpdate?: string | undefined;
894
- onDelete?: string | undefined;
895
886
  name: string;
896
887
  tableFrom: string;
897
888
  columnsFrom: string[];
898
889
  tableTo: string;
899
890
  columnsTo: string[];
891
+ onUpdate?: string | undefined;
892
+ onDelete?: string | undefined;
900
893
  }>;
901
894
  compositePrimaryKeys: Record<string, {
902
895
  name: string;
@@ -915,7 +908,6 @@ declare const schema: zod.ZodObject<zod.extendShape<{
915
908
  columns: Record<string, string>;
916
909
  tables: Record<string, string>;
917
910
  };
918
- }, {
919
911
  internal?: {
920
912
  tables: Record<string, {
921
913
  columns: Record<string, {
@@ -923,42 +915,43 @@ declare const schema: zod.ZodObject<zod.extendShape<{
923
915
  } | undefined>;
924
916
  } | undefined>;
925
917
  } | undefined;
918
+ }, {
926
919
  tables: Record<string, {
927
- uniqueConstraints?: Record<string, {
928
- name: string;
929
- columns: string[];
930
- }> | undefined;
931
920
  name: string;
932
921
  columns: Record<string, {
933
- default?: any;
934
- onUpdate?: any;
935
- autoincrement?: boolean | undefined;
936
922
  type: string;
937
923
  name: string;
938
924
  primaryKey: boolean;
939
925
  notNull: boolean;
926
+ default?: any;
927
+ onUpdate?: any;
928
+ autoincrement?: boolean | undefined;
940
929
  }>;
941
930
  indexes: Record<string, {
942
- using?: "btree" | "hash" | undefined;
943
- algorithm?: "default" | "inplace" | "copy" | undefined;
944
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
945
931
  name: string;
946
932
  columns: string[];
947
933
  isUnique: boolean;
934
+ using?: "btree" | "hash" | undefined;
935
+ algorithm?: "default" | "inplace" | "copy" | undefined;
936
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
948
937
  }>;
949
938
  foreignKeys: Record<string, {
950
- onUpdate?: string | undefined;
951
- onDelete?: string | undefined;
952
939
  name: string;
953
940
  tableFrom: string;
954
941
  columnsFrom: string[];
955
942
  tableTo: string;
956
943
  columnsTo: string[];
944
+ onUpdate?: string | undefined;
945
+ onDelete?: string | undefined;
957
946
  }>;
958
947
  compositePrimaryKeys: Record<string, {
959
948
  name: string;
960
949
  columns: string[];
961
950
  }>;
951
+ uniqueConstraints?: Record<string, {
952
+ name: string;
953
+ columns: string[];
954
+ }> | undefined;
962
955
  }>;
963
956
  id: string;
964
957
  prevId: string;
@@ -968,6 +961,13 @@ declare const schema: zod.ZodObject<zod.extendShape<{
968
961
  columns: Record<string, string>;
969
962
  tables: Record<string, string>;
970
963
  };
964
+ internal?: {
965
+ tables: Record<string, {
966
+ columns: Record<string, {
967
+ isDefaultAnExpression?: boolean | undefined;
968
+ } | undefined>;
969
+ } | undefined>;
970
+ } | undefined;
971
971
  }>;
972
972
  type MySqlSchema = TypeOf<typeof schema>;
973
973
 
@@ -999,30 +999,21 @@ declare const pushMySQLSchema: (imports: Record<string, unknown>, drizzleInstanc
999
999
  apply: () => Promise<void>;
1000
1000
  }>;
1001
1001
  declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
1002
- internal?: {
1003
- tables: Record<string, {
1004
- columns: Record<string, {
1005
- isArray?: boolean | undefined;
1006
- dimensions?: number | undefined;
1007
- rawType?: string | undefined;
1008
- } | undefined>;
1009
- } | undefined>;
1010
- } | undefined;
1011
1002
  version: "6";
1012
1003
  dialect: "postgresql";
1013
1004
  tables: Record<string, {
1014
1005
  name: string;
1015
1006
  schema: string;
1016
1007
  columns: Record<string, {
1008
+ type: string;
1009
+ name: string;
1010
+ primaryKey: boolean;
1011
+ notNull: boolean;
1017
1012
  typeSchema?: string | undefined;
1018
1013
  default?: any;
1019
1014
  isUnique?: any;
1020
1015
  uniqueName?: string | undefined;
1021
1016
  nullsNotDistinct?: boolean | undefined;
1022
- type: string;
1023
- name: string;
1024
- primaryKey: boolean;
1025
- notNull: boolean;
1026
1017
  }>;
1027
1018
  indexes: Record<string, {
1028
1019
  name: string;
@@ -1030,14 +1021,14 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
1030
1021
  isUnique: boolean;
1031
1022
  }>;
1032
1023
  foreignKeys: Record<string, {
1033
- schemaTo?: string | undefined;
1034
- onUpdate?: string | undefined;
1035
- onDelete?: string | undefined;
1036
1024
  name: string;
1037
1025
  tableFrom: string;
1038
1026
  columnsFrom: string[];
1039
1027
  tableTo: string;
1040
1028
  columnsTo: string[];
1029
+ schemaTo?: string | undefined;
1030
+ onUpdate?: string | undefined;
1031
+ onDelete?: string | undefined;
1041
1032
  }>;
1042
1033
  compositePrimaryKeys: Record<string, {
1043
1034
  name: string;
@@ -1062,6 +1053,15 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
1062
1053
  };
1063
1054
  id: string;
1064
1055
  prevId: string;
1056
+ internal?: {
1057
+ tables: Record<string, {
1058
+ columns: Record<string, {
1059
+ isArray?: boolean | undefined;
1060
+ dimensions?: number | undefined;
1061
+ rawType?: string | undefined;
1062
+ } | undefined>;
1063
+ } | undefined>;
1064
+ } | undefined;
1065
1065
  };
1066
1066
 
1067
1067
  export { type DrizzleMySQLSnapshotJSON, type DrizzleSQLiteSnapshotJSON, type DrizzleSnapshotJSON, generateDrizzleJson, generateMigration, generateMySQLDrizzleJson, generateMySQLMigration, generateSQLiteDrizzleJson, generateSQLiteMigration, pushMySQLSchema, pushSQLiteSchema, pushSchema, upPgSnapshot };