drizzle-kit 0.20.17-f1d07ae → 0.20.17-ff96495

Sign up to get free protection for your applications and to get access to all the features.
Files changed (21) hide show
  1. package/bin.cjs +18143 -7454
  2. package/cli/commands/migrate.d.ts +39 -39
  3. package/cli/commands/mysqlIntrospect.d.ts +8 -8
  4. package/cli/commands/pgIntrospect.d.ts +7 -7
  5. package/cli/commands/sqliteIntrospect.d.ts +12 -12
  6. package/cli/validations/cli.d.ts +13 -13
  7. package/cli/validations/common.d.ts +27 -27
  8. package/cli/validations/mysql.d.ts +4 -4
  9. package/cli/validations/pg.d.ts +4 -4
  10. package/package.json +2 -1
  11. package/payload.js +1027 -406
  12. package/payload.mjs +834 -213
  13. package/schemaValidator.d.ts +215 -215
  14. package/serializer/mysqlSchema.d.ts +892 -892
  15. package/serializer/pgSchema.d.ts +734 -734
  16. package/serializer/sqliteSchema.d.ts +457 -457
  17. package/snapshotsDiffer.d.ts +314 -314
  18. package/utils-studio.js +939 -833
  19. package/utils-studio.mjs +912 -806
  20. package/utils.js +839 -214
  21. package/utils.mjs +814 -189
package/schemaValidator.d.ts CHANGED
@@ -18,25 +18,25 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
18
18
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
19
19
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
20
20
  }, "strict", import("zod").ZodTypeAny, {
21
+ name: string;
22
+ type: string;
23
+ primaryKey: boolean;
24
+ notNull: boolean;
21
25
  isUnique?: any;
22
26
  default?: any;
23
27
  typeSchema?: string | undefined;
24
28
  uniqueName?: string | undefined;
25
29
  nullsNotDistinct?: boolean | undefined;
30
+ }, {
26
31
  name: string;
27
32
  type: string;
28
33
  primaryKey: boolean;
29
34
  notNull: boolean;
30
- }, {
31
35
  isUnique?: any;
32
36
  default?: any;
33
37
  typeSchema?: string | undefined;
34
38
  uniqueName?: string | undefined;
35
39
  nullsNotDistinct?: boolean | undefined;
36
- name: string;
37
- type: string;
38
- primaryKey: boolean;
39
- notNull: boolean;
40
40
  }>>;
41
41
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
42
42
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -45,15 +45,15 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
45
45
  }, "strict", import("zod").ZodTypeAny, {
46
46
  name: string;
47
47
  columns: Record<string, {
48
+ name: string;
49
+ type: string;
50
+ primaryKey: boolean;
51
+ notNull: boolean;
48
52
  isUnique?: any;
49
53
  default?: any;
50
54
  typeSchema?: string | undefined;
51
55
  uniqueName?: string | undefined;
52
56
  nullsNotDistinct?: boolean | undefined;
53
- name: string;
54
- type: string;
55
- primaryKey: boolean;
56
- notNull: boolean;
57
57
  }>;
58
58
  indexes: Record<string, string>;
59
59
  foreignKeys: Record<string, string>;
@@ -63,15 +63,15 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
63
63
  }, {
64
64
  name: string;
65
65
  columns: Record<string, {
66
+ name: string;
67
+ type: string;
68
+ primaryKey: boolean;
69
+ notNull: boolean;
66
70
  isUnique?: any;
67
71
  default?: any;
68
72
  typeSchema?: string | undefined;
69
73
  uniqueName?: string | undefined;
70
74
  nullsNotDistinct?: boolean | undefined;
71
- name: string;
72
- type: string;
73
- primaryKey: boolean;
74
- notNull: boolean;
75
75
  }>;
76
76
  indexes: Record<string, string>;
77
77
  foreignKeys: Record<string, string>;
@@ -97,15 +97,15 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
97
97
  tables: Record<string, {
98
98
  name: string;
99
99
  columns: Record<string, {
100
+ name: string;
101
+ type: string;
102
+ primaryKey: boolean;
103
+ notNull: boolean;
100
104
  isUnique?: any;
101
105
  default?: any;
102
106
  typeSchema?: string | undefined;
103
107
  uniqueName?: string | undefined;
104
108
  nullsNotDistinct?: boolean | undefined;
105
- name: string;
106
- type: string;
107
- primaryKey: boolean;
108
- notNull: boolean;
109
109
  }>;
110
110
  indexes: Record<string, string>;
111
111
  foreignKeys: Record<string, string>;
@@ -125,15 +125,15 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
125
125
  tables: Record<string, {
126
126
  name: string;
127
127
  columns: Record<string, {
128
+ name: string;
129
+ type: string;
130
+ primaryKey: boolean;
131
+ notNull: boolean;
128
132
  isUnique?: any;
129
133
  default?: any;
130
134
  typeSchema?: string | undefined;
131
135
  uniqueName?: string | undefined;
132
136
  nullsNotDistinct?: boolean | undefined;
133
- name: string;
134
- type: string;
135
- primaryKey: boolean;
136
- notNull: boolean;
137
137
  }>;
138
138
  indexes: Record<string, string>;
139
139
  foreignKeys: Record<string, string>;
@@ -163,21 +163,21 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
163
163
  default: import("zod").ZodOptional<import("zod").ZodAny>;
164
164
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
165
165
  }, "strict", import("zod").ZodTypeAny, {
166
- default?: any;
167
- onUpdate?: any;
168
- autoincrement?: boolean | undefined;
169
166
  name: string;
170
167
  type: string;
171
168
  primaryKey: boolean;
172
169
  notNull: boolean;
173
- }, {
174
170
  default?: any;
175
171
  onUpdate?: any;
176
172
  autoincrement?: boolean | undefined;
173
+ }, {
177
174
  name: string;
178
175
  type: string;
179
176
  primaryKey: boolean;
180
177
  notNull: boolean;
178
+ default?: any;
179
+ onUpdate?: any;
180
+ autoincrement?: boolean | undefined;
181
181
  }>>;
182
182
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
183
183
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -186,45 +186,45 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
186
186
  }, "strict", import("zod").ZodTypeAny, {
187
187
  name: string;
188
188
  columns: Record<string, {
189
- default?: any;
190
- onUpdate?: any;
191
- autoincrement?: boolean | undefined;
192
189
  name: string;
193
190
  type: string;
194
191
  primaryKey: boolean;
195
192
  notNull: boolean;
193
+ default?: any;
194
+ onUpdate?: any;
195
+ autoincrement?: boolean | undefined;
196
196
  }>;
197
197
  indexes: Record<string, string>;
198
198
  foreignKeys: Record<string, string>;
199
199
  compositePrimaryKeys: Record<string, string>;
200
200
  uniqueConstraints: Record<string, string>;
201
201
  }, {
202
- uniqueConstraints?: Record<string, string> | undefined;
203
202
  name: string;
204
203
  columns: Record<string, {
205
- default?: any;
206
- onUpdate?: any;
207
- autoincrement?: boolean | undefined;
208
204
  name: string;
209
205
  type: string;
210
206
  primaryKey: boolean;
211
207
  notNull: boolean;
208
+ default?: any;
209
+ onUpdate?: any;
210
+ autoincrement?: boolean | undefined;
212
211
  }>;
213
212
  indexes: Record<string, string>;
214
213
  foreignKeys: Record<string, string>;
215
214
  compositePrimaryKeys: Record<string, string>;
215
+ uniqueConstraints?: Record<string, string> | undefined;
216
216
  }>>;
217
217
  }, "strict", import("zod").ZodTypeAny, {
218
218
  tables: Record<string, {
219
219
  name: string;
220
220
  columns: Record<string, {
221
- default?: any;
222
- onUpdate?: any;
223
- autoincrement?: boolean | undefined;
224
221
  name: string;
225
222
  type: string;
226
223
  primaryKey: boolean;
227
224
  notNull: boolean;
225
+ default?: any;
226
+ onUpdate?: any;
227
+ autoincrement?: boolean | undefined;
228
228
  }>;
229
229
  indexes: Record<string, string>;
230
230
  foreignKeys: Record<string, string>;
@@ -235,20 +235,20 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
235
235
  dialect: "mysql";
236
236
  }, {
237
237
  tables: Record<string, {
238
- uniqueConstraints?: Record<string, string> | undefined;
239
238
  name: string;
240
239
  columns: Record<string, {
241
- default?: any;
242
- onUpdate?: any;
243
- autoincrement?: boolean | undefined;
244
240
  name: string;
245
241
  type: string;
246
242
  primaryKey: boolean;
247
243
  notNull: boolean;
244
+ default?: any;
245
+ onUpdate?: any;
246
+ autoincrement?: boolean | undefined;
248
247
  }>;
249
248
  indexes: Record<string, string>;
250
249
  foreignKeys: Record<string, string>;
251
250
  compositePrimaryKeys: Record<string, string>;
251
+ uniqueConstraints?: Record<string, string> | undefined;
252
252
  }>;
253
253
  version: "5";
254
254
  dialect: "mysql";
@@ -265,19 +265,19 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
265
265
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
266
266
  default: import("zod").ZodOptional<import("zod").ZodAny>;
267
267
  }, "strict", import("zod").ZodTypeAny, {
268
- default?: any;
269
- autoincrement?: boolean | undefined;
270
268
  name: string;
271
269
  type: string;
272
270
  primaryKey: boolean;
273
271
  notNull: boolean;
274
- }, {
275
272
  default?: any;
276
273
  autoincrement?: boolean | undefined;
274
+ }, {
277
275
  name: string;
278
276
  type: string;
279
277
  primaryKey: boolean;
280
278
  notNull: boolean;
279
+ default?: any;
280
+ autoincrement?: boolean | undefined;
281
281
  }>>;
282
282
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
283
283
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -286,44 +286,43 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
286
286
  }, "strict", import("zod").ZodTypeAny, {
287
287
  name: string;
288
288
  columns: Record<string, {
289
- default?: any;
290
- autoincrement?: boolean | undefined;
291
289
  name: string;
292
290
  type: string;
293
291
  primaryKey: boolean;
294
292
  notNull: boolean;
293
+ default?: any;
294
+ autoincrement?: boolean | undefined;
295
295
  }>;
296
296
  indexes: Record<string, string>;
297
297
  foreignKeys: Record<string, string>;
298
298
  compositePrimaryKeys: Record<string, string>;
299
299
  uniqueConstraints: Record<string, string>;
300
300
  }, {
301
- uniqueConstraints?: Record<string, string> | undefined;
302
301
  name: string;
303
302
  columns: Record<string, {
304
- default?: any;
305
- autoincrement?: boolean | undefined;
306
303
  name: string;
307
304
  type: string;
308
305
  primaryKey: boolean;
309
306
  notNull: boolean;
307
+ default?: any;
308
+ autoincrement?: boolean | undefined;
310
309
  }>;
311
310
  indexes: Record<string, string>;
312
311
  foreignKeys: Record<string, string>;
313
312
  compositePrimaryKeys: Record<string, string>;
313
+ uniqueConstraints?: Record<string, string> | undefined;
314
314
  }>>;
315
315
  enums: import("zod").ZodAny;
316
316
  }, "strict", import("zod").ZodTypeAny, {
317
- enums?: any;
318
317
  tables: Record<string, {
319
318
  name: string;
320
319
  columns: Record<string, {
321
- default?: any;
322
- autoincrement?: boolean | undefined;
323
320
  name: string;
324
321
  type: string;
325
322
  primaryKey: boolean;
326
323
  notNull: boolean;
324
+ default?: any;
325
+ autoincrement?: boolean | undefined;
327
326
  }>;
328
327
  indexes: Record<string, string>;
329
328
  foreignKeys: Record<string, string>;
@@ -332,27 +331,28 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
332
331
  }>;
333
332
  version: "5";
334
333
  dialect: "sqlite";
335
- }, {
336
334
  enums?: any;
335
+ }, {
337
336
  tables: Record<string, {
338
- uniqueConstraints?: Record<string, string> | undefined;
339
337
  name: string;
340
338
  columns: Record<string, {
341
- default?: any;
342
- autoincrement?: boolean | undefined;
343
339
  name: string;
344
340
  type: string;
345
341
  primaryKey: boolean;
346
342
  notNull: boolean;
343
+ default?: any;
344
+ autoincrement?: boolean | undefined;
347
345
  }>;
348
346
  indexes: Record<string, string>;
349
347
  foreignKeys: Record<string, string>;
350
348
  compositePrimaryKeys: Record<string, string>;
349
+ uniqueConstraints?: Record<string, string> | undefined;
351
350
  }>;
352
351
  version: "5";
353
352
  dialect: "sqlite";
353
+ enums?: any;
354
354
  }>]>;
355
- declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
355
+ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
356
356
  version: import("zod").ZodLiteral<"6">;
357
357
  dialect: import("zod").ZodLiteral<"pg">;
358
358
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -369,25 +369,25 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
369
369
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
370
370
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
371
371
  }, "strict", import("zod").ZodTypeAny, {
372
+ name: string;
373
+ type: string;
374
+ primaryKey: boolean;
375
+ notNull: boolean;
372
376
  isUnique?: any;
373
377
  default?: any;
374
378
  typeSchema?: string | undefined;
375
379
  uniqueName?: string | undefined;
376
380
  nullsNotDistinct?: boolean | undefined;
381
+ }, {
377
382
  name: string;
378
383
  type: string;
379
384
  primaryKey: boolean;
380
385
  notNull: boolean;
381
- }, {
382
386
  isUnique?: any;
383
387
  default?: any;
384
388
  typeSchema?: string | undefined;
385
389
  uniqueName?: string | undefined;
386
390
  nullsNotDistinct?: boolean | undefined;
387
- name: string;
388
- type: string;
389
- primaryKey: boolean;
390
- notNull: boolean;
391
391
  }>>;
392
392
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
393
393
  name: import("zod").ZodString;
@@ -412,23 +412,23 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
412
412
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
413
413
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
414
414
  }, "strict", import("zod").ZodTypeAny, {
415
- onUpdate?: string | undefined;
416
- onDelete?: string | undefined;
417
- schemaTo?: string | undefined;
418
415
  name: string;
419
416
  tableFrom: string;
420
417
  columnsFrom: string[];
421
418
  tableTo: string;
422
419
  columnsTo: string[];
423
- }, {
424
420
  onUpdate?: string | undefined;
425
421
  onDelete?: string | undefined;
426
422
  schemaTo?: string | undefined;
423
+ }, {
427
424
  name: string;
428
425
  tableFrom: string;
429
426
  columnsFrom: string[];
430
427
  tableTo: string;
431
428
  columnsTo: string[];
429
+ onUpdate?: string | undefined;
430
+ onDelete?: string | undefined;
431
+ schemaTo?: string | undefined;
432
432
  }>>;
433
433
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
434
434
  name: import("zod").ZodString;
@@ -456,15 +456,15 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
456
456
  }, "strict", import("zod").ZodTypeAny, {
457
457
  name: string;
458
458
  columns: Record<string, {
459
+ name: string;
460
+ type: string;
461
+ primaryKey: boolean;
462
+ notNull: boolean;
459
463
  isUnique?: any;
460
464
  default?: any;
461
465
  typeSchema?: string | undefined;
462
466
  uniqueName?: string | undefined;
463
467
  nullsNotDistinct?: boolean | undefined;
464
- name: string;
465
- type: string;
466
- primaryKey: boolean;
467
- notNull: boolean;
468
468
  }>;
469
469
  indexes: Record<string, {
470
470
  name: string;
@@ -472,14 +472,14 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
472
472
  isUnique: boolean;
473
473
  }>;
474
474
  foreignKeys: Record<string, {
475
- onUpdate?: string | undefined;
476
- onDelete?: string | undefined;
477
- schemaTo?: string | undefined;
478
475
  name: string;
479
476
  tableFrom: string;
480
477
  columnsFrom: string[];
481
478
  tableTo: string;
482
479
  columnsTo: string[];
480
+ onUpdate?: string | undefined;
481
+ onDelete?: string | undefined;
482
+ schemaTo?: string | undefined;
483
483
  }>;
484
484
  schema: string;
485
485
  compositePrimaryKeys: Record<string, {
@@ -492,22 +492,17 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
492
492
  nullsNotDistinct: boolean;
493
493
  }>;
494
494
  }, {
495
- uniqueConstraints?: Record<string, {
496
- name: string;
497
- columns: string[];
498
- nullsNotDistinct: boolean;
499
- }> | undefined;
500
495
  name: string;
501
496
  columns: Record<string, {
497
+ name: string;
498
+ type: string;
499
+ primaryKey: boolean;
500
+ notNull: boolean;
502
501
  isUnique?: any;
503
502
  default?: any;
504
503
  typeSchema?: string | undefined;
505
504
  uniqueName?: string | undefined;
506
505
  nullsNotDistinct?: boolean | undefined;
507
- name: string;
508
- type: string;
509
- primaryKey: boolean;
510
- notNull: boolean;
511
506
  }>;
512
507
  indexes: Record<string, {
513
508
  name: string;
@@ -515,20 +510,25 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
515
510
  isUnique: boolean;
516
511
  }>;
517
512
  foreignKeys: Record<string, {
518
- onUpdate?: string | undefined;
519
- onDelete?: string | undefined;
520
- schemaTo?: string | undefined;
521
513
  name: string;
522
514
  tableFrom: string;
523
515
  columnsFrom: string[];
524
516
  tableTo: string;
525
517
  columnsTo: string[];
518
+ onUpdate?: string | undefined;
519
+ onDelete?: string | undefined;
520
+ schemaTo?: string | undefined;
526
521
  }>;
527
522
  schema: string;
528
523
  compositePrimaryKeys: Record<string, {
529
524
  name: string;
530
525
  columns: string[];
531
526
  }>;
527
+ uniqueConstraints?: Record<string, {
528
+ name: string;
529
+ columns: string[];
530
+ nullsNotDistinct: boolean;
531
+ }> | undefined;
532
532
  }>>;
533
533
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
534
534
  name: import("zod").ZodString;
@@ -606,27 +606,18 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
606
606
  id: import("zod").ZodString;
607
607
  prevId: import("zod").ZodString;
608
608
  }>, "strip", import("zod").ZodTypeAny, {
609
- internal?: {
610
- tables: Record<string, {
611
- columns: Record<string, {
612
- isArray?: boolean | undefined;
613
- dimensions?: number | undefined;
614
- rawType?: string | undefined;
615
- } | undefined>;
616
- } | undefined>;
617
- } | undefined;
618
609
  tables: Record<string, {
619
610
  name: string;
620
611
  columns: Record<string, {
612
+ name: string;
613
+ type: string;
614
+ primaryKey: boolean;
615
+ notNull: boolean;
621
616
  isUnique?: any;
622
617
  default?: any;
623
618
  typeSchema?: string | undefined;
624
619
  uniqueName?: string | undefined;
625
620
  nullsNotDistinct?: boolean | undefined;
626
- name: string;
627
- type: string;
628
- primaryKey: boolean;
629
- notNull: boolean;
630
621
  }>;
631
622
  indexes: Record<string, {
632
623
  name: string;
@@ -634,14 +625,14 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
634
625
  isUnique: boolean;
635
626
  }>;
636
627
  foreignKeys: Record<string, {
637
- onUpdate?: string | undefined;
638
- onDelete?: string | undefined;
639
- schemaTo?: string | undefined;
640
628
  name: string;
641
629
  tableFrom: string;
642
630
  columnsFrom: string[];
643
631
  tableTo: string;
644
632
  columnsTo: string[];
633
+ onUpdate?: string | undefined;
634
+ onDelete?: string | undefined;
635
+ schemaTo?: string | undefined;
645
636
  }>;
646
637
  schema: string;
647
638
  compositePrimaryKeys: Record<string, {
@@ -669,7 +660,6 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
669
660
  values: string[];
670
661
  schema: string;
671
662
  }>;
672
- }, {
673
663
  internal?: {
674
664
  tables: Record<string, {
675
665
  columns: Record<string, {
@@ -679,23 +669,19 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
679
669
  } | undefined>;
680
670
  } | undefined>;
681
671
  } | undefined;
672
+ }, {
682
673
  tables: Record<string, {
683
- uniqueConstraints?: Record<string, {
684
- name: string;
685
- columns: string[];
686
- nullsNotDistinct: boolean;
687
- }> | undefined;
688
674
  name: string;
689
675
  columns: Record<string, {
676
+ name: string;
677
+ type: string;
678
+ primaryKey: boolean;
679
+ notNull: boolean;
690
680
  isUnique?: any;
691
681
  default?: any;
692
682
  typeSchema?: string | undefined;
693
683
  uniqueName?: string | undefined;
694
684
  nullsNotDistinct?: boolean | undefined;
695
- name: string;
696
- type: string;
697
- primaryKey: boolean;
698
- notNull: boolean;
699
685
  }>;
700
686
  indexes: Record<string, {
701
687
  name: string;
@@ -703,20 +689,25 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
703
689
  isUnique: boolean;
704
690
  }>;
705
691
  foreignKeys: Record<string, {
706
- onUpdate?: string | undefined;
707
- onDelete?: string | undefined;
708
- schemaTo?: string | undefined;
709
692
  name: string;
710
693
  tableFrom: string;
711
694
  columnsFrom: string[];
712
695
  tableTo: string;
713
696
  columnsTo: string[];
697
+ onUpdate?: string | undefined;
698
+ onDelete?: string | undefined;
699
+ schemaTo?: string | undefined;
714
700
  }>;
715
701
  schema: string;
716
702
  compositePrimaryKeys: Record<string, {
717
703
  name: string;
718
704
  columns: string[];
719
705
  }>;
706
+ uniqueConstraints?: Record<string, {
707
+ name: string;
708
+ columns: string[];
709
+ nullsNotDistinct: boolean;
710
+ }> | undefined;
720
711
  }>;
721
712
  id: string;
722
713
  prevId: string;
@@ -733,7 +724,16 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
733
724
  values: string[];
734
725
  schema: string;
735
726
  }>;
736
- }>, import("zod").ZodObject<import("zod").extendShape<{
727
+ internal?: {
728
+ tables: Record<string, {
729
+ columns: Record<string, {
730
+ isArray?: boolean | undefined;
731
+ dimensions?: number | undefined;
732
+ rawType?: string | undefined;
733
+ } | undefined>;
734
+ } | undefined>;
735
+ } | undefined;
736
+ }>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
737
737
  version: import("zod").ZodLiteral<"5">;
738
738
  dialect: import("zod").ZodLiteral<"mysql">;
739
739
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -747,21 +747,21 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
747
747
  default: import("zod").ZodOptional<import("zod").ZodAny>;
748
748
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
749
749
  }, "strict", import("zod").ZodTypeAny, {
750
- default?: any;
751
- onUpdate?: any;
752
- autoincrement?: boolean | undefined;
753
750
  name: string;
754
751
  type: string;
755
752
  primaryKey: boolean;
756
753
  notNull: boolean;
757
- }, {
758
754
  default?: any;
759
755
  onUpdate?: any;
760
756
  autoincrement?: boolean | undefined;
757
+ }, {
761
758
  name: string;
762
759
  type: string;
763
760
  primaryKey: boolean;
764
761
  notNull: boolean;
762
+ default?: any;
763
+ onUpdate?: any;
764
+ autoincrement?: boolean | undefined;
765
765
  }>>;
766
766
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
767
767
  name: import("zod").ZodString;
@@ -771,19 +771,19 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
771
771
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
772
772
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
773
773
  }, "strict", import("zod").ZodTypeAny, {
774
- using?: "btree" | "hash" | undefined;
775
- algorithm?: "default" | "inplace" | "copy" | undefined;
776
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
777
774
  name: string;
778
775
  columns: string[];
779
776
  isUnique: boolean;
780
- }, {
781
777
  using?: "btree" | "hash" | undefined;
782
778
  algorithm?: "default" | "inplace" | "copy" | undefined;
783
779
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
780
+ }, {
784
781
  name: string;
785
782
  columns: string[];
786
783
  isUnique: boolean;
784
+ using?: "btree" | "hash" | undefined;
785
+ algorithm?: "default" | "inplace" | "copy" | undefined;
786
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
787
787
  }>>;
788
788
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
789
789
  name: import("zod").ZodString;
@@ -794,21 +794,21 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
794
794
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
795
795
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
796
796
  }, "strict", import("zod").ZodTypeAny, {
797
- onUpdate?: string | undefined;
798
- onDelete?: string | undefined;
799
797
  name: string;
800
798
  tableFrom: string;
801
799
  columnsFrom: string[];
802
800
  tableTo: string;
803
801
  columnsTo: string[];
804
- }, {
805
802
  onUpdate?: string | undefined;
806
803
  onDelete?: string | undefined;
804
+ }, {
807
805
  name: string;
808
806
  tableFrom: string;
809
807
  columnsFrom: string[];
810
808
  tableTo: string;
811
809
  columnsTo: string[];
810
+ onUpdate?: string | undefined;
811
+ onDelete?: string | undefined;
812
812
  }>>;
813
813
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
814
814
  name: import("zod").ZodString;
@@ -833,30 +833,30 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
833
833
  }, "strict", import("zod").ZodTypeAny, {
834
834
  name: string;
835
835
  columns: Record<string, {
836
- default?: any;
837
- onUpdate?: any;
838
- autoincrement?: boolean | undefined;
839
836
  name: string;
840
837
  type: string;
841
838
  primaryKey: boolean;
842
839
  notNull: boolean;
840
+ default?: any;
841
+ onUpdate?: any;
842
+ autoincrement?: boolean | undefined;
843
843
  }>;
844
844
  indexes: Record<string, {
845
- using?: "btree" | "hash" | undefined;
846
- algorithm?: "default" | "inplace" | "copy" | undefined;
847
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
848
845
  name: string;
849
846
  columns: string[];
850
847
  isUnique: boolean;
848
+ using?: "btree" | "hash" | undefined;
849
+ algorithm?: "default" | "inplace" | "copy" | undefined;
850
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
851
851
  }>;
852
852
  foreignKeys: Record<string, {
853
- onUpdate?: string | undefined;
854
- onDelete?: string | undefined;
855
853
  name: string;
856
854
  tableFrom: string;
857
855
  columnsFrom: string[];
858
856
  tableTo: string;
859
857
  columnsTo: string[];
858
+ onUpdate?: string | undefined;
859
+ onDelete?: string | undefined;
860
860
  }>;
861
861
  compositePrimaryKeys: Record<string, {
862
862
  name: string;
@@ -867,41 +867,41 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
867
867
  columns: string[];
868
868
  }>;
869
869
  }, {
870
- uniqueConstraints?: Record<string, {
871
- name: string;
872
- columns: string[];
873
- }> | undefined;
874
870
  name: string;
875
871
  columns: Record<string, {
876
- default?: any;
877
- onUpdate?: any;
878
- autoincrement?: boolean | undefined;
879
872
  name: string;
880
873
  type: string;
881
874
  primaryKey: boolean;
882
875
  notNull: boolean;
876
+ default?: any;
877
+ onUpdate?: any;
878
+ autoincrement?: boolean | undefined;
883
879
  }>;
884
880
  indexes: Record<string, {
885
- using?: "btree" | "hash" | undefined;
886
- algorithm?: "default" | "inplace" | "copy" | undefined;
887
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
888
881
  name: string;
889
882
  columns: string[];
890
883
  isUnique: boolean;
884
+ using?: "btree" | "hash" | undefined;
885
+ algorithm?: "default" | "inplace" | "copy" | undefined;
886
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
891
887
  }>;
892
888
  foreignKeys: Record<string, {
893
- onUpdate?: string | undefined;
894
- onDelete?: string | undefined;
895
889
  name: string;
896
890
  tableFrom: string;
897
891
  columnsFrom: string[];
898
892
  tableTo: string;
899
893
  columnsTo: string[];
894
+ onUpdate?: string | undefined;
895
+ onDelete?: string | undefined;
900
896
  }>;
901
897
  compositePrimaryKeys: Record<string, {
902
898
  name: string;
903
899
  columns: string[];
904
900
  }>;
901
+ uniqueConstraints?: Record<string, {
902
+ name: string;
903
+ columns: string[];
904
+ }> | undefined;
905
905
  }>>;
906
906
  _meta: import("zod").ZodObject<{
907
907
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -948,40 +948,33 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
948
948
  id: import("zod").ZodString;
949
949
  prevId: import("zod").ZodString;
950
950
  }>, "strip", import("zod").ZodTypeAny, {
951
- internal?: {
952
- tables: Record<string, {
953
- columns: Record<string, {
954
- isDefaultAnExpression?: boolean | undefined;
955
- } | undefined>;
956
- } | undefined>;
957
- } | undefined;
958
951
  tables: Record<string, {
959
952
  name: string;
960
953
  columns: Record<string, {
961
- default?: any;
962
- onUpdate?: any;
963
- autoincrement?: boolean | undefined;
964
954
  name: string;
965
955
  type: string;
966
956
  primaryKey: boolean;
967
957
  notNull: boolean;
958
+ default?: any;
959
+ onUpdate?: any;
960
+ autoincrement?: boolean | undefined;
968
961
  }>;
969
962
  indexes: Record<string, {
970
- using?: "btree" | "hash" | undefined;
971
- algorithm?: "default" | "inplace" | "copy" | undefined;
972
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
973
963
  name: string;
974
964
  columns: string[];
975
965
  isUnique: boolean;
966
+ using?: "btree" | "hash" | undefined;
967
+ algorithm?: "default" | "inplace" | "copy" | undefined;
968
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
976
969
  }>;
977
970
  foreignKeys: Record<string, {
978
- onUpdate?: string | undefined;
979
- onDelete?: string | undefined;
980
971
  name: string;
981
972
  tableFrom: string;
982
973
  columnsFrom: string[];
983
974
  tableTo: string;
984
975
  columnsTo: string[];
976
+ onUpdate?: string | undefined;
977
+ onDelete?: string | undefined;
985
978
  }>;
986
979
  compositePrimaryKeys: Record<string, {
987
980
  name: string;
@@ -1000,7 +993,6 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1000
993
  columns: Record<string, string>;
1001
994
  tables: Record<string, string>;
1002
995
  };
1003
- }, {
1004
996
  internal?: {
1005
997
  tables: Record<string, {
1006
998
  columns: Record<string, {
@@ -1008,42 +1000,43 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1008
1000
  } | undefined>;
1009
1001
  } | undefined>;
1010
1002
  } | undefined;
1003
+ }, {
1011
1004
  tables: Record<string, {
1012
- uniqueConstraints?: Record<string, {
1013
- name: string;
1014
- columns: string[];
1015
- }> | undefined;
1016
1005
  name: string;
1017
1006
  columns: Record<string, {
1018
- default?: any;
1019
- onUpdate?: any;
1020
- autoincrement?: boolean | undefined;
1021
1007
  name: string;
1022
1008
  type: string;
1023
1009
  primaryKey: boolean;
1024
1010
  notNull: boolean;
1011
+ default?: any;
1012
+ onUpdate?: any;
1013
+ autoincrement?: boolean | undefined;
1025
1014
  }>;
1026
1015
  indexes: Record<string, {
1027
- using?: "btree" | "hash" | undefined;
1028
- algorithm?: "default" | "inplace" | "copy" | undefined;
1029
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1030
1016
  name: string;
1031
1017
  columns: string[];
1032
1018
  isUnique: boolean;
1019
+ using?: "btree" | "hash" | undefined;
1020
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1021
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1033
1022
  }>;
1034
1023
  foreignKeys: Record<string, {
1035
- onUpdate?: string | undefined;
1036
- onDelete?: string | undefined;
1037
1024
  name: string;
1038
1025
  tableFrom: string;
1039
1026
  columnsFrom: string[];
1040
1027
  tableTo: string;
1041
1028
  columnsTo: string[];
1029
+ onUpdate?: string | undefined;
1030
+ onDelete?: string | undefined;
1042
1031
  }>;
1043
1032
  compositePrimaryKeys: Record<string, {
1044
1033
  name: string;
1045
1034
  columns: string[];
1046
1035
  }>;
1036
+ uniqueConstraints?: Record<string, {
1037
+ name: string;
1038
+ columns: string[];
1039
+ }> | undefined;
1047
1040
  }>;
1048
1041
  id: string;
1049
1042
  prevId: string;
@@ -1053,7 +1046,14 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1053
1046
  columns: Record<string, string>;
1054
1047
  tables: Record<string, string>;
1055
1048
  };
1056
- }>, import("zod").ZodObject<import("zod").extendShape<{
1049
+ internal?: {
1050
+ tables: Record<string, {
1051
+ columns: Record<string, {
1052
+ isDefaultAnExpression?: boolean | undefined;
1053
+ } | undefined>;
1054
+ } | undefined>;
1055
+ } | undefined;
1056
+ }>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
1057
1057
  version: import("zod").ZodLiteral<"5">;
1058
1058
  dialect: import("zod").ZodEnum<["sqlite"]>;
1059
1059
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1066,19 +1066,19 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1066
1066
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1067
1067
  default: import("zod").ZodOptional<import("zod").ZodAny>;
1068
1068
  }, "strict", import("zod").ZodTypeAny, {
1069
- default?: any;
1070
- autoincrement?: boolean | undefined;
1071
1069
  name: string;
1072
1070
  type: string;
1073
1071
  primaryKey: boolean;
1074
1072
  notNull: boolean;
1075
- }, {
1076
1073
  default?: any;
1077
1074
  autoincrement?: boolean | undefined;
1075
+ }, {
1078
1076
  name: string;
1079
1077
  type: string;
1080
1078
  primaryKey: boolean;
1081
1079
  notNull: boolean;
1080
+ default?: any;
1081
+ autoincrement?: boolean | undefined;
1082
1082
  }>>;
1083
1083
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1084
1084
  name: import("zod").ZodString;
@@ -1086,15 +1086,15 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1086
1086
  where: import("zod").ZodOptional<import("zod").ZodString>;
1087
1087
  isUnique: import("zod").ZodBoolean;
1088
1088
  }, "strict", import("zod").ZodTypeAny, {
1089
- where?: string | undefined;
1090
1089
  name: string;
1091
1090
  columns: string[];
1092
1091
  isUnique: boolean;
1093
- }, {
1094
1092
  where?: string | undefined;
1093
+ }, {
1095
1094
  name: string;
1096
1095
  columns: string[];
1097
1096
  isUnique: boolean;
1097
+ where?: string | undefined;
1098
1098
  }>>;
1099
1099
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1100
1100
  name: import("zod").ZodString;
@@ -1105,31 +1105,31 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1105
1105
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1106
1106
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1107
1107
  }, "strict", import("zod").ZodTypeAny, {
1108
- onUpdate?: string | undefined;
1109
- onDelete?: string | undefined;
1110
1108
  name: string;
1111
1109
  tableFrom: string;
1112
1110
  columnsFrom: string[];
1113
1111
  tableTo: string;
1114
1112
  columnsTo: string[];
1115
- }, {
1116
1113
  onUpdate?: string | undefined;
1117
1114
  onDelete?: string | undefined;
1115
+ }, {
1118
1116
  name: string;
1119
1117
  tableFrom: string;
1120
1118
  columnsFrom: string[];
1121
1119
  tableTo: string;
1122
1120
  columnsTo: string[];
1121
+ onUpdate?: string | undefined;
1122
+ onDelete?: string | undefined;
1123
1123
  }>>;
1124
1124
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1125
1125
  columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1126
1126
  name: import("zod").ZodOptional<import("zod").ZodString>;
1127
1127
  }, "strict", import("zod").ZodTypeAny, {
1128
- name?: string | undefined;
1129
1128
  columns: string[];
1130
- }, {
1131
1129
  name?: string | undefined;
1130
+ }, {
1132
1131
  columns: string[];
1132
+ name?: string | undefined;
1133
1133
  }>>;
1134
1134
  uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1135
1135
  name: import("zod").ZodString;
@@ -1144,69 +1144,69 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1144
1144
  }, "strict", import("zod").ZodTypeAny, {
1145
1145
  name: string;
1146
1146
  columns: Record<string, {
1147
- default?: any;
1148
- autoincrement?: boolean | undefined;
1149
1147
  name: string;
1150
1148
  type: string;
1151
1149
  primaryKey: boolean;
1152
1150
  notNull: boolean;
1151
+ default?: any;
1152
+ autoincrement?: boolean | undefined;
1153
1153
  }>;
1154
1154
  indexes: Record<string, {
1155
- where?: string | undefined;
1156
1155
  name: string;
1157
1156
  columns: string[];
1158
1157
  isUnique: boolean;
1158
+ where?: string | undefined;
1159
1159
  }>;
1160
1160
  foreignKeys: Record<string, {
1161
- onUpdate?: string | undefined;
1162
- onDelete?: string | undefined;
1163
1161
  name: string;
1164
1162
  tableFrom: string;
1165
1163
  columnsFrom: string[];
1166
1164
  tableTo: string;
1167
1165
  columnsTo: string[];
1166
+ onUpdate?: string | undefined;
1167
+ onDelete?: string | undefined;
1168
1168
  }>;
1169
1169
  compositePrimaryKeys: Record<string, {
1170
- name?: string | undefined;
1171
1170
  columns: string[];
1171
+ name?: string | undefined;
1172
1172
  }>;
1173
1173
  uniqueConstraints: Record<string, {
1174
1174
  name: string;
1175
1175
  columns: string[];
1176
1176
  }>;
1177
1177
  }, {
1178
- uniqueConstraints?: Record<string, {
1179
- name: string;
1180
- columns: string[];
1181
- }> | undefined;
1182
1178
  name: string;
1183
1179
  columns: Record<string, {
1184
- default?: any;
1185
- autoincrement?: boolean | undefined;
1186
1180
  name: string;
1187
1181
  type: string;
1188
1182
  primaryKey: boolean;
1189
1183
  notNull: boolean;
1184
+ default?: any;
1185
+ autoincrement?: boolean | undefined;
1190
1186
  }>;
1191
1187
  indexes: Record<string, {
1192
- where?: string | undefined;
1193
1188
  name: string;
1194
1189
  columns: string[];
1195
1190
  isUnique: boolean;
1191
+ where?: string | undefined;
1196
1192
  }>;
1197
1193
  foreignKeys: Record<string, {
1198
- onUpdate?: string | undefined;
1199
- onDelete?: string | undefined;
1200
1194
  name: string;
1201
1195
  tableFrom: string;
1202
1196
  columnsFrom: string[];
1203
1197
  tableTo: string;
1204
1198
  columnsTo: string[];
1199
+ onUpdate?: string | undefined;
1200
+ onDelete?: string | undefined;
1205
1201
  }>;
1206
1202
  compositePrimaryKeys: Record<string, {
1207
- name?: string | undefined;
1208
1203
  columns: string[];
1204
+ name?: string | undefined;
1209
1205
  }>;
1206
+ uniqueConstraints?: Record<string, {
1207
+ name: string;
1208
+ columns: string[];
1209
+ }> | undefined;
1210
1210
  }>>;
1211
1211
  enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
1212
1212
  _meta: import("zod").ZodObject<{
@@ -1226,31 +1226,31 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1226
1226
  tables: Record<string, {
1227
1227
  name: string;
1228
1228
  columns: Record<string, {
1229
- default?: any;
1230
- autoincrement?: boolean | undefined;
1231
1229
  name: string;
1232
1230
  type: string;
1233
1231
  primaryKey: boolean;
1234
1232
  notNull: boolean;
1233
+ default?: any;
1234
+ autoincrement?: boolean | undefined;
1235
1235
  }>;
1236
1236
  indexes: Record<string, {
1237
- where?: string | undefined;
1238
1237
  name: string;
1239
1238
  columns: string[];
1240
1239
  isUnique: boolean;
1240
+ where?: string | undefined;
1241
1241
  }>;
1242
1242
  foreignKeys: Record<string, {
1243
- onUpdate?: string | undefined;
1244
- onDelete?: string | undefined;
1245
1243
  name: string;
1246
1244
  tableFrom: string;
1247
1245
  columnsFrom: string[];
1248
1246
  tableTo: string;
1249
1247
  columnsTo: string[];
1248
+ onUpdate?: string | undefined;
1249
+ onDelete?: string | undefined;
1250
1250
  }>;
1251
1251
  compositePrimaryKeys: Record<string, {
1252
- name?: string | undefined;
1253
1252
  columns: string[];
1253
+ name?: string | undefined;
1254
1254
  }>;
1255
1255
  uniqueConstraints: Record<string, {
1256
1256
  name: string;
@@ -1268,38 +1268,38 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1268
1268
  enums: {};
1269
1269
  }, {
1270
1270
  tables: Record<string, {
1271
- uniqueConstraints?: Record<string, {
1272
- name: string;
1273
- columns: string[];
1274
- }> | undefined;
1275
1271
  name: string;
1276
1272
  columns: Record<string, {
1277
- default?: any;
1278
- autoincrement?: boolean | undefined;
1279
1273
  name: string;
1280
1274
  type: string;
1281
1275
  primaryKey: boolean;
1282
1276
  notNull: boolean;
1277
+ default?: any;
1278
+ autoincrement?: boolean | undefined;
1283
1279
  }>;
1284
1280
  indexes: Record<string, {
1285
- where?: string | undefined;
1286
1281
  name: string;
1287
1282
  columns: string[];
1288
1283
  isUnique: boolean;
1284
+ where?: string | undefined;
1289
1285
  }>;
1290
1286
  foreignKeys: Record<string, {
1291
- onUpdate?: string | undefined;
1292
- onDelete?: string | undefined;
1293
1287
  name: string;
1294
1288
  tableFrom: string;
1295
1289
  columnsFrom: string[];
1296
1290
  tableTo: string;
1297
1291
  columnsTo: string[];
1292
+ onUpdate?: string | undefined;
1293
+ onDelete?: string | undefined;
1298
1294
  }>;
1299
1295
  compositePrimaryKeys: Record<string, {
1300
- name?: string | undefined;
1301
1296
  columns: string[];
1297
+ name?: string | undefined;
1302
1298
  }>;
1299
+ uniqueConstraints?: Record<string, {
1300
+ name: string;
1301
+ columns: string[];
1302
+ }> | undefined;
1303
1303
  }>;
1304
1304
  id: string;
1305
1305
  prevId: string;