drizzle-kit 0.20.17-4e262b7 → 0.20.17-7776aba

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