drizzle-kit 0.20.17-b4f119e → 0.20.17-c8aaf94

Sign up to get free protection for your applications and to get access to all the features.
Files changed (24) hide show
  1. package/@types/utils.d.ts +1 -0
  2. package/bin.cjs +25449 -26297
  3. package/cli/commands/migrate.d.ts +39 -39
  4. package/cli/commands/mysqlIntrospect.d.ts +8 -8
  5. package/cli/commands/pgIntrospect.d.ts +7 -7
  6. package/cli/commands/sqliteIntrospect.d.ts +12 -12
  7. package/cli/validations/cli.d.ts +13 -13
  8. package/cli/validations/common.d.ts +27 -27
  9. package/cli/validations/mysql.d.ts +4 -4
  10. package/cli/validations/outputs.d.ts +1 -0
  11. package/cli/validations/pg.d.ts +4 -4
  12. package/cli/views.d.ts +1 -0
  13. package/package.json +1 -1
  14. package/payload.js +436 -1037
  15. package/payload.mjs +243 -844
  16. package/schemaValidator.d.ts +215 -215
  17. package/serializer/mysqlSchema.d.ts +890 -890
  18. package/serializer/pgSchema.d.ts +734 -734
  19. package/serializer/sqliteSchema.d.ts +457 -457
  20. package/snapshotsDiffer.d.ts +314 -314
  21. package/utils-studio.js +837 -940
  22. package/utils-studio.mjs +810 -913
  23. package/utils.js +214 -839
  24. package/utils.mjs +189 -814
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;
25
21
  isUnique?: any;
26
22
  default?: any;
27
23
  typeSchema?: string | undefined;
28
24
  uniqueName?: string | undefined;
29
25
  nullsNotDistinct?: boolean | undefined;
30
- }, {
31
26
  name: string;
32
27
  type: string;
33
28
  primaryKey: boolean;
34
29
  notNull: boolean;
30
+ }, {
35
31
  isUnique?: any;
36
32
  default?: any;
37
33
  typeSchema?: string | undefined;
38
34
  uniqueName?: string | undefined;
39
35
  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;
52
48
  isUnique?: any;
53
49
  default?: any;
54
50
  typeSchema?: string | undefined;
55
51
  uniqueName?: string | undefined;
56
52
  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;
70
66
  isUnique?: any;
71
67
  default?: any;
72
68
  typeSchema?: string | undefined;
73
69
  uniqueName?: string | undefined;
74
70
  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;
104
100
  isUnique?: any;
105
101
  default?: any;
106
102
  typeSchema?: string | undefined;
107
103
  uniqueName?: string | undefined;
108
104
  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;
132
128
  isUnique?: any;
133
129
  default?: any;
134
130
  typeSchema?: string | undefined;
135
131
  uniqueName?: string | undefined;
136
132
  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;
166
169
  name: string;
167
170
  type: string;
168
171
  primaryKey: boolean;
169
172
  notNull: boolean;
173
+ }, {
170
174
  default?: any;
171
175
  onUpdate?: any;
172
176
  autoincrement?: boolean | undefined;
173
- }, {
174
177
  name: string;
175
178
  type: string;
176
179
  primaryKey: boolean;
177
180
  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;
189
192
  name: string;
190
193
  type: string;
191
194
  primaryKey: boolean;
192
195
  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;
202
203
  name: string;
203
204
  columns: Record<string, {
205
+ default?: any;
206
+ onUpdate?: any;
207
+ autoincrement?: boolean | undefined;
204
208
  name: string;
205
209
  type: string;
206
210
  primaryKey: boolean;
207
211
  notNull: boolean;
208
- default?: any;
209
- onUpdate?: any;
210
- autoincrement?: boolean | undefined;
211
212
  }>;
212
213
  indexes: Record<string, string>;
213
214
  foreignKeys: Record<string, string>;
214
215
  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;
221
224
  name: string;
222
225
  type: string;
223
226
  primaryKey: boolean;
224
227
  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;
238
239
  name: string;
239
240
  columns: Record<string, {
241
+ default?: any;
242
+ onUpdate?: any;
243
+ autoincrement?: boolean | undefined;
240
244
  name: string;
241
245
  type: string;
242
246
  primaryKey: boolean;
243
247
  notNull: boolean;
244
- default?: any;
245
- onUpdate?: any;
246
- autoincrement?: boolean | undefined;
247
248
  }>;
248
249
  indexes: Record<string, string>;
249
250
  foreignKeys: Record<string, string>;
250
251
  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;
268
270
  name: string;
269
271
  type: string;
270
272
  primaryKey: boolean;
271
273
  notNull: boolean;
274
+ }, {
272
275
  default?: any;
273
276
  autoincrement?: boolean | undefined;
274
- }, {
275
277
  name: string;
276
278
  type: string;
277
279
  primaryKey: boolean;
278
280
  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,43 +286,44 @@ 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;
289
291
  name: string;
290
292
  type: string;
291
293
  primaryKey: boolean;
292
294
  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;
301
302
  name: string;
302
303
  columns: Record<string, {
304
+ default?: any;
305
+ autoincrement?: boolean | undefined;
303
306
  name: string;
304
307
  type: string;
305
308
  primaryKey: boolean;
306
309
  notNull: boolean;
307
- default?: any;
308
- autoincrement?: boolean | undefined;
309
310
  }>;
310
311
  indexes: Record<string, string>;
311
312
  foreignKeys: Record<string, string>;
312
313
  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;
317
318
  tables: Record<string, {
318
319
  name: string;
319
320
  columns: Record<string, {
321
+ default?: any;
322
+ autoincrement?: boolean | undefined;
320
323
  name: string;
321
324
  type: string;
322
325
  primaryKey: boolean;
323
326
  notNull: boolean;
324
- default?: any;
325
- autoincrement?: boolean | undefined;
326
327
  }>;
327
328
  indexes: Record<string, string>;
328
329
  foreignKeys: Record<string, string>;
@@ -331,28 +332,27 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
331
332
  }>;
332
333
  version: "5";
333
334
  dialect: "sqlite";
334
- enums?: any;
335
335
  }, {
336
+ enums?: any;
336
337
  tables: Record<string, {
338
+ uniqueConstraints?: Record<string, string> | undefined;
337
339
  name: string;
338
340
  columns: Record<string, {
341
+ default?: any;
342
+ autoincrement?: boolean | undefined;
339
343
  name: string;
340
344
  type: string;
341
345
  primaryKey: boolean;
342
346
  notNull: boolean;
343
- default?: any;
344
- autoincrement?: boolean | undefined;
345
347
  }>;
346
348
  indexes: Record<string, string>;
347
349
  foreignKeys: Record<string, string>;
348
350
  compositePrimaryKeys: Record<string, string>;
349
- uniqueConstraints?: Record<string, string> | undefined;
350
351
  }>;
351
352
  version: "5";
352
353
  dialect: "sqlite";
353
- enums?: any;
354
354
  }>]>;
355
- declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
355
+ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
356
356
  version: import("zod").ZodLiteral<"6">;
357
357
  dialect: import("zod").ZodLiteral<"postgresql">;
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;
376
372
  isUnique?: any;
377
373
  default?: any;
378
374
  typeSchema?: string | undefined;
379
375
  uniqueName?: string | undefined;
380
376
  nullsNotDistinct?: boolean | undefined;
381
- }, {
382
377
  name: string;
383
378
  type: string;
384
379
  primaryKey: boolean;
385
380
  notNull: boolean;
381
+ }, {
386
382
  isUnique?: any;
387
383
  default?: any;
388
384
  typeSchema?: string | undefined;
389
385
  uniqueName?: string | undefined;
390
386
  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;
415
418
  name: string;
416
419
  tableFrom: string;
417
420
  columnsFrom: string[];
418
421
  tableTo: string;
419
422
  columnsTo: string[];
423
+ }, {
420
424
  onUpdate?: string | undefined;
421
425
  onDelete?: string | undefined;
422
426
  schemaTo?: string | undefined;
423
- }, {
424
427
  name: string;
425
428
  tableFrom: string;
426
429
  columnsFrom: string[];
427
430
  tableTo: string;
428
431
  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;
463
459
  isUnique?: any;
464
460
  default?: any;
465
461
  typeSchema?: string | undefined;
466
462
  uniqueName?: string | undefined;
467
463
  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;
475
478
  name: string;
476
479
  tableFrom: string;
477
480
  columnsFrom: string[];
478
481
  tableTo: string;
479
482
  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,17 +492,22 @@ 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;
495
500
  name: string;
496
501
  columns: Record<string, {
497
- name: string;
498
- type: string;
499
- primaryKey: boolean;
500
- notNull: boolean;
501
502
  isUnique?: any;
502
503
  default?: any;
503
504
  typeSchema?: string | undefined;
504
505
  uniqueName?: string | undefined;
505
506
  nullsNotDistinct?: boolean | undefined;
507
+ name: string;
508
+ type: string;
509
+ primaryKey: boolean;
510
+ notNull: boolean;
506
511
  }>;
507
512
  indexes: Record<string, {
508
513
  name: string;
@@ -510,25 +515,20 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
510
515
  isUnique: boolean;
511
516
  }>;
512
517
  foreignKeys: Record<string, {
518
+ onUpdate?: string | undefined;
519
+ onDelete?: string | undefined;
520
+ schemaTo?: string | undefined;
513
521
  name: string;
514
522
  tableFrom: string;
515
523
  columnsFrom: string[];
516
524
  tableTo: string;
517
525
  columnsTo: string[];
518
- onUpdate?: string | undefined;
519
- onDelete?: string | undefined;
520
- schemaTo?: string | undefined;
521
526
  }>;
522
527
  schema: string;
523
528
  compositePrimaryKeys: Record<string, {
524
529
  name: string;
525
530
  columns: string[];
526
531
  }>;
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,18 +606,27 @@ 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;
609
618
  tables: Record<string, {
610
619
  name: string;
611
620
  columns: Record<string, {
612
- name: string;
613
- type: string;
614
- primaryKey: boolean;
615
- notNull: boolean;
616
621
  isUnique?: any;
617
622
  default?: any;
618
623
  typeSchema?: string | undefined;
619
624
  uniqueName?: string | undefined;
620
625
  nullsNotDistinct?: boolean | undefined;
626
+ name: string;
627
+ type: string;
628
+ primaryKey: boolean;
629
+ notNull: boolean;
621
630
  }>;
622
631
  indexes: Record<string, {
623
632
  name: string;
@@ -625,14 +634,14 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
625
634
  isUnique: boolean;
626
635
  }>;
627
636
  foreignKeys: Record<string, {
637
+ onUpdate?: string | undefined;
638
+ onDelete?: string | undefined;
639
+ schemaTo?: string | undefined;
628
640
  name: string;
629
641
  tableFrom: string;
630
642
  columnsFrom: string[];
631
643
  tableTo: string;
632
644
  columnsTo: string[];
633
- onUpdate?: string | undefined;
634
- onDelete?: string | undefined;
635
- schemaTo?: string | undefined;
636
645
  }>;
637
646
  schema: string;
638
647
  compositePrimaryKeys: Record<string, {
@@ -660,6 +669,7 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
660
669
  values: string[];
661
670
  schema: string;
662
671
  }>;
672
+ }, {
663
673
  internal?: {
664
674
  tables: Record<string, {
665
675
  columns: Record<string, {
@@ -669,19 +679,23 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
669
679
  } | undefined>;
670
680
  } | undefined>;
671
681
  } | undefined;
672
- }, {
673
682
  tables: Record<string, {
683
+ uniqueConstraints?: Record<string, {
684
+ name: string;
685
+ columns: string[];
686
+ nullsNotDistinct: boolean;
687
+ }> | undefined;
674
688
  name: string;
675
689
  columns: Record<string, {
676
- name: string;
677
- type: string;
678
- primaryKey: boolean;
679
- notNull: boolean;
680
690
  isUnique?: any;
681
691
  default?: any;
682
692
  typeSchema?: string | undefined;
683
693
  uniqueName?: string | undefined;
684
694
  nullsNotDistinct?: boolean | undefined;
695
+ name: string;
696
+ type: string;
697
+ primaryKey: boolean;
698
+ notNull: boolean;
685
699
  }>;
686
700
  indexes: Record<string, {
687
701
  name: string;
@@ -689,25 +703,20 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
689
703
  isUnique: boolean;
690
704
  }>;
691
705
  foreignKeys: Record<string, {
706
+ onUpdate?: string | undefined;
707
+ onDelete?: string | undefined;
708
+ schemaTo?: string | undefined;
692
709
  name: string;
693
710
  tableFrom: string;
694
711
  columnsFrom: string[];
695
712
  tableTo: string;
696
713
  columnsTo: string[];
697
- onUpdate?: string | undefined;
698
- onDelete?: string | undefined;
699
- schemaTo?: string | undefined;
700
714
  }>;
701
715
  schema: string;
702
716
  compositePrimaryKeys: Record<string, {
703
717
  name: string;
704
718
  columns: string[];
705
719
  }>;
706
- uniqueConstraints?: Record<string, {
707
- name: string;
708
- columns: string[];
709
- nullsNotDistinct: boolean;
710
- }> | undefined;
711
720
  }>;
712
721
  id: string;
713
722
  prevId: string;
@@ -724,16 +733,7 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
724
733
  values: string[];
725
734
  schema: string;
726
735
  }>;
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<{
736
+ }>, import("zod").ZodObject<import("zod").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;
750
753
  name: string;
751
754
  type: string;
752
755
  primaryKey: boolean;
753
756
  notNull: boolean;
757
+ }, {
754
758
  default?: any;
755
759
  onUpdate?: any;
756
760
  autoincrement?: boolean | undefined;
757
- }, {
758
761
  name: string;
759
762
  type: string;
760
763
  primaryKey: boolean;
761
764
  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
- name: string;
775
- columns: string[];
776
- isUnique: boolean;
777
774
  using?: "btree" | "hash" | undefined;
778
775
  algorithm?: "default" | "inplace" | "copy" | undefined;
779
776
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
780
- }, {
781
777
  name: string;
782
778
  columns: string[];
783
779
  isUnique: boolean;
780
+ }, {
784
781
  using?: "btree" | "hash" | undefined;
785
782
  algorithm?: "default" | "inplace" | "copy" | undefined;
786
783
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
784
+ name: string;
785
+ columns: string[];
786
+ isUnique: boolean;
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;
797
799
  name: string;
798
800
  tableFrom: string;
799
801
  columnsFrom: string[];
800
802
  tableTo: string;
801
803
  columnsTo: string[];
804
+ }, {
802
805
  onUpdate?: string | undefined;
803
806
  onDelete?: string | undefined;
804
- }, {
805
807
  name: string;
806
808
  tableFrom: string;
807
809
  columnsFrom: string[];
808
810
  tableTo: string;
809
811
  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;
836
839
  name: string;
837
840
  type: string;
838
841
  primaryKey: boolean;
839
842
  notNull: boolean;
840
- default?: any;
841
- onUpdate?: any;
842
- autoincrement?: boolean | undefined;
843
843
  }>;
844
844
  indexes: Record<string, {
845
- name: string;
846
- columns: string[];
847
- isUnique: boolean;
848
845
  using?: "btree" | "hash" | undefined;
849
846
  algorithm?: "default" | "inplace" | "copy" | undefined;
850
847
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
848
+ name: string;
849
+ columns: string[];
850
+ isUnique: boolean;
851
851
  }>;
852
852
  foreignKeys: Record<string, {
853
+ onUpdate?: string | undefined;
854
+ onDelete?: string | undefined;
853
855
  name: string;
854
856
  tableFrom: string;
855
857
  columnsFrom: string[];
856
858
  tableTo: string;
857
859
  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;
870
874
  name: string;
871
875
  columns: Record<string, {
876
+ default?: any;
877
+ onUpdate?: any;
878
+ autoincrement?: boolean | undefined;
872
879
  name: string;
873
880
  type: string;
874
881
  primaryKey: boolean;
875
882
  notNull: boolean;
876
- default?: any;
877
- onUpdate?: any;
878
- autoincrement?: boolean | undefined;
879
883
  }>;
880
884
  indexes: Record<string, {
881
- name: string;
882
- columns: string[];
883
- isUnique: boolean;
884
885
  using?: "btree" | "hash" | undefined;
885
886
  algorithm?: "default" | "inplace" | "copy" | undefined;
886
887
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
888
+ name: string;
889
+ columns: string[];
890
+ isUnique: boolean;
887
891
  }>;
888
892
  foreignKeys: Record<string, {
893
+ onUpdate?: string | undefined;
894
+ onDelete?: string | undefined;
889
895
  name: string;
890
896
  tableFrom: string;
891
897
  columnsFrom: string[];
892
898
  tableTo: string;
893
899
  columnsTo: string[];
894
- onUpdate?: string | undefined;
895
- onDelete?: string | undefined;
896
900
  }>;
897
901
  compositePrimaryKeys: Record<string, {
898
902
  name: string;
899
903
  columns: string[];
900
904
  }>;
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,33 +948,40 @@ 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;
951
958
  tables: Record<string, {
952
959
  name: string;
953
960
  columns: Record<string, {
961
+ default?: any;
962
+ onUpdate?: any;
963
+ autoincrement?: boolean | undefined;
954
964
  name: string;
955
965
  type: string;
956
966
  primaryKey: boolean;
957
967
  notNull: boolean;
958
- default?: any;
959
- onUpdate?: any;
960
- autoincrement?: boolean | undefined;
961
968
  }>;
962
969
  indexes: Record<string, {
963
- name: string;
964
- columns: string[];
965
- isUnique: boolean;
966
970
  using?: "btree" | "hash" | undefined;
967
971
  algorithm?: "default" | "inplace" | "copy" | undefined;
968
972
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
973
+ name: string;
974
+ columns: string[];
975
+ isUnique: boolean;
969
976
  }>;
970
977
  foreignKeys: Record<string, {
978
+ onUpdate?: string | undefined;
979
+ onDelete?: string | undefined;
971
980
  name: string;
972
981
  tableFrom: string;
973
982
  columnsFrom: string[];
974
983
  tableTo: string;
975
984
  columnsTo: string[];
976
- onUpdate?: string | undefined;
977
- onDelete?: string | undefined;
978
985
  }>;
979
986
  compositePrimaryKeys: Record<string, {
980
987
  name: string;
@@ -993,6 +1000,7 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
993
1000
  columns: Record<string, string>;
994
1001
  tables: Record<string, string>;
995
1002
  };
1003
+ }, {
996
1004
  internal?: {
997
1005
  tables: Record<string, {
998
1006
  columns: Record<string, {
@@ -1000,43 +1008,42 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1000
1008
  } | undefined>;
1001
1009
  } | undefined>;
1002
1010
  } | undefined;
1003
- }, {
1004
1011
  tables: Record<string, {
1012
+ uniqueConstraints?: Record<string, {
1013
+ name: string;
1014
+ columns: string[];
1015
+ }> | undefined;
1005
1016
  name: string;
1006
1017
  columns: Record<string, {
1018
+ default?: any;
1019
+ onUpdate?: any;
1020
+ autoincrement?: boolean | undefined;
1007
1021
  name: string;
1008
1022
  type: string;
1009
1023
  primaryKey: boolean;
1010
1024
  notNull: boolean;
1011
- default?: any;
1012
- onUpdate?: any;
1013
- autoincrement?: boolean | undefined;
1014
1025
  }>;
1015
1026
  indexes: Record<string, {
1016
- name: string;
1017
- columns: string[];
1018
- isUnique: boolean;
1019
1027
  using?: "btree" | "hash" | undefined;
1020
1028
  algorithm?: "default" | "inplace" | "copy" | undefined;
1021
1029
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1030
+ name: string;
1031
+ columns: string[];
1032
+ isUnique: boolean;
1022
1033
  }>;
1023
1034
  foreignKeys: Record<string, {
1035
+ onUpdate?: string | undefined;
1036
+ onDelete?: string | undefined;
1024
1037
  name: string;
1025
1038
  tableFrom: string;
1026
1039
  columnsFrom: string[];
1027
1040
  tableTo: string;
1028
1041
  columnsTo: string[];
1029
- onUpdate?: string | undefined;
1030
- onDelete?: string | undefined;
1031
1042
  }>;
1032
1043
  compositePrimaryKeys: Record<string, {
1033
1044
  name: string;
1034
1045
  columns: string[];
1035
1046
  }>;
1036
- uniqueConstraints?: Record<string, {
1037
- name: string;
1038
- columns: string[];
1039
- }> | undefined;
1040
1047
  }>;
1041
1048
  id: string;
1042
1049
  prevId: string;
@@ -1046,14 +1053,7 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1046
1053
  columns: Record<string, string>;
1047
1054
  tables: Record<string, string>;
1048
1055
  };
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<{
1056
+ }>, import("zod").ZodObject<import("zod").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;
1069
1071
  name: string;
1070
1072
  type: string;
1071
1073
  primaryKey: boolean;
1072
1074
  notNull: boolean;
1075
+ }, {
1073
1076
  default?: any;
1074
1077
  autoincrement?: boolean | undefined;
1075
- }, {
1076
1078
  name: string;
1077
1079
  type: string;
1078
1080
  primaryKey: boolean;
1079
1081
  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;
1089
1090
  name: string;
1090
1091
  columns: string[];
1091
1092
  isUnique: boolean;
1092
- where?: string | undefined;
1093
1093
  }, {
1094
+ where?: string | undefined;
1094
1095
  name: string;
1095
1096
  columns: string[];
1096
1097
  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;
1108
1110
  name: string;
1109
1111
  tableFrom: string;
1110
1112
  columnsFrom: string[];
1111
1113
  tableTo: string;
1112
1114
  columnsTo: string[];
1115
+ }, {
1113
1116
  onUpdate?: string | undefined;
1114
1117
  onDelete?: string | undefined;
1115
- }, {
1116
1118
  name: string;
1117
1119
  tableFrom: string;
1118
1120
  columnsFrom: string[];
1119
1121
  tableTo: string;
1120
1122
  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
- columns: string[];
1129
1128
  name?: string | undefined;
1130
- }, {
1131
1129
  columns: string[];
1130
+ }, {
1132
1131
  name?: string | undefined;
1132
+ columns: string[];
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;
1147
1149
  name: string;
1148
1150
  type: string;
1149
1151
  primaryKey: boolean;
1150
1152
  notNull: boolean;
1151
- default?: any;
1152
- autoincrement?: boolean | undefined;
1153
1153
  }>;
1154
1154
  indexes: Record<string, {
1155
+ where?: string | undefined;
1155
1156
  name: string;
1156
1157
  columns: string[];
1157
1158
  isUnique: boolean;
1158
- where?: string | undefined;
1159
1159
  }>;
1160
1160
  foreignKeys: Record<string, {
1161
+ onUpdate?: string | undefined;
1162
+ onDelete?: string | undefined;
1161
1163
  name: string;
1162
1164
  tableFrom: string;
1163
1165
  columnsFrom: string[];
1164
1166
  tableTo: string;
1165
1167
  columnsTo: string[];
1166
- onUpdate?: string | undefined;
1167
- onDelete?: string | undefined;
1168
1168
  }>;
1169
1169
  compositePrimaryKeys: Record<string, {
1170
- columns: string[];
1171
1170
  name?: string | undefined;
1171
+ columns: string[];
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;
1178
1182
  name: string;
1179
1183
  columns: Record<string, {
1184
+ default?: any;
1185
+ autoincrement?: boolean | undefined;
1180
1186
  name: string;
1181
1187
  type: string;
1182
1188
  primaryKey: boolean;
1183
1189
  notNull: boolean;
1184
- default?: any;
1185
- autoincrement?: boolean | undefined;
1186
1190
  }>;
1187
1191
  indexes: Record<string, {
1192
+ where?: string | undefined;
1188
1193
  name: string;
1189
1194
  columns: string[];
1190
1195
  isUnique: boolean;
1191
- where?: string | undefined;
1192
1196
  }>;
1193
1197
  foreignKeys: Record<string, {
1198
+ onUpdate?: string | undefined;
1199
+ onDelete?: string | undefined;
1194
1200
  name: string;
1195
1201
  tableFrom: string;
1196
1202
  columnsFrom: string[];
1197
1203
  tableTo: string;
1198
1204
  columnsTo: string[];
1199
- onUpdate?: string | undefined;
1200
- onDelete?: string | undefined;
1201
1205
  }>;
1202
1206
  compositePrimaryKeys: Record<string, {
1203
- columns: string[];
1204
1207
  name?: string | undefined;
1205
- }>;
1206
- uniqueConstraints?: Record<string, {
1207
- name: string;
1208
1208
  columns: string[];
1209
- }> | undefined;
1209
+ }>;
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;
1229
1231
  name: string;
1230
1232
  type: string;
1231
1233
  primaryKey: boolean;
1232
1234
  notNull: boolean;
1233
- default?: any;
1234
- autoincrement?: boolean | undefined;
1235
1235
  }>;
1236
1236
  indexes: Record<string, {
1237
+ where?: string | undefined;
1237
1238
  name: string;
1238
1239
  columns: string[];
1239
1240
  isUnique: boolean;
1240
- where?: string | undefined;
1241
1241
  }>;
1242
1242
  foreignKeys: Record<string, {
1243
+ onUpdate?: string | undefined;
1244
+ onDelete?: string | undefined;
1243
1245
  name: string;
1244
1246
  tableFrom: string;
1245
1247
  columnsFrom: string[];
1246
1248
  tableTo: string;
1247
1249
  columnsTo: string[];
1248
- onUpdate?: string | undefined;
1249
- onDelete?: string | undefined;
1250
1250
  }>;
1251
1251
  compositePrimaryKeys: Record<string, {
1252
- columns: string[];
1253
1252
  name?: string | undefined;
1253
+ columns: string[];
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;
1271
1275
  name: string;
1272
1276
  columns: Record<string, {
1277
+ default?: any;
1278
+ autoincrement?: boolean | undefined;
1273
1279
  name: string;
1274
1280
  type: string;
1275
1281
  primaryKey: boolean;
1276
1282
  notNull: boolean;
1277
- default?: any;
1278
- autoincrement?: boolean | undefined;
1279
1283
  }>;
1280
1284
  indexes: Record<string, {
1285
+ where?: string | undefined;
1281
1286
  name: string;
1282
1287
  columns: string[];
1283
1288
  isUnique: boolean;
1284
- where?: string | undefined;
1285
1289
  }>;
1286
1290
  foreignKeys: Record<string, {
1291
+ onUpdate?: string | undefined;
1292
+ onDelete?: string | undefined;
1287
1293
  name: string;
1288
1294
  tableFrom: string;
1289
1295
  columnsFrom: string[];
1290
1296
  tableTo: string;
1291
1297
  columnsTo: string[];
1292
- onUpdate?: string | undefined;
1293
- onDelete?: string | undefined;
1294
1298
  }>;
1295
1299
  compositePrimaryKeys: Record<string, {
1296
- columns: string[];
1297
1300
  name?: string | undefined;
1298
- }>;
1299
- uniqueConstraints?: Record<string, {
1300
- name: string;
1301
1301
  columns: string[];
1302
- }> | undefined;
1302
+ }>;
1303
1303
  }>;
1304
1304
  id: string;
1305
1305
  prevId: string;