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

Sign up to get free protection for your applications and to get access to all the features.
Files changed (56) hide show
  1. package/bin.cjs +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>;