drizzle-kit 0.20.17-9d75ea5 → 0.20.17-a2979a1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (26) hide show
  1. package/bin.cjs +26299 -25536
  2. package/cli/commands/migrate.d.ts +41 -41
  3. package/cli/commands/mysqlIntrospect.d.ts +8 -8
  4. package/cli/commands/pgIntrospect.d.ts +8 -8
  5. package/cli/commands/sqliteIntrospect.d.ts +12 -12
  6. package/cli/commands/utils.d.ts +2 -2
  7. package/cli/validations/cli.d.ts +28 -28
  8. package/cli/validations/common.d.ts +35 -35
  9. package/cli/validations/mysql.d.ts +4 -4
  10. package/cli/validations/outputs.d.ts +2 -1
  11. package/cli/validations/pg.d.ts +4 -4
  12. package/index.d.mts +48 -2
  13. package/index.d.ts +48 -2
  14. package/package.json +1 -1
  15. package/payload.js +1079 -475
  16. package/payload.mjs +886 -282
  17. package/schemaValidator.d.ts +222 -222
  18. package/serializer/mysqlSchema.d.ts +892 -892
  19. package/serializer/pgSchema.d.ts +749 -749
  20. package/serializer/sqliteSchema.d.ts +457 -457
  21. package/serializer/studio.d.ts +1 -1
  22. package/snapshotsDiffer.d.ts +316 -315
  23. package/utils-studio.js +947 -841
  24. package/utils-studio.mjs +920 -814
  25. package/utils.js +844 -219
  26. package/utils.mjs +819 -194
package/schemaValidator.d.ts CHANGED
@@ -1,9 +1,9 @@
1
1
  import { TypeOf } from "zod";
2
- export declare const dialect: import("zod").ZodEnum<["postgresql", "mysql", "sqlite"]>;
2
+ export declare const dialect: import("zod").ZodEnum<["pg", "mysql", "sqlite"]>;
3
3
  export type Dialect = TypeOf<typeof dialect>;
4
4
  declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObject<{
5
5
  version: import("zod").ZodLiteral<"6">;
6
- dialect: import("zod").ZodLiteral<"postgresql">;
6
+ dialect: import("zod").ZodEnum<["pg"]>;
7
7
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
8
8
  name: import("zod").ZodString;
9
9
  schema: import("zod").ZodString;
@@ -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>;
@@ -114,7 +114,7 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
114
114
  uniqueConstraints: Record<string, string>;
115
115
  }>;
116
116
  version: "6";
117
- dialect: "postgresql";
117
+ dialect: "pg";
118
118
  schemas: Record<string, string>;
119
119
  enums: Record<string, {
120
120
  name: 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>;
@@ -142,7 +142,7 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
142
142
  uniqueConstraints: Record<string, string>;
143
143
  }>;
144
144
  version: "6";
145
- dialect: "postgresql";
145
+ dialect: "pg";
146
146
  schemas: Record<string, string>;
147
147
  enums: Record<string, {
148
148
  name: 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,29 +331,30 @@ 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
- dialect: import("zod").ZodLiteral<"postgresql">;
357
+ dialect: import("zod").ZodLiteral<"pg">;
358
358
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
359
359
  name: import("zod").ZodString;
360
360
  schema: import("zod").ZodString;
@@ -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, {
@@ -657,7 +648,7 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
657
648
  id: string;
658
649
  prevId: string;
659
650
  version: "6";
660
- dialect: "postgresql";
651
+ dialect: "pg";
661
652
  schemas: Record<string, string>;
662
653
  _meta: {
663
654
  columns: Record<string, 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,25 +689,30 @@ 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;
723
714
  version: "6";
724
- dialect: "postgresql";
715
+ dialect: "pg";
725
716
  schemas: Record<string, string>;
726
717
  _meta: {
727
718
  columns: Record<string, 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;