drizzle-kit 0.20.16 → 0.20.17-5938f5d

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 (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>;