drizzle-kit 0.20.18-d190692 → 0.20.18

Sign up to get free protection for your applications and to get access to all the features.
Files changed (59) hide show
  1. package/@types/utils.d.ts +12 -0
  2. package/bin.cjs +55769 -103683
  3. package/cli/commands/migrate.d.ts +270 -0
  4. package/cli/commands/mysqlIntrospect.d.ts +119 -0
  5. package/cli/commands/mysqlPushUtils.d.ts +18 -0
  6. package/cli/commands/mysqlUp.d.ts +4 -0
  7. package/cli/commands/pgConnect.d.ts +5 -0
  8. package/cli/commands/pgIntrospect.d.ts +123 -0
  9. package/cli/commands/pgPushUtils.d.ts +14 -0
  10. package/cli/commands/pgUp.d.ts +4 -0
  11. package/cli/commands/sqliteIntrospect.d.ts +107 -0
  12. package/cli/commands/sqlitePushUtils.d.ts +21 -0
  13. package/cli/commands/sqliteUtils.d.ts +162 -0
  14. package/cli/commands/upFolders.d.ts +27 -0
  15. package/cli/commands/utils.d.ts +274 -0
  16. package/cli/selector-ui.d.ts +13 -0
  17. package/cli/validations/common.d.ts +13 -0
  18. package/cli/validations/mysql.d.ts +365 -0
  19. package/cli/validations/outputs.d.ts +40 -0
  20. package/cli/validations/pg.d.ts +438 -0
  21. package/cli/views.d.ts +61 -0
  22. package/drivers/index.d.ts +39 -0
  23. package/global.d.ts +4 -0
  24. package/index.d.mts +68 -46
  25. package/index.d.ts +68 -46
  26. package/index.js +0 -1
  27. package/introspect-mysql.d.ts +9 -0
  28. package/introspect-pg.d.ts +12 -0
  29. package/introspect-sqlite.d.ts +10 -0
  30. package/jsonDiffer.d.ts +76 -0
  31. package/jsonStatements.d.ts +349 -0
  32. package/migrationPreparator.d.ts +35 -0
  33. package/package.json +64 -31
  34. package/payload.d.mts +18 -1052
  35. package/payload.d.ts +18 -1052
  36. package/payload.js +33563 -19279
  37. package/payload.mjs +33457 -19180
  38. package/schemaValidator.d.ts +1313 -0
  39. package/serializer/index.d.ts +9 -0
  40. package/serializer/mysqlImports.d.ts +11 -0
  41. package/serializer/mysqlSchema.d.ts +3833 -0
  42. package/serializer/mysqlSerializer.d.ts +7 -0
  43. package/serializer/pgImports.d.ts +11 -0
  44. package/serializer/pgSchema.d.ts +4333 -0
  45. package/serializer/pgSerializer.d.ts +7 -0
  46. package/serializer/schemaToDrizzle.d.ts +7 -0
  47. package/serializer/sqliteImports.d.ts +9 -0
  48. package/serializer/sqliteSchema.d.ts +3227 -0
  49. package/serializer/sqliteSerializer.d.ts +6 -0
  50. package/snapshotsDiffer.d.ts +2660 -0
  51. package/sqlgenerator.d.ts +33 -0
  52. package/utils/words.d.ts +7 -0
  53. package/utils-studio.d.mts +5 -0
  54. package/utils-studio.d.ts +5 -0
  55. package/utils-studio.js +809 -4584
  56. package/utils-studio.mjs +793 -4565
  57. package/utils.d.ts +199 -0
  58. package/utils.js +7165 -4635
  59. package/utils.mjs +7125 -4595
package/serializer/mysqlSchema.d.ts ADDED
@@ -0,0 +1,3833 @@
1
+ import { TypeOf } from "zod";
2
+ declare const index: import("zod").ZodObject<{
3
+ name: import("zod").ZodString;
4
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
5
+ isUnique: import("zod").ZodBoolean;
6
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
7
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
8
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
9
+ }, "strict", import("zod").ZodTypeAny, {
10
+ using?: "btree" | "hash" | undefined;
11
+ algorithm?: "default" | "inplace" | "copy" | undefined;
12
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
13
+ name: string;
14
+ columns: string[];
15
+ isUnique: boolean;
16
+ }, {
17
+ using?: "btree" | "hash" | undefined;
18
+ algorithm?: "default" | "inplace" | "copy" | undefined;
19
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
20
+ name: string;
21
+ columns: string[];
22
+ isUnique: boolean;
23
+ }>;
24
+ declare const fk: import("zod").ZodObject<{
25
+ name: import("zod").ZodString;
26
+ tableFrom: import("zod").ZodString;
27
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
28
+ tableTo: import("zod").ZodString;
29
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
30
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
31
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
32
+ }, "strict", import("zod").ZodTypeAny, {
33
+ onUpdate?: string | undefined;
34
+ onDelete?: string | undefined;
35
+ name: string;
36
+ tableFrom: string;
37
+ columnsFrom: string[];
38
+ tableTo: string;
39
+ columnsTo: string[];
40
+ }, {
41
+ onUpdate?: string | undefined;
42
+ onDelete?: string | undefined;
43
+ name: string;
44
+ tableFrom: string;
45
+ columnsFrom: string[];
46
+ tableTo: string;
47
+ columnsTo: string[];
48
+ }>;
49
+ declare const column: import("zod").ZodObject<{
50
+ name: import("zod").ZodString;
51
+ type: import("zod").ZodString;
52
+ primaryKey: import("zod").ZodBoolean;
53
+ notNull: import("zod").ZodBoolean;
54
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
55
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
56
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
57
+ }, "strict", import("zod").ZodTypeAny, {
58
+ default?: any;
59
+ onUpdate?: any;
60
+ autoincrement?: boolean | undefined;
61
+ name: string;
62
+ type: string;
63
+ primaryKey: boolean;
64
+ notNull: boolean;
65
+ }, {
66
+ default?: any;
67
+ onUpdate?: any;
68
+ autoincrement?: boolean | undefined;
69
+ name: string;
70
+ type: string;
71
+ primaryKey: boolean;
72
+ notNull: boolean;
73
+ }>;
74
+ declare const compositePK: import("zod").ZodObject<{
75
+ name: import("zod").ZodString;
76
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
77
+ }, "strict", import("zod").ZodTypeAny, {
78
+ name: string;
79
+ columns: string[];
80
+ }, {
81
+ name: string;
82
+ columns: string[];
83
+ }>;
84
+ declare const uniqueConstraint: import("zod").ZodObject<{
85
+ name: import("zod").ZodString;
86
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
87
+ }, "strict", import("zod").ZodTypeAny, {
88
+ name: string;
89
+ columns: string[];
90
+ }, {
91
+ name: string;
92
+ columns: string[];
93
+ }>;
94
+ declare const tableV4: import("zod").ZodObject<{
95
+ name: import("zod").ZodString;
96
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
97
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
98
+ name: import("zod").ZodString;
99
+ type: import("zod").ZodString;
100
+ primaryKey: import("zod").ZodBoolean;
101
+ notNull: import("zod").ZodBoolean;
102
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
103
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
104
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
105
+ }, "strict", import("zod").ZodTypeAny, {
106
+ default?: any;
107
+ onUpdate?: any;
108
+ autoincrement?: boolean | undefined;
109
+ name: string;
110
+ type: string;
111
+ primaryKey: boolean;
112
+ notNull: boolean;
113
+ }, {
114
+ default?: any;
115
+ onUpdate?: any;
116
+ autoincrement?: boolean | undefined;
117
+ name: string;
118
+ type: string;
119
+ primaryKey: boolean;
120
+ notNull: boolean;
121
+ }>>;
122
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
123
+ name: import("zod").ZodString;
124
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
125
+ isUnique: import("zod").ZodBoolean;
126
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
127
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
128
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
129
+ }, "strict", import("zod").ZodTypeAny, {
130
+ using?: "btree" | "hash" | undefined;
131
+ algorithm?: "default" | "inplace" | "copy" | undefined;
132
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
133
+ name: string;
134
+ columns: string[];
135
+ isUnique: boolean;
136
+ }, {
137
+ using?: "btree" | "hash" | undefined;
138
+ algorithm?: "default" | "inplace" | "copy" | undefined;
139
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
140
+ name: string;
141
+ columns: string[];
142
+ isUnique: boolean;
143
+ }>>;
144
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
145
+ name: import("zod").ZodString;
146
+ tableFrom: import("zod").ZodString;
147
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
148
+ tableTo: import("zod").ZodString;
149
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
150
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
151
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
152
+ }, "strict", import("zod").ZodTypeAny, {
153
+ onUpdate?: string | undefined;
154
+ onDelete?: string | undefined;
155
+ name: string;
156
+ tableFrom: string;
157
+ columnsFrom: string[];
158
+ tableTo: string;
159
+ columnsTo: string[];
160
+ }, {
161
+ onUpdate?: string | undefined;
162
+ onDelete?: string | undefined;
163
+ name: string;
164
+ tableFrom: string;
165
+ columnsFrom: string[];
166
+ tableTo: string;
167
+ columnsTo: string[];
168
+ }>>;
169
+ }, "strict", import("zod").ZodTypeAny, {
170
+ schema?: string | undefined;
171
+ name: string;
172
+ columns: Record<string, {
173
+ default?: any;
174
+ onUpdate?: any;
175
+ autoincrement?: boolean | undefined;
176
+ name: string;
177
+ type: string;
178
+ primaryKey: boolean;
179
+ notNull: boolean;
180
+ }>;
181
+ indexes: Record<string, {
182
+ using?: "btree" | "hash" | undefined;
183
+ algorithm?: "default" | "inplace" | "copy" | undefined;
184
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
185
+ name: string;
186
+ columns: string[];
187
+ isUnique: boolean;
188
+ }>;
189
+ foreignKeys: Record<string, {
190
+ onUpdate?: string | undefined;
191
+ onDelete?: string | undefined;
192
+ name: string;
193
+ tableFrom: string;
194
+ columnsFrom: string[];
195
+ tableTo: string;
196
+ columnsTo: string[];
197
+ }>;
198
+ }, {
199
+ schema?: string | undefined;
200
+ name: string;
201
+ columns: Record<string, {
202
+ default?: any;
203
+ onUpdate?: any;
204
+ autoincrement?: boolean | undefined;
205
+ name: string;
206
+ type: string;
207
+ primaryKey: boolean;
208
+ notNull: boolean;
209
+ }>;
210
+ indexes: Record<string, {
211
+ using?: "btree" | "hash" | undefined;
212
+ algorithm?: "default" | "inplace" | "copy" | undefined;
213
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
214
+ name: string;
215
+ columns: string[];
216
+ isUnique: boolean;
217
+ }>;
218
+ foreignKeys: Record<string, {
219
+ onUpdate?: string | undefined;
220
+ onDelete?: string | undefined;
221
+ name: string;
222
+ tableFrom: string;
223
+ columnsFrom: string[];
224
+ tableTo: string;
225
+ columnsTo: string[];
226
+ }>;
227
+ }>;
228
+ declare const table: import("zod").ZodObject<{
229
+ name: import("zod").ZodString;
230
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
231
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
232
+ name: import("zod").ZodString;
233
+ type: import("zod").ZodString;
234
+ primaryKey: import("zod").ZodBoolean;
235
+ notNull: import("zod").ZodBoolean;
236
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
237
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
238
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
239
+ }, "strict", import("zod").ZodTypeAny, {
240
+ default?: any;
241
+ onUpdate?: any;
242
+ autoincrement?: boolean | undefined;
243
+ name: string;
244
+ type: string;
245
+ primaryKey: boolean;
246
+ notNull: boolean;
247
+ }, {
248
+ default?: any;
249
+ onUpdate?: any;
250
+ autoincrement?: boolean | undefined;
251
+ name: string;
252
+ type: string;
253
+ primaryKey: boolean;
254
+ notNull: boolean;
255
+ }>>;
256
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
257
+ name: import("zod").ZodString;
258
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
259
+ isUnique: import("zod").ZodBoolean;
260
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
261
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
262
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
263
+ }, "strict", import("zod").ZodTypeAny, {
264
+ using?: "btree" | "hash" | undefined;
265
+ algorithm?: "default" | "inplace" | "copy" | undefined;
266
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
267
+ name: string;
268
+ columns: string[];
269
+ isUnique: boolean;
270
+ }, {
271
+ using?: "btree" | "hash" | undefined;
272
+ algorithm?: "default" | "inplace" | "copy" | undefined;
273
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
274
+ name: string;
275
+ columns: string[];
276
+ isUnique: boolean;
277
+ }>>;
278
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
279
+ name: import("zod").ZodString;
280
+ tableFrom: import("zod").ZodString;
281
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
282
+ tableTo: import("zod").ZodString;
283
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
284
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
285
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
286
+ }, "strict", import("zod").ZodTypeAny, {
287
+ onUpdate?: string | undefined;
288
+ onDelete?: string | undefined;
289
+ name: string;
290
+ tableFrom: string;
291
+ columnsFrom: string[];
292
+ tableTo: string;
293
+ columnsTo: string[];
294
+ }, {
295
+ onUpdate?: string | undefined;
296
+ onDelete?: string | undefined;
297
+ name: string;
298
+ tableFrom: string;
299
+ columnsFrom: string[];
300
+ tableTo: string;
301
+ columnsTo: string[];
302
+ }>>;
303
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
304
+ name: import("zod").ZodString;
305
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
306
+ }, "strict", import("zod").ZodTypeAny, {
307
+ name: string;
308
+ columns: string[];
309
+ }, {
310
+ name: string;
311
+ columns: string[];
312
+ }>>;
313
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
314
+ name: import("zod").ZodString;
315
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
316
+ }, "strict", import("zod").ZodTypeAny, {
317
+ name: string;
318
+ columns: string[];
319
+ }, {
320
+ name: string;
321
+ columns: string[];
322
+ }>>>;
323
+ }, "strict", import("zod").ZodTypeAny, {
324
+ schema?: string | undefined;
325
+ name: string;
326
+ columns: Record<string, {
327
+ default?: any;
328
+ onUpdate?: any;
329
+ autoincrement?: boolean | undefined;
330
+ name: string;
331
+ type: string;
332
+ primaryKey: boolean;
333
+ notNull: boolean;
334
+ }>;
335
+ indexes: Record<string, {
336
+ using?: "btree" | "hash" | undefined;
337
+ algorithm?: "default" | "inplace" | "copy" | undefined;
338
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
339
+ name: string;
340
+ columns: string[];
341
+ isUnique: boolean;
342
+ }>;
343
+ foreignKeys: Record<string, {
344
+ onUpdate?: string | undefined;
345
+ onDelete?: string | undefined;
346
+ name: string;
347
+ tableFrom: string;
348
+ columnsFrom: string[];
349
+ tableTo: string;
350
+ columnsTo: string[];
351
+ }>;
352
+ compositePrimaryKeys: Record<string, {
353
+ name: string;
354
+ columns: string[];
355
+ }>;
356
+ uniqueConstraints: Record<string, {
357
+ name: string;
358
+ columns: string[];
359
+ }>;
360
+ }, {
361
+ schema?: string | undefined;
362
+ uniqueConstraints?: Record<string, {
363
+ name: string;
364
+ columns: string[];
365
+ }> | undefined;
366
+ name: string;
367
+ columns: Record<string, {
368
+ default?: any;
369
+ onUpdate?: any;
370
+ autoincrement?: boolean | undefined;
371
+ name: string;
372
+ type: string;
373
+ primaryKey: boolean;
374
+ notNull: boolean;
375
+ }>;
376
+ indexes: Record<string, {
377
+ using?: "btree" | "hash" | undefined;
378
+ algorithm?: "default" | "inplace" | "copy" | undefined;
379
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
380
+ name: string;
381
+ columns: string[];
382
+ isUnique: boolean;
383
+ }>;
384
+ foreignKeys: Record<string, {
385
+ onUpdate?: string | undefined;
386
+ onDelete?: string | undefined;
387
+ name: string;
388
+ tableFrom: string;
389
+ columnsFrom: string[];
390
+ tableTo: string;
391
+ columnsTo: string[];
392
+ }>;
393
+ compositePrimaryKeys: Record<string, {
394
+ name: string;
395
+ columns: string[];
396
+ }>;
397
+ }>;
398
+ declare const dialect: import("zod").ZodLiteral<"mysql">;
399
+ export declare const schemaInternalV3: import("zod").ZodObject<{
400
+ version: import("zod").ZodLiteral<"3">;
401
+ dialect: import("zod").ZodLiteral<"mysql">;
402
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
403
+ name: import("zod").ZodString;
404
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
405
+ name: import("zod").ZodString;
406
+ type: import("zod").ZodString;
407
+ primaryKey: import("zod").ZodBoolean;
408
+ notNull: import("zod").ZodBoolean;
409
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
410
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
411
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
412
+ }, "strict", import("zod").ZodTypeAny, {
413
+ default?: any;
414
+ onUpdate?: any;
415
+ autoincrement?: boolean | undefined;
416
+ name: string;
417
+ type: string;
418
+ primaryKey: boolean;
419
+ notNull: boolean;
420
+ }, {
421
+ default?: any;
422
+ onUpdate?: any;
423
+ autoincrement?: boolean | undefined;
424
+ name: string;
425
+ type: string;
426
+ primaryKey: boolean;
427
+ notNull: boolean;
428
+ }>>;
429
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
430
+ name: import("zod").ZodString;
431
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
432
+ isUnique: import("zod").ZodBoolean;
433
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
434
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
435
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
436
+ }, "strict", import("zod").ZodTypeAny, {
437
+ using?: "btree" | "hash" | undefined;
438
+ algorithm?: "default" | "inplace" | "copy" | undefined;
439
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
440
+ name: string;
441
+ columns: string[];
442
+ isUnique: boolean;
443
+ }, {
444
+ using?: "btree" | "hash" | undefined;
445
+ algorithm?: "default" | "inplace" | "copy" | undefined;
446
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
447
+ name: string;
448
+ columns: string[];
449
+ isUnique: boolean;
450
+ }>>;
451
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
452
+ name: import("zod").ZodString;
453
+ tableFrom: import("zod").ZodString;
454
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
455
+ tableTo: import("zod").ZodString;
456
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
457
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
458
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
459
+ }, "strict", import("zod").ZodTypeAny, {
460
+ onUpdate?: string | undefined;
461
+ onDelete?: string | undefined;
462
+ name: string;
463
+ tableFrom: string;
464
+ columnsFrom: string[];
465
+ tableTo: string;
466
+ columnsTo: string[];
467
+ }, {
468
+ onUpdate?: string | undefined;
469
+ onDelete?: string | undefined;
470
+ name: string;
471
+ tableFrom: string;
472
+ columnsFrom: string[];
473
+ tableTo: string;
474
+ columnsTo: string[];
475
+ }>>;
476
+ }, "strict", import("zod").ZodTypeAny, {
477
+ name: string;
478
+ columns: Record<string, {
479
+ default?: any;
480
+ onUpdate?: any;
481
+ autoincrement?: boolean | undefined;
482
+ name: string;
483
+ type: string;
484
+ primaryKey: boolean;
485
+ notNull: boolean;
486
+ }>;
487
+ indexes: Record<string, {
488
+ using?: "btree" | "hash" | undefined;
489
+ algorithm?: "default" | "inplace" | "copy" | undefined;
490
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
491
+ name: string;
492
+ columns: string[];
493
+ isUnique: boolean;
494
+ }>;
495
+ foreignKeys: Record<string, {
496
+ onUpdate?: string | undefined;
497
+ onDelete?: string | undefined;
498
+ name: string;
499
+ tableFrom: string;
500
+ columnsFrom: string[];
501
+ tableTo: string;
502
+ columnsTo: string[];
503
+ }>;
504
+ }, {
505
+ name: string;
506
+ columns: Record<string, {
507
+ default?: any;
508
+ onUpdate?: any;
509
+ autoincrement?: boolean | undefined;
510
+ name: string;
511
+ type: string;
512
+ primaryKey: boolean;
513
+ notNull: boolean;
514
+ }>;
515
+ indexes: Record<string, {
516
+ using?: "btree" | "hash" | undefined;
517
+ algorithm?: "default" | "inplace" | "copy" | undefined;
518
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
519
+ name: string;
520
+ columns: string[];
521
+ isUnique: boolean;
522
+ }>;
523
+ foreignKeys: Record<string, {
524
+ onUpdate?: string | undefined;
525
+ onDelete?: string | undefined;
526
+ name: string;
527
+ tableFrom: string;
528
+ columnsFrom: string[];
529
+ tableTo: string;
530
+ columnsTo: string[];
531
+ }>;
532
+ }>>;
533
+ }, "strict", import("zod").ZodTypeAny, {
534
+ version: "3";
535
+ dialect: "mysql";
536
+ tables: Record<string, {
537
+ name: string;
538
+ columns: Record<string, {
539
+ default?: any;
540
+ onUpdate?: any;
541
+ autoincrement?: boolean | undefined;
542
+ name: string;
543
+ type: string;
544
+ primaryKey: boolean;
545
+ notNull: boolean;
546
+ }>;
547
+ indexes: Record<string, {
548
+ using?: "btree" | "hash" | undefined;
549
+ algorithm?: "default" | "inplace" | "copy" | undefined;
550
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
551
+ name: string;
552
+ columns: string[];
553
+ isUnique: boolean;
554
+ }>;
555
+ foreignKeys: Record<string, {
556
+ onUpdate?: string | undefined;
557
+ onDelete?: string | undefined;
558
+ name: string;
559
+ tableFrom: string;
560
+ columnsFrom: string[];
561
+ tableTo: string;
562
+ columnsTo: string[];
563
+ }>;
564
+ }>;
565
+ }, {
566
+ version: "3";
567
+ dialect: "mysql";
568
+ tables: Record<string, {
569
+ name: string;
570
+ columns: Record<string, {
571
+ default?: any;
572
+ onUpdate?: any;
573
+ autoincrement?: boolean | undefined;
574
+ name: string;
575
+ type: string;
576
+ primaryKey: boolean;
577
+ notNull: boolean;
578
+ }>;
579
+ indexes: Record<string, {
580
+ using?: "btree" | "hash" | undefined;
581
+ algorithm?: "default" | "inplace" | "copy" | undefined;
582
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
583
+ name: string;
584
+ columns: string[];
585
+ isUnique: boolean;
586
+ }>;
587
+ foreignKeys: Record<string, {
588
+ onUpdate?: string | undefined;
589
+ onDelete?: string | undefined;
590
+ name: string;
591
+ tableFrom: string;
592
+ columnsFrom: string[];
593
+ tableTo: string;
594
+ columnsTo: string[];
595
+ }>;
596
+ }>;
597
+ }>;
598
+ export declare const schemaInternalV4: import("zod").ZodObject<{
599
+ version: import("zod").ZodLiteral<"4">;
600
+ dialect: import("zod").ZodLiteral<"mysql">;
601
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
602
+ name: import("zod").ZodString;
603
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
604
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
605
+ name: import("zod").ZodString;
606
+ type: import("zod").ZodString;
607
+ primaryKey: import("zod").ZodBoolean;
608
+ notNull: import("zod").ZodBoolean;
609
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
610
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
611
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
612
+ }, "strict", import("zod").ZodTypeAny, {
613
+ default?: any;
614
+ onUpdate?: any;
615
+ autoincrement?: boolean | undefined;
616
+ name: string;
617
+ type: string;
618
+ primaryKey: boolean;
619
+ notNull: boolean;
620
+ }, {
621
+ default?: any;
622
+ onUpdate?: any;
623
+ autoincrement?: boolean | undefined;
624
+ name: string;
625
+ type: string;
626
+ primaryKey: boolean;
627
+ notNull: boolean;
628
+ }>>;
629
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
630
+ name: import("zod").ZodString;
631
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
632
+ isUnique: import("zod").ZodBoolean;
633
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
634
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
635
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
636
+ }, "strict", import("zod").ZodTypeAny, {
637
+ using?: "btree" | "hash" | undefined;
638
+ algorithm?: "default" | "inplace" | "copy" | undefined;
639
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
640
+ name: string;
641
+ columns: string[];
642
+ isUnique: boolean;
643
+ }, {
644
+ using?: "btree" | "hash" | undefined;
645
+ algorithm?: "default" | "inplace" | "copy" | undefined;
646
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
647
+ name: string;
648
+ columns: string[];
649
+ isUnique: boolean;
650
+ }>>;
651
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
652
+ name: import("zod").ZodString;
653
+ tableFrom: import("zod").ZodString;
654
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
655
+ tableTo: import("zod").ZodString;
656
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
657
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
658
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
659
+ }, "strict", import("zod").ZodTypeAny, {
660
+ onUpdate?: string | undefined;
661
+ onDelete?: string | undefined;
662
+ name: string;
663
+ tableFrom: string;
664
+ columnsFrom: string[];
665
+ tableTo: string;
666
+ columnsTo: string[];
667
+ }, {
668
+ onUpdate?: string | undefined;
669
+ onDelete?: string | undefined;
670
+ name: string;
671
+ tableFrom: string;
672
+ columnsFrom: string[];
673
+ tableTo: string;
674
+ columnsTo: string[];
675
+ }>>;
676
+ }, "strict", import("zod").ZodTypeAny, {
677
+ schema?: string | undefined;
678
+ name: string;
679
+ columns: Record<string, {
680
+ default?: any;
681
+ onUpdate?: any;
682
+ autoincrement?: boolean | undefined;
683
+ name: string;
684
+ type: string;
685
+ primaryKey: boolean;
686
+ notNull: boolean;
687
+ }>;
688
+ indexes: Record<string, {
689
+ using?: "btree" | "hash" | undefined;
690
+ algorithm?: "default" | "inplace" | "copy" | undefined;
691
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
692
+ name: string;
693
+ columns: string[];
694
+ isUnique: boolean;
695
+ }>;
696
+ foreignKeys: Record<string, {
697
+ onUpdate?: string | undefined;
698
+ onDelete?: string | undefined;
699
+ name: string;
700
+ tableFrom: string;
701
+ columnsFrom: string[];
702
+ tableTo: string;
703
+ columnsTo: string[];
704
+ }>;
705
+ }, {
706
+ schema?: string | undefined;
707
+ name: string;
708
+ columns: Record<string, {
709
+ default?: any;
710
+ onUpdate?: any;
711
+ autoincrement?: boolean | undefined;
712
+ name: string;
713
+ type: string;
714
+ primaryKey: boolean;
715
+ notNull: boolean;
716
+ }>;
717
+ indexes: Record<string, {
718
+ using?: "btree" | "hash" | undefined;
719
+ algorithm?: "default" | "inplace" | "copy" | undefined;
720
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
721
+ name: string;
722
+ columns: string[];
723
+ isUnique: boolean;
724
+ }>;
725
+ foreignKeys: Record<string, {
726
+ onUpdate?: string | undefined;
727
+ onDelete?: string | undefined;
728
+ name: string;
729
+ tableFrom: string;
730
+ columnsFrom: string[];
731
+ tableTo: string;
732
+ columnsTo: string[];
733
+ }>;
734
+ }>>;
735
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
736
+ }, "strict", import("zod").ZodTypeAny, {
737
+ version: "4";
738
+ dialect: "mysql";
739
+ tables: Record<string, {
740
+ schema?: string | undefined;
741
+ name: string;
742
+ columns: Record<string, {
743
+ default?: any;
744
+ onUpdate?: any;
745
+ autoincrement?: boolean | undefined;
746
+ name: string;
747
+ type: string;
748
+ primaryKey: boolean;
749
+ notNull: boolean;
750
+ }>;
751
+ indexes: Record<string, {
752
+ using?: "btree" | "hash" | undefined;
753
+ algorithm?: "default" | "inplace" | "copy" | undefined;
754
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
755
+ name: string;
756
+ columns: string[];
757
+ isUnique: boolean;
758
+ }>;
759
+ foreignKeys: Record<string, {
760
+ onUpdate?: string | undefined;
761
+ onDelete?: string | undefined;
762
+ name: string;
763
+ tableFrom: string;
764
+ columnsFrom: string[];
765
+ tableTo: string;
766
+ columnsTo: string[];
767
+ }>;
768
+ }>;
769
+ schemas: Record<string, string>;
770
+ }, {
771
+ version: "4";
772
+ dialect: "mysql";
773
+ tables: Record<string, {
774
+ schema?: string | undefined;
775
+ name: string;
776
+ columns: Record<string, {
777
+ default?: any;
778
+ onUpdate?: any;
779
+ autoincrement?: boolean | undefined;
780
+ name: string;
781
+ type: string;
782
+ primaryKey: boolean;
783
+ notNull: boolean;
784
+ }>;
785
+ indexes: Record<string, {
786
+ using?: "btree" | "hash" | undefined;
787
+ algorithm?: "default" | "inplace" | "copy" | undefined;
788
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
789
+ name: string;
790
+ columns: string[];
791
+ isUnique: boolean;
792
+ }>;
793
+ foreignKeys: Record<string, {
794
+ onUpdate?: string | undefined;
795
+ onDelete?: string | undefined;
796
+ name: string;
797
+ tableFrom: string;
798
+ columnsFrom: string[];
799
+ tableTo: string;
800
+ columnsTo: string[];
801
+ }>;
802
+ }>;
803
+ schemas: Record<string, string>;
804
+ }>;
805
+ export declare const kitInternals: import("zod").ZodOptional<import("zod").ZodObject<{
806
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
807
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
808
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
809
+ }, "strip", import("zod").ZodTypeAny, {
810
+ isDefaultAnExpression?: boolean | undefined;
811
+ }, {
812
+ isDefaultAnExpression?: boolean | undefined;
813
+ }>>>;
814
+ }, "strip", import("zod").ZodTypeAny, {
815
+ columns: Record<string, {
816
+ isDefaultAnExpression?: boolean | undefined;
817
+ } | undefined>;
818
+ }, {
819
+ columns: Record<string, {
820
+ isDefaultAnExpression?: boolean | undefined;
821
+ } | undefined>;
822
+ }>>>;
823
+ }, "strip", import("zod").ZodTypeAny, {
824
+ tables: Record<string, {
825
+ columns: Record<string, {
826
+ isDefaultAnExpression?: boolean | undefined;
827
+ } | undefined>;
828
+ } | undefined>;
829
+ }, {
830
+ tables: Record<string, {
831
+ columns: Record<string, {
832
+ isDefaultAnExpression?: boolean | undefined;
833
+ } | undefined>;
834
+ } | undefined>;
835
+ }>>;
836
+ export declare const schemaInternal: import("zod").ZodObject<{
837
+ version: import("zod").ZodLiteral<"5">;
838
+ dialect: import("zod").ZodLiteral<"mysql">;
839
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
840
+ name: import("zod").ZodString;
841
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
842
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
843
+ name: import("zod").ZodString;
844
+ type: import("zod").ZodString;
845
+ primaryKey: import("zod").ZodBoolean;
846
+ notNull: import("zod").ZodBoolean;
847
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
848
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
849
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
850
+ }, "strict", import("zod").ZodTypeAny, {
851
+ default?: any;
852
+ onUpdate?: any;
853
+ autoincrement?: boolean | undefined;
854
+ name: string;
855
+ type: string;
856
+ primaryKey: boolean;
857
+ notNull: boolean;
858
+ }, {
859
+ default?: any;
860
+ onUpdate?: any;
861
+ autoincrement?: boolean | undefined;
862
+ name: string;
863
+ type: string;
864
+ primaryKey: boolean;
865
+ notNull: boolean;
866
+ }>>;
867
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
868
+ name: import("zod").ZodString;
869
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
870
+ isUnique: import("zod").ZodBoolean;
871
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
872
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
873
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
874
+ }, "strict", import("zod").ZodTypeAny, {
875
+ using?: "btree" | "hash" | undefined;
876
+ algorithm?: "default" | "inplace" | "copy" | undefined;
877
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
878
+ name: string;
879
+ columns: string[];
880
+ isUnique: boolean;
881
+ }, {
882
+ using?: "btree" | "hash" | undefined;
883
+ algorithm?: "default" | "inplace" | "copy" | undefined;
884
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
885
+ name: string;
886
+ columns: string[];
887
+ isUnique: boolean;
888
+ }>>;
889
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
890
+ name: import("zod").ZodString;
891
+ tableFrom: import("zod").ZodString;
892
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
893
+ tableTo: import("zod").ZodString;
894
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
895
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
896
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
897
+ }, "strict", import("zod").ZodTypeAny, {
898
+ onUpdate?: string | undefined;
899
+ onDelete?: string | undefined;
900
+ name: string;
901
+ tableFrom: string;
902
+ columnsFrom: string[];
903
+ tableTo: string;
904
+ columnsTo: string[];
905
+ }, {
906
+ onUpdate?: string | undefined;
907
+ onDelete?: string | undefined;
908
+ name: string;
909
+ tableFrom: string;
910
+ columnsFrom: string[];
911
+ tableTo: string;
912
+ columnsTo: string[];
913
+ }>>;
914
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
915
+ name: import("zod").ZodString;
916
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
917
+ }, "strict", import("zod").ZodTypeAny, {
918
+ name: string;
919
+ columns: string[];
920
+ }, {
921
+ name: string;
922
+ columns: string[];
923
+ }>>;
924
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
925
+ name: import("zod").ZodString;
926
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
927
+ }, "strict", import("zod").ZodTypeAny, {
928
+ name: string;
929
+ columns: string[];
930
+ }, {
931
+ name: string;
932
+ columns: string[];
933
+ }>>>;
934
+ }, "strict", import("zod").ZodTypeAny, {
935
+ schema?: string | undefined;
936
+ name: string;
937
+ columns: Record<string, {
938
+ default?: any;
939
+ onUpdate?: any;
940
+ autoincrement?: boolean | undefined;
941
+ name: string;
942
+ type: string;
943
+ primaryKey: boolean;
944
+ notNull: boolean;
945
+ }>;
946
+ indexes: Record<string, {
947
+ using?: "btree" | "hash" | undefined;
948
+ algorithm?: "default" | "inplace" | "copy" | undefined;
949
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
950
+ name: string;
951
+ columns: string[];
952
+ isUnique: boolean;
953
+ }>;
954
+ foreignKeys: Record<string, {
955
+ onUpdate?: string | undefined;
956
+ onDelete?: string | undefined;
957
+ name: string;
958
+ tableFrom: string;
959
+ columnsFrom: string[];
960
+ tableTo: string;
961
+ columnsTo: string[];
962
+ }>;
963
+ compositePrimaryKeys: Record<string, {
964
+ name: string;
965
+ columns: string[];
966
+ }>;
967
+ uniqueConstraints: Record<string, {
968
+ name: string;
969
+ columns: string[];
970
+ }>;
971
+ }, {
972
+ schema?: string | undefined;
973
+ uniqueConstraints?: Record<string, {
974
+ name: string;
975
+ columns: string[];
976
+ }> | undefined;
977
+ name: string;
978
+ columns: Record<string, {
979
+ default?: any;
980
+ onUpdate?: any;
981
+ autoincrement?: boolean | undefined;
982
+ name: string;
983
+ type: string;
984
+ primaryKey: boolean;
985
+ notNull: boolean;
986
+ }>;
987
+ indexes: Record<string, {
988
+ using?: "btree" | "hash" | undefined;
989
+ algorithm?: "default" | "inplace" | "copy" | undefined;
990
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
991
+ name: string;
992
+ columns: string[];
993
+ isUnique: boolean;
994
+ }>;
995
+ foreignKeys: Record<string, {
996
+ onUpdate?: string | undefined;
997
+ onDelete?: string | undefined;
998
+ name: string;
999
+ tableFrom: string;
1000
+ columnsFrom: string[];
1001
+ tableTo: string;
1002
+ columnsTo: string[];
1003
+ }>;
1004
+ compositePrimaryKeys: Record<string, {
1005
+ name: string;
1006
+ columns: string[];
1007
+ }>;
1008
+ }>>;
1009
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1010
+ _meta: import("zod").ZodObject<{
1011
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1012
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1013
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1014
+ }, "strip", import("zod").ZodTypeAny, {
1015
+ columns: Record<string, string>;
1016
+ tables: Record<string, string>;
1017
+ schemas: Record<string, string>;
1018
+ }, {
1019
+ columns: Record<string, string>;
1020
+ tables: Record<string, string>;
1021
+ schemas: Record<string, string>;
1022
+ }>;
1023
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
1024
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1025
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1026
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
1027
+ }, "strip", import("zod").ZodTypeAny, {
1028
+ isDefaultAnExpression?: boolean | undefined;
1029
+ }, {
1030
+ isDefaultAnExpression?: boolean | undefined;
1031
+ }>>>;
1032
+ }, "strip", import("zod").ZodTypeAny, {
1033
+ columns: Record<string, {
1034
+ isDefaultAnExpression?: boolean | undefined;
1035
+ } | undefined>;
1036
+ }, {
1037
+ columns: Record<string, {
1038
+ isDefaultAnExpression?: boolean | undefined;
1039
+ } | undefined>;
1040
+ }>>>;
1041
+ }, "strip", import("zod").ZodTypeAny, {
1042
+ tables: Record<string, {
1043
+ columns: Record<string, {
1044
+ isDefaultAnExpression?: boolean | undefined;
1045
+ } | undefined>;
1046
+ } | undefined>;
1047
+ }, {
1048
+ tables: Record<string, {
1049
+ columns: Record<string, {
1050
+ isDefaultAnExpression?: boolean | undefined;
1051
+ } | undefined>;
1052
+ } | undefined>;
1053
+ }>>;
1054
+ }, "strict", import("zod").ZodTypeAny, {
1055
+ internal?: {
1056
+ tables: Record<string, {
1057
+ columns: Record<string, {
1058
+ isDefaultAnExpression?: boolean | undefined;
1059
+ } | undefined>;
1060
+ } | undefined>;
1061
+ } | undefined;
1062
+ version: "5";
1063
+ dialect: "mysql";
1064
+ tables: Record<string, {
1065
+ schema?: string | undefined;
1066
+ name: string;
1067
+ columns: Record<string, {
1068
+ default?: any;
1069
+ onUpdate?: any;
1070
+ autoincrement?: boolean | undefined;
1071
+ name: string;
1072
+ type: string;
1073
+ primaryKey: boolean;
1074
+ notNull: boolean;
1075
+ }>;
1076
+ indexes: Record<string, {
1077
+ using?: "btree" | "hash" | undefined;
1078
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1079
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1080
+ name: string;
1081
+ columns: string[];
1082
+ isUnique: boolean;
1083
+ }>;
1084
+ foreignKeys: Record<string, {
1085
+ onUpdate?: string | undefined;
1086
+ onDelete?: string | undefined;
1087
+ name: string;
1088
+ tableFrom: string;
1089
+ columnsFrom: string[];
1090
+ tableTo: string;
1091
+ columnsTo: string[];
1092
+ }>;
1093
+ compositePrimaryKeys: Record<string, {
1094
+ name: string;
1095
+ columns: string[];
1096
+ }>;
1097
+ uniqueConstraints: Record<string, {
1098
+ name: string;
1099
+ columns: string[];
1100
+ }>;
1101
+ }>;
1102
+ schemas: Record<string, string>;
1103
+ _meta: {
1104
+ columns: Record<string, string>;
1105
+ tables: Record<string, string>;
1106
+ schemas: Record<string, string>;
1107
+ };
1108
+ }, {
1109
+ internal?: {
1110
+ tables: Record<string, {
1111
+ columns: Record<string, {
1112
+ isDefaultAnExpression?: boolean | undefined;
1113
+ } | undefined>;
1114
+ } | undefined>;
1115
+ } | undefined;
1116
+ version: "5";
1117
+ dialect: "mysql";
1118
+ tables: Record<string, {
1119
+ schema?: string | undefined;
1120
+ uniqueConstraints?: Record<string, {
1121
+ name: string;
1122
+ columns: string[];
1123
+ }> | undefined;
1124
+ name: string;
1125
+ columns: Record<string, {
1126
+ default?: any;
1127
+ onUpdate?: any;
1128
+ autoincrement?: boolean | undefined;
1129
+ name: string;
1130
+ type: string;
1131
+ primaryKey: boolean;
1132
+ notNull: boolean;
1133
+ }>;
1134
+ indexes: Record<string, {
1135
+ using?: "btree" | "hash" | undefined;
1136
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1137
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1138
+ name: string;
1139
+ columns: string[];
1140
+ isUnique: boolean;
1141
+ }>;
1142
+ foreignKeys: Record<string, {
1143
+ onUpdate?: string | undefined;
1144
+ onDelete?: string | undefined;
1145
+ name: string;
1146
+ tableFrom: string;
1147
+ columnsFrom: string[];
1148
+ tableTo: string;
1149
+ columnsTo: string[];
1150
+ }>;
1151
+ compositePrimaryKeys: Record<string, {
1152
+ name: string;
1153
+ columns: string[];
1154
+ }>;
1155
+ }>;
1156
+ schemas: Record<string, string>;
1157
+ _meta: {
1158
+ columns: Record<string, string>;
1159
+ tables: Record<string, string>;
1160
+ schemas: Record<string, string>;
1161
+ };
1162
+ }>;
1163
+ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
1164
+ version: import("zod").ZodLiteral<"3">;
1165
+ dialect: import("zod").ZodLiteral<"mysql">;
1166
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1167
+ name: import("zod").ZodString;
1168
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1169
+ name: import("zod").ZodString;
1170
+ type: import("zod").ZodString;
1171
+ primaryKey: import("zod").ZodBoolean;
1172
+ notNull: import("zod").ZodBoolean;
1173
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1174
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
1175
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
1176
+ }, "strict", import("zod").ZodTypeAny, {
1177
+ default?: any;
1178
+ onUpdate?: any;
1179
+ autoincrement?: boolean | undefined;
1180
+ name: string;
1181
+ type: string;
1182
+ primaryKey: boolean;
1183
+ notNull: boolean;
1184
+ }, {
1185
+ default?: any;
1186
+ onUpdate?: any;
1187
+ autoincrement?: boolean | undefined;
1188
+ name: string;
1189
+ type: string;
1190
+ primaryKey: boolean;
1191
+ notNull: boolean;
1192
+ }>>;
1193
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1194
+ name: import("zod").ZodString;
1195
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1196
+ isUnique: import("zod").ZodBoolean;
1197
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
1198
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
1199
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
1200
+ }, "strict", import("zod").ZodTypeAny, {
1201
+ using?: "btree" | "hash" | undefined;
1202
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1203
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1204
+ name: string;
1205
+ columns: string[];
1206
+ isUnique: boolean;
1207
+ }, {
1208
+ using?: "btree" | "hash" | undefined;
1209
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1210
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1211
+ name: string;
1212
+ columns: string[];
1213
+ isUnique: boolean;
1214
+ }>>;
1215
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1216
+ name: import("zod").ZodString;
1217
+ tableFrom: import("zod").ZodString;
1218
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1219
+ tableTo: import("zod").ZodString;
1220
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1221
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1222
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1223
+ }, "strict", import("zod").ZodTypeAny, {
1224
+ onUpdate?: string | undefined;
1225
+ onDelete?: string | undefined;
1226
+ name: string;
1227
+ tableFrom: string;
1228
+ columnsFrom: string[];
1229
+ tableTo: string;
1230
+ columnsTo: string[];
1231
+ }, {
1232
+ onUpdate?: string | undefined;
1233
+ onDelete?: string | undefined;
1234
+ name: string;
1235
+ tableFrom: string;
1236
+ columnsFrom: string[];
1237
+ tableTo: string;
1238
+ columnsTo: string[];
1239
+ }>>;
1240
+ }, "strict", import("zod").ZodTypeAny, {
1241
+ name: string;
1242
+ columns: Record<string, {
1243
+ default?: any;
1244
+ onUpdate?: any;
1245
+ autoincrement?: boolean | undefined;
1246
+ name: string;
1247
+ type: string;
1248
+ primaryKey: boolean;
1249
+ notNull: boolean;
1250
+ }>;
1251
+ indexes: Record<string, {
1252
+ using?: "btree" | "hash" | undefined;
1253
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1254
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1255
+ name: string;
1256
+ columns: string[];
1257
+ isUnique: boolean;
1258
+ }>;
1259
+ foreignKeys: Record<string, {
1260
+ onUpdate?: string | undefined;
1261
+ onDelete?: string | undefined;
1262
+ name: string;
1263
+ tableFrom: string;
1264
+ columnsFrom: string[];
1265
+ tableTo: string;
1266
+ columnsTo: string[];
1267
+ }>;
1268
+ }, {
1269
+ name: string;
1270
+ columns: Record<string, {
1271
+ default?: any;
1272
+ onUpdate?: any;
1273
+ autoincrement?: boolean | undefined;
1274
+ name: string;
1275
+ type: string;
1276
+ primaryKey: boolean;
1277
+ notNull: boolean;
1278
+ }>;
1279
+ indexes: Record<string, {
1280
+ using?: "btree" | "hash" | undefined;
1281
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1282
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1283
+ name: string;
1284
+ columns: string[];
1285
+ isUnique: boolean;
1286
+ }>;
1287
+ foreignKeys: Record<string, {
1288
+ onUpdate?: string | undefined;
1289
+ onDelete?: string | undefined;
1290
+ name: string;
1291
+ tableFrom: string;
1292
+ columnsFrom: string[];
1293
+ tableTo: string;
1294
+ columnsTo: string[];
1295
+ }>;
1296
+ }>>;
1297
+ }, {
1298
+ id: import("zod").ZodString;
1299
+ prevId: import("zod").ZodString;
1300
+ }>, "strip", import("zod").ZodTypeAny, {
1301
+ id: string;
1302
+ prevId: string;
1303
+ version: "3";
1304
+ dialect: "mysql";
1305
+ tables: Record<string, {
1306
+ name: string;
1307
+ columns: Record<string, {
1308
+ default?: any;
1309
+ onUpdate?: any;
1310
+ autoincrement?: boolean | undefined;
1311
+ name: string;
1312
+ type: string;
1313
+ primaryKey: boolean;
1314
+ notNull: boolean;
1315
+ }>;
1316
+ indexes: Record<string, {
1317
+ using?: "btree" | "hash" | undefined;
1318
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1319
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1320
+ name: string;
1321
+ columns: string[];
1322
+ isUnique: boolean;
1323
+ }>;
1324
+ foreignKeys: Record<string, {
1325
+ onUpdate?: string | undefined;
1326
+ onDelete?: string | undefined;
1327
+ name: string;
1328
+ tableFrom: string;
1329
+ columnsFrom: string[];
1330
+ tableTo: string;
1331
+ columnsTo: string[];
1332
+ }>;
1333
+ }>;
1334
+ }, {
1335
+ id: string;
1336
+ prevId: string;
1337
+ version: "3";
1338
+ dialect: "mysql";
1339
+ tables: Record<string, {
1340
+ name: string;
1341
+ columns: Record<string, {
1342
+ default?: any;
1343
+ onUpdate?: any;
1344
+ autoincrement?: boolean | undefined;
1345
+ name: string;
1346
+ type: string;
1347
+ primaryKey: boolean;
1348
+ notNull: boolean;
1349
+ }>;
1350
+ indexes: Record<string, {
1351
+ using?: "btree" | "hash" | undefined;
1352
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1353
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1354
+ name: string;
1355
+ columns: string[];
1356
+ isUnique: boolean;
1357
+ }>;
1358
+ foreignKeys: Record<string, {
1359
+ onUpdate?: string | undefined;
1360
+ onDelete?: string | undefined;
1361
+ name: string;
1362
+ tableFrom: string;
1363
+ columnsFrom: string[];
1364
+ tableTo: string;
1365
+ columnsTo: string[];
1366
+ }>;
1367
+ }>;
1368
+ }>;
1369
+ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
1370
+ version: import("zod").ZodLiteral<"4">;
1371
+ dialect: import("zod").ZodLiteral<"mysql">;
1372
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1373
+ name: import("zod").ZodString;
1374
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
1375
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1376
+ name: import("zod").ZodString;
1377
+ type: import("zod").ZodString;
1378
+ primaryKey: import("zod").ZodBoolean;
1379
+ notNull: import("zod").ZodBoolean;
1380
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1381
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
1382
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
1383
+ }, "strict", import("zod").ZodTypeAny, {
1384
+ default?: any;
1385
+ onUpdate?: any;
1386
+ autoincrement?: boolean | undefined;
1387
+ name: string;
1388
+ type: string;
1389
+ primaryKey: boolean;
1390
+ notNull: boolean;
1391
+ }, {
1392
+ default?: any;
1393
+ onUpdate?: any;
1394
+ autoincrement?: boolean | undefined;
1395
+ name: string;
1396
+ type: string;
1397
+ primaryKey: boolean;
1398
+ notNull: boolean;
1399
+ }>>;
1400
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1401
+ name: import("zod").ZodString;
1402
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1403
+ isUnique: import("zod").ZodBoolean;
1404
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
1405
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
1406
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
1407
+ }, "strict", import("zod").ZodTypeAny, {
1408
+ using?: "btree" | "hash" | undefined;
1409
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1410
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1411
+ name: string;
1412
+ columns: string[];
1413
+ isUnique: boolean;
1414
+ }, {
1415
+ using?: "btree" | "hash" | undefined;
1416
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1417
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1418
+ name: string;
1419
+ columns: string[];
1420
+ isUnique: boolean;
1421
+ }>>;
1422
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1423
+ name: import("zod").ZodString;
1424
+ tableFrom: import("zod").ZodString;
1425
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1426
+ tableTo: import("zod").ZodString;
1427
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1428
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1429
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1430
+ }, "strict", import("zod").ZodTypeAny, {
1431
+ onUpdate?: string | undefined;
1432
+ onDelete?: string | undefined;
1433
+ name: string;
1434
+ tableFrom: string;
1435
+ columnsFrom: string[];
1436
+ tableTo: string;
1437
+ columnsTo: string[];
1438
+ }, {
1439
+ onUpdate?: string | undefined;
1440
+ onDelete?: string | undefined;
1441
+ name: string;
1442
+ tableFrom: string;
1443
+ columnsFrom: string[];
1444
+ tableTo: string;
1445
+ columnsTo: string[];
1446
+ }>>;
1447
+ }, "strict", import("zod").ZodTypeAny, {
1448
+ schema?: string | undefined;
1449
+ name: string;
1450
+ columns: Record<string, {
1451
+ default?: any;
1452
+ onUpdate?: any;
1453
+ autoincrement?: boolean | undefined;
1454
+ name: string;
1455
+ type: string;
1456
+ primaryKey: boolean;
1457
+ notNull: boolean;
1458
+ }>;
1459
+ indexes: Record<string, {
1460
+ using?: "btree" | "hash" | undefined;
1461
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1462
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1463
+ name: string;
1464
+ columns: string[];
1465
+ isUnique: boolean;
1466
+ }>;
1467
+ foreignKeys: Record<string, {
1468
+ onUpdate?: string | undefined;
1469
+ onDelete?: string | undefined;
1470
+ name: string;
1471
+ tableFrom: string;
1472
+ columnsFrom: string[];
1473
+ tableTo: string;
1474
+ columnsTo: string[];
1475
+ }>;
1476
+ }, {
1477
+ schema?: string | undefined;
1478
+ name: string;
1479
+ columns: Record<string, {
1480
+ default?: any;
1481
+ onUpdate?: any;
1482
+ autoincrement?: boolean | undefined;
1483
+ name: string;
1484
+ type: string;
1485
+ primaryKey: boolean;
1486
+ notNull: boolean;
1487
+ }>;
1488
+ indexes: Record<string, {
1489
+ using?: "btree" | "hash" | undefined;
1490
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1491
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1492
+ name: string;
1493
+ columns: string[];
1494
+ isUnique: boolean;
1495
+ }>;
1496
+ foreignKeys: Record<string, {
1497
+ onUpdate?: string | undefined;
1498
+ onDelete?: string | undefined;
1499
+ name: string;
1500
+ tableFrom: string;
1501
+ columnsFrom: string[];
1502
+ tableTo: string;
1503
+ columnsTo: string[];
1504
+ }>;
1505
+ }>>;
1506
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1507
+ }, {
1508
+ id: import("zod").ZodString;
1509
+ prevId: import("zod").ZodString;
1510
+ }>, "strip", import("zod").ZodTypeAny, {
1511
+ id: string;
1512
+ prevId: string;
1513
+ version: "4";
1514
+ dialect: "mysql";
1515
+ tables: Record<string, {
1516
+ schema?: string | undefined;
1517
+ name: string;
1518
+ columns: Record<string, {
1519
+ default?: any;
1520
+ onUpdate?: any;
1521
+ autoincrement?: boolean | undefined;
1522
+ name: string;
1523
+ type: string;
1524
+ primaryKey: boolean;
1525
+ notNull: boolean;
1526
+ }>;
1527
+ indexes: Record<string, {
1528
+ using?: "btree" | "hash" | undefined;
1529
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1530
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1531
+ name: string;
1532
+ columns: string[];
1533
+ isUnique: boolean;
1534
+ }>;
1535
+ foreignKeys: Record<string, {
1536
+ onUpdate?: string | undefined;
1537
+ onDelete?: string | undefined;
1538
+ name: string;
1539
+ tableFrom: string;
1540
+ columnsFrom: string[];
1541
+ tableTo: string;
1542
+ columnsTo: string[];
1543
+ }>;
1544
+ }>;
1545
+ schemas: Record<string, string>;
1546
+ }, {
1547
+ id: string;
1548
+ prevId: string;
1549
+ version: "4";
1550
+ dialect: "mysql";
1551
+ tables: Record<string, {
1552
+ schema?: string | undefined;
1553
+ name: string;
1554
+ columns: Record<string, {
1555
+ default?: any;
1556
+ onUpdate?: any;
1557
+ autoincrement?: boolean | undefined;
1558
+ name: string;
1559
+ type: string;
1560
+ primaryKey: boolean;
1561
+ notNull: boolean;
1562
+ }>;
1563
+ indexes: Record<string, {
1564
+ using?: "btree" | "hash" | undefined;
1565
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1566
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1567
+ name: string;
1568
+ columns: string[];
1569
+ isUnique: boolean;
1570
+ }>;
1571
+ foreignKeys: Record<string, {
1572
+ onUpdate?: string | undefined;
1573
+ onDelete?: string | undefined;
1574
+ name: string;
1575
+ tableFrom: string;
1576
+ columnsFrom: string[];
1577
+ tableTo: string;
1578
+ columnsTo: string[];
1579
+ }>;
1580
+ }>;
1581
+ schemas: Record<string, string>;
1582
+ }>;
1583
+ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1584
+ version: import("zod").ZodLiteral<"5">;
1585
+ dialect: import("zod").ZodLiteral<"mysql">;
1586
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1587
+ name: import("zod").ZodString;
1588
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
1589
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1590
+ name: import("zod").ZodString;
1591
+ type: import("zod").ZodString;
1592
+ primaryKey: import("zod").ZodBoolean;
1593
+ notNull: import("zod").ZodBoolean;
1594
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1595
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
1596
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
1597
+ }, "strict", import("zod").ZodTypeAny, {
1598
+ default?: any;
1599
+ onUpdate?: any;
1600
+ autoincrement?: boolean | undefined;
1601
+ name: string;
1602
+ type: string;
1603
+ primaryKey: boolean;
1604
+ notNull: boolean;
1605
+ }, {
1606
+ default?: any;
1607
+ onUpdate?: any;
1608
+ autoincrement?: boolean | undefined;
1609
+ name: string;
1610
+ type: string;
1611
+ primaryKey: boolean;
1612
+ notNull: boolean;
1613
+ }>>;
1614
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1615
+ name: import("zod").ZodString;
1616
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1617
+ isUnique: import("zod").ZodBoolean;
1618
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
1619
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
1620
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
1621
+ }, "strict", import("zod").ZodTypeAny, {
1622
+ using?: "btree" | "hash" | undefined;
1623
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1624
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1625
+ name: string;
1626
+ columns: string[];
1627
+ isUnique: boolean;
1628
+ }, {
1629
+ using?: "btree" | "hash" | undefined;
1630
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1631
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1632
+ name: string;
1633
+ columns: string[];
1634
+ isUnique: boolean;
1635
+ }>>;
1636
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1637
+ name: import("zod").ZodString;
1638
+ tableFrom: import("zod").ZodString;
1639
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1640
+ tableTo: import("zod").ZodString;
1641
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1642
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1643
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1644
+ }, "strict", import("zod").ZodTypeAny, {
1645
+ onUpdate?: string | undefined;
1646
+ onDelete?: string | undefined;
1647
+ name: string;
1648
+ tableFrom: string;
1649
+ columnsFrom: string[];
1650
+ tableTo: string;
1651
+ columnsTo: string[];
1652
+ }, {
1653
+ onUpdate?: string | undefined;
1654
+ onDelete?: string | undefined;
1655
+ name: string;
1656
+ tableFrom: string;
1657
+ columnsFrom: string[];
1658
+ tableTo: string;
1659
+ columnsTo: string[];
1660
+ }>>;
1661
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1662
+ name: import("zod").ZodString;
1663
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1664
+ }, "strict", import("zod").ZodTypeAny, {
1665
+ name: string;
1666
+ columns: string[];
1667
+ }, {
1668
+ name: string;
1669
+ columns: string[];
1670
+ }>>;
1671
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1672
+ name: import("zod").ZodString;
1673
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1674
+ }, "strict", import("zod").ZodTypeAny, {
1675
+ name: string;
1676
+ columns: string[];
1677
+ }, {
1678
+ name: string;
1679
+ columns: string[];
1680
+ }>>>;
1681
+ }, "strict", import("zod").ZodTypeAny, {
1682
+ schema?: string | undefined;
1683
+ name: string;
1684
+ columns: Record<string, {
1685
+ default?: any;
1686
+ onUpdate?: any;
1687
+ autoincrement?: boolean | undefined;
1688
+ name: string;
1689
+ type: string;
1690
+ primaryKey: boolean;
1691
+ notNull: boolean;
1692
+ }>;
1693
+ indexes: Record<string, {
1694
+ using?: "btree" | "hash" | undefined;
1695
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1696
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1697
+ name: string;
1698
+ columns: string[];
1699
+ isUnique: boolean;
1700
+ }>;
1701
+ foreignKeys: Record<string, {
1702
+ onUpdate?: string | undefined;
1703
+ onDelete?: string | undefined;
1704
+ name: string;
1705
+ tableFrom: string;
1706
+ columnsFrom: string[];
1707
+ tableTo: string;
1708
+ columnsTo: string[];
1709
+ }>;
1710
+ compositePrimaryKeys: Record<string, {
1711
+ name: string;
1712
+ columns: string[];
1713
+ }>;
1714
+ uniqueConstraints: Record<string, {
1715
+ name: string;
1716
+ columns: string[];
1717
+ }>;
1718
+ }, {
1719
+ schema?: string | undefined;
1720
+ uniqueConstraints?: Record<string, {
1721
+ name: string;
1722
+ columns: string[];
1723
+ }> | undefined;
1724
+ name: string;
1725
+ columns: Record<string, {
1726
+ default?: any;
1727
+ onUpdate?: any;
1728
+ autoincrement?: boolean | undefined;
1729
+ name: string;
1730
+ type: string;
1731
+ primaryKey: boolean;
1732
+ notNull: boolean;
1733
+ }>;
1734
+ indexes: Record<string, {
1735
+ using?: "btree" | "hash" | undefined;
1736
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1737
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1738
+ name: string;
1739
+ columns: string[];
1740
+ isUnique: boolean;
1741
+ }>;
1742
+ foreignKeys: Record<string, {
1743
+ onUpdate?: string | undefined;
1744
+ onDelete?: string | undefined;
1745
+ name: string;
1746
+ tableFrom: string;
1747
+ columnsFrom: string[];
1748
+ tableTo: string;
1749
+ columnsTo: string[];
1750
+ }>;
1751
+ compositePrimaryKeys: Record<string, {
1752
+ name: string;
1753
+ columns: string[];
1754
+ }>;
1755
+ }>>;
1756
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1757
+ _meta: import("zod").ZodObject<{
1758
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1759
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1760
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1761
+ }, "strip", import("zod").ZodTypeAny, {
1762
+ columns: Record<string, string>;
1763
+ tables: Record<string, string>;
1764
+ schemas: Record<string, string>;
1765
+ }, {
1766
+ columns: Record<string, string>;
1767
+ tables: Record<string, string>;
1768
+ schemas: Record<string, string>;
1769
+ }>;
1770
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
1771
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1772
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
1773
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
1774
+ }, "strip", import("zod").ZodTypeAny, {
1775
+ isDefaultAnExpression?: boolean | undefined;
1776
+ }, {
1777
+ isDefaultAnExpression?: boolean | undefined;
1778
+ }>>>;
1779
+ }, "strip", import("zod").ZodTypeAny, {
1780
+ columns: Record<string, {
1781
+ isDefaultAnExpression?: boolean | undefined;
1782
+ } | undefined>;
1783
+ }, {
1784
+ columns: Record<string, {
1785
+ isDefaultAnExpression?: boolean | undefined;
1786
+ } | undefined>;
1787
+ }>>>;
1788
+ }, "strip", import("zod").ZodTypeAny, {
1789
+ tables: Record<string, {
1790
+ columns: Record<string, {
1791
+ isDefaultAnExpression?: boolean | undefined;
1792
+ } | undefined>;
1793
+ } | undefined>;
1794
+ }, {
1795
+ tables: Record<string, {
1796
+ columns: Record<string, {
1797
+ isDefaultAnExpression?: boolean | undefined;
1798
+ } | undefined>;
1799
+ } | undefined>;
1800
+ }>>;
1801
+ }, {
1802
+ id: import("zod").ZodString;
1803
+ prevId: import("zod").ZodString;
1804
+ }>, "strip", import("zod").ZodTypeAny, {
1805
+ internal?: {
1806
+ tables: Record<string, {
1807
+ columns: Record<string, {
1808
+ isDefaultAnExpression?: boolean | undefined;
1809
+ } | undefined>;
1810
+ } | undefined>;
1811
+ } | undefined;
1812
+ id: string;
1813
+ prevId: string;
1814
+ version: "5";
1815
+ dialect: "mysql";
1816
+ tables: Record<string, {
1817
+ schema?: string | undefined;
1818
+ name: string;
1819
+ columns: Record<string, {
1820
+ default?: any;
1821
+ onUpdate?: any;
1822
+ autoincrement?: boolean | undefined;
1823
+ name: string;
1824
+ type: string;
1825
+ primaryKey: boolean;
1826
+ notNull: boolean;
1827
+ }>;
1828
+ indexes: Record<string, {
1829
+ using?: "btree" | "hash" | undefined;
1830
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1831
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1832
+ name: string;
1833
+ columns: string[];
1834
+ isUnique: boolean;
1835
+ }>;
1836
+ foreignKeys: Record<string, {
1837
+ onUpdate?: string | undefined;
1838
+ onDelete?: string | undefined;
1839
+ name: string;
1840
+ tableFrom: string;
1841
+ columnsFrom: string[];
1842
+ tableTo: string;
1843
+ columnsTo: string[];
1844
+ }>;
1845
+ compositePrimaryKeys: Record<string, {
1846
+ name: string;
1847
+ columns: string[];
1848
+ }>;
1849
+ uniqueConstraints: Record<string, {
1850
+ name: string;
1851
+ columns: string[];
1852
+ }>;
1853
+ }>;
1854
+ schemas: Record<string, string>;
1855
+ _meta: {
1856
+ columns: Record<string, string>;
1857
+ tables: Record<string, string>;
1858
+ schemas: Record<string, string>;
1859
+ };
1860
+ }, {
1861
+ internal?: {
1862
+ tables: Record<string, {
1863
+ columns: Record<string, {
1864
+ isDefaultAnExpression?: boolean | undefined;
1865
+ } | undefined>;
1866
+ } | undefined>;
1867
+ } | undefined;
1868
+ id: string;
1869
+ prevId: string;
1870
+ version: "5";
1871
+ dialect: "mysql";
1872
+ tables: Record<string, {
1873
+ schema?: string | undefined;
1874
+ uniqueConstraints?: Record<string, {
1875
+ name: string;
1876
+ columns: string[];
1877
+ }> | undefined;
1878
+ name: string;
1879
+ columns: Record<string, {
1880
+ default?: any;
1881
+ onUpdate?: any;
1882
+ autoincrement?: boolean | undefined;
1883
+ name: string;
1884
+ type: string;
1885
+ primaryKey: boolean;
1886
+ notNull: boolean;
1887
+ }>;
1888
+ indexes: Record<string, {
1889
+ using?: "btree" | "hash" | undefined;
1890
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1891
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1892
+ name: string;
1893
+ columns: string[];
1894
+ isUnique: boolean;
1895
+ }>;
1896
+ foreignKeys: Record<string, {
1897
+ onUpdate?: string | undefined;
1898
+ onDelete?: string | undefined;
1899
+ name: string;
1900
+ tableFrom: string;
1901
+ columnsFrom: string[];
1902
+ tableTo: string;
1903
+ columnsTo: string[];
1904
+ }>;
1905
+ compositePrimaryKeys: Record<string, {
1906
+ name: string;
1907
+ columns: string[];
1908
+ }>;
1909
+ }>;
1910
+ schemas: Record<string, string>;
1911
+ _meta: {
1912
+ columns: Record<string, string>;
1913
+ tables: Record<string, string>;
1914
+ schemas: Record<string, string>;
1915
+ };
1916
+ }>;
1917
+ export declare const schemaSquashed: import("zod").ZodObject<{
1918
+ version: import("zod").ZodLiteral<"5">;
1919
+ dialect: import("zod").ZodLiteral<"mysql">;
1920
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1921
+ name: import("zod").ZodString;
1922
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
1923
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1924
+ name: import("zod").ZodString;
1925
+ type: import("zod").ZodString;
1926
+ primaryKey: import("zod").ZodBoolean;
1927
+ notNull: import("zod").ZodBoolean;
1928
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1929
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
1930
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
1931
+ }, "strict", import("zod").ZodTypeAny, {
1932
+ default?: any;
1933
+ onUpdate?: any;
1934
+ autoincrement?: boolean | undefined;
1935
+ name: string;
1936
+ type: string;
1937
+ primaryKey: boolean;
1938
+ notNull: boolean;
1939
+ }, {
1940
+ default?: any;
1941
+ onUpdate?: any;
1942
+ autoincrement?: boolean | undefined;
1943
+ name: string;
1944
+ type: string;
1945
+ primaryKey: boolean;
1946
+ notNull: boolean;
1947
+ }>>;
1948
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1949
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1950
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1951
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
1952
+ }, "strict", import("zod").ZodTypeAny, {
1953
+ schema?: string | undefined;
1954
+ name: string;
1955
+ columns: Record<string, {
1956
+ default?: any;
1957
+ onUpdate?: any;
1958
+ autoincrement?: boolean | undefined;
1959
+ name: string;
1960
+ type: string;
1961
+ primaryKey: boolean;
1962
+ notNull: boolean;
1963
+ }>;
1964
+ indexes: Record<string, string>;
1965
+ foreignKeys: Record<string, string>;
1966
+ compositePrimaryKeys: Record<string, string>;
1967
+ uniqueConstraints: Record<string, string>;
1968
+ }, {
1969
+ schema?: string | undefined;
1970
+ uniqueConstraints?: Record<string, string> | undefined;
1971
+ name: string;
1972
+ columns: Record<string, {
1973
+ default?: any;
1974
+ onUpdate?: any;
1975
+ autoincrement?: boolean | undefined;
1976
+ name: string;
1977
+ type: string;
1978
+ primaryKey: boolean;
1979
+ notNull: boolean;
1980
+ }>;
1981
+ indexes: Record<string, string>;
1982
+ foreignKeys: Record<string, string>;
1983
+ compositePrimaryKeys: Record<string, string>;
1984
+ }>>;
1985
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1986
+ }, "strict", import("zod").ZodTypeAny, {
1987
+ version: "5";
1988
+ dialect: "mysql";
1989
+ tables: Record<string, {
1990
+ schema?: string | undefined;
1991
+ name: string;
1992
+ columns: Record<string, {
1993
+ default?: any;
1994
+ onUpdate?: any;
1995
+ autoincrement?: boolean | undefined;
1996
+ name: string;
1997
+ type: string;
1998
+ primaryKey: boolean;
1999
+ notNull: boolean;
2000
+ }>;
2001
+ indexes: Record<string, string>;
2002
+ foreignKeys: Record<string, string>;
2003
+ compositePrimaryKeys: Record<string, string>;
2004
+ uniqueConstraints: Record<string, string>;
2005
+ }>;
2006
+ schemas: Record<string, string>;
2007
+ }, {
2008
+ version: "5";
2009
+ dialect: "mysql";
2010
+ tables: Record<string, {
2011
+ schema?: string | undefined;
2012
+ uniqueConstraints?: Record<string, string> | undefined;
2013
+ name: string;
2014
+ columns: Record<string, {
2015
+ default?: any;
2016
+ onUpdate?: any;
2017
+ autoincrement?: boolean | undefined;
2018
+ name: string;
2019
+ type: string;
2020
+ primaryKey: boolean;
2021
+ notNull: boolean;
2022
+ }>;
2023
+ indexes: Record<string, string>;
2024
+ foreignKeys: Record<string, string>;
2025
+ compositePrimaryKeys: Record<string, string>;
2026
+ }>;
2027
+ schemas: Record<string, string>;
2028
+ }>;
2029
+ export declare const schemaSquashedV4: import("zod").ZodObject<{
2030
+ version: import("zod").ZodLiteral<"4">;
2031
+ dialect: import("zod").ZodLiteral<"mysql">;
2032
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2033
+ name: import("zod").ZodString;
2034
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
2035
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2036
+ name: import("zod").ZodString;
2037
+ type: import("zod").ZodString;
2038
+ primaryKey: import("zod").ZodBoolean;
2039
+ notNull: import("zod").ZodBoolean;
2040
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2041
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2042
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2043
+ }, "strict", import("zod").ZodTypeAny, {
2044
+ default?: any;
2045
+ onUpdate?: any;
2046
+ autoincrement?: boolean | undefined;
2047
+ name: string;
2048
+ type: string;
2049
+ primaryKey: boolean;
2050
+ notNull: boolean;
2051
+ }, {
2052
+ default?: any;
2053
+ onUpdate?: any;
2054
+ autoincrement?: boolean | undefined;
2055
+ name: string;
2056
+ type: string;
2057
+ primaryKey: boolean;
2058
+ notNull: boolean;
2059
+ }>>;
2060
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2061
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2062
+ }, "strict", import("zod").ZodTypeAny, {
2063
+ schema?: string | undefined;
2064
+ name: string;
2065
+ columns: Record<string, {
2066
+ default?: any;
2067
+ onUpdate?: any;
2068
+ autoincrement?: boolean | undefined;
2069
+ name: string;
2070
+ type: string;
2071
+ primaryKey: boolean;
2072
+ notNull: boolean;
2073
+ }>;
2074
+ indexes: Record<string, string>;
2075
+ foreignKeys: Record<string, string>;
2076
+ }, {
2077
+ schema?: string | undefined;
2078
+ name: string;
2079
+ columns: Record<string, {
2080
+ default?: any;
2081
+ onUpdate?: any;
2082
+ autoincrement?: boolean | undefined;
2083
+ name: string;
2084
+ type: string;
2085
+ primaryKey: boolean;
2086
+ notNull: boolean;
2087
+ }>;
2088
+ indexes: Record<string, string>;
2089
+ foreignKeys: Record<string, string>;
2090
+ }>>;
2091
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2092
+ }, "strict", import("zod").ZodTypeAny, {
2093
+ version: "4";
2094
+ dialect: "mysql";
2095
+ tables: Record<string, {
2096
+ schema?: string | undefined;
2097
+ name: string;
2098
+ columns: Record<string, {
2099
+ default?: any;
2100
+ onUpdate?: any;
2101
+ autoincrement?: boolean | undefined;
2102
+ name: string;
2103
+ type: string;
2104
+ primaryKey: boolean;
2105
+ notNull: boolean;
2106
+ }>;
2107
+ indexes: Record<string, string>;
2108
+ foreignKeys: Record<string, string>;
2109
+ }>;
2110
+ schemas: Record<string, string>;
2111
+ }, {
2112
+ version: "4";
2113
+ dialect: "mysql";
2114
+ tables: Record<string, {
2115
+ schema?: string | undefined;
2116
+ name: string;
2117
+ columns: Record<string, {
2118
+ default?: any;
2119
+ onUpdate?: any;
2120
+ autoincrement?: boolean | undefined;
2121
+ name: string;
2122
+ type: string;
2123
+ primaryKey: boolean;
2124
+ notNull: boolean;
2125
+ }>;
2126
+ indexes: Record<string, string>;
2127
+ foreignKeys: Record<string, string>;
2128
+ }>;
2129
+ schemas: Record<string, string>;
2130
+ }>;
2131
+ export type Dialect = TypeOf<typeof dialect>;
2132
+ export type Column = TypeOf<typeof column>;
2133
+ export type Table = TypeOf<typeof table>;
2134
+ export type TableV4 = TypeOf<typeof tableV4>;
2135
+ export type MySqlSchema = TypeOf<typeof schema>;
2136
+ export type MySqlSchemaV3 = TypeOf<typeof schemaV3>;
2137
+ export type MySqlSchemaV4 = TypeOf<typeof schemaV4>;
2138
+ export type MySqlSchemaInternal = TypeOf<typeof schemaInternal>;
2139
+ export type MySqlKitInternals = TypeOf<typeof kitInternals>;
2140
+ export type MySqlSchemaSquashed = TypeOf<typeof schemaSquashed>;
2141
+ export type MySqlSchemaSquashedV4 = TypeOf<typeof schemaSquashedV4>;
2142
+ export type Index = TypeOf<typeof index>;
2143
+ export type ForeignKey = TypeOf<typeof fk>;
2144
+ export type PrimaryKey = TypeOf<typeof compositePK>;
2145
+ export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
2146
+ export declare const MySqlSquasher: {
2147
+ squashIdx: (idx: Index) => string;
2148
+ unsquashIdx: (input: string) => Index;
2149
+ squashPK: (pk: PrimaryKey) => string;
2150
+ unsquashPK: (pk: string) => PrimaryKey;
2151
+ squashUnique: (unq: UniqueConstraint) => string;
2152
+ unsquashUnique: (unq: string) => UniqueConstraint;
2153
+ squashFK: (fk: ForeignKey) => string;
2154
+ unsquashFK: (input: string) => ForeignKey;
2155
+ };
2156
+ export declare const squashMysqlSchemeV4: (json: MySqlSchemaV4) => MySqlSchemaSquashedV4;
2157
+ export declare const squashMysqlScheme: (json: MySqlSchema) => MySqlSchemaSquashed;
2158
+ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendShape<{
2159
+ version: import("zod").ZodLiteral<"5">;
2160
+ dialect: import("zod").ZodLiteral<"mysql">;
2161
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2162
+ name: import("zod").ZodString;
2163
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
2164
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2165
+ name: import("zod").ZodString;
2166
+ type: import("zod").ZodString;
2167
+ primaryKey: import("zod").ZodBoolean;
2168
+ notNull: import("zod").ZodBoolean;
2169
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2170
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2171
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2172
+ }, "strict", import("zod").ZodTypeAny, {
2173
+ default?: any;
2174
+ onUpdate?: any;
2175
+ autoincrement?: boolean | undefined;
2176
+ name: string;
2177
+ type: string;
2178
+ primaryKey: boolean;
2179
+ notNull: boolean;
2180
+ }, {
2181
+ default?: any;
2182
+ onUpdate?: any;
2183
+ autoincrement?: boolean | undefined;
2184
+ name: string;
2185
+ type: string;
2186
+ primaryKey: boolean;
2187
+ notNull: boolean;
2188
+ }>>;
2189
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2190
+ name: import("zod").ZodString;
2191
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2192
+ isUnique: import("zod").ZodBoolean;
2193
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
2194
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
2195
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
2196
+ }, "strict", import("zod").ZodTypeAny, {
2197
+ using?: "btree" | "hash" | undefined;
2198
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2199
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2200
+ name: string;
2201
+ columns: string[];
2202
+ isUnique: boolean;
2203
+ }, {
2204
+ using?: "btree" | "hash" | undefined;
2205
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2206
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2207
+ name: string;
2208
+ columns: string[];
2209
+ isUnique: boolean;
2210
+ }>>;
2211
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2212
+ name: import("zod").ZodString;
2213
+ tableFrom: import("zod").ZodString;
2214
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2215
+ tableTo: import("zod").ZodString;
2216
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2217
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2218
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2219
+ }, "strict", import("zod").ZodTypeAny, {
2220
+ onUpdate?: string | undefined;
2221
+ onDelete?: string | undefined;
2222
+ name: string;
2223
+ tableFrom: string;
2224
+ columnsFrom: string[];
2225
+ tableTo: string;
2226
+ columnsTo: string[];
2227
+ }, {
2228
+ onUpdate?: string | undefined;
2229
+ onDelete?: string | undefined;
2230
+ name: string;
2231
+ tableFrom: string;
2232
+ columnsFrom: string[];
2233
+ tableTo: string;
2234
+ columnsTo: string[];
2235
+ }>>;
2236
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2237
+ name: import("zod").ZodString;
2238
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2239
+ }, "strict", import("zod").ZodTypeAny, {
2240
+ name: string;
2241
+ columns: string[];
2242
+ }, {
2243
+ name: string;
2244
+ columns: string[];
2245
+ }>>;
2246
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2247
+ name: import("zod").ZodString;
2248
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2249
+ }, "strict", import("zod").ZodTypeAny, {
2250
+ name: string;
2251
+ columns: string[];
2252
+ }, {
2253
+ name: string;
2254
+ columns: string[];
2255
+ }>>>;
2256
+ }, "strict", import("zod").ZodTypeAny, {
2257
+ schema?: string | undefined;
2258
+ name: string;
2259
+ columns: Record<string, {
2260
+ default?: any;
2261
+ onUpdate?: any;
2262
+ autoincrement?: boolean | undefined;
2263
+ name: string;
2264
+ type: string;
2265
+ primaryKey: boolean;
2266
+ notNull: boolean;
2267
+ }>;
2268
+ indexes: Record<string, {
2269
+ using?: "btree" | "hash" | undefined;
2270
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2271
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2272
+ name: string;
2273
+ columns: string[];
2274
+ isUnique: boolean;
2275
+ }>;
2276
+ foreignKeys: Record<string, {
2277
+ onUpdate?: string | undefined;
2278
+ onDelete?: string | undefined;
2279
+ name: string;
2280
+ tableFrom: string;
2281
+ columnsFrom: string[];
2282
+ tableTo: string;
2283
+ columnsTo: string[];
2284
+ }>;
2285
+ compositePrimaryKeys: Record<string, {
2286
+ name: string;
2287
+ columns: string[];
2288
+ }>;
2289
+ uniqueConstraints: Record<string, {
2290
+ name: string;
2291
+ columns: string[];
2292
+ }>;
2293
+ }, {
2294
+ schema?: string | undefined;
2295
+ uniqueConstraints?: Record<string, {
2296
+ name: string;
2297
+ columns: string[];
2298
+ }> | undefined;
2299
+ name: string;
2300
+ columns: Record<string, {
2301
+ default?: any;
2302
+ onUpdate?: any;
2303
+ autoincrement?: boolean | undefined;
2304
+ name: string;
2305
+ type: string;
2306
+ primaryKey: boolean;
2307
+ notNull: boolean;
2308
+ }>;
2309
+ indexes: Record<string, {
2310
+ using?: "btree" | "hash" | undefined;
2311
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2312
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2313
+ name: string;
2314
+ columns: string[];
2315
+ isUnique: boolean;
2316
+ }>;
2317
+ foreignKeys: Record<string, {
2318
+ onUpdate?: string | undefined;
2319
+ onDelete?: string | undefined;
2320
+ name: string;
2321
+ tableFrom: string;
2322
+ columnsFrom: string[];
2323
+ tableTo: string;
2324
+ columnsTo: string[];
2325
+ }>;
2326
+ compositePrimaryKeys: Record<string, {
2327
+ name: string;
2328
+ columns: string[];
2329
+ }>;
2330
+ }>>;
2331
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2332
+ _meta: import("zod").ZodObject<{
2333
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2334
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2335
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2336
+ }, "strip", import("zod").ZodTypeAny, {
2337
+ columns: Record<string, string>;
2338
+ tables: Record<string, string>;
2339
+ schemas: Record<string, string>;
2340
+ }, {
2341
+ columns: Record<string, string>;
2342
+ tables: Record<string, string>;
2343
+ schemas: Record<string, string>;
2344
+ }>;
2345
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
2346
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
2347
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
2348
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
2349
+ }, "strip", import("zod").ZodTypeAny, {
2350
+ isDefaultAnExpression?: boolean | undefined;
2351
+ }, {
2352
+ isDefaultAnExpression?: boolean | undefined;
2353
+ }>>>;
2354
+ }, "strip", import("zod").ZodTypeAny, {
2355
+ columns: Record<string, {
2356
+ isDefaultAnExpression?: boolean | undefined;
2357
+ } | undefined>;
2358
+ }, {
2359
+ columns: Record<string, {
2360
+ isDefaultAnExpression?: boolean | undefined;
2361
+ } | undefined>;
2362
+ }>>>;
2363
+ }, "strip", import("zod").ZodTypeAny, {
2364
+ tables: Record<string, {
2365
+ columns: Record<string, {
2366
+ isDefaultAnExpression?: boolean | undefined;
2367
+ } | undefined>;
2368
+ } | undefined>;
2369
+ }, {
2370
+ tables: Record<string, {
2371
+ columns: Record<string, {
2372
+ isDefaultAnExpression?: boolean | undefined;
2373
+ } | undefined>;
2374
+ } | undefined>;
2375
+ }>>;
2376
+ }, {
2377
+ id: import("zod").ZodString;
2378
+ prevId: import("zod").ZodString;
2379
+ }>, "strip", import("zod").ZodTypeAny, {
2380
+ internal?: {
2381
+ tables: Record<string, {
2382
+ columns: Record<string, {
2383
+ isDefaultAnExpression?: boolean | undefined;
2384
+ } | undefined>;
2385
+ } | undefined>;
2386
+ } | undefined;
2387
+ id: string;
2388
+ prevId: string;
2389
+ version: "5";
2390
+ dialect: "mysql";
2391
+ tables: Record<string, {
2392
+ schema?: string | undefined;
2393
+ name: string;
2394
+ columns: Record<string, {
2395
+ default?: any;
2396
+ onUpdate?: any;
2397
+ autoincrement?: boolean | undefined;
2398
+ name: string;
2399
+ type: string;
2400
+ primaryKey: boolean;
2401
+ notNull: boolean;
2402
+ }>;
2403
+ indexes: Record<string, {
2404
+ using?: "btree" | "hash" | undefined;
2405
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2406
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2407
+ name: string;
2408
+ columns: string[];
2409
+ isUnique: boolean;
2410
+ }>;
2411
+ foreignKeys: Record<string, {
2412
+ onUpdate?: string | undefined;
2413
+ onDelete?: string | undefined;
2414
+ name: string;
2415
+ tableFrom: string;
2416
+ columnsFrom: string[];
2417
+ tableTo: string;
2418
+ columnsTo: string[];
2419
+ }>;
2420
+ compositePrimaryKeys: Record<string, {
2421
+ name: string;
2422
+ columns: string[];
2423
+ }>;
2424
+ uniqueConstraints: Record<string, {
2425
+ name: string;
2426
+ columns: string[];
2427
+ }>;
2428
+ }>;
2429
+ schemas: Record<string, string>;
2430
+ _meta: {
2431
+ columns: Record<string, string>;
2432
+ tables: Record<string, string>;
2433
+ schemas: Record<string, string>;
2434
+ };
2435
+ }, {
2436
+ internal?: {
2437
+ tables: Record<string, {
2438
+ columns: Record<string, {
2439
+ isDefaultAnExpression?: boolean | undefined;
2440
+ } | undefined>;
2441
+ } | undefined>;
2442
+ } | undefined;
2443
+ id: string;
2444
+ prevId: string;
2445
+ version: "5";
2446
+ dialect: "mysql";
2447
+ tables: Record<string, {
2448
+ schema?: string | undefined;
2449
+ uniqueConstraints?: Record<string, {
2450
+ name: string;
2451
+ columns: string[];
2452
+ }> | undefined;
2453
+ name: string;
2454
+ columns: Record<string, {
2455
+ default?: any;
2456
+ onUpdate?: any;
2457
+ autoincrement?: boolean | undefined;
2458
+ name: string;
2459
+ type: string;
2460
+ primaryKey: boolean;
2461
+ notNull: boolean;
2462
+ }>;
2463
+ indexes: Record<string, {
2464
+ using?: "btree" | "hash" | undefined;
2465
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2466
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2467
+ name: string;
2468
+ columns: string[];
2469
+ isUnique: boolean;
2470
+ }>;
2471
+ foreignKeys: Record<string, {
2472
+ onUpdate?: string | undefined;
2473
+ onDelete?: string | undefined;
2474
+ name: string;
2475
+ tableFrom: string;
2476
+ columnsFrom: string[];
2477
+ tableTo: string;
2478
+ columnsTo: string[];
2479
+ }>;
2480
+ compositePrimaryKeys: Record<string, {
2481
+ name: string;
2482
+ columns: string[];
2483
+ }>;
2484
+ }>;
2485
+ schemas: Record<string, string>;
2486
+ _meta: {
2487
+ columns: Record<string, string>;
2488
+ tables: Record<string, string>;
2489
+ schemas: Record<string, string>;
2490
+ };
2491
+ }>;
2492
+ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
2493
+ version: import("zod").ZodLiteral<"4">;
2494
+ dialect: import("zod").ZodLiteral<"mysql">;
2495
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2496
+ name: import("zod").ZodString;
2497
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
2498
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2499
+ name: import("zod").ZodString;
2500
+ type: import("zod").ZodString;
2501
+ primaryKey: import("zod").ZodBoolean;
2502
+ notNull: import("zod").ZodBoolean;
2503
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2504
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2505
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2506
+ }, "strict", import("zod").ZodTypeAny, {
2507
+ default?: any;
2508
+ onUpdate?: any;
2509
+ autoincrement?: boolean | undefined;
2510
+ name: string;
2511
+ type: string;
2512
+ primaryKey: boolean;
2513
+ notNull: boolean;
2514
+ }, {
2515
+ default?: any;
2516
+ onUpdate?: any;
2517
+ autoincrement?: boolean | undefined;
2518
+ name: string;
2519
+ type: string;
2520
+ primaryKey: boolean;
2521
+ notNull: boolean;
2522
+ }>>;
2523
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2524
+ name: import("zod").ZodString;
2525
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2526
+ isUnique: import("zod").ZodBoolean;
2527
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
2528
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
2529
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
2530
+ }, "strict", import("zod").ZodTypeAny, {
2531
+ using?: "btree" | "hash" | undefined;
2532
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2533
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2534
+ name: string;
2535
+ columns: string[];
2536
+ isUnique: boolean;
2537
+ }, {
2538
+ using?: "btree" | "hash" | undefined;
2539
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2540
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2541
+ name: string;
2542
+ columns: string[];
2543
+ isUnique: boolean;
2544
+ }>>;
2545
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2546
+ name: import("zod").ZodString;
2547
+ tableFrom: import("zod").ZodString;
2548
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2549
+ tableTo: import("zod").ZodString;
2550
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2551
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2552
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2553
+ }, "strict", import("zod").ZodTypeAny, {
2554
+ onUpdate?: string | undefined;
2555
+ onDelete?: string | undefined;
2556
+ name: string;
2557
+ tableFrom: string;
2558
+ columnsFrom: string[];
2559
+ tableTo: string;
2560
+ columnsTo: string[];
2561
+ }, {
2562
+ onUpdate?: string | undefined;
2563
+ onDelete?: string | undefined;
2564
+ name: string;
2565
+ tableFrom: string;
2566
+ columnsFrom: string[];
2567
+ tableTo: string;
2568
+ columnsTo: string[];
2569
+ }>>;
2570
+ }, "strict", import("zod").ZodTypeAny, {
2571
+ schema?: string | undefined;
2572
+ name: string;
2573
+ columns: Record<string, {
2574
+ default?: any;
2575
+ onUpdate?: any;
2576
+ autoincrement?: boolean | undefined;
2577
+ name: string;
2578
+ type: string;
2579
+ primaryKey: boolean;
2580
+ notNull: boolean;
2581
+ }>;
2582
+ indexes: Record<string, {
2583
+ using?: "btree" | "hash" | undefined;
2584
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2585
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2586
+ name: string;
2587
+ columns: string[];
2588
+ isUnique: boolean;
2589
+ }>;
2590
+ foreignKeys: Record<string, {
2591
+ onUpdate?: string | undefined;
2592
+ onDelete?: string | undefined;
2593
+ name: string;
2594
+ tableFrom: string;
2595
+ columnsFrom: string[];
2596
+ tableTo: string;
2597
+ columnsTo: string[];
2598
+ }>;
2599
+ }, {
2600
+ schema?: string | undefined;
2601
+ name: string;
2602
+ columns: Record<string, {
2603
+ default?: any;
2604
+ onUpdate?: any;
2605
+ autoincrement?: boolean | undefined;
2606
+ name: string;
2607
+ type: string;
2608
+ primaryKey: boolean;
2609
+ notNull: boolean;
2610
+ }>;
2611
+ indexes: Record<string, {
2612
+ using?: "btree" | "hash" | undefined;
2613
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2614
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2615
+ name: string;
2616
+ columns: string[];
2617
+ isUnique: boolean;
2618
+ }>;
2619
+ foreignKeys: Record<string, {
2620
+ onUpdate?: string | undefined;
2621
+ onDelete?: string | undefined;
2622
+ name: string;
2623
+ tableFrom: string;
2624
+ columnsFrom: string[];
2625
+ tableTo: string;
2626
+ columnsTo: string[];
2627
+ }>;
2628
+ }>>;
2629
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2630
+ }, {
2631
+ id: import("zod").ZodString;
2632
+ prevId: import("zod").ZodString;
2633
+ }>, "strip", import("zod").ZodTypeAny, {
2634
+ id: string;
2635
+ prevId: string;
2636
+ version: "4";
2637
+ dialect: "mysql";
2638
+ tables: Record<string, {
2639
+ schema?: string | undefined;
2640
+ name: string;
2641
+ columns: Record<string, {
2642
+ default?: any;
2643
+ onUpdate?: any;
2644
+ autoincrement?: boolean | undefined;
2645
+ name: string;
2646
+ type: string;
2647
+ primaryKey: boolean;
2648
+ notNull: boolean;
2649
+ }>;
2650
+ indexes: Record<string, {
2651
+ using?: "btree" | "hash" | undefined;
2652
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2653
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2654
+ name: string;
2655
+ columns: string[];
2656
+ isUnique: boolean;
2657
+ }>;
2658
+ foreignKeys: Record<string, {
2659
+ onUpdate?: string | undefined;
2660
+ onDelete?: string | undefined;
2661
+ name: string;
2662
+ tableFrom: string;
2663
+ columnsFrom: string[];
2664
+ tableTo: string;
2665
+ columnsTo: string[];
2666
+ }>;
2667
+ }>;
2668
+ schemas: Record<string, string>;
2669
+ }, {
2670
+ id: string;
2671
+ prevId: string;
2672
+ version: "4";
2673
+ dialect: "mysql";
2674
+ tables: Record<string, {
2675
+ schema?: string | undefined;
2676
+ name: string;
2677
+ columns: Record<string, {
2678
+ default?: any;
2679
+ onUpdate?: any;
2680
+ autoincrement?: boolean | undefined;
2681
+ name: string;
2682
+ type: string;
2683
+ primaryKey: boolean;
2684
+ notNull: boolean;
2685
+ }>;
2686
+ indexes: Record<string, {
2687
+ using?: "btree" | "hash" | undefined;
2688
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2689
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2690
+ name: string;
2691
+ columns: string[];
2692
+ isUnique: boolean;
2693
+ }>;
2694
+ foreignKeys: Record<string, {
2695
+ onUpdate?: string | undefined;
2696
+ onDelete?: string | undefined;
2697
+ name: string;
2698
+ tableFrom: string;
2699
+ columnsFrom: string[];
2700
+ tableTo: string;
2701
+ columnsTo: string[];
2702
+ }>;
2703
+ }>;
2704
+ schemas: Record<string, string>;
2705
+ }>;
2706
+ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
2707
+ version: import("zod").ZodLiteral<"3">;
2708
+ dialect: import("zod").ZodLiteral<"mysql">;
2709
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2710
+ name: import("zod").ZodString;
2711
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2712
+ name: import("zod").ZodString;
2713
+ type: import("zod").ZodString;
2714
+ primaryKey: import("zod").ZodBoolean;
2715
+ notNull: import("zod").ZodBoolean;
2716
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2717
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2718
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2719
+ }, "strict", import("zod").ZodTypeAny, {
2720
+ default?: any;
2721
+ onUpdate?: any;
2722
+ autoincrement?: boolean | undefined;
2723
+ name: string;
2724
+ type: string;
2725
+ primaryKey: boolean;
2726
+ notNull: boolean;
2727
+ }, {
2728
+ default?: any;
2729
+ onUpdate?: any;
2730
+ autoincrement?: boolean | undefined;
2731
+ name: string;
2732
+ type: string;
2733
+ primaryKey: boolean;
2734
+ notNull: boolean;
2735
+ }>>;
2736
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2737
+ name: import("zod").ZodString;
2738
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2739
+ isUnique: import("zod").ZodBoolean;
2740
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
2741
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
2742
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
2743
+ }, "strict", import("zod").ZodTypeAny, {
2744
+ using?: "btree" | "hash" | undefined;
2745
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2746
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2747
+ name: string;
2748
+ columns: string[];
2749
+ isUnique: boolean;
2750
+ }, {
2751
+ using?: "btree" | "hash" | undefined;
2752
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2753
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2754
+ name: string;
2755
+ columns: string[];
2756
+ isUnique: boolean;
2757
+ }>>;
2758
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2759
+ name: import("zod").ZodString;
2760
+ tableFrom: import("zod").ZodString;
2761
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2762
+ tableTo: import("zod").ZodString;
2763
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2764
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2765
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2766
+ }, "strict", import("zod").ZodTypeAny, {
2767
+ onUpdate?: string | undefined;
2768
+ onDelete?: string | undefined;
2769
+ name: string;
2770
+ tableFrom: string;
2771
+ columnsFrom: string[];
2772
+ tableTo: string;
2773
+ columnsTo: string[];
2774
+ }, {
2775
+ onUpdate?: string | undefined;
2776
+ onDelete?: string | undefined;
2777
+ name: string;
2778
+ tableFrom: string;
2779
+ columnsFrom: string[];
2780
+ tableTo: string;
2781
+ columnsTo: string[];
2782
+ }>>;
2783
+ }, "strict", import("zod").ZodTypeAny, {
2784
+ name: string;
2785
+ columns: Record<string, {
2786
+ default?: any;
2787
+ onUpdate?: any;
2788
+ autoincrement?: boolean | undefined;
2789
+ name: string;
2790
+ type: string;
2791
+ primaryKey: boolean;
2792
+ notNull: boolean;
2793
+ }>;
2794
+ indexes: Record<string, {
2795
+ using?: "btree" | "hash" | undefined;
2796
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2797
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2798
+ name: string;
2799
+ columns: string[];
2800
+ isUnique: boolean;
2801
+ }>;
2802
+ foreignKeys: Record<string, {
2803
+ onUpdate?: string | undefined;
2804
+ onDelete?: string | undefined;
2805
+ name: string;
2806
+ tableFrom: string;
2807
+ columnsFrom: string[];
2808
+ tableTo: string;
2809
+ columnsTo: string[];
2810
+ }>;
2811
+ }, {
2812
+ name: string;
2813
+ columns: Record<string, {
2814
+ default?: any;
2815
+ onUpdate?: any;
2816
+ autoincrement?: boolean | undefined;
2817
+ name: string;
2818
+ type: string;
2819
+ primaryKey: boolean;
2820
+ notNull: boolean;
2821
+ }>;
2822
+ indexes: Record<string, {
2823
+ using?: "btree" | "hash" | undefined;
2824
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2825
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2826
+ name: string;
2827
+ columns: string[];
2828
+ isUnique: boolean;
2829
+ }>;
2830
+ foreignKeys: Record<string, {
2831
+ onUpdate?: string | undefined;
2832
+ onDelete?: string | undefined;
2833
+ name: string;
2834
+ tableFrom: string;
2835
+ columnsFrom: string[];
2836
+ tableTo: string;
2837
+ columnsTo: string[];
2838
+ }>;
2839
+ }>>;
2840
+ }, {
2841
+ id: import("zod").ZodString;
2842
+ prevId: import("zod").ZodString;
2843
+ }>, "strip", import("zod").ZodTypeAny, {
2844
+ id: string;
2845
+ prevId: string;
2846
+ version: "3";
2847
+ dialect: "mysql";
2848
+ tables: Record<string, {
2849
+ name: string;
2850
+ columns: Record<string, {
2851
+ default?: any;
2852
+ onUpdate?: any;
2853
+ autoincrement?: boolean | undefined;
2854
+ name: string;
2855
+ type: string;
2856
+ primaryKey: boolean;
2857
+ notNull: boolean;
2858
+ }>;
2859
+ indexes: Record<string, {
2860
+ using?: "btree" | "hash" | undefined;
2861
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2862
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2863
+ name: string;
2864
+ columns: string[];
2865
+ isUnique: boolean;
2866
+ }>;
2867
+ foreignKeys: Record<string, {
2868
+ onUpdate?: string | undefined;
2869
+ onDelete?: string | undefined;
2870
+ name: string;
2871
+ tableFrom: string;
2872
+ columnsFrom: string[];
2873
+ tableTo: string;
2874
+ columnsTo: string[];
2875
+ }>;
2876
+ }>;
2877
+ }, {
2878
+ id: string;
2879
+ prevId: string;
2880
+ version: "3";
2881
+ dialect: "mysql";
2882
+ tables: Record<string, {
2883
+ name: string;
2884
+ columns: Record<string, {
2885
+ default?: any;
2886
+ onUpdate?: any;
2887
+ autoincrement?: boolean | undefined;
2888
+ name: string;
2889
+ type: string;
2890
+ primaryKey: boolean;
2891
+ notNull: boolean;
2892
+ }>;
2893
+ indexes: Record<string, {
2894
+ using?: "btree" | "hash" | undefined;
2895
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2896
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2897
+ name: string;
2898
+ columns: string[];
2899
+ isUnique: boolean;
2900
+ }>;
2901
+ foreignKeys: Record<string, {
2902
+ onUpdate?: string | undefined;
2903
+ onDelete?: string | undefined;
2904
+ name: string;
2905
+ tableFrom: string;
2906
+ columnsFrom: string[];
2907
+ tableTo: string;
2908
+ columnsTo: string[];
2909
+ }>;
2910
+ }>;
2911
+ }>;
2912
+ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
2913
+ version: import("zod").ZodLiteral<"5">;
2914
+ dialect: import("zod").ZodLiteral<"mysql">;
2915
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2916
+ name: import("zod").ZodString;
2917
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
2918
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2919
+ name: import("zod").ZodString;
2920
+ type: import("zod").ZodString;
2921
+ primaryKey: import("zod").ZodBoolean;
2922
+ notNull: import("zod").ZodBoolean;
2923
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2924
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2925
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2926
+ }, "strict", import("zod").ZodTypeAny, {
2927
+ default?: any;
2928
+ onUpdate?: any;
2929
+ autoincrement?: boolean | undefined;
2930
+ name: string;
2931
+ type: string;
2932
+ primaryKey: boolean;
2933
+ notNull: boolean;
2934
+ }, {
2935
+ default?: any;
2936
+ onUpdate?: any;
2937
+ autoincrement?: boolean | undefined;
2938
+ name: string;
2939
+ type: string;
2940
+ primaryKey: boolean;
2941
+ notNull: boolean;
2942
+ }>>;
2943
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2944
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2945
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2946
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
2947
+ }, "strict", import("zod").ZodTypeAny, {
2948
+ schema?: string | undefined;
2949
+ name: string;
2950
+ columns: Record<string, {
2951
+ default?: any;
2952
+ onUpdate?: any;
2953
+ autoincrement?: boolean | undefined;
2954
+ name: string;
2955
+ type: string;
2956
+ primaryKey: boolean;
2957
+ notNull: boolean;
2958
+ }>;
2959
+ indexes: Record<string, string>;
2960
+ foreignKeys: Record<string, string>;
2961
+ compositePrimaryKeys: Record<string, string>;
2962
+ uniqueConstraints: Record<string, string>;
2963
+ }, {
2964
+ schema?: string | undefined;
2965
+ uniqueConstraints?: Record<string, string> | undefined;
2966
+ name: string;
2967
+ columns: Record<string, {
2968
+ default?: any;
2969
+ onUpdate?: any;
2970
+ autoincrement?: boolean | undefined;
2971
+ name: string;
2972
+ type: string;
2973
+ primaryKey: boolean;
2974
+ notNull: boolean;
2975
+ }>;
2976
+ indexes: Record<string, string>;
2977
+ foreignKeys: Record<string, string>;
2978
+ compositePrimaryKeys: Record<string, string>;
2979
+ }>>;
2980
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2981
+ }, "strict", import("zod").ZodTypeAny, {
2982
+ version: "5";
2983
+ dialect: "mysql";
2984
+ tables: Record<string, {
2985
+ schema?: string | undefined;
2986
+ name: string;
2987
+ columns: Record<string, {
2988
+ default?: any;
2989
+ onUpdate?: any;
2990
+ autoincrement?: boolean | undefined;
2991
+ name: string;
2992
+ type: string;
2993
+ primaryKey: boolean;
2994
+ notNull: boolean;
2995
+ }>;
2996
+ indexes: Record<string, string>;
2997
+ foreignKeys: Record<string, string>;
2998
+ compositePrimaryKeys: Record<string, string>;
2999
+ uniqueConstraints: Record<string, string>;
3000
+ }>;
3001
+ schemas: Record<string, string>;
3002
+ }, {
3003
+ version: "5";
3004
+ dialect: "mysql";
3005
+ tables: Record<string, {
3006
+ schema?: string | undefined;
3007
+ uniqueConstraints?: Record<string, string> | undefined;
3008
+ name: string;
3009
+ columns: Record<string, {
3010
+ default?: any;
3011
+ onUpdate?: any;
3012
+ autoincrement?: boolean | undefined;
3013
+ name: string;
3014
+ type: string;
3015
+ primaryKey: boolean;
3016
+ notNull: boolean;
3017
+ }>;
3018
+ indexes: Record<string, string>;
3019
+ foreignKeys: Record<string, string>;
3020
+ compositePrimaryKeys: Record<string, string>;
3021
+ }>;
3022
+ schemas: Record<string, string>;
3023
+ }>;
3024
+ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
3025
+ version: import("zod").ZodLiteral<"3">;
3026
+ dialect: import("zod").ZodLiteral<"mysql">;
3027
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3028
+ name: import("zod").ZodString;
3029
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3030
+ name: import("zod").ZodString;
3031
+ type: import("zod").ZodString;
3032
+ primaryKey: import("zod").ZodBoolean;
3033
+ notNull: import("zod").ZodBoolean;
3034
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
3035
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
3036
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
3037
+ }, "strict", import("zod").ZodTypeAny, {
3038
+ default?: any;
3039
+ onUpdate?: any;
3040
+ autoincrement?: boolean | undefined;
3041
+ name: string;
3042
+ type: string;
3043
+ primaryKey: boolean;
3044
+ notNull: boolean;
3045
+ }, {
3046
+ default?: any;
3047
+ onUpdate?: any;
3048
+ autoincrement?: boolean | undefined;
3049
+ name: string;
3050
+ type: string;
3051
+ primaryKey: boolean;
3052
+ notNull: boolean;
3053
+ }>>;
3054
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3055
+ name: import("zod").ZodString;
3056
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3057
+ isUnique: import("zod").ZodBoolean;
3058
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
3059
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
3060
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
3061
+ }, "strict", import("zod").ZodTypeAny, {
3062
+ using?: "btree" | "hash" | undefined;
3063
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3064
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3065
+ name: string;
3066
+ columns: string[];
3067
+ isUnique: boolean;
3068
+ }, {
3069
+ using?: "btree" | "hash" | undefined;
3070
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3071
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3072
+ name: string;
3073
+ columns: string[];
3074
+ isUnique: boolean;
3075
+ }>>;
3076
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3077
+ name: import("zod").ZodString;
3078
+ tableFrom: import("zod").ZodString;
3079
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
3080
+ tableTo: import("zod").ZodString;
3081
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
3082
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3083
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3084
+ }, "strict", import("zod").ZodTypeAny, {
3085
+ onUpdate?: string | undefined;
3086
+ onDelete?: string | undefined;
3087
+ name: string;
3088
+ tableFrom: string;
3089
+ columnsFrom: string[];
3090
+ tableTo: string;
3091
+ columnsTo: string[];
3092
+ }, {
3093
+ onUpdate?: string | undefined;
3094
+ onDelete?: string | undefined;
3095
+ name: string;
3096
+ tableFrom: string;
3097
+ columnsFrom: string[];
3098
+ tableTo: string;
3099
+ columnsTo: string[];
3100
+ }>>;
3101
+ }, "strict", import("zod").ZodTypeAny, {
3102
+ name: string;
3103
+ columns: Record<string, {
3104
+ default?: any;
3105
+ onUpdate?: any;
3106
+ autoincrement?: boolean | undefined;
3107
+ name: string;
3108
+ type: string;
3109
+ primaryKey: boolean;
3110
+ notNull: boolean;
3111
+ }>;
3112
+ indexes: Record<string, {
3113
+ using?: "btree" | "hash" | undefined;
3114
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3115
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3116
+ name: string;
3117
+ columns: string[];
3118
+ isUnique: boolean;
3119
+ }>;
3120
+ foreignKeys: Record<string, {
3121
+ onUpdate?: string | undefined;
3122
+ onDelete?: string | undefined;
3123
+ name: string;
3124
+ tableFrom: string;
3125
+ columnsFrom: string[];
3126
+ tableTo: string;
3127
+ columnsTo: string[];
3128
+ }>;
3129
+ }, {
3130
+ name: string;
3131
+ columns: Record<string, {
3132
+ default?: any;
3133
+ onUpdate?: any;
3134
+ autoincrement?: boolean | undefined;
3135
+ name: string;
3136
+ type: string;
3137
+ primaryKey: boolean;
3138
+ notNull: boolean;
3139
+ }>;
3140
+ indexes: Record<string, {
3141
+ using?: "btree" | "hash" | undefined;
3142
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3143
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3144
+ name: string;
3145
+ columns: string[];
3146
+ isUnique: boolean;
3147
+ }>;
3148
+ foreignKeys: Record<string, {
3149
+ onUpdate?: string | undefined;
3150
+ onDelete?: string | undefined;
3151
+ name: string;
3152
+ tableFrom: string;
3153
+ columnsFrom: string[];
3154
+ tableTo: string;
3155
+ columnsTo: string[];
3156
+ }>;
3157
+ }>>;
3158
+ }, {
3159
+ id: import("zod").ZodString;
3160
+ prevId: import("zod").ZodString;
3161
+ }>, "strip", import("zod").ZodTypeAny, {
3162
+ id: string;
3163
+ prevId: string;
3164
+ version: "3";
3165
+ dialect: "mysql";
3166
+ tables: Record<string, {
3167
+ name: string;
3168
+ columns: Record<string, {
3169
+ default?: any;
3170
+ onUpdate?: any;
3171
+ autoincrement?: boolean | undefined;
3172
+ name: string;
3173
+ type: string;
3174
+ primaryKey: boolean;
3175
+ notNull: boolean;
3176
+ }>;
3177
+ indexes: Record<string, {
3178
+ using?: "btree" | "hash" | undefined;
3179
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3180
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3181
+ name: string;
3182
+ columns: string[];
3183
+ isUnique: boolean;
3184
+ }>;
3185
+ foreignKeys: Record<string, {
3186
+ onUpdate?: string | undefined;
3187
+ onDelete?: string | undefined;
3188
+ name: string;
3189
+ tableFrom: string;
3190
+ columnsFrom: string[];
3191
+ tableTo: string;
3192
+ columnsTo: string[];
3193
+ }>;
3194
+ }>;
3195
+ }, {
3196
+ id: string;
3197
+ prevId: string;
3198
+ version: "3";
3199
+ dialect: "mysql";
3200
+ tables: Record<string, {
3201
+ name: string;
3202
+ columns: Record<string, {
3203
+ default?: any;
3204
+ onUpdate?: any;
3205
+ autoincrement?: boolean | undefined;
3206
+ name: string;
3207
+ type: string;
3208
+ primaryKey: boolean;
3209
+ notNull: boolean;
3210
+ }>;
3211
+ indexes: Record<string, {
3212
+ using?: "btree" | "hash" | undefined;
3213
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3214
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3215
+ name: string;
3216
+ columns: string[];
3217
+ isUnique: boolean;
3218
+ }>;
3219
+ foreignKeys: Record<string, {
3220
+ onUpdate?: string | undefined;
3221
+ onDelete?: string | undefined;
3222
+ name: string;
3223
+ tableFrom: string;
3224
+ columnsFrom: string[];
3225
+ tableTo: string;
3226
+ columnsTo: string[];
3227
+ }>;
3228
+ }>;
3229
+ }>, import("zod").ZodObject<import("zod").extendShape<{
3230
+ version: import("zod").ZodLiteral<"4">;
3231
+ dialect: import("zod").ZodLiteral<"mysql">;
3232
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3233
+ name: import("zod").ZodString;
3234
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
3235
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3236
+ name: import("zod").ZodString;
3237
+ type: import("zod").ZodString;
3238
+ primaryKey: import("zod").ZodBoolean;
3239
+ notNull: import("zod").ZodBoolean;
3240
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
3241
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
3242
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
3243
+ }, "strict", import("zod").ZodTypeAny, {
3244
+ default?: any;
3245
+ onUpdate?: any;
3246
+ autoincrement?: boolean | undefined;
3247
+ name: string;
3248
+ type: string;
3249
+ primaryKey: boolean;
3250
+ notNull: boolean;
3251
+ }, {
3252
+ default?: any;
3253
+ onUpdate?: any;
3254
+ autoincrement?: boolean | undefined;
3255
+ name: string;
3256
+ type: string;
3257
+ primaryKey: boolean;
3258
+ notNull: boolean;
3259
+ }>>;
3260
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3261
+ name: import("zod").ZodString;
3262
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3263
+ isUnique: import("zod").ZodBoolean;
3264
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
3265
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
3266
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
3267
+ }, "strict", import("zod").ZodTypeAny, {
3268
+ using?: "btree" | "hash" | undefined;
3269
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3270
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3271
+ name: string;
3272
+ columns: string[];
3273
+ isUnique: boolean;
3274
+ }, {
3275
+ using?: "btree" | "hash" | undefined;
3276
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3277
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3278
+ name: string;
3279
+ columns: string[];
3280
+ isUnique: boolean;
3281
+ }>>;
3282
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3283
+ name: import("zod").ZodString;
3284
+ tableFrom: import("zod").ZodString;
3285
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
3286
+ tableTo: import("zod").ZodString;
3287
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
3288
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3289
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3290
+ }, "strict", import("zod").ZodTypeAny, {
3291
+ onUpdate?: string | undefined;
3292
+ onDelete?: string | undefined;
3293
+ name: string;
3294
+ tableFrom: string;
3295
+ columnsFrom: string[];
3296
+ tableTo: string;
3297
+ columnsTo: string[];
3298
+ }, {
3299
+ onUpdate?: string | undefined;
3300
+ onDelete?: string | undefined;
3301
+ name: string;
3302
+ tableFrom: string;
3303
+ columnsFrom: string[];
3304
+ tableTo: string;
3305
+ columnsTo: string[];
3306
+ }>>;
3307
+ }, "strict", import("zod").ZodTypeAny, {
3308
+ schema?: string | undefined;
3309
+ name: string;
3310
+ columns: Record<string, {
3311
+ default?: any;
3312
+ onUpdate?: any;
3313
+ autoincrement?: boolean | undefined;
3314
+ name: string;
3315
+ type: string;
3316
+ primaryKey: boolean;
3317
+ notNull: boolean;
3318
+ }>;
3319
+ indexes: Record<string, {
3320
+ using?: "btree" | "hash" | undefined;
3321
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3322
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3323
+ name: string;
3324
+ columns: string[];
3325
+ isUnique: boolean;
3326
+ }>;
3327
+ foreignKeys: Record<string, {
3328
+ onUpdate?: string | undefined;
3329
+ onDelete?: string | undefined;
3330
+ name: string;
3331
+ tableFrom: string;
3332
+ columnsFrom: string[];
3333
+ tableTo: string;
3334
+ columnsTo: string[];
3335
+ }>;
3336
+ }, {
3337
+ schema?: string | undefined;
3338
+ name: string;
3339
+ columns: Record<string, {
3340
+ default?: any;
3341
+ onUpdate?: any;
3342
+ autoincrement?: boolean | undefined;
3343
+ name: string;
3344
+ type: string;
3345
+ primaryKey: boolean;
3346
+ notNull: boolean;
3347
+ }>;
3348
+ indexes: Record<string, {
3349
+ using?: "btree" | "hash" | undefined;
3350
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3351
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3352
+ name: string;
3353
+ columns: string[];
3354
+ isUnique: boolean;
3355
+ }>;
3356
+ foreignKeys: Record<string, {
3357
+ onUpdate?: string | undefined;
3358
+ onDelete?: string | undefined;
3359
+ name: string;
3360
+ tableFrom: string;
3361
+ columnsFrom: string[];
3362
+ tableTo: string;
3363
+ columnsTo: string[];
3364
+ }>;
3365
+ }>>;
3366
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3367
+ }, {
3368
+ id: import("zod").ZodString;
3369
+ prevId: import("zod").ZodString;
3370
+ }>, "strip", import("zod").ZodTypeAny, {
3371
+ id: string;
3372
+ prevId: string;
3373
+ version: "4";
3374
+ dialect: "mysql";
3375
+ tables: Record<string, {
3376
+ schema?: string | undefined;
3377
+ name: string;
3378
+ columns: Record<string, {
3379
+ default?: any;
3380
+ onUpdate?: any;
3381
+ autoincrement?: boolean | undefined;
3382
+ name: string;
3383
+ type: string;
3384
+ primaryKey: boolean;
3385
+ notNull: boolean;
3386
+ }>;
3387
+ indexes: Record<string, {
3388
+ using?: "btree" | "hash" | undefined;
3389
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3390
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3391
+ name: string;
3392
+ columns: string[];
3393
+ isUnique: boolean;
3394
+ }>;
3395
+ foreignKeys: Record<string, {
3396
+ onUpdate?: string | undefined;
3397
+ onDelete?: string | undefined;
3398
+ name: string;
3399
+ tableFrom: string;
3400
+ columnsFrom: string[];
3401
+ tableTo: string;
3402
+ columnsTo: string[];
3403
+ }>;
3404
+ }>;
3405
+ schemas: Record<string, string>;
3406
+ }, {
3407
+ id: string;
3408
+ prevId: string;
3409
+ version: "4";
3410
+ dialect: "mysql";
3411
+ tables: Record<string, {
3412
+ schema?: string | undefined;
3413
+ name: string;
3414
+ columns: Record<string, {
3415
+ default?: any;
3416
+ onUpdate?: any;
3417
+ autoincrement?: boolean | undefined;
3418
+ name: string;
3419
+ type: string;
3420
+ primaryKey: boolean;
3421
+ notNull: boolean;
3422
+ }>;
3423
+ indexes: Record<string, {
3424
+ using?: "btree" | "hash" | undefined;
3425
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3426
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3427
+ name: string;
3428
+ columns: string[];
3429
+ isUnique: boolean;
3430
+ }>;
3431
+ foreignKeys: Record<string, {
3432
+ onUpdate?: string | undefined;
3433
+ onDelete?: string | undefined;
3434
+ name: string;
3435
+ tableFrom: string;
3436
+ columnsFrom: string[];
3437
+ tableTo: string;
3438
+ columnsTo: string[];
3439
+ }>;
3440
+ }>;
3441
+ schemas: Record<string, string>;
3442
+ }>, import("zod").ZodObject<import("zod").extendShape<{
3443
+ version: import("zod").ZodLiteral<"5">;
3444
+ dialect: import("zod").ZodLiteral<"mysql">;
3445
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3446
+ name: import("zod").ZodString;
3447
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
3448
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3449
+ name: import("zod").ZodString;
3450
+ type: import("zod").ZodString;
3451
+ primaryKey: import("zod").ZodBoolean;
3452
+ notNull: import("zod").ZodBoolean;
3453
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
3454
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
3455
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
3456
+ }, "strict", import("zod").ZodTypeAny, {
3457
+ default?: any;
3458
+ onUpdate?: any;
3459
+ autoincrement?: boolean | undefined;
3460
+ name: string;
3461
+ type: string;
3462
+ primaryKey: boolean;
3463
+ notNull: boolean;
3464
+ }, {
3465
+ default?: any;
3466
+ onUpdate?: any;
3467
+ autoincrement?: boolean | undefined;
3468
+ name: string;
3469
+ type: string;
3470
+ primaryKey: boolean;
3471
+ notNull: boolean;
3472
+ }>>;
3473
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3474
+ name: import("zod").ZodString;
3475
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3476
+ isUnique: import("zod").ZodBoolean;
3477
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
3478
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
3479
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
3480
+ }, "strict", import("zod").ZodTypeAny, {
3481
+ using?: "btree" | "hash" | undefined;
3482
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3483
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3484
+ name: string;
3485
+ columns: string[];
3486
+ isUnique: boolean;
3487
+ }, {
3488
+ using?: "btree" | "hash" | undefined;
3489
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3490
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3491
+ name: string;
3492
+ columns: string[];
3493
+ isUnique: boolean;
3494
+ }>>;
3495
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3496
+ name: import("zod").ZodString;
3497
+ tableFrom: import("zod").ZodString;
3498
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
3499
+ tableTo: import("zod").ZodString;
3500
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
3501
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3502
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3503
+ }, "strict", import("zod").ZodTypeAny, {
3504
+ onUpdate?: string | undefined;
3505
+ onDelete?: string | undefined;
3506
+ name: string;
3507
+ tableFrom: string;
3508
+ columnsFrom: string[];
3509
+ tableTo: string;
3510
+ columnsTo: string[];
3511
+ }, {
3512
+ onUpdate?: string | undefined;
3513
+ onDelete?: string | undefined;
3514
+ name: string;
3515
+ tableFrom: string;
3516
+ columnsFrom: string[];
3517
+ tableTo: string;
3518
+ columnsTo: string[];
3519
+ }>>;
3520
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3521
+ name: import("zod").ZodString;
3522
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3523
+ }, "strict", import("zod").ZodTypeAny, {
3524
+ name: string;
3525
+ columns: string[];
3526
+ }, {
3527
+ name: string;
3528
+ columns: string[];
3529
+ }>>;
3530
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3531
+ name: import("zod").ZodString;
3532
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3533
+ }, "strict", import("zod").ZodTypeAny, {
3534
+ name: string;
3535
+ columns: string[];
3536
+ }, {
3537
+ name: string;
3538
+ columns: string[];
3539
+ }>>>;
3540
+ }, "strict", import("zod").ZodTypeAny, {
3541
+ schema?: string | undefined;
3542
+ name: string;
3543
+ columns: Record<string, {
3544
+ default?: any;
3545
+ onUpdate?: any;
3546
+ autoincrement?: boolean | undefined;
3547
+ name: string;
3548
+ type: string;
3549
+ primaryKey: boolean;
3550
+ notNull: boolean;
3551
+ }>;
3552
+ indexes: Record<string, {
3553
+ using?: "btree" | "hash" | undefined;
3554
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3555
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3556
+ name: string;
3557
+ columns: string[];
3558
+ isUnique: boolean;
3559
+ }>;
3560
+ foreignKeys: Record<string, {
3561
+ onUpdate?: string | undefined;
3562
+ onDelete?: string | undefined;
3563
+ name: string;
3564
+ tableFrom: string;
3565
+ columnsFrom: string[];
3566
+ tableTo: string;
3567
+ columnsTo: string[];
3568
+ }>;
3569
+ compositePrimaryKeys: Record<string, {
3570
+ name: string;
3571
+ columns: string[];
3572
+ }>;
3573
+ uniqueConstraints: Record<string, {
3574
+ name: string;
3575
+ columns: string[];
3576
+ }>;
3577
+ }, {
3578
+ schema?: string | undefined;
3579
+ uniqueConstraints?: Record<string, {
3580
+ name: string;
3581
+ columns: string[];
3582
+ }> | undefined;
3583
+ name: string;
3584
+ columns: Record<string, {
3585
+ default?: any;
3586
+ onUpdate?: any;
3587
+ autoincrement?: boolean | undefined;
3588
+ name: string;
3589
+ type: string;
3590
+ primaryKey: boolean;
3591
+ notNull: boolean;
3592
+ }>;
3593
+ indexes: Record<string, {
3594
+ using?: "btree" | "hash" | undefined;
3595
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3596
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3597
+ name: string;
3598
+ columns: string[];
3599
+ isUnique: boolean;
3600
+ }>;
3601
+ foreignKeys: Record<string, {
3602
+ onUpdate?: string | undefined;
3603
+ onDelete?: string | undefined;
3604
+ name: string;
3605
+ tableFrom: string;
3606
+ columnsFrom: string[];
3607
+ tableTo: string;
3608
+ columnsTo: string[];
3609
+ }>;
3610
+ compositePrimaryKeys: Record<string, {
3611
+ name: string;
3612
+ columns: string[];
3613
+ }>;
3614
+ }>>;
3615
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3616
+ _meta: import("zod").ZodObject<{
3617
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3618
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3619
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3620
+ }, "strip", import("zod").ZodTypeAny, {
3621
+ columns: Record<string, string>;
3622
+ tables: Record<string, string>;
3623
+ schemas: Record<string, string>;
3624
+ }, {
3625
+ columns: Record<string, string>;
3626
+ tables: Record<string, string>;
3627
+ schemas: Record<string, string>;
3628
+ }>;
3629
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
3630
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
3631
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
3632
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
3633
+ }, "strip", import("zod").ZodTypeAny, {
3634
+ isDefaultAnExpression?: boolean | undefined;
3635
+ }, {
3636
+ isDefaultAnExpression?: boolean | undefined;
3637
+ }>>>;
3638
+ }, "strip", import("zod").ZodTypeAny, {
3639
+ columns: Record<string, {
3640
+ isDefaultAnExpression?: boolean | undefined;
3641
+ } | undefined>;
3642
+ }, {
3643
+ columns: Record<string, {
3644
+ isDefaultAnExpression?: boolean | undefined;
3645
+ } | undefined>;
3646
+ }>>>;
3647
+ }, "strip", import("zod").ZodTypeAny, {
3648
+ tables: Record<string, {
3649
+ columns: Record<string, {
3650
+ isDefaultAnExpression?: boolean | undefined;
3651
+ } | undefined>;
3652
+ } | undefined>;
3653
+ }, {
3654
+ tables: Record<string, {
3655
+ columns: Record<string, {
3656
+ isDefaultAnExpression?: boolean | undefined;
3657
+ } | undefined>;
3658
+ } | undefined>;
3659
+ }>>;
3660
+ }, {
3661
+ id: import("zod").ZodString;
3662
+ prevId: import("zod").ZodString;
3663
+ }>, "strip", import("zod").ZodTypeAny, {
3664
+ internal?: {
3665
+ tables: Record<string, {
3666
+ columns: Record<string, {
3667
+ isDefaultAnExpression?: boolean | undefined;
3668
+ } | undefined>;
3669
+ } | undefined>;
3670
+ } | undefined;
3671
+ id: string;
3672
+ prevId: string;
3673
+ version: "5";
3674
+ dialect: "mysql";
3675
+ tables: Record<string, {
3676
+ schema?: string | undefined;
3677
+ name: string;
3678
+ columns: Record<string, {
3679
+ default?: any;
3680
+ onUpdate?: any;
3681
+ autoincrement?: boolean | undefined;
3682
+ name: string;
3683
+ type: string;
3684
+ primaryKey: boolean;
3685
+ notNull: boolean;
3686
+ }>;
3687
+ indexes: Record<string, {
3688
+ using?: "btree" | "hash" | undefined;
3689
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3690
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3691
+ name: string;
3692
+ columns: string[];
3693
+ isUnique: boolean;
3694
+ }>;
3695
+ foreignKeys: Record<string, {
3696
+ onUpdate?: string | undefined;
3697
+ onDelete?: string | undefined;
3698
+ name: string;
3699
+ tableFrom: string;
3700
+ columnsFrom: string[];
3701
+ tableTo: string;
3702
+ columnsTo: string[];
3703
+ }>;
3704
+ compositePrimaryKeys: Record<string, {
3705
+ name: string;
3706
+ columns: string[];
3707
+ }>;
3708
+ uniqueConstraints: Record<string, {
3709
+ name: string;
3710
+ columns: string[];
3711
+ }>;
3712
+ }>;
3713
+ schemas: Record<string, string>;
3714
+ _meta: {
3715
+ columns: Record<string, string>;
3716
+ tables: Record<string, string>;
3717
+ schemas: Record<string, string>;
3718
+ };
3719
+ }, {
3720
+ internal?: {
3721
+ tables: Record<string, {
3722
+ columns: Record<string, {
3723
+ isDefaultAnExpression?: boolean | undefined;
3724
+ } | undefined>;
3725
+ } | undefined>;
3726
+ } | undefined;
3727
+ id: string;
3728
+ prevId: string;
3729
+ version: "5";
3730
+ dialect: "mysql";
3731
+ tables: Record<string, {
3732
+ schema?: string | undefined;
3733
+ uniqueConstraints?: Record<string, {
3734
+ name: string;
3735
+ columns: string[];
3736
+ }> | undefined;
3737
+ name: string;
3738
+ columns: Record<string, {
3739
+ default?: any;
3740
+ onUpdate?: any;
3741
+ autoincrement?: boolean | undefined;
3742
+ name: string;
3743
+ type: string;
3744
+ primaryKey: boolean;
3745
+ notNull: boolean;
3746
+ }>;
3747
+ indexes: Record<string, {
3748
+ using?: "btree" | "hash" | undefined;
3749
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3750
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3751
+ name: string;
3752
+ columns: string[];
3753
+ isUnique: boolean;
3754
+ }>;
3755
+ foreignKeys: Record<string, {
3756
+ onUpdate?: string | undefined;
3757
+ onDelete?: string | undefined;
3758
+ name: string;
3759
+ tableFrom: string;
3760
+ columnsFrom: string[];
3761
+ tableTo: string;
3762
+ columnsTo: string[];
3763
+ }>;
3764
+ compositePrimaryKeys: Record<string, {
3765
+ name: string;
3766
+ columns: string[];
3767
+ }>;
3768
+ }>;
3769
+ schemas: Record<string, string>;
3770
+ _meta: {
3771
+ columns: Record<string, string>;
3772
+ tables: Record<string, string>;
3773
+ schemas: Record<string, string>;
3774
+ };
3775
+ }>]>;
3776
+ export declare const dryMySql: {
3777
+ internal?: {
3778
+ tables: Record<string, {
3779
+ columns: Record<string, {
3780
+ isDefaultAnExpression?: boolean | undefined;
3781
+ } | undefined>;
3782
+ } | undefined>;
3783
+ } | undefined;
3784
+ id: string;
3785
+ prevId: string;
3786
+ version: "5";
3787
+ dialect: "mysql";
3788
+ tables: Record<string, {
3789
+ schema?: string | undefined;
3790
+ name: string;
3791
+ columns: Record<string, {
3792
+ default?: any;
3793
+ onUpdate?: any;
3794
+ autoincrement?: boolean | undefined;
3795
+ name: string;
3796
+ type: string;
3797
+ primaryKey: boolean;
3798
+ notNull: boolean;
3799
+ }>;
3800
+ indexes: Record<string, {
3801
+ using?: "btree" | "hash" | undefined;
3802
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3803
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3804
+ name: string;
3805
+ columns: string[];
3806
+ isUnique: boolean;
3807
+ }>;
3808
+ foreignKeys: Record<string, {
3809
+ onUpdate?: string | undefined;
3810
+ onDelete?: string | undefined;
3811
+ name: string;
3812
+ tableFrom: string;
3813
+ columnsFrom: string[];
3814
+ tableTo: string;
3815
+ columnsTo: string[];
3816
+ }>;
3817
+ compositePrimaryKeys: Record<string, {
3818
+ name: string;
3819
+ columns: string[];
3820
+ }>;
3821
+ uniqueConstraints: Record<string, {
3822
+ name: string;
3823
+ columns: string[];
3824
+ }>;
3825
+ }>;
3826
+ schemas: Record<string, string>;
3827
+ _meta: {
3828
+ columns: Record<string, string>;
3829
+ tables: Record<string, string>;
3830
+ schemas: Record<string, string>;
3831
+ };
3832
+ };
3833
+ export {};