drizzle-kit 0.20.17-a2979a1 → 0.20.17-b08243d

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (26) hide show
  1. package/bin.cjs +25462 -26322
  2. package/cli/commands/migrate.d.ts +41 -41
  3. package/cli/commands/mysqlIntrospect.d.ts +8 -8
  4. package/cli/commands/pgIntrospect.d.ts +8 -8
  5. package/cli/commands/sqliteIntrospect.d.ts +12 -12
  6. package/cli/commands/utils.d.ts +2 -2
  7. package/cli/validations/cli.d.ts +29 -29
  8. package/cli/validations/common.d.ts +35 -35
  9. package/cli/validations/mysql.d.ts +4 -4
  10. package/cli/validations/outputs.d.ts +1 -2
  11. package/cli/validations/pg.d.ts +4 -4
  12. package/index.d.mts +2 -48
  13. package/index.d.ts +2 -48
  14. package/package.json +1 -1
  15. package/payload.js +476 -1080
  16. package/payload.mjs +283 -887
  17. package/schemaValidator.d.ts +222 -222
  18. package/serializer/mysqlSchema.d.ts +890 -890
  19. package/serializer/pgSchema.d.ts +745 -745
  20. package/serializer/sqliteSchema.d.ts +457 -457
  21. package/serializer/studio.d.ts +1 -1
  22. package/snapshotsDiffer.d.ts +315 -316
  23. package/utils-studio.js +841 -947
  24. package/utils-studio.mjs +814 -920
  25. package/utils.js +219 -844
  26. package/utils.mjs +194 -819
package/schemaValidator.d.ts CHANGED
@@ -1,9 +1,9 @@
1
1
  import { TypeOf } from "zod";
2
- export declare const dialect: import("zod").ZodEnum<["pg", "mysql", "sqlite"]>;
2
+ export declare const dialect: import("zod").ZodEnum<["postgresql", "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").ZodEnum<["pg"]>;
6
+ dialect: import("zod").ZodLiteral<"postgresql">;
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;
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>;
@@ -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: "pg";
117
+ dialect: "postgresql";
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;
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>;
@@ -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: "pg";
145
+ dialect: "postgresql";
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;
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,30 +332,29 @@ 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
- dialect: import("zod").ZodLiteral<"pg">;
357
+ dialect: import("zod").ZodLiteral<"postgresql">;
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;
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, {
@@ -648,7 +657,7 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
648
657
  id: string;
649
658
  prevId: string;
650
659
  version: "6";
651
- dialect: "pg";
660
+ dialect: "postgresql";
652
661
  schemas: Record<string, string>;
653
662
  _meta: {
654
663
  columns: Record<string, 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,30 +703,25 @@ 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;
714
723
  version: "6";
715
- dialect: "pg";
724
+ dialect: "postgresql";
716
725
  schemas: Record<string, string>;
717
726
  _meta: {
718
727
  columns: Record<string, 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;