drizzle-kit 0.20.17-cab52ad → 0.20.17-d71f2ee

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