drizzle-kit 0.20.16 → 0.20.17-5938f5d

Sign up to get free protection for your applications and to get access to all the features.
Files changed (56) hide show
  1. package/bin.cjs +67328 -54482
  2. package/cli/commands/migrate.d.ts +152 -135
  3. package/cli/commands/mysqlIntrospect.d.ts +15 -79
  4. package/cli/commands/mysqlPushUtils.d.ts +4 -8
  5. package/cli/commands/pgIntrospect.d.ts +12 -76
  6. package/cli/commands/pgPushUtils.d.ts +3 -6
  7. package/cli/commands/sqliteIntrospect.d.ts +26 -29
  8. package/cli/commands/sqlitePushUtils.d.ts +4 -10
  9. package/cli/commands/utils.d.ts +39 -255
  10. package/cli/utils.d.ts +13 -0
  11. package/cli/validations/cli.d.ts +169 -0
  12. package/cli/validations/common.d.ts +208 -7
  13. package/cli/validations/mysql.d.ts +7 -337
  14. package/cli/validations/outputs.d.ts +1 -0
  15. package/cli/validations/pg.d.ts +4 -411
  16. package/cli/validations/sqlite.d.ts +34 -0
  17. package/cli/views.d.ts +7 -5
  18. package/global.d.ts +3 -1
  19. package/index.d.mts +23 -15
  20. package/index.d.ts +23 -15
  21. package/index.js +1 -0
  22. package/introspect-sqlite.d.ts +2 -2
  23. package/jsonDiffer.d.ts +14 -29
  24. package/jsonStatements.d.ts +38 -11
  25. package/package.json +26 -51
  26. package/payload.d.mts +5 -5
  27. package/payload.d.ts +5 -5
  28. package/payload.js +34052 -32232
  29. package/payload.mjs +26475 -24666
  30. package/schemaValidator.d.ts +289 -286
  31. package/serializer/mysqlImports.d.ts +3 -7
  32. package/serializer/mysqlSchema.d.ts +2501 -1370
  33. package/serializer/mysqlSerializer.d.ts +6 -6
  34. package/serializer/pgImports.d.ts +2 -2
  35. package/serializer/pgSchema.d.ts +1741 -1282
  36. package/serializer/pgSerializer.d.ts +2 -2
  37. package/serializer/sqliteImports.d.ts +2 -4
  38. package/serializer/sqliteSchema.d.ts +553 -979
  39. package/serializer/sqliteSerializer.d.ts +4 -4
  40. package/snapshotsDiffer.d.ts +2486 -1209
  41. package/utils/words.d.ts +1 -1
  42. package/utils-studio.d.mts +0 -1
  43. package/utils-studio.d.ts +0 -1
  44. package/utils-studio.js +7056 -847
  45. package/utils-studio.mjs +7034 -828
  46. package/utils.d.ts +14 -141
  47. package/utils.js +4380 -6916
  48. package/utils.mjs +4593 -7129
  49. package/cli/commands/mysqlUp.d.ts +0 -4
  50. package/cli/commands/pgConnect.d.ts +0 -5
  51. package/cli/commands/pgUp.d.ts +0 -4
  52. package/cli/commands/sqliteUtils.d.ts +0 -162
  53. package/cli/commands/upFolders.d.ts +0 -27
  54. package/drivers/index.d.ts +0 -39
  55. package/introspect-mysql.d.ts +0 -9
  56. package/introspect-pg.d.ts +0 -12
package/schemaValidator.d.ts CHANGED
@@ -1,8 +1,8 @@
1
1
  import { TypeOf } from "zod";
2
- declare const dialect: import("zod").ZodEnum<["pg", "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
- version: import("zod").ZodLiteral<"5">;
5
+ version: import("zod").ZodLiteral<"6">;
6
6
  dialect: import("zod").ZodEnum<["pg"]>;
7
7
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
8
8
  name: import("zod").ZodString;
@@ -10,6 +10,7 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
10
10
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
11
11
  name: import("zod").ZodString;
12
12
  type: import("zod").ZodString;
13
+ typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
13
14
  primaryKey: import("zod").ZodBoolean;
14
15
  notNull: import("zod").ZodBoolean;
15
16
  default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -17,23 +18,25 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
17
18
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
18
19
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
19
20
  }, "strict", import("zod").ZodTypeAny, {
20
- isUnique?: any;
21
- default?: any;
22
- uniqueName?: string | undefined;
23
- nullsNotDistinct?: boolean | undefined;
24
21
  name: string;
25
22
  type: string;
26
23
  primaryKey: boolean;
27
24
  notNull: boolean;
28
- }, {
29
25
  isUnique?: any;
30
26
  default?: any;
27
+ typeSchema?: string | undefined;
31
28
  uniqueName?: string | undefined;
32
29
  nullsNotDistinct?: boolean | undefined;
30
+ }, {
33
31
  name: string;
34
32
  type: string;
35
33
  primaryKey: boolean;
36
34
  notNull: boolean;
35
+ isUnique?: any;
36
+ default?: any;
37
+ typeSchema?: string | undefined;
38
+ uniqueName?: string | undefined;
39
+ nullsNotDistinct?: boolean | undefined;
37
40
  }>>;
38
41
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
39
42
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -42,14 +45,15 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
42
45
  }, "strict", import("zod").ZodTypeAny, {
43
46
  name: string;
44
47
  columns: Record<string, {
45
- isUnique?: any;
46
- default?: any;
47
- uniqueName?: string | undefined;
48
- nullsNotDistinct?: boolean | undefined;
49
48
  name: string;
50
49
  type: string;
51
50
  primaryKey: boolean;
52
51
  notNull: boolean;
52
+ isUnique?: any;
53
+ default?: any;
54
+ typeSchema?: string | undefined;
55
+ uniqueName?: string | undefined;
56
+ nullsNotDistinct?: boolean | undefined;
53
57
  }>;
54
58
  indexes: Record<string, string>;
55
59
  foreignKeys: Record<string, string>;
@@ -59,14 +63,15 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
59
63
  }, {
60
64
  name: string;
61
65
  columns: Record<string, {
62
- isUnique?: any;
63
- default?: any;
64
- uniqueName?: string | undefined;
65
- nullsNotDistinct?: boolean | undefined;
66
66
  name: string;
67
67
  type: string;
68
68
  primaryKey: boolean;
69
69
  notNull: boolean;
70
+ isUnique?: any;
71
+ default?: any;
72
+ typeSchema?: string | undefined;
73
+ uniqueName?: string | undefined;
74
+ nullsNotDistinct?: boolean | undefined;
70
75
  }>;
71
76
  indexes: Record<string, string>;
72
77
  foreignKeys: Record<string, string>;
@@ -76,29 +81,31 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
76
81
  }>>;
77
82
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
78
83
  name: import("zod").ZodString;
79
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
84
+ schema: import("zod").ZodString;
85
+ values: import("zod").ZodArray<import("zod").ZodString, "many">;
80
86
  }, "strict", import("zod").ZodTypeAny, {
81
87
  name: string;
82
- values: Record<string, string>;
88
+ values: string[];
89
+ schema: string;
83
90
  }, {
84
91
  name: string;
85
- values: Record<string, string>;
92
+ values: string[];
93
+ schema: string;
86
94
  }>>;
87
95
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
88
96
  }, "strict", import("zod").ZodTypeAny, {
89
- version: "5";
90
- dialect: "pg";
91
97
  tables: Record<string, {
92
98
  name: string;
93
99
  columns: Record<string, {
94
- isUnique?: any;
95
- default?: any;
96
- uniqueName?: string | undefined;
97
- nullsNotDistinct?: boolean | undefined;
98
100
  name: string;
99
101
  type: string;
100
102
  primaryKey: boolean;
101
103
  notNull: boolean;
104
+ isUnique?: any;
105
+ default?: any;
106
+ typeSchema?: string | undefined;
107
+ uniqueName?: string | undefined;
108
+ nullsNotDistinct?: boolean | undefined;
102
109
  }>;
103
110
  indexes: Record<string, string>;
104
111
  foreignKeys: Record<string, string>;
@@ -106,25 +113,27 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
106
113
  compositePrimaryKeys: Record<string, string>;
107
114
  uniqueConstraints: Record<string, string>;
108
115
  }>;
116
+ version: "6";
117
+ dialect: "pg";
109
118
  schemas: Record<string, string>;
110
119
  enums: Record<string, {
111
120
  name: string;
112
- values: Record<string, string>;
121
+ values: string[];
122
+ schema: string;
113
123
  }>;
114
124
  }, {
115
- version: "5";
116
- dialect: "pg";
117
125
  tables: Record<string, {
118
126
  name: string;
119
127
  columns: Record<string, {
120
- isUnique?: any;
121
- default?: any;
122
- uniqueName?: string | undefined;
123
- nullsNotDistinct?: boolean | undefined;
124
128
  name: string;
125
129
  type: string;
126
130
  primaryKey: boolean;
127
131
  notNull: boolean;
132
+ isUnique?: any;
133
+ default?: any;
134
+ typeSchema?: string | undefined;
135
+ uniqueName?: string | undefined;
136
+ nullsNotDistinct?: boolean | undefined;
128
137
  }>;
129
138
  indexes: Record<string, string>;
130
139
  foreignKeys: Record<string, string>;
@@ -132,17 +141,19 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
132
141
  compositePrimaryKeys: Record<string, string>;
133
142
  uniqueConstraints: Record<string, string>;
134
143
  }>;
144
+ version: "6";
145
+ dialect: "pg";
135
146
  schemas: Record<string, string>;
136
147
  enums: Record<string, {
137
148
  name: string;
138
- values: Record<string, string>;
149
+ values: string[];
150
+ schema: string;
139
151
  }>;
140
152
  }>, import("zod").ZodObject<{
141
- version: import("zod").ZodLiteral<"5">;
153
+ version: import("zod").ZodLiteral<"6">;
142
154
  dialect: import("zod").ZodLiteral<"mysql">;
143
155
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
144
156
  name: import("zod").ZodString;
145
- schema: import("zod").ZodOptional<import("zod").ZodString>;
146
157
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
147
158
  name: import("zod").ZodString;
148
159
  type: import("zod").ZodString;
@@ -152,102 +163,95 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
152
163
  default: import("zod").ZodOptional<import("zod").ZodAny>;
153
164
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
154
165
  }, "strict", import("zod").ZodTypeAny, {
155
- default?: any;
156
- onUpdate?: any;
157
- autoincrement?: boolean | undefined;
158
166
  name: string;
159
167
  type: string;
160
168
  primaryKey: boolean;
161
169
  notNull: boolean;
162
- }, {
163
170
  default?: any;
164
171
  onUpdate?: any;
165
172
  autoincrement?: boolean | undefined;
173
+ }, {
166
174
  name: string;
167
175
  type: string;
168
176
  primaryKey: boolean;
169
177
  notNull: boolean;
178
+ default?: any;
179
+ onUpdate?: any;
180
+ autoincrement?: boolean | undefined;
170
181
  }>>;
171
182
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
172
183
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
173
184
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
174
185
  uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
175
186
  }, "strict", import("zod").ZodTypeAny, {
176
- schema?: string | undefined;
177
187
  name: string;
178
188
  columns: Record<string, {
179
- default?: any;
180
- onUpdate?: any;
181
- autoincrement?: boolean | undefined;
182
189
  name: string;
183
190
  type: string;
184
191
  primaryKey: boolean;
185
192
  notNull: boolean;
193
+ default?: any;
194
+ onUpdate?: any;
195
+ autoincrement?: boolean | undefined;
186
196
  }>;
187
197
  indexes: Record<string, string>;
188
198
  foreignKeys: Record<string, string>;
189
199
  compositePrimaryKeys: Record<string, string>;
190
200
  uniqueConstraints: Record<string, string>;
191
201
  }, {
192
- schema?: string | undefined;
193
- uniqueConstraints?: Record<string, string> | undefined;
194
202
  name: string;
195
203
  columns: Record<string, {
196
- default?: any;
197
- onUpdate?: any;
198
- autoincrement?: boolean | undefined;
199
204
  name: string;
200
205
  type: string;
201
206
  primaryKey: boolean;
202
207
  notNull: boolean;
208
+ default?: any;
209
+ onUpdate?: any;
210
+ autoincrement?: boolean | undefined;
203
211
  }>;
204
212
  indexes: Record<string, string>;
205
213
  foreignKeys: Record<string, string>;
206
214
  compositePrimaryKeys: Record<string, string>;
215
+ uniqueConstraints?: Record<string, string> | undefined;
207
216
  }>>;
208
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
209
217
  }, "strict", import("zod").ZodTypeAny, {
210
- version: "5";
211
- dialect: "mysql";
212
218
  tables: Record<string, {
213
- schema?: string | undefined;
214
219
  name: string;
215
220
  columns: Record<string, {
216
- default?: any;
217
- onUpdate?: any;
218
- autoincrement?: boolean | undefined;
219
221
  name: string;
220
222
  type: string;
221
223
  primaryKey: boolean;
222
224
  notNull: boolean;
225
+ default?: any;
226
+ onUpdate?: any;
227
+ autoincrement?: boolean | undefined;
223
228
  }>;
224
229
  indexes: Record<string, string>;
225
230
  foreignKeys: Record<string, string>;
226
231
  compositePrimaryKeys: Record<string, string>;
227
232
  uniqueConstraints: Record<string, string>;
228
233
  }>;
229
- schemas: Record<string, string>;
230
- }, {
231
- version: "5";
234
+ version: "6";
232
235
  dialect: "mysql";
236
+ }, {
233
237
  tables: Record<string, {
234
- schema?: string | undefined;
235
- uniqueConstraints?: Record<string, string> | undefined;
236
238
  name: string;
237
239
  columns: Record<string, {
238
- default?: any;
239
- onUpdate?: any;
240
- autoincrement?: boolean | undefined;
241
240
  name: string;
242
241
  type: string;
243
242
  primaryKey: boolean;
244
243
  notNull: boolean;
244
+ default?: any;
245
+ onUpdate?: any;
246
+ autoincrement?: boolean | undefined;
245
247
  }>;
246
248
  indexes: Record<string, string>;
247
249
  foreignKeys: Record<string, string>;
248
250
  compositePrimaryKeys: Record<string, string>;
251
+ uniqueConstraints?: Record<string, string> | undefined;
249
252
  }>;
250
- schemas: Record<string, string>;
253
+ version: "6";
254
+ dialect: "mysql";
251
255
  }>, import("zod").ZodObject<{
252
256
  version: import("zod").ZodLiteral<"5">;
253
257
  dialect: import("zod").ZodEnum<["sqlite"]>;
@@ -261,19 +265,19 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
261
265
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
262
266
  default: import("zod").ZodOptional<import("zod").ZodAny>;
263
267
  }, "strict", import("zod").ZodTypeAny, {
264
- default?: any;
265
- autoincrement?: boolean | undefined;
266
268
  name: string;
267
269
  type: string;
268
270
  primaryKey: boolean;
269
271
  notNull: boolean;
270
- }, {
271
272
  default?: any;
272
273
  autoincrement?: boolean | undefined;
274
+ }, {
273
275
  name: string;
274
276
  type: string;
275
277
  primaryKey: boolean;
276
278
  notNull: boolean;
279
+ default?: any;
280
+ autoincrement?: boolean | undefined;
277
281
  }>>;
278
282
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
279
283
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -282,74 +286,74 @@ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObj
282
286
  }, "strict", import("zod").ZodTypeAny, {
283
287
  name: string;
284
288
  columns: Record<string, {
285
- default?: any;
286
- autoincrement?: boolean | undefined;
287
289
  name: string;
288
290
  type: string;
289
291
  primaryKey: boolean;
290
292
  notNull: boolean;
293
+ default?: any;
294
+ autoincrement?: boolean | undefined;
291
295
  }>;
292
296
  indexes: Record<string, string>;
293
297
  foreignKeys: Record<string, string>;
294
298
  compositePrimaryKeys: Record<string, string>;
295
299
  uniqueConstraints: Record<string, string>;
296
300
  }, {
297
- uniqueConstraints?: Record<string, string> | undefined;
298
301
  name: string;
299
302
  columns: Record<string, {
300
- default?: any;
301
- autoincrement?: boolean | undefined;
302
303
  name: string;
303
304
  type: string;
304
305
  primaryKey: boolean;
305
306
  notNull: boolean;
307
+ default?: any;
308
+ autoincrement?: boolean | undefined;
306
309
  }>;
307
310
  indexes: Record<string, string>;
308
311
  foreignKeys: Record<string, string>;
309
312
  compositePrimaryKeys: Record<string, string>;
313
+ uniqueConstraints?: Record<string, string> | undefined;
310
314
  }>>;
311
315
  enums: import("zod").ZodAny;
312
316
  }, "strict", import("zod").ZodTypeAny, {
313
- enums?: any;
314
- version: "5";
315
- dialect: "sqlite";
316
317
  tables: Record<string, {
317
318
  name: string;
318
319
  columns: Record<string, {
319
- default?: any;
320
- autoincrement?: boolean | undefined;
321
320
  name: string;
322
321
  type: string;
323
322
  primaryKey: boolean;
324
323
  notNull: boolean;
324
+ default?: any;
325
+ autoincrement?: boolean | undefined;
325
326
  }>;
326
327
  indexes: Record<string, string>;
327
328
  foreignKeys: Record<string, string>;
328
329
  compositePrimaryKeys: Record<string, string>;
329
330
  uniqueConstraints: Record<string, string>;
330
331
  }>;
331
- }, {
332
- enums?: any;
333
332
  version: "5";
334
333
  dialect: "sqlite";
334
+ enums?: any;
335
+ }, {
335
336
  tables: Record<string, {
336
- uniqueConstraints?: Record<string, string> | undefined;
337
337
  name: string;
338
338
  columns: Record<string, {
339
- default?: any;
340
- autoincrement?: boolean | undefined;
341
339
  name: string;
342
340
  type: string;
343
341
  primaryKey: boolean;
344
342
  notNull: boolean;
343
+ default?: any;
344
+ autoincrement?: boolean | undefined;
345
345
  }>;
346
346
  indexes: Record<string, string>;
347
347
  foreignKeys: Record<string, string>;
348
348
  compositePrimaryKeys: Record<string, string>;
349
+ uniqueConstraints?: Record<string, string> | undefined;
349
350
  }>;
351
+ version: "5";
352
+ dialect: "sqlite";
353
+ enums?: any;
350
354
  }>]>;
351
- declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
352
- version: import("zod").ZodLiteral<"5">;
355
+ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
356
+ version: import("zod").ZodLiteral<"6">;
353
357
  dialect: import("zod").ZodLiteral<"pg">;
354
358
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
355
359
  name: import("zod").ZodString;
@@ -357,6 +361,7 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
357
361
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
358
362
  name: import("zod").ZodString;
359
363
  type: import("zod").ZodString;
364
+ typeSchema: import("zod").ZodOptional<import("zod").ZodString>;
360
365
  primaryKey: import("zod").ZodBoolean;
361
366
  notNull: import("zod").ZodBoolean;
362
367
  default: import("zod").ZodOptional<import("zod").ZodAny>;
@@ -364,23 +369,25 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
364
369
  uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
365
370
  nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
366
371
  }, "strict", import("zod").ZodTypeAny, {
367
- isUnique?: any;
368
- default?: any;
369
- uniqueName?: string | undefined;
370
- nullsNotDistinct?: boolean | undefined;
371
372
  name: string;
372
373
  type: string;
373
374
  primaryKey: boolean;
374
375
  notNull: boolean;
375
- }, {
376
376
  isUnique?: any;
377
377
  default?: any;
378
+ typeSchema?: string | undefined;
378
379
  uniqueName?: string | undefined;
379
380
  nullsNotDistinct?: boolean | undefined;
381
+ }, {
380
382
  name: string;
381
383
  type: string;
382
384
  primaryKey: boolean;
383
385
  notNull: boolean;
386
+ isUnique?: any;
387
+ default?: any;
388
+ typeSchema?: string | undefined;
389
+ uniqueName?: string | undefined;
390
+ nullsNotDistinct?: boolean | undefined;
384
391
  }>>;
385
392
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
386
393
  name: import("zod").ZodString;
@@ -405,23 +412,23 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
405
412
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
406
413
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
407
414
  }, "strict", import("zod").ZodTypeAny, {
408
- onUpdate?: string | undefined;
409
- onDelete?: string | undefined;
410
- schemaTo?: string | undefined;
411
415
  name: string;
412
416
  tableFrom: string;
413
417
  columnsFrom: string[];
414
418
  tableTo: string;
415
419
  columnsTo: string[];
416
- }, {
417
420
  onUpdate?: string | undefined;
418
421
  onDelete?: string | undefined;
419
422
  schemaTo?: string | undefined;
423
+ }, {
420
424
  name: string;
421
425
  tableFrom: string;
422
426
  columnsFrom: string[];
423
427
  tableTo: string;
424
428
  columnsTo: string[];
429
+ onUpdate?: string | undefined;
430
+ onDelete?: string | undefined;
431
+ schemaTo?: string | undefined;
425
432
  }>>;
426
433
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
427
434
  name: import("zod").ZodString;
@@ -449,14 +456,15 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
449
456
  }, "strict", import("zod").ZodTypeAny, {
450
457
  name: string;
451
458
  columns: Record<string, {
452
- isUnique?: any;
453
- default?: any;
454
- uniqueName?: string | undefined;
455
- nullsNotDistinct?: boolean | undefined;
456
459
  name: string;
457
460
  type: string;
458
461
  primaryKey: boolean;
459
462
  notNull: boolean;
463
+ isUnique?: any;
464
+ default?: any;
465
+ typeSchema?: string | undefined;
466
+ uniqueName?: string | undefined;
467
+ nullsNotDistinct?: boolean | undefined;
460
468
  }>;
461
469
  indexes: Record<string, {
462
470
  name: string;
@@ -464,14 +472,14 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
464
472
  isUnique: boolean;
465
473
  }>;
466
474
  foreignKeys: Record<string, {
467
- onUpdate?: string | undefined;
468
- onDelete?: string | undefined;
469
- schemaTo?: string | undefined;
470
475
  name: string;
471
476
  tableFrom: string;
472
477
  columnsFrom: string[];
473
478
  tableTo: string;
474
479
  columnsTo: string[];
480
+ onUpdate?: string | undefined;
481
+ onDelete?: string | undefined;
482
+ schemaTo?: string | undefined;
475
483
  }>;
476
484
  schema: string;
477
485
  compositePrimaryKeys: Record<string, {
@@ -484,21 +492,17 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
484
492
  nullsNotDistinct: boolean;
485
493
  }>;
486
494
  }, {
487
- uniqueConstraints?: Record<string, {
488
- name: string;
489
- columns: string[];
490
- nullsNotDistinct: boolean;
491
- }> | undefined;
492
495
  name: string;
493
496
  columns: Record<string, {
494
- isUnique?: any;
495
- default?: any;
496
- uniqueName?: string | undefined;
497
- nullsNotDistinct?: boolean | undefined;
498
497
  name: string;
499
498
  type: string;
500
499
  primaryKey: boolean;
501
500
  notNull: boolean;
501
+ isUnique?: any;
502
+ default?: any;
503
+ typeSchema?: string | undefined;
504
+ uniqueName?: string | undefined;
505
+ nullsNotDistinct?: boolean | undefined;
502
506
  }>;
503
507
  indexes: Record<string, {
504
508
  name: string;
@@ -506,30 +510,38 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
506
510
  isUnique: boolean;
507
511
  }>;
508
512
  foreignKeys: Record<string, {
509
- onUpdate?: string | undefined;
510
- onDelete?: string | undefined;
511
- schemaTo?: string | undefined;
512
513
  name: string;
513
514
  tableFrom: string;
514
515
  columnsFrom: string[];
515
516
  tableTo: string;
516
517
  columnsTo: string[];
518
+ onUpdate?: string | undefined;
519
+ onDelete?: string | undefined;
520
+ schemaTo?: string | undefined;
517
521
  }>;
518
522
  schema: string;
519
523
  compositePrimaryKeys: Record<string, {
520
524
  name: string;
521
525
  columns: string[];
522
526
  }>;
527
+ uniqueConstraints?: Record<string, {
528
+ name: string;
529
+ columns: string[];
530
+ nullsNotDistinct: boolean;
531
+ }> | undefined;
523
532
  }>>;
524
533
  enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
525
534
  name: import("zod").ZodString;
526
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
535
+ schema: import("zod").ZodString;
536
+ values: import("zod").ZodArray<import("zod").ZodString, "many">;
527
537
  }, "strict", import("zod").ZodTypeAny, {
528
538
  name: string;
529
- values: Record<string, string>;
539
+ values: string[];
540
+ schema: string;
530
541
  }, {
531
542
  name: string;
532
- values: Record<string, string>;
543
+ values: string[];
544
+ schema: string;
533
545
  }>>;
534
546
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
535
547
  _meta: import("zod").ZodObject<{
@@ -594,30 +606,18 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
594
606
  id: import("zod").ZodString;
595
607
  prevId: import("zod").ZodString;
596
608
  }>, "strip", import("zod").ZodTypeAny, {
597
- internal?: {
598
- tables: Record<string, {
599
- columns: Record<string, {
600
- isArray?: boolean | undefined;
601
- dimensions?: number | undefined;
602
- rawType?: string | undefined;
603
- } | undefined>;
604
- } | undefined>;
605
- } | undefined;
606
- id: string;
607
- prevId: string;
608
- version: "5";
609
- dialect: "pg";
610
609
  tables: Record<string, {
611
610
  name: string;
612
611
  columns: Record<string, {
613
- isUnique?: any;
614
- default?: any;
615
- uniqueName?: string | undefined;
616
- nullsNotDistinct?: boolean | undefined;
617
612
  name: string;
618
613
  type: string;
619
614
  primaryKey: boolean;
620
615
  notNull: boolean;
616
+ isUnique?: any;
617
+ default?: any;
618
+ typeSchema?: string | undefined;
619
+ uniqueName?: string | undefined;
620
+ nullsNotDistinct?: boolean | undefined;
621
621
  }>;
622
622
  indexes: Record<string, {
623
623
  name: string;
@@ -625,14 +625,14 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
625
625
  isUnique: boolean;
626
626
  }>;
627
627
  foreignKeys: Record<string, {
628
- onUpdate?: string | undefined;
629
- onDelete?: string | undefined;
630
- schemaTo?: string | undefined;
631
628
  name: string;
632
629
  tableFrom: string;
633
630
  columnsFrom: string[];
634
631
  tableTo: string;
635
632
  columnsTo: string[];
633
+ onUpdate?: string | undefined;
634
+ onDelete?: string | undefined;
635
+ schemaTo?: string | undefined;
636
636
  }>;
637
637
  schema: string;
638
638
  compositePrimaryKeys: Record<string, {
@@ -645,6 +645,10 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
645
645
  nullsNotDistinct: boolean;
646
646
  }>;
647
647
  }>;
648
+ id: string;
649
+ prevId: string;
650
+ version: "6";
651
+ dialect: "pg";
648
652
  schemas: Record<string, string>;
649
653
  _meta: {
650
654
  columns: Record<string, string>;
@@ -653,9 +657,9 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
653
657
  };
654
658
  enums: Record<string, {
655
659
  name: string;
656
- values: Record<string, string>;
660
+ values: string[];
661
+ schema: string;
657
662
  }>;
658
- }, {
659
663
  internal?: {
660
664
  tables: Record<string, {
661
665
  columns: Record<string, {
@@ -665,26 +669,19 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
665
669
  } | undefined>;
666
670
  } | undefined>;
667
671
  } | undefined;
668
- id: string;
669
- prevId: string;
670
- version: "5";
671
- dialect: "pg";
672
+ }, {
672
673
  tables: Record<string, {
673
- uniqueConstraints?: Record<string, {
674
- name: string;
675
- columns: string[];
676
- nullsNotDistinct: boolean;
677
- }> | undefined;
678
674
  name: string;
679
675
  columns: Record<string, {
680
- isUnique?: any;
681
- default?: any;
682
- uniqueName?: string | undefined;
683
- nullsNotDistinct?: boolean | undefined;
684
676
  name: string;
685
677
  type: string;
686
678
  primaryKey: boolean;
687
679
  notNull: boolean;
680
+ isUnique?: any;
681
+ default?: any;
682
+ typeSchema?: string | undefined;
683
+ uniqueName?: string | undefined;
684
+ nullsNotDistinct?: boolean | undefined;
688
685
  }>;
689
686
  indexes: Record<string, {
690
687
  name: string;
@@ -692,21 +689,30 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
692
689
  isUnique: boolean;
693
690
  }>;
694
691
  foreignKeys: Record<string, {
695
- onUpdate?: string | undefined;
696
- onDelete?: string | undefined;
697
- schemaTo?: string | undefined;
698
692
  name: string;
699
693
  tableFrom: string;
700
694
  columnsFrom: string[];
701
695
  tableTo: string;
702
696
  columnsTo: string[];
697
+ onUpdate?: string | undefined;
698
+ onDelete?: string | undefined;
699
+ schemaTo?: string | undefined;
703
700
  }>;
704
701
  schema: string;
705
702
  compositePrimaryKeys: Record<string, {
706
703
  name: string;
707
704
  columns: string[];
708
705
  }>;
706
+ uniqueConstraints?: Record<string, {
707
+ name: string;
708
+ columns: string[];
709
+ nullsNotDistinct: boolean;
710
+ }> | undefined;
709
711
  }>;
712
+ id: string;
713
+ prevId: string;
714
+ version: "6";
715
+ dialect: "pg";
710
716
  schemas: Record<string, string>;
711
717
  _meta: {
712
718
  columns: Record<string, string>;
@@ -715,14 +721,23 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
715
721
  };
716
722
  enums: Record<string, {
717
723
  name: string;
718
- values: Record<string, string>;
724
+ values: string[];
725
+ schema: string;
719
726
  }>;
720
- }>, import("zod").ZodObject<import("zod").extendShape<{
721
- version: import("zod").ZodLiteral<"5">;
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
+ version: import("zod").ZodLiteral<"6">;
722
738
  dialect: import("zod").ZodLiteral<"mysql">;
723
739
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
724
740
  name: import("zod").ZodString;
725
- schema: import("zod").ZodOptional<import("zod").ZodString>;
726
741
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
727
742
  name: import("zod").ZodString;
728
743
  type: import("zod").ZodString;
@@ -732,21 +747,21 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
732
747
  default: import("zod").ZodOptional<import("zod").ZodAny>;
733
748
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
734
749
  }, "strict", import("zod").ZodTypeAny, {
735
- default?: any;
736
- onUpdate?: any;
737
- autoincrement?: boolean | undefined;
738
750
  name: string;
739
751
  type: string;
740
752
  primaryKey: boolean;
741
753
  notNull: boolean;
742
- }, {
743
754
  default?: any;
744
755
  onUpdate?: any;
745
756
  autoincrement?: boolean | undefined;
757
+ }, {
746
758
  name: string;
747
759
  type: string;
748
760
  primaryKey: boolean;
749
761
  notNull: boolean;
762
+ default?: any;
763
+ onUpdate?: any;
764
+ autoincrement?: boolean | undefined;
750
765
  }>>;
751
766
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
752
767
  name: import("zod").ZodString;
@@ -756,19 +771,19 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
756
771
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
757
772
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
758
773
  }, "strict", import("zod").ZodTypeAny, {
759
- using?: "btree" | "hash" | undefined;
760
- algorithm?: "default" | "inplace" | "copy" | undefined;
761
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
762
774
  name: string;
763
775
  columns: string[];
764
776
  isUnique: boolean;
765
- }, {
766
777
  using?: "btree" | "hash" | undefined;
767
778
  algorithm?: "default" | "inplace" | "copy" | undefined;
768
779
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
780
+ }, {
769
781
  name: string;
770
782
  columns: string[];
771
783
  isUnique: boolean;
784
+ using?: "btree" | "hash" | undefined;
785
+ algorithm?: "default" | "inplace" | "copy" | undefined;
786
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
772
787
  }>>;
773
788
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
774
789
  name: import("zod").ZodString;
@@ -779,21 +794,21 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
779
794
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
780
795
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
781
796
  }, "strict", import("zod").ZodTypeAny, {
782
- onUpdate?: string | undefined;
783
- onDelete?: string | undefined;
784
797
  name: string;
785
798
  tableFrom: string;
786
799
  columnsFrom: string[];
787
800
  tableTo: string;
788
801
  columnsTo: string[];
789
- }, {
790
802
  onUpdate?: string | undefined;
791
803
  onDelete?: string | undefined;
804
+ }, {
792
805
  name: string;
793
806
  tableFrom: string;
794
807
  columnsFrom: string[];
795
808
  tableTo: string;
796
809
  columnsTo: string[];
810
+ onUpdate?: string | undefined;
811
+ onDelete?: string | undefined;
797
812
  }>>;
798
813
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
799
814
  name: import("zod").ZodString;
@@ -816,33 +831,32 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
816
831
  columns: string[];
817
832
  }>>>;
818
833
  }, "strict", import("zod").ZodTypeAny, {
819
- schema?: string | undefined;
820
834
  name: string;
821
835
  columns: Record<string, {
822
- default?: any;
823
- onUpdate?: any;
824
- autoincrement?: boolean | undefined;
825
836
  name: string;
826
837
  type: string;
827
838
  primaryKey: boolean;
828
839
  notNull: boolean;
840
+ default?: any;
841
+ onUpdate?: any;
842
+ autoincrement?: boolean | undefined;
829
843
  }>;
830
844
  indexes: Record<string, {
831
- using?: "btree" | "hash" | undefined;
832
- algorithm?: "default" | "inplace" | "copy" | undefined;
833
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
834
845
  name: string;
835
846
  columns: string[];
836
847
  isUnique: boolean;
848
+ using?: "btree" | "hash" | undefined;
849
+ algorithm?: "default" | "inplace" | "copy" | undefined;
850
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
837
851
  }>;
838
852
  foreignKeys: Record<string, {
839
- onUpdate?: string | undefined;
840
- onDelete?: string | undefined;
841
853
  name: string;
842
854
  tableFrom: string;
843
855
  columnsFrom: string[];
844
856
  tableTo: string;
845
857
  columnsTo: string[];
858
+ onUpdate?: string | undefined;
859
+ onDelete?: string | undefined;
846
860
  }>;
847
861
  compositePrimaryKeys: Record<string, {
848
862
  name: string;
@@ -853,56 +867,51 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
853
867
  columns: string[];
854
868
  }>;
855
869
  }, {
856
- schema?: string | undefined;
857
- uniqueConstraints?: Record<string, {
858
- name: string;
859
- columns: string[];
860
- }> | undefined;
861
870
  name: string;
862
871
  columns: Record<string, {
863
- default?: any;
864
- onUpdate?: any;
865
- autoincrement?: boolean | undefined;
866
872
  name: string;
867
873
  type: string;
868
874
  primaryKey: boolean;
869
875
  notNull: boolean;
876
+ default?: any;
877
+ onUpdate?: any;
878
+ autoincrement?: boolean | undefined;
870
879
  }>;
871
880
  indexes: Record<string, {
872
- using?: "btree" | "hash" | undefined;
873
- algorithm?: "default" | "inplace" | "copy" | undefined;
874
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
875
881
  name: string;
876
882
  columns: string[];
877
883
  isUnique: boolean;
884
+ using?: "btree" | "hash" | undefined;
885
+ algorithm?: "default" | "inplace" | "copy" | undefined;
886
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
878
887
  }>;
879
888
  foreignKeys: Record<string, {
880
- onUpdate?: string | undefined;
881
- onDelete?: string | undefined;
882
889
  name: string;
883
890
  tableFrom: string;
884
891
  columnsFrom: string[];
885
892
  tableTo: string;
886
893
  columnsTo: string[];
894
+ onUpdate?: string | undefined;
895
+ onDelete?: string | undefined;
887
896
  }>;
888
897
  compositePrimaryKeys: Record<string, {
889
898
  name: string;
890
899
  columns: string[];
891
900
  }>;
901
+ uniqueConstraints?: Record<string, {
902
+ name: string;
903
+ columns: string[];
904
+ }> | undefined;
892
905
  }>>;
893
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
894
906
  _meta: import("zod").ZodObject<{
895
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
896
907
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
897
908
  columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
898
909
  }, "strip", import("zod").ZodTypeAny, {
899
910
  columns: Record<string, string>;
900
911
  tables: Record<string, string>;
901
- schemas: Record<string, string>;
902
912
  }, {
903
913
  columns: Record<string, string>;
904
914
  tables: Record<string, string>;
905
- schemas: Record<string, string>;
906
915
  }>;
907
916
  internal: import("zod").ZodOptional<import("zod").ZodObject<{
908
917
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
@@ -939,45 +948,33 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
939
948
  id: import("zod").ZodString;
940
949
  prevId: import("zod").ZodString;
941
950
  }>, "strip", import("zod").ZodTypeAny, {
942
- internal?: {
943
- tables: Record<string, {
944
- columns: Record<string, {
945
- isDefaultAnExpression?: boolean | undefined;
946
- } | undefined>;
947
- } | undefined>;
948
- } | undefined;
949
- id: string;
950
- prevId: string;
951
- version: "5";
952
- dialect: "mysql";
953
951
  tables: Record<string, {
954
- schema?: string | undefined;
955
952
  name: string;
956
953
  columns: Record<string, {
957
- default?: any;
958
- onUpdate?: any;
959
- autoincrement?: boolean | undefined;
960
954
  name: string;
961
955
  type: string;
962
956
  primaryKey: boolean;
963
957
  notNull: boolean;
958
+ default?: any;
959
+ onUpdate?: any;
960
+ autoincrement?: boolean | undefined;
964
961
  }>;
965
962
  indexes: Record<string, {
966
- using?: "btree" | "hash" | undefined;
967
- algorithm?: "default" | "inplace" | "copy" | undefined;
968
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
969
963
  name: string;
970
964
  columns: string[];
971
965
  isUnique: boolean;
966
+ using?: "btree" | "hash" | undefined;
967
+ algorithm?: "default" | "inplace" | "copy" | undefined;
968
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
972
969
  }>;
973
970
  foreignKeys: Record<string, {
974
- onUpdate?: string | undefined;
975
- onDelete?: string | undefined;
976
971
  name: string;
977
972
  tableFrom: string;
978
973
  columnsFrom: string[];
979
974
  tableTo: string;
980
975
  columnsTo: string[];
976
+ onUpdate?: string | undefined;
977
+ onDelete?: string | undefined;
981
978
  }>;
982
979
  compositePrimaryKeys: Record<string, {
983
980
  name: string;
@@ -988,13 +985,14 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
988
985
  columns: string[];
989
986
  }>;
990
987
  }>;
991
- schemas: Record<string, string>;
988
+ id: string;
989
+ prevId: string;
990
+ version: "6";
991
+ dialect: "mysql";
992
992
  _meta: {
993
993
  columns: Record<string, string>;
994
994
  tables: Record<string, string>;
995
- schemas: Record<string, string>;
996
995
  };
997
- }, {
998
996
  internal?: {
999
997
  tables: Record<string, {
1000
998
  columns: Record<string, {
@@ -1002,55 +1000,60 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1002
1000
  } | undefined>;
1003
1001
  } | undefined>;
1004
1002
  } | undefined;
1005
- id: string;
1006
- prevId: string;
1007
- version: "5";
1008
- dialect: "mysql";
1003
+ }, {
1009
1004
  tables: Record<string, {
1010
- schema?: string | undefined;
1011
- uniqueConstraints?: Record<string, {
1012
- name: string;
1013
- columns: string[];
1014
- }> | undefined;
1015
1005
  name: string;
1016
1006
  columns: Record<string, {
1017
- default?: any;
1018
- onUpdate?: any;
1019
- autoincrement?: boolean | undefined;
1020
1007
  name: string;
1021
1008
  type: string;
1022
1009
  primaryKey: boolean;
1023
1010
  notNull: boolean;
1011
+ default?: any;
1012
+ onUpdate?: any;
1013
+ autoincrement?: boolean | undefined;
1024
1014
  }>;
1025
1015
  indexes: Record<string, {
1026
- using?: "btree" | "hash" | undefined;
1027
- algorithm?: "default" | "inplace" | "copy" | undefined;
1028
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1029
1016
  name: string;
1030
1017
  columns: string[];
1031
1018
  isUnique: boolean;
1019
+ using?: "btree" | "hash" | undefined;
1020
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1021
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1032
1022
  }>;
1033
1023
  foreignKeys: Record<string, {
1034
- onUpdate?: string | undefined;
1035
- onDelete?: string | undefined;
1036
1024
  name: string;
1037
1025
  tableFrom: string;
1038
1026
  columnsFrom: string[];
1039
1027
  tableTo: string;
1040
1028
  columnsTo: string[];
1029
+ onUpdate?: string | undefined;
1030
+ onDelete?: string | undefined;
1041
1031
  }>;
1042
1032
  compositePrimaryKeys: Record<string, {
1043
1033
  name: string;
1044
1034
  columns: string[];
1045
1035
  }>;
1036
+ uniqueConstraints?: Record<string, {
1037
+ name: string;
1038
+ columns: string[];
1039
+ }> | undefined;
1046
1040
  }>;
1047
- schemas: Record<string, string>;
1041
+ id: string;
1042
+ prevId: string;
1043
+ version: "6";
1044
+ dialect: "mysql";
1048
1045
  _meta: {
1049
1046
  columns: Record<string, string>;
1050
1047
  tables: Record<string, string>;
1051
- schemas: Record<string, string>;
1052
1048
  };
1053
- }>, 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<{
1054
1057
  version: import("zod").ZodLiteral<"5">;
1055
1058
  dialect: import("zod").ZodEnum<["sqlite"]>;
1056
1059
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1063,19 +1066,19 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1063
1066
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1064
1067
  default: import("zod").ZodOptional<import("zod").ZodAny>;
1065
1068
  }, "strict", import("zod").ZodTypeAny, {
1066
- default?: any;
1067
- autoincrement?: boolean | undefined;
1068
1069
  name: string;
1069
1070
  type: string;
1070
1071
  primaryKey: boolean;
1071
1072
  notNull: boolean;
1072
- }, {
1073
1073
  default?: any;
1074
1074
  autoincrement?: boolean | undefined;
1075
+ }, {
1075
1076
  name: string;
1076
1077
  type: string;
1077
1078
  primaryKey: boolean;
1078
1079
  notNull: boolean;
1080
+ default?: any;
1081
+ autoincrement?: boolean | undefined;
1079
1082
  }>>;
1080
1083
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1081
1084
  name: import("zod").ZodString;
@@ -1083,15 +1086,15 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1083
1086
  where: import("zod").ZodOptional<import("zod").ZodString>;
1084
1087
  isUnique: import("zod").ZodBoolean;
1085
1088
  }, "strict", import("zod").ZodTypeAny, {
1086
- where?: string | undefined;
1087
1089
  name: string;
1088
1090
  columns: string[];
1089
1091
  isUnique: boolean;
1090
- }, {
1091
1092
  where?: string | undefined;
1093
+ }, {
1092
1094
  name: string;
1093
1095
  columns: string[];
1094
1096
  isUnique: boolean;
1097
+ where?: string | undefined;
1095
1098
  }>>;
1096
1099
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1097
1100
  name: import("zod").ZodString;
@@ -1102,31 +1105,31 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1102
1105
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1103
1106
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1104
1107
  }, "strict", import("zod").ZodTypeAny, {
1105
- onUpdate?: string | undefined;
1106
- onDelete?: string | undefined;
1107
1108
  name: string;
1108
1109
  tableFrom: string;
1109
1110
  columnsFrom: string[];
1110
1111
  tableTo: string;
1111
1112
  columnsTo: string[];
1112
- }, {
1113
1113
  onUpdate?: string | undefined;
1114
1114
  onDelete?: string | undefined;
1115
+ }, {
1115
1116
  name: string;
1116
1117
  tableFrom: string;
1117
1118
  columnsFrom: string[];
1118
1119
  tableTo: string;
1119
1120
  columnsTo: string[];
1121
+ onUpdate?: string | undefined;
1122
+ onDelete?: string | undefined;
1120
1123
  }>>;
1121
1124
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1122
1125
  columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1123
1126
  name: import("zod").ZodOptional<import("zod").ZodString>;
1124
1127
  }, "strict", import("zod").ZodTypeAny, {
1125
- name?: string | undefined;
1126
1128
  columns: string[];
1127
- }, {
1128
1129
  name?: string | undefined;
1130
+ }, {
1129
1131
  columns: string[];
1132
+ name?: string | undefined;
1130
1133
  }>>;
1131
1134
  uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1132
1135
  name: import("zod").ZodString;
@@ -1141,69 +1144,69 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1141
1144
  }, "strict", import("zod").ZodTypeAny, {
1142
1145
  name: string;
1143
1146
  columns: Record<string, {
1144
- default?: any;
1145
- autoincrement?: boolean | undefined;
1146
1147
  name: string;
1147
1148
  type: string;
1148
1149
  primaryKey: boolean;
1149
1150
  notNull: boolean;
1151
+ default?: any;
1152
+ autoincrement?: boolean | undefined;
1150
1153
  }>;
1151
1154
  indexes: Record<string, {
1152
- where?: string | undefined;
1153
1155
  name: string;
1154
1156
  columns: string[];
1155
1157
  isUnique: boolean;
1158
+ where?: string | undefined;
1156
1159
  }>;
1157
1160
  foreignKeys: Record<string, {
1158
- onUpdate?: string | undefined;
1159
- onDelete?: string | undefined;
1160
1161
  name: string;
1161
1162
  tableFrom: string;
1162
1163
  columnsFrom: string[];
1163
1164
  tableTo: string;
1164
1165
  columnsTo: string[];
1166
+ onUpdate?: string | undefined;
1167
+ onDelete?: string | undefined;
1165
1168
  }>;
1166
1169
  compositePrimaryKeys: Record<string, {
1167
- name?: string | undefined;
1168
1170
  columns: string[];
1171
+ name?: string | undefined;
1169
1172
  }>;
1170
1173
  uniqueConstraints: Record<string, {
1171
1174
  name: string;
1172
1175
  columns: string[];
1173
1176
  }>;
1174
1177
  }, {
1175
- uniqueConstraints?: Record<string, {
1176
- name: string;
1177
- columns: string[];
1178
- }> | undefined;
1179
1178
  name: string;
1180
1179
  columns: Record<string, {
1181
- default?: any;
1182
- autoincrement?: boolean | undefined;
1183
1180
  name: string;
1184
1181
  type: string;
1185
1182
  primaryKey: boolean;
1186
1183
  notNull: boolean;
1184
+ default?: any;
1185
+ autoincrement?: boolean | undefined;
1187
1186
  }>;
1188
1187
  indexes: Record<string, {
1189
- where?: string | undefined;
1190
1188
  name: string;
1191
1189
  columns: string[];
1192
1190
  isUnique: boolean;
1191
+ where?: string | undefined;
1193
1192
  }>;
1194
1193
  foreignKeys: Record<string, {
1195
- onUpdate?: string | undefined;
1196
- onDelete?: string | undefined;
1197
1194
  name: string;
1198
1195
  tableFrom: string;
1199
1196
  columnsFrom: string[];
1200
1197
  tableTo: string;
1201
1198
  columnsTo: string[];
1199
+ onUpdate?: string | undefined;
1200
+ onDelete?: string | undefined;
1202
1201
  }>;
1203
1202
  compositePrimaryKeys: Record<string, {
1204
- name?: string | undefined;
1205
1203
  columns: string[];
1204
+ name?: string | undefined;
1206
1205
  }>;
1206
+ uniqueConstraints?: Record<string, {
1207
+ name: string;
1208
+ columns: string[];
1209
+ }> | undefined;
1207
1210
  }>>;
1208
1211
  enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
1209
1212
  _meta: import("zod").ZodObject<{
@@ -1220,88 +1223,88 @@ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<impo
1220
1223
  id: import("zod").ZodString;
1221
1224
  prevId: import("zod").ZodString;
1222
1225
  }>, "strict", import("zod").ZodTypeAny, {
1223
- id: string;
1224
- prevId: string;
1225
- version: "5";
1226
- dialect: "sqlite";
1227
1226
  tables: Record<string, {
1228
1227
  name: string;
1229
1228
  columns: Record<string, {
1230
- default?: any;
1231
- autoincrement?: boolean | undefined;
1232
1229
  name: string;
1233
1230
  type: string;
1234
1231
  primaryKey: boolean;
1235
1232
  notNull: boolean;
1233
+ default?: any;
1234
+ autoincrement?: boolean | undefined;
1236
1235
  }>;
1237
1236
  indexes: Record<string, {
1238
- where?: string | undefined;
1239
1237
  name: string;
1240
1238
  columns: string[];
1241
1239
  isUnique: boolean;
1240
+ where?: string | undefined;
1242
1241
  }>;
1243
1242
  foreignKeys: Record<string, {
1244
- onUpdate?: string | undefined;
1245
- onDelete?: string | undefined;
1246
1243
  name: string;
1247
1244
  tableFrom: string;
1248
1245
  columnsFrom: string[];
1249
1246
  tableTo: string;
1250
1247
  columnsTo: string[];
1248
+ onUpdate?: string | undefined;
1249
+ onDelete?: string | undefined;
1251
1250
  }>;
1252
1251
  compositePrimaryKeys: Record<string, {
1253
- name?: string | undefined;
1254
1252
  columns: string[];
1253
+ name?: string | undefined;
1255
1254
  }>;
1256
1255
  uniqueConstraints: Record<string, {
1257
1256
  name: string;
1258
1257
  columns: string[];
1259
1258
  }>;
1260
1259
  }>;
1260
+ id: string;
1261
+ prevId: string;
1262
+ version: "5";
1263
+ dialect: "sqlite";
1261
1264
  _meta: {
1262
1265
  columns: Record<string, string>;
1263
1266
  tables: Record<string, string>;
1264
1267
  };
1265
1268
  enums: {};
1266
1269
  }, {
1267
- id: string;
1268
- prevId: string;
1269
- version: "5";
1270
- dialect: "sqlite";
1271
1270
  tables: Record<string, {
1272
- uniqueConstraints?: Record<string, {
1273
- name: string;
1274
- columns: string[];
1275
- }> | undefined;
1276
1271
  name: string;
1277
1272
  columns: Record<string, {
1278
- default?: any;
1279
- autoincrement?: boolean | undefined;
1280
1273
  name: string;
1281
1274
  type: string;
1282
1275
  primaryKey: boolean;
1283
1276
  notNull: boolean;
1277
+ default?: any;
1278
+ autoincrement?: boolean | undefined;
1284
1279
  }>;
1285
1280
  indexes: Record<string, {
1286
- where?: string | undefined;
1287
1281
  name: string;
1288
1282
  columns: string[];
1289
1283
  isUnique: boolean;
1284
+ where?: string | undefined;
1290
1285
  }>;
1291
1286
  foreignKeys: Record<string, {
1292
- onUpdate?: string | undefined;
1293
- onDelete?: string | undefined;
1294
1287
  name: string;
1295
1288
  tableFrom: string;
1296
1289
  columnsFrom: string[];
1297
1290
  tableTo: string;
1298
1291
  columnsTo: string[];
1292
+ onUpdate?: string | undefined;
1293
+ onDelete?: string | undefined;
1299
1294
  }>;
1300
1295
  compositePrimaryKeys: Record<string, {
1301
- name?: string | undefined;
1302
1296
  columns: string[];
1297
+ name?: string | undefined;
1303
1298
  }>;
1299
+ uniqueConstraints?: Record<string, {
1300
+ name: string;
1301
+ columns: string[];
1302
+ }> | undefined;
1304
1303
  }>;
1304
+ id: string;
1305
+ prevId: string;
1306
+ version: "5";
1307
+ dialect: "sqlite";
1305
1308
  _meta: {
1306
1309
  columns: Record<string, string>;
1307
1310
  tables: Record<string, string>;