drizzle-kit 0.20.18 → 0.21.0-57cc2fe

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