drizzle-kit 0.20.17-a2979a1 → 0.20.17-ab24478

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