drizzle-kit 0.20.17-c057923 → 0.20.17-c50cacb

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 +24347 -16460
  2. package/index.d.mts +28 -14
  3. package/index.d.ts +28 -14
  4. package/package.json +5 -16
  5. package/payload.d.mts +987 -18
  6. package/payload.d.ts +987 -18
  7. package/payload.js +19792 -16880
  8. package/payload.mjs +19830 -16893
  9. package/utils-studio.js +949 -835
  10. package/utils-studio.mjs +922 -808
  11. package/utils.js +842 -214
  12. package/utils.mjs +817 -189
  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 -41
  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 -3936
  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
- using?: "btree" | "hash" | undefined;
11
- algorithm?: "default" | "inplace" | "copy" | undefined;
12
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
13
- name: string;
14
- columns: string[];
15
- isUnique: boolean;
16
- }, {
17
- using?: "btree" | "hash" | undefined;
18
- algorithm?: "default" | "inplace" | "copy" | undefined;
19
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
20
- name: string;
21
- columns: string[];
22
- isUnique: boolean;
23
- }>;
24
- declare const fk: import("zod").ZodObject<{
25
- name: import("zod").ZodString;
26
- tableFrom: import("zod").ZodString;
27
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
28
- tableTo: import("zod").ZodString;
29
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
30
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
31
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
32
- }, "strict", import("zod").ZodTypeAny, {
33
- onUpdate?: string | undefined;
34
- onDelete?: string | undefined;
35
- name: string;
36
- tableFrom: string;
37
- columnsFrom: string[];
38
- tableTo: string;
39
- columnsTo: string[];
40
- }, {
41
- onUpdate?: string | undefined;
42
- onDelete?: string | undefined;
43
- name: string;
44
- tableFrom: string;
45
- columnsFrom: string[];
46
- tableTo: string;
47
- columnsTo: string[];
48
- }>;
49
- declare const column: import("zod").ZodObject<{
50
- name: import("zod").ZodString;
51
- type: import("zod").ZodString;
52
- primaryKey: import("zod").ZodBoolean;
53
- notNull: import("zod").ZodBoolean;
54
- autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
55
- default: import("zod").ZodOptional<import("zod").ZodAny>;
56
- onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
57
- }, "strict", import("zod").ZodTypeAny, {
58
- default?: any;
59
- onUpdate?: any;
60
- autoincrement?: boolean | undefined;
61
- name: string;
62
- type: string;
63
- primaryKey: boolean;
64
- notNull: boolean;
65
- }, {
66
- default?: any;
67
- onUpdate?: any;
68
- autoincrement?: boolean | undefined;
69
- name: string;
70
- type: string;
71
- primaryKey: boolean;
72
- notNull: boolean;
73
- }>;
74
- declare const compositePK: import("zod").ZodObject<{
75
- name: import("zod").ZodString;
76
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
77
- }, "strict", import("zod").ZodTypeAny, {
78
- name: string;
79
- columns: string[];
80
- }, {
81
- name: string;
82
- columns: string[];
83
- }>;
84
- declare const uniqueConstraint: import("zod").ZodObject<{
85
- name: import("zod").ZodString;
86
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
87
- }, "strict", import("zod").ZodTypeAny, {
88
- name: string;
89
- columns: string[];
90
- }, {
91
- name: string;
92
- columns: string[];
93
- }>;
94
- declare const tableV4: import("zod").ZodObject<{
95
- name: import("zod").ZodString;
96
- schema: import("zod").ZodOptional<import("zod").ZodString>;
97
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
98
- name: import("zod").ZodString;
99
- type: import("zod").ZodString;
100
- primaryKey: import("zod").ZodBoolean;
101
- notNull: import("zod").ZodBoolean;
102
- autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
103
- default: import("zod").ZodOptional<import("zod").ZodAny>;
104
- onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
105
- }, "strict", import("zod").ZodTypeAny, {
106
- default?: any;
107
- onUpdate?: any;
108
- autoincrement?: boolean | undefined;
109
- name: string;
110
- type: string;
111
- primaryKey: boolean;
112
- notNull: boolean;
113
- }, {
114
- default?: any;
115
- onUpdate?: any;
116
- autoincrement?: boolean | undefined;
117
- name: string;
118
- type: string;
119
- primaryKey: boolean;
120
- notNull: boolean;
121
- }>>;
122
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
123
- name: import("zod").ZodString;
124
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
125
- isUnique: import("zod").ZodBoolean;
126
- using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
127
- algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
128
- lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
129
- }, "strict", import("zod").ZodTypeAny, {
130
- using?: "btree" | "hash" | undefined;
131
- algorithm?: "default" | "inplace" | "copy" | undefined;
132
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
133
- name: string;
134
- columns: string[];
135
- isUnique: boolean;
136
- }, {
137
- using?: "btree" | "hash" | undefined;
138
- algorithm?: "default" | "inplace" | "copy" | undefined;
139
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
140
- name: string;
141
- columns: string[];
142
- isUnique: boolean;
143
- }>>;
144
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
145
- name: import("zod").ZodString;
146
- tableFrom: import("zod").ZodString;
147
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
148
- tableTo: import("zod").ZodString;
149
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
150
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
151
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
152
- }, "strict", import("zod").ZodTypeAny, {
153
- onUpdate?: string | undefined;
154
- onDelete?: string | undefined;
155
- name: string;
156
- tableFrom: string;
157
- columnsFrom: string[];
158
- tableTo: string;
159
- columnsTo: string[];
160
- }, {
161
- onUpdate?: string | undefined;
162
- onDelete?: string | undefined;
163
- name: string;
164
- tableFrom: string;
165
- columnsFrom: string[];
166
- tableTo: string;
167
- columnsTo: string[];
168
- }>>;
169
- }, "strict", import("zod").ZodTypeAny, {
170
- schema?: string | undefined;
171
- name: string;
172
- columns: Record<string, {
173
- default?: any;
174
- onUpdate?: any;
175
- autoincrement?: boolean | undefined;
176
- name: string;
177
- type: string;
178
- primaryKey: boolean;
179
- notNull: boolean;
180
- }>;
181
- indexes: Record<string, {
182
- using?: "btree" | "hash" | undefined;
183
- algorithm?: "default" | "inplace" | "copy" | undefined;
184
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
185
- name: string;
186
- columns: string[];
187
- isUnique: boolean;
188
- }>;
189
- foreignKeys: Record<string, {
190
- onUpdate?: string | undefined;
191
- onDelete?: string | undefined;
192
- name: string;
193
- tableFrom: string;
194
- columnsFrom: string[];
195
- tableTo: string;
196
- columnsTo: string[];
197
- }>;
198
- }, {
199
- schema?: string | undefined;
200
- name: string;
201
- columns: Record<string, {
202
- default?: any;
203
- onUpdate?: any;
204
- autoincrement?: boolean | undefined;
205
- name: string;
206
- type: string;
207
- primaryKey: boolean;
208
- notNull: boolean;
209
- }>;
210
- indexes: Record<string, {
211
- using?: "btree" | "hash" | undefined;
212
- algorithm?: "default" | "inplace" | "copy" | undefined;
213
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
214
- name: string;
215
- columns: string[];
216
- isUnique: boolean;
217
- }>;
218
- foreignKeys: Record<string, {
219
- onUpdate?: string | undefined;
220
- onDelete?: string | undefined;
221
- name: string;
222
- tableFrom: string;
223
- columnsFrom: string[];
224
- tableTo: string;
225
- columnsTo: string[];
226
- }>;
227
- }>;
228
- declare const table: import("zod").ZodObject<{
229
- name: import("zod").ZodString;
230
- 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
- default?: any;
240
- onUpdate?: any;
241
- autoincrement?: boolean | undefined;
242
- name: string;
243
- type: string;
244
- primaryKey: boolean;
245
- notNull: boolean;
246
- }, {
247
- default?: any;
248
- onUpdate?: any;
249
- autoincrement?: boolean | undefined;
250
- name: string;
251
- type: string;
252
- primaryKey: boolean;
253
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
264
- algorithm?: "default" | "inplace" | "copy" | undefined;
265
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
266
- name: string;
267
- columns: string[];
268
- isUnique: boolean;
269
- }, {
270
- using?: "btree" | "hash" | undefined;
271
- algorithm?: "default" | "inplace" | "copy" | undefined;
272
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
273
- name: string;
274
- columns: string[];
275
- isUnique: boolean;
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
- onUpdate?: string | undefined;
287
- onDelete?: string | undefined;
288
- name: string;
289
- tableFrom: string;
290
- columnsFrom: string[];
291
- tableTo: string;
292
- columnsTo: string[];
293
- }, {
294
- onUpdate?: string | undefined;
295
- onDelete?: string | undefined;
296
- name: string;
297
- tableFrom: string;
298
- columnsFrom: string[];
299
- tableTo: string;
300
- columnsTo: string[];
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
- default?: any;
326
- onUpdate?: any;
327
- autoincrement?: boolean | undefined;
328
- name: string;
329
- type: string;
330
- primaryKey: boolean;
331
- notNull: boolean;
332
- }>;
333
- indexes: Record<string, {
334
- using?: "btree" | "hash" | undefined;
335
- algorithm?: "default" | "inplace" | "copy" | undefined;
336
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
337
- name: string;
338
- columns: string[];
339
- isUnique: boolean;
340
- }>;
341
- foreignKeys: Record<string, {
342
- onUpdate?: string | undefined;
343
- onDelete?: string | undefined;
344
- name: string;
345
- tableFrom: string;
346
- columnsFrom: string[];
347
- tableTo: string;
348
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
360
- name: string;
361
- columns: string[];
362
- }> | undefined;
363
- name: string;
364
- columns: Record<string, {
365
- default?: any;
366
- onUpdate?: any;
367
- autoincrement?: boolean | undefined;
368
- name: string;
369
- type: string;
370
- primaryKey: boolean;
371
- notNull: boolean;
372
- }>;
373
- indexes: Record<string, {
374
- using?: "btree" | "hash" | undefined;
375
- algorithm?: "default" | "inplace" | "copy" | undefined;
376
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
377
- name: string;
378
- columns: string[];
379
- isUnique: boolean;
380
- }>;
381
- foreignKeys: Record<string, {
382
- onUpdate?: string | undefined;
383
- onDelete?: string | undefined;
384
- name: string;
385
- tableFrom: string;
386
- columnsFrom: string[];
387
- tableTo: string;
388
- columnsTo: string[];
389
- }>;
390
- compositePrimaryKeys: Record<string, {
391
- name: string;
392
- columns: string[];
393
- }>;
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
- default?: any;
442
- onUpdate?: any;
443
- autoincrement?: boolean | undefined;
444
- name: string;
445
- type: string;
446
- primaryKey: boolean;
447
- notNull: boolean;
448
- }, {
449
- default?: any;
450
- onUpdate?: any;
451
- autoincrement?: boolean | undefined;
452
- name: string;
453
- type: string;
454
- primaryKey: boolean;
455
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
466
- algorithm?: "default" | "inplace" | "copy" | undefined;
467
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
468
- name: string;
469
- columns: string[];
470
- isUnique: boolean;
471
- }, {
472
- using?: "btree" | "hash" | undefined;
473
- algorithm?: "default" | "inplace" | "copy" | undefined;
474
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
475
- name: string;
476
- columns: string[];
477
- isUnique: boolean;
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
- onUpdate?: string | undefined;
489
- onDelete?: string | undefined;
490
- name: string;
491
- tableFrom: string;
492
- columnsFrom: string[];
493
- tableTo: string;
494
- columnsTo: string[];
495
- }, {
496
- onUpdate?: string | undefined;
497
- onDelete?: string | undefined;
498
- name: string;
499
- tableFrom: string;
500
- columnsFrom: string[];
501
- tableTo: string;
502
- columnsTo: string[];
503
- }>>;
504
- }, "strict", import("zod").ZodTypeAny, {
505
- name: string;
506
- columns: Record<string, {
507
- default?: any;
508
- onUpdate?: any;
509
- autoincrement?: boolean | undefined;
510
- name: string;
511
- type: string;
512
- primaryKey: boolean;
513
- notNull: boolean;
514
- }>;
515
- indexes: Record<string, {
516
- using?: "btree" | "hash" | undefined;
517
- algorithm?: "default" | "inplace" | "copy" | undefined;
518
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
519
- name: string;
520
- columns: string[];
521
- isUnique: boolean;
522
- }>;
523
- foreignKeys: Record<string, {
524
- onUpdate?: string | undefined;
525
- onDelete?: string | undefined;
526
- name: string;
527
- tableFrom: string;
528
- columnsFrom: string[];
529
- tableTo: string;
530
- columnsTo: string[];
531
- }>;
532
- }, {
533
- name: string;
534
- columns: Record<string, {
535
- default?: any;
536
- onUpdate?: any;
537
- autoincrement?: boolean | undefined;
538
- name: string;
539
- type: string;
540
- primaryKey: boolean;
541
- notNull: boolean;
542
- }>;
543
- indexes: Record<string, {
544
- using?: "btree" | "hash" | undefined;
545
- algorithm?: "default" | "inplace" | "copy" | undefined;
546
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
547
- name: string;
548
- columns: string[];
549
- isUnique: boolean;
550
- }>;
551
- foreignKeys: Record<string, {
552
- onUpdate?: string | undefined;
553
- onDelete?: string | undefined;
554
- name: string;
555
- tableFrom: string;
556
- columnsFrom: string[];
557
- tableTo: string;
558
- columnsTo: string[];
559
- }>;
560
- }>>;
561
- }, "strict", import("zod").ZodTypeAny, {
562
- tables: Record<string, {
563
- name: string;
564
- columns: Record<string, {
565
- default?: any;
566
- onUpdate?: any;
567
- autoincrement?: boolean | undefined;
568
- name: string;
569
- type: string;
570
- primaryKey: boolean;
571
- notNull: boolean;
572
- }>;
573
- indexes: Record<string, {
574
- using?: "btree" | "hash" | undefined;
575
- algorithm?: "default" | "inplace" | "copy" | undefined;
576
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
577
- name: string;
578
- columns: string[];
579
- isUnique: boolean;
580
- }>;
581
- foreignKeys: Record<string, {
582
- onUpdate?: string | undefined;
583
- onDelete?: string | undefined;
584
- name: string;
585
- tableFrom: string;
586
- columnsFrom: string[];
587
- tableTo: string;
588
- columnsTo: string[];
589
- }>;
590
- }>;
591
- version: "3";
592
- dialect: "mysql";
593
- }, {
594
- tables: Record<string, {
595
- name: string;
596
- columns: Record<string, {
597
- default?: any;
598
- onUpdate?: any;
599
- autoincrement?: boolean | undefined;
600
- name: string;
601
- type: string;
602
- primaryKey: boolean;
603
- notNull: boolean;
604
- }>;
605
- indexes: Record<string, {
606
- using?: "btree" | "hash" | undefined;
607
- algorithm?: "default" | "inplace" | "copy" | undefined;
608
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
609
- name: string;
610
- columns: string[];
611
- isUnique: boolean;
612
- }>;
613
- foreignKeys: Record<string, {
614
- onUpdate?: string | undefined;
615
- onDelete?: string | undefined;
616
- name: string;
617
- tableFrom: string;
618
- columnsFrom: string[];
619
- tableTo: string;
620
- columnsTo: string[];
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
- default?: any;
642
- onUpdate?: any;
643
- autoincrement?: boolean | undefined;
644
- name: string;
645
- type: string;
646
- primaryKey: boolean;
647
- notNull: boolean;
648
- }, {
649
- default?: any;
650
- onUpdate?: any;
651
- autoincrement?: boolean | undefined;
652
- name: string;
653
- type: string;
654
- primaryKey: boolean;
655
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
666
- algorithm?: "default" | "inplace" | "copy" | undefined;
667
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
668
- name: string;
669
- columns: string[];
670
- isUnique: boolean;
671
- }, {
672
- using?: "btree" | "hash" | undefined;
673
- algorithm?: "default" | "inplace" | "copy" | undefined;
674
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
675
- name: string;
676
- columns: string[];
677
- isUnique: boolean;
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
- onUpdate?: string | undefined;
689
- onDelete?: string | undefined;
690
- name: string;
691
- tableFrom: string;
692
- columnsFrom: string[];
693
- tableTo: string;
694
- columnsTo: string[];
695
- }, {
696
- onUpdate?: string | undefined;
697
- onDelete?: string | undefined;
698
- name: string;
699
- tableFrom: string;
700
- columnsFrom: string[];
701
- tableTo: string;
702
- columnsTo: string[];
703
- }>>;
704
- }, "strict", import("zod").ZodTypeAny, {
705
- schema?: string | undefined;
706
- name: string;
707
- columns: Record<string, {
708
- default?: any;
709
- onUpdate?: any;
710
- autoincrement?: boolean | undefined;
711
- name: string;
712
- type: string;
713
- primaryKey: boolean;
714
- notNull: boolean;
715
- }>;
716
- indexes: Record<string, {
717
- using?: "btree" | "hash" | undefined;
718
- algorithm?: "default" | "inplace" | "copy" | undefined;
719
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
720
- name: string;
721
- columns: string[];
722
- isUnique: boolean;
723
- }>;
724
- foreignKeys: Record<string, {
725
- onUpdate?: string | undefined;
726
- onDelete?: string | undefined;
727
- name: string;
728
- tableFrom: string;
729
- columnsFrom: string[];
730
- tableTo: string;
731
- columnsTo: string[];
732
- }>;
733
- }, {
734
- schema?: string | undefined;
735
- name: string;
736
- columns: Record<string, {
737
- default?: any;
738
- onUpdate?: any;
739
- autoincrement?: boolean | undefined;
740
- name: string;
741
- type: string;
742
- primaryKey: boolean;
743
- notNull: boolean;
744
- }>;
745
- indexes: Record<string, {
746
- using?: "btree" | "hash" | undefined;
747
- algorithm?: "default" | "inplace" | "copy" | undefined;
748
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
749
- name: string;
750
- columns: string[];
751
- isUnique: boolean;
752
- }>;
753
- foreignKeys: Record<string, {
754
- onUpdate?: string | undefined;
755
- onDelete?: string | undefined;
756
- name: string;
757
- tableFrom: string;
758
- columnsFrom: string[];
759
- tableTo: string;
760
- columnsTo: string[];
761
- }>;
762
- }>>;
763
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
764
- }, "strict", import("zod").ZodTypeAny, {
765
- tables: Record<string, {
766
- schema?: string | undefined;
767
- name: string;
768
- columns: Record<string, {
769
- default?: any;
770
- onUpdate?: any;
771
- autoincrement?: boolean | undefined;
772
- name: string;
773
- type: string;
774
- primaryKey: boolean;
775
- notNull: boolean;
776
- }>;
777
- indexes: Record<string, {
778
- using?: "btree" | "hash" | undefined;
779
- algorithm?: "default" | "inplace" | "copy" | undefined;
780
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
781
- name: string;
782
- columns: string[];
783
- isUnique: boolean;
784
- }>;
785
- foreignKeys: Record<string, {
786
- onUpdate?: string | undefined;
787
- onDelete?: string | undefined;
788
- name: string;
789
- tableFrom: string;
790
- columnsFrom: string[];
791
- tableTo: string;
792
- columnsTo: string[];
793
- }>;
794
- }>;
795
- version: "4";
796
- dialect: "mysql";
797
- schemas: Record<string, string>;
798
- }, {
799
- tables: Record<string, {
800
- schema?: string | undefined;
801
- name: string;
802
- columns: Record<string, {
803
- default?: any;
804
- onUpdate?: any;
805
- autoincrement?: boolean | undefined;
806
- name: string;
807
- type: string;
808
- primaryKey: boolean;
809
- notNull: boolean;
810
- }>;
811
- indexes: Record<string, {
812
- using?: "btree" | "hash" | undefined;
813
- algorithm?: "default" | "inplace" | "copy" | undefined;
814
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
815
- name: string;
816
- columns: string[];
817
- isUnique: boolean;
818
- }>;
819
- foreignKeys: Record<string, {
820
- onUpdate?: string | undefined;
821
- onDelete?: string | undefined;
822
- name: string;
823
- tableFrom: string;
824
- columnsFrom: string[];
825
- tableTo: string;
826
- columnsTo: string[];
827
- }>;
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
- default?: any;
848
- onUpdate?: any;
849
- autoincrement?: boolean | undefined;
850
- name: string;
851
- type: string;
852
- primaryKey: boolean;
853
- notNull: boolean;
854
- }, {
855
- default?: any;
856
- onUpdate?: any;
857
- autoincrement?: boolean | undefined;
858
- name: string;
859
- type: string;
860
- primaryKey: boolean;
861
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
872
- algorithm?: "default" | "inplace" | "copy" | undefined;
873
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
874
- name: string;
875
- columns: string[];
876
- isUnique: boolean;
877
- }, {
878
- using?: "btree" | "hash" | undefined;
879
- algorithm?: "default" | "inplace" | "copy" | undefined;
880
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
881
- name: string;
882
- columns: string[];
883
- isUnique: boolean;
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
- onUpdate?: string | undefined;
895
- onDelete?: string | undefined;
896
- name: string;
897
- tableFrom: string;
898
- columnsFrom: string[];
899
- tableTo: string;
900
- columnsTo: string[];
901
- }, {
902
- onUpdate?: string | undefined;
903
- onDelete?: string | undefined;
904
- name: string;
905
- tableFrom: string;
906
- columnsFrom: string[];
907
- tableTo: string;
908
- columnsTo: string[];
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
- default?: any;
934
- onUpdate?: any;
935
- autoincrement?: boolean | undefined;
936
- name: string;
937
- type: string;
938
- primaryKey: boolean;
939
- notNull: boolean;
940
- }>;
941
- indexes: Record<string, {
942
- using?: "btree" | "hash" | undefined;
943
- algorithm?: "default" | "inplace" | "copy" | undefined;
944
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
945
- name: string;
946
- columns: string[];
947
- isUnique: boolean;
948
- }>;
949
- foreignKeys: Record<string, {
950
- onUpdate?: string | undefined;
951
- onDelete?: string | undefined;
952
- name: string;
953
- tableFrom: string;
954
- columnsFrom: string[];
955
- tableTo: string;
956
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
968
- name: string;
969
- columns: string[];
970
- }> | undefined;
971
- name: string;
972
- columns: Record<string, {
973
- default?: any;
974
- onUpdate?: any;
975
- autoincrement?: boolean | undefined;
976
- name: string;
977
- type: string;
978
- primaryKey: boolean;
979
- notNull: boolean;
980
- }>;
981
- indexes: Record<string, {
982
- using?: "btree" | "hash" | undefined;
983
- algorithm?: "default" | "inplace" | "copy" | undefined;
984
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
985
- name: string;
986
- columns: string[];
987
- isUnique: boolean;
988
- }>;
989
- foreignKeys: Record<string, {
990
- onUpdate?: string | undefined;
991
- onDelete?: string | undefined;
992
- name: string;
993
- tableFrom: string;
994
- columnsFrom: string[];
995
- tableTo: string;
996
- columnsTo: string[];
997
- }>;
998
- compositePrimaryKeys: Record<string, {
999
- name: string;
1000
- columns: string[];
1001
- }>;
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
- internal?: {
1050
- tables: Record<string, {
1051
- columns: Record<string, {
1052
- isDefaultAnExpression?: boolean | undefined;
1053
- } | undefined>;
1054
- } | undefined>;
1055
- } | undefined;
1056
- tables: Record<string, {
1057
- name: string;
1058
- columns: Record<string, {
1059
- default?: any;
1060
- onUpdate?: any;
1061
- autoincrement?: boolean | undefined;
1062
- name: string;
1063
- type: string;
1064
- primaryKey: boolean;
1065
- notNull: boolean;
1066
- }>;
1067
- indexes: Record<string, {
1068
- using?: "btree" | "hash" | undefined;
1069
- algorithm?: "default" | "inplace" | "copy" | undefined;
1070
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1071
- name: string;
1072
- columns: string[];
1073
- isUnique: boolean;
1074
- }>;
1075
- foreignKeys: Record<string, {
1076
- onUpdate?: string | undefined;
1077
- onDelete?: string | undefined;
1078
- name: string;
1079
- tableFrom: string;
1080
- columnsFrom: string[];
1081
- tableTo: string;
1082
- columnsTo: string[];
1083
- }>;
1084
- compositePrimaryKeys: Record<string, {
1085
- name: string;
1086
- columns: string[];
1087
- }>;
1088
- uniqueConstraints: Record<string, {
1089
- name: string;
1090
- columns: string[];
1091
- }>;
1092
- }>;
1093
- version: "5";
1094
- dialect: "mysql";
1095
- schemas: Record<string, string>;
1096
- _meta: {
1097
- columns: Record<string, string>;
1098
- tables: Record<string, string>;
1099
- schemas: Record<string, string>;
1100
- };
1101
- }, {
1102
- internal?: {
1103
- tables: Record<string, {
1104
- columns: Record<string, {
1105
- isDefaultAnExpression?: boolean | undefined;
1106
- } | undefined>;
1107
- } | undefined>;
1108
- } | undefined;
1109
- tables: Record<string, {
1110
- uniqueConstraints?: Record<string, {
1111
- name: string;
1112
- columns: string[];
1113
- }> | undefined;
1114
- name: string;
1115
- columns: Record<string, {
1116
- default?: any;
1117
- onUpdate?: any;
1118
- autoincrement?: boolean | undefined;
1119
- name: string;
1120
- type: string;
1121
- primaryKey: boolean;
1122
- notNull: boolean;
1123
- }>;
1124
- indexes: Record<string, {
1125
- using?: "btree" | "hash" | undefined;
1126
- algorithm?: "default" | "inplace" | "copy" | undefined;
1127
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1128
- name: string;
1129
- columns: string[];
1130
- isUnique: boolean;
1131
- }>;
1132
- foreignKeys: Record<string, {
1133
- onUpdate?: string | undefined;
1134
- onDelete?: string | undefined;
1135
- name: string;
1136
- tableFrom: string;
1137
- columnsFrom: string[];
1138
- tableTo: string;
1139
- columnsTo: string[];
1140
- }>;
1141
- compositePrimaryKeys: Record<string, {
1142
- name: string;
1143
- columns: string[];
1144
- }>;
1145
- }>;
1146
- version: "5";
1147
- dialect: "mysql";
1148
- schemas: Record<string, string>;
1149
- _meta: {
1150
- columns: Record<string, string>;
1151
- tables: Record<string, string>;
1152
- schemas: Record<string, string>;
1153
- };
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
- default?: any;
1170
- onUpdate?: any;
1171
- autoincrement?: boolean | undefined;
1172
- name: string;
1173
- type: string;
1174
- primaryKey: boolean;
1175
- notNull: boolean;
1176
- }, {
1177
- default?: any;
1178
- onUpdate?: any;
1179
- autoincrement?: boolean | undefined;
1180
- name: string;
1181
- type: string;
1182
- primaryKey: boolean;
1183
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
1194
- algorithm?: "default" | "inplace" | "copy" | undefined;
1195
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1196
- name: string;
1197
- columns: string[];
1198
- isUnique: boolean;
1199
- }, {
1200
- using?: "btree" | "hash" | undefined;
1201
- algorithm?: "default" | "inplace" | "copy" | undefined;
1202
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1203
- name: string;
1204
- columns: string[];
1205
- isUnique: boolean;
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
- onUpdate?: string | undefined;
1217
- onDelete?: string | undefined;
1218
- name: string;
1219
- tableFrom: string;
1220
- columnsFrom: string[];
1221
- tableTo: string;
1222
- columnsTo: string[];
1223
- }, {
1224
- onUpdate?: string | undefined;
1225
- onDelete?: string | undefined;
1226
- name: string;
1227
- tableFrom: string;
1228
- columnsFrom: string[];
1229
- tableTo: string;
1230
- columnsTo: string[];
1231
- }>>;
1232
- 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
- default?: any;
1256
- onUpdate?: any;
1257
- autoincrement?: boolean | undefined;
1258
- name: string;
1259
- type: string;
1260
- primaryKey: boolean;
1261
- notNull: boolean;
1262
- }>;
1263
- indexes: Record<string, {
1264
- using?: "btree" | "hash" | undefined;
1265
- algorithm?: "default" | "inplace" | "copy" | undefined;
1266
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1267
- name: string;
1268
- columns: string[];
1269
- isUnique: boolean;
1270
- }>;
1271
- foreignKeys: Record<string, {
1272
- onUpdate?: string | undefined;
1273
- onDelete?: string | undefined;
1274
- name: string;
1275
- tableFrom: string;
1276
- columnsFrom: string[];
1277
- tableTo: string;
1278
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
1290
- name: string;
1291
- columns: string[];
1292
- }> | undefined;
1293
- name: string;
1294
- columns: Record<string, {
1295
- default?: any;
1296
- onUpdate?: any;
1297
- autoincrement?: boolean | undefined;
1298
- name: string;
1299
- type: string;
1300
- primaryKey: boolean;
1301
- notNull: boolean;
1302
- }>;
1303
- indexes: Record<string, {
1304
- using?: "btree" | "hash" | undefined;
1305
- algorithm?: "default" | "inplace" | "copy" | undefined;
1306
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1307
- name: string;
1308
- columns: string[];
1309
- isUnique: boolean;
1310
- }>;
1311
- foreignKeys: Record<string, {
1312
- onUpdate?: string | undefined;
1313
- onDelete?: string | undefined;
1314
- name: string;
1315
- tableFrom: string;
1316
- columnsFrom: string[];
1317
- tableTo: string;
1318
- columnsTo: string[];
1319
- }>;
1320
- compositePrimaryKeys: Record<string, {
1321
- name: string;
1322
- columns: string[];
1323
- }>;
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
- internal?: {
1368
- tables: Record<string, {
1369
- columns: Record<string, {
1370
- isDefaultAnExpression?: boolean | undefined;
1371
- } | undefined>;
1372
- } | undefined>;
1373
- } | undefined;
1374
- tables: Record<string, {
1375
- name: string;
1376
- columns: Record<string, {
1377
- default?: any;
1378
- onUpdate?: any;
1379
- autoincrement?: boolean | undefined;
1380
- name: string;
1381
- type: string;
1382
- primaryKey: boolean;
1383
- notNull: boolean;
1384
- }>;
1385
- indexes: Record<string, {
1386
- using?: "btree" | "hash" | undefined;
1387
- algorithm?: "default" | "inplace" | "copy" | undefined;
1388
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1389
- name: string;
1390
- columns: string[];
1391
- isUnique: boolean;
1392
- }>;
1393
- foreignKeys: Record<string, {
1394
- onUpdate?: string | undefined;
1395
- onDelete?: string | undefined;
1396
- name: string;
1397
- tableFrom: string;
1398
- columnsFrom: string[];
1399
- tableTo: string;
1400
- columnsTo: string[];
1401
- }>;
1402
- compositePrimaryKeys: Record<string, {
1403
- name: string;
1404
- columns: string[];
1405
- }>;
1406
- uniqueConstraints: Record<string, {
1407
- name: string;
1408
- columns: string[];
1409
- }>;
1410
- }>;
1411
- version: "5";
1412
- dialect: "mysql";
1413
- _meta: {
1414
- columns: Record<string, string>;
1415
- tables: Record<string, string>;
1416
- };
1417
- }, {
1418
- internal?: {
1419
- tables: Record<string, {
1420
- columns: Record<string, {
1421
- isDefaultAnExpression?: boolean | undefined;
1422
- } | undefined>;
1423
- } | undefined>;
1424
- } | undefined;
1425
- tables: Record<string, {
1426
- uniqueConstraints?: Record<string, {
1427
- name: string;
1428
- columns: string[];
1429
- }> | undefined;
1430
- name: string;
1431
- columns: Record<string, {
1432
- default?: any;
1433
- onUpdate?: any;
1434
- autoincrement?: boolean | undefined;
1435
- name: string;
1436
- type: string;
1437
- primaryKey: boolean;
1438
- notNull: boolean;
1439
- }>;
1440
- indexes: Record<string, {
1441
- using?: "btree" | "hash" | undefined;
1442
- algorithm?: "default" | "inplace" | "copy" | undefined;
1443
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1444
- name: string;
1445
- columns: string[];
1446
- isUnique: boolean;
1447
- }>;
1448
- foreignKeys: Record<string, {
1449
- onUpdate?: string | undefined;
1450
- onDelete?: string | undefined;
1451
- name: string;
1452
- tableFrom: string;
1453
- columnsFrom: string[];
1454
- tableTo: string;
1455
- columnsTo: string[];
1456
- }>;
1457
- compositePrimaryKeys: Record<string, {
1458
- name: string;
1459
- columns: string[];
1460
- }>;
1461
- }>;
1462
- version: "5";
1463
- dialect: "mysql";
1464
- _meta: {
1465
- columns: Record<string, string>;
1466
- tables: Record<string, string>;
1467
- };
1468
- }>;
1469
- export declare const schemaV3: import("zod").ZodObject<import("zod").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
- default?: any;
1484
- onUpdate?: any;
1485
- autoincrement?: boolean | undefined;
1486
- name: string;
1487
- type: string;
1488
- primaryKey: boolean;
1489
- notNull: boolean;
1490
- }, {
1491
- default?: any;
1492
- onUpdate?: any;
1493
- autoincrement?: boolean | undefined;
1494
- name: string;
1495
- type: string;
1496
- primaryKey: boolean;
1497
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
1508
- algorithm?: "default" | "inplace" | "copy" | undefined;
1509
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1510
- name: string;
1511
- columns: string[];
1512
- isUnique: boolean;
1513
- }, {
1514
- using?: "btree" | "hash" | undefined;
1515
- algorithm?: "default" | "inplace" | "copy" | undefined;
1516
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1517
- name: string;
1518
- columns: string[];
1519
- isUnique: boolean;
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
- onUpdate?: string | undefined;
1531
- onDelete?: string | undefined;
1532
- name: string;
1533
- tableFrom: string;
1534
- columnsFrom: string[];
1535
- tableTo: string;
1536
- columnsTo: string[];
1537
- }, {
1538
- onUpdate?: string | undefined;
1539
- onDelete?: string | undefined;
1540
- name: string;
1541
- tableFrom: string;
1542
- columnsFrom: string[];
1543
- tableTo: string;
1544
- columnsTo: string[];
1545
- }>>;
1546
- }, "strict", import("zod").ZodTypeAny, {
1547
- name: string;
1548
- columns: Record<string, {
1549
- default?: any;
1550
- onUpdate?: any;
1551
- autoincrement?: boolean | undefined;
1552
- name: string;
1553
- type: string;
1554
- primaryKey: boolean;
1555
- notNull: boolean;
1556
- }>;
1557
- indexes: Record<string, {
1558
- using?: "btree" | "hash" | undefined;
1559
- algorithm?: "default" | "inplace" | "copy" | undefined;
1560
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1561
- name: string;
1562
- columns: string[];
1563
- isUnique: boolean;
1564
- }>;
1565
- foreignKeys: Record<string, {
1566
- onUpdate?: string | undefined;
1567
- onDelete?: string | undefined;
1568
- name: string;
1569
- tableFrom: string;
1570
- columnsFrom: string[];
1571
- tableTo: string;
1572
- columnsTo: string[];
1573
- }>;
1574
- }, {
1575
- name: string;
1576
- columns: Record<string, {
1577
- default?: any;
1578
- onUpdate?: any;
1579
- autoincrement?: boolean | undefined;
1580
- name: string;
1581
- type: string;
1582
- primaryKey: boolean;
1583
- notNull: boolean;
1584
- }>;
1585
- indexes: Record<string, {
1586
- using?: "btree" | "hash" | undefined;
1587
- algorithm?: "default" | "inplace" | "copy" | undefined;
1588
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1589
- name: string;
1590
- columns: string[];
1591
- isUnique: boolean;
1592
- }>;
1593
- foreignKeys: Record<string, {
1594
- onUpdate?: string | undefined;
1595
- onDelete?: string | undefined;
1596
- name: string;
1597
- tableFrom: string;
1598
- columnsFrom: string[];
1599
- tableTo: string;
1600
- columnsTo: string[];
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
- default?: any;
1611
- onUpdate?: any;
1612
- autoincrement?: boolean | undefined;
1613
- name: string;
1614
- type: string;
1615
- primaryKey: boolean;
1616
- notNull: boolean;
1617
- }>;
1618
- indexes: Record<string, {
1619
- using?: "btree" | "hash" | undefined;
1620
- algorithm?: "default" | "inplace" | "copy" | undefined;
1621
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1622
- name: string;
1623
- columns: string[];
1624
- isUnique: boolean;
1625
- }>;
1626
- foreignKeys: Record<string, {
1627
- onUpdate?: string | undefined;
1628
- onDelete?: string | undefined;
1629
- name: string;
1630
- tableFrom: string;
1631
- columnsFrom: string[];
1632
- tableTo: string;
1633
- columnsTo: string[];
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
- default?: any;
1645
- onUpdate?: any;
1646
- autoincrement?: boolean | undefined;
1647
- name: string;
1648
- type: string;
1649
- primaryKey: boolean;
1650
- notNull: boolean;
1651
- }>;
1652
- indexes: Record<string, {
1653
- using?: "btree" | "hash" | undefined;
1654
- algorithm?: "default" | "inplace" | "copy" | undefined;
1655
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1656
- name: string;
1657
- columns: string[];
1658
- isUnique: boolean;
1659
- }>;
1660
- foreignKeys: Record<string, {
1661
- onUpdate?: string | undefined;
1662
- onDelete?: string | undefined;
1663
- name: string;
1664
- tableFrom: string;
1665
- columnsFrom: string[];
1666
- tableTo: string;
1667
- columnsTo: string[];
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").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
- default?: any;
1691
- onUpdate?: any;
1692
- autoincrement?: boolean | undefined;
1693
- name: string;
1694
- type: string;
1695
- primaryKey: boolean;
1696
- notNull: boolean;
1697
- }, {
1698
- default?: any;
1699
- onUpdate?: any;
1700
- autoincrement?: boolean | undefined;
1701
- name: string;
1702
- type: string;
1703
- primaryKey: boolean;
1704
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
1715
- algorithm?: "default" | "inplace" | "copy" | undefined;
1716
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1717
- name: string;
1718
- columns: string[];
1719
- isUnique: boolean;
1720
- }, {
1721
- using?: "btree" | "hash" | undefined;
1722
- algorithm?: "default" | "inplace" | "copy" | undefined;
1723
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1724
- name: string;
1725
- columns: string[];
1726
- isUnique: boolean;
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
- onUpdate?: string | undefined;
1738
- onDelete?: string | undefined;
1739
- name: string;
1740
- tableFrom: string;
1741
- columnsFrom: string[];
1742
- tableTo: string;
1743
- columnsTo: string[];
1744
- }, {
1745
- onUpdate?: string | undefined;
1746
- onDelete?: string | undefined;
1747
- name: string;
1748
- tableFrom: string;
1749
- columnsFrom: string[];
1750
- tableTo: string;
1751
- columnsTo: string[];
1752
- }>>;
1753
- }, "strict", import("zod").ZodTypeAny, {
1754
- schema?: string | undefined;
1755
- name: string;
1756
- columns: Record<string, {
1757
- default?: any;
1758
- onUpdate?: any;
1759
- autoincrement?: boolean | undefined;
1760
- name: string;
1761
- type: string;
1762
- primaryKey: boolean;
1763
- notNull: boolean;
1764
- }>;
1765
- indexes: Record<string, {
1766
- using?: "btree" | "hash" | undefined;
1767
- algorithm?: "default" | "inplace" | "copy" | undefined;
1768
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1769
- name: string;
1770
- columns: string[];
1771
- isUnique: boolean;
1772
- }>;
1773
- foreignKeys: Record<string, {
1774
- onUpdate?: string | undefined;
1775
- onDelete?: string | undefined;
1776
- name: string;
1777
- tableFrom: string;
1778
- columnsFrom: string[];
1779
- tableTo: string;
1780
- columnsTo: string[];
1781
- }>;
1782
- }, {
1783
- schema?: string | undefined;
1784
- name: string;
1785
- columns: Record<string, {
1786
- default?: any;
1787
- onUpdate?: any;
1788
- autoincrement?: boolean | undefined;
1789
- name: string;
1790
- type: string;
1791
- primaryKey: boolean;
1792
- notNull: boolean;
1793
- }>;
1794
- indexes: Record<string, {
1795
- using?: "btree" | "hash" | undefined;
1796
- algorithm?: "default" | "inplace" | "copy" | undefined;
1797
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1798
- name: string;
1799
- columns: string[];
1800
- isUnique: boolean;
1801
- }>;
1802
- foreignKeys: Record<string, {
1803
- onUpdate?: string | undefined;
1804
- onDelete?: string | undefined;
1805
- name: string;
1806
- tableFrom: string;
1807
- columnsFrom: string[];
1808
- tableTo: string;
1809
- columnsTo: string[];
1810
- }>;
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
- schema?: string | undefined;
1819
- name: string;
1820
- columns: Record<string, {
1821
- default?: any;
1822
- onUpdate?: any;
1823
- autoincrement?: boolean | undefined;
1824
- name: string;
1825
- type: string;
1826
- primaryKey: boolean;
1827
- notNull: boolean;
1828
- }>;
1829
- indexes: Record<string, {
1830
- using?: "btree" | "hash" | undefined;
1831
- algorithm?: "default" | "inplace" | "copy" | undefined;
1832
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1833
- name: string;
1834
- columns: string[];
1835
- isUnique: boolean;
1836
- }>;
1837
- foreignKeys: Record<string, {
1838
- onUpdate?: string | undefined;
1839
- onDelete?: string | undefined;
1840
- name: string;
1841
- tableFrom: string;
1842
- columnsFrom: string[];
1843
- tableTo: string;
1844
- columnsTo: string[];
1845
- }>;
1846
- }>;
1847
- id: string;
1848
- prevId: string;
1849
- version: "4";
1850
- dialect: "mysql";
1851
- schemas: Record<string, string>;
1852
- }, {
1853
- tables: Record<string, {
1854
- schema?: string | undefined;
1855
- name: string;
1856
- columns: Record<string, {
1857
- default?: any;
1858
- onUpdate?: any;
1859
- autoincrement?: boolean | undefined;
1860
- name: string;
1861
- type: string;
1862
- primaryKey: boolean;
1863
- notNull: boolean;
1864
- }>;
1865
- indexes: Record<string, {
1866
- using?: "btree" | "hash" | undefined;
1867
- algorithm?: "default" | "inplace" | "copy" | undefined;
1868
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1869
- name: string;
1870
- columns: string[];
1871
- isUnique: boolean;
1872
- }>;
1873
- foreignKeys: Record<string, {
1874
- onUpdate?: string | undefined;
1875
- onDelete?: string | undefined;
1876
- name: string;
1877
- tableFrom: string;
1878
- columnsFrom: string[];
1879
- tableTo: string;
1880
- columnsTo: string[];
1881
- }>;
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").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
- default?: any;
1904
- onUpdate?: any;
1905
- autoincrement?: boolean | undefined;
1906
- name: string;
1907
- type: string;
1908
- primaryKey: boolean;
1909
- notNull: boolean;
1910
- }, {
1911
- default?: any;
1912
- onUpdate?: any;
1913
- autoincrement?: boolean | undefined;
1914
- name: string;
1915
- type: string;
1916
- primaryKey: boolean;
1917
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
1928
- algorithm?: "default" | "inplace" | "copy" | undefined;
1929
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1930
- name: string;
1931
- columns: string[];
1932
- isUnique: boolean;
1933
- }, {
1934
- using?: "btree" | "hash" | undefined;
1935
- algorithm?: "default" | "inplace" | "copy" | undefined;
1936
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1937
- name: string;
1938
- columns: string[];
1939
- isUnique: boolean;
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
- onUpdate?: string | undefined;
1951
- onDelete?: string | undefined;
1952
- name: string;
1953
- tableFrom: string;
1954
- columnsFrom: string[];
1955
- tableTo: string;
1956
- columnsTo: string[];
1957
- }, {
1958
- onUpdate?: string | undefined;
1959
- onDelete?: string | undefined;
1960
- name: string;
1961
- tableFrom: string;
1962
- columnsFrom: string[];
1963
- tableTo: string;
1964
- columnsTo: string[];
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
- default?: any;
1990
- onUpdate?: any;
1991
- autoincrement?: boolean | undefined;
1992
- name: string;
1993
- type: string;
1994
- primaryKey: boolean;
1995
- notNull: boolean;
1996
- }>;
1997
- indexes: Record<string, {
1998
- using?: "btree" | "hash" | undefined;
1999
- algorithm?: "default" | "inplace" | "copy" | undefined;
2000
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2001
- name: string;
2002
- columns: string[];
2003
- isUnique: boolean;
2004
- }>;
2005
- foreignKeys: Record<string, {
2006
- onUpdate?: string | undefined;
2007
- onDelete?: string | undefined;
2008
- name: string;
2009
- tableFrom: string;
2010
- columnsFrom: string[];
2011
- tableTo: string;
2012
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
2024
- name: string;
2025
- columns: string[];
2026
- }> | undefined;
2027
- name: string;
2028
- columns: Record<string, {
2029
- default?: any;
2030
- onUpdate?: any;
2031
- autoincrement?: boolean | undefined;
2032
- name: string;
2033
- type: string;
2034
- primaryKey: boolean;
2035
- notNull: boolean;
2036
- }>;
2037
- indexes: Record<string, {
2038
- using?: "btree" | "hash" | undefined;
2039
- algorithm?: "default" | "inplace" | "copy" | undefined;
2040
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2041
- name: string;
2042
- columns: string[];
2043
- isUnique: boolean;
2044
- }>;
2045
- foreignKeys: Record<string, {
2046
- onUpdate?: string | undefined;
2047
- onDelete?: string | undefined;
2048
- name: string;
2049
- tableFrom: string;
2050
- columnsFrom: string[];
2051
- tableTo: string;
2052
- columnsTo: string[];
2053
- }>;
2054
- compositePrimaryKeys: Record<string, {
2055
- name: string;
2056
- columns: string[];
2057
- }>;
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
- internal?: {
2109
- tables: Record<string, {
2110
- columns: Record<string, {
2111
- isDefaultAnExpression?: boolean | undefined;
2112
- } | undefined>;
2113
- } | undefined>;
2114
- } | undefined;
2115
- tables: Record<string, {
2116
- name: string;
2117
- columns: Record<string, {
2118
- default?: any;
2119
- onUpdate?: any;
2120
- autoincrement?: boolean | undefined;
2121
- name: string;
2122
- type: string;
2123
- primaryKey: boolean;
2124
- notNull: boolean;
2125
- }>;
2126
- indexes: Record<string, {
2127
- using?: "btree" | "hash" | undefined;
2128
- algorithm?: "default" | "inplace" | "copy" | undefined;
2129
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2130
- name: string;
2131
- columns: string[];
2132
- isUnique: boolean;
2133
- }>;
2134
- foreignKeys: Record<string, {
2135
- onUpdate?: string | undefined;
2136
- onDelete?: string | undefined;
2137
- name: string;
2138
- tableFrom: string;
2139
- columnsFrom: string[];
2140
- tableTo: string;
2141
- columnsTo: string[];
2142
- }>;
2143
- compositePrimaryKeys: Record<string, {
2144
- name: string;
2145
- columns: string[];
2146
- }>;
2147
- uniqueConstraints: Record<string, {
2148
- name: string;
2149
- columns: string[];
2150
- }>;
2151
- }>;
2152
- id: string;
2153
- prevId: string;
2154
- version: "5";
2155
- dialect: "mysql";
2156
- schemas: Record<string, string>;
2157
- _meta: {
2158
- columns: Record<string, string>;
2159
- tables: Record<string, string>;
2160
- schemas: Record<string, string>;
2161
- };
2162
- }, {
2163
- internal?: {
2164
- tables: Record<string, {
2165
- columns: Record<string, {
2166
- isDefaultAnExpression?: boolean | undefined;
2167
- } | undefined>;
2168
- } | undefined>;
2169
- } | undefined;
2170
- tables: Record<string, {
2171
- uniqueConstraints?: Record<string, {
2172
- name: string;
2173
- columns: string[];
2174
- }> | undefined;
2175
- name: string;
2176
- columns: Record<string, {
2177
- default?: any;
2178
- onUpdate?: any;
2179
- autoincrement?: boolean | undefined;
2180
- name: string;
2181
- type: string;
2182
- primaryKey: boolean;
2183
- notNull: boolean;
2184
- }>;
2185
- indexes: Record<string, {
2186
- using?: "btree" | "hash" | undefined;
2187
- algorithm?: "default" | "inplace" | "copy" | undefined;
2188
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2189
- name: string;
2190
- columns: string[];
2191
- isUnique: boolean;
2192
- }>;
2193
- foreignKeys: Record<string, {
2194
- onUpdate?: string | undefined;
2195
- onDelete?: string | undefined;
2196
- name: string;
2197
- tableFrom: string;
2198
- columnsFrom: string[];
2199
- tableTo: string;
2200
- columnsTo: string[];
2201
- }>;
2202
- compositePrimaryKeys: Record<string, {
2203
- name: string;
2204
- columns: string[];
2205
- }>;
2206
- }>;
2207
- id: string;
2208
- prevId: string;
2209
- version: "5";
2210
- dialect: "mysql";
2211
- schemas: Record<string, string>;
2212
- _meta: {
2213
- columns: Record<string, string>;
2214
- tables: Record<string, string>;
2215
- schemas: Record<string, string>;
2216
- };
2217
- }>;
2218
- export declare const schema: import("zod").ZodObject<import("zod").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
- default?: any;
2233
- onUpdate?: any;
2234
- autoincrement?: boolean | undefined;
2235
- name: string;
2236
- type: string;
2237
- primaryKey: boolean;
2238
- notNull: boolean;
2239
- }, {
2240
- default?: any;
2241
- onUpdate?: any;
2242
- autoincrement?: boolean | undefined;
2243
- name: string;
2244
- type: string;
2245
- primaryKey: boolean;
2246
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
2257
- algorithm?: "default" | "inplace" | "copy" | undefined;
2258
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2259
- name: string;
2260
- columns: string[];
2261
- isUnique: boolean;
2262
- }, {
2263
- using?: "btree" | "hash" | undefined;
2264
- algorithm?: "default" | "inplace" | "copy" | undefined;
2265
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2266
- name: string;
2267
- columns: string[];
2268
- isUnique: boolean;
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
- onUpdate?: string | undefined;
2280
- onDelete?: string | undefined;
2281
- name: string;
2282
- tableFrom: string;
2283
- columnsFrom: string[];
2284
- tableTo: string;
2285
- columnsTo: string[];
2286
- }, {
2287
- onUpdate?: string | undefined;
2288
- onDelete?: string | undefined;
2289
- name: string;
2290
- tableFrom: string;
2291
- columnsFrom: string[];
2292
- tableTo: string;
2293
- columnsTo: string[];
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
- default?: any;
2319
- onUpdate?: any;
2320
- autoincrement?: boolean | undefined;
2321
- name: string;
2322
- type: string;
2323
- primaryKey: boolean;
2324
- notNull: boolean;
2325
- }>;
2326
- indexes: Record<string, {
2327
- using?: "btree" | "hash" | undefined;
2328
- algorithm?: "default" | "inplace" | "copy" | undefined;
2329
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2330
- name: string;
2331
- columns: string[];
2332
- isUnique: boolean;
2333
- }>;
2334
- foreignKeys: Record<string, {
2335
- onUpdate?: string | undefined;
2336
- onDelete?: string | undefined;
2337
- name: string;
2338
- tableFrom: string;
2339
- columnsFrom: string[];
2340
- tableTo: string;
2341
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
2353
- name: string;
2354
- columns: string[];
2355
- }> | undefined;
2356
- name: string;
2357
- columns: Record<string, {
2358
- default?: any;
2359
- onUpdate?: any;
2360
- autoincrement?: boolean | undefined;
2361
- name: string;
2362
- type: string;
2363
- primaryKey: boolean;
2364
- notNull: boolean;
2365
- }>;
2366
- indexes: Record<string, {
2367
- using?: "btree" | "hash" | undefined;
2368
- algorithm?: "default" | "inplace" | "copy" | undefined;
2369
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2370
- name: string;
2371
- columns: string[];
2372
- isUnique: boolean;
2373
- }>;
2374
- foreignKeys: Record<string, {
2375
- onUpdate?: string | undefined;
2376
- onDelete?: string | undefined;
2377
- name: string;
2378
- tableFrom: string;
2379
- columnsFrom: string[];
2380
- tableTo: string;
2381
- columnsTo: string[];
2382
- }>;
2383
- compositePrimaryKeys: Record<string, {
2384
- name: string;
2385
- columns: string[];
2386
- }>;
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
- internal?: {
2434
- tables: Record<string, {
2435
- columns: Record<string, {
2436
- isDefaultAnExpression?: boolean | undefined;
2437
- } | undefined>;
2438
- } | undefined>;
2439
- } | undefined;
2440
- tables: Record<string, {
2441
- name: string;
2442
- columns: Record<string, {
2443
- default?: any;
2444
- onUpdate?: any;
2445
- autoincrement?: boolean | undefined;
2446
- name: string;
2447
- type: string;
2448
- primaryKey: boolean;
2449
- notNull: boolean;
2450
- }>;
2451
- indexes: Record<string, {
2452
- using?: "btree" | "hash" | undefined;
2453
- algorithm?: "default" | "inplace" | "copy" | undefined;
2454
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2455
- name: string;
2456
- columns: string[];
2457
- isUnique: boolean;
2458
- }>;
2459
- foreignKeys: Record<string, {
2460
- onUpdate?: string | undefined;
2461
- onDelete?: string | undefined;
2462
- name: string;
2463
- tableFrom: string;
2464
- columnsFrom: string[];
2465
- tableTo: string;
2466
- columnsTo: string[];
2467
- }>;
2468
- compositePrimaryKeys: Record<string, {
2469
- name: string;
2470
- columns: string[];
2471
- }>;
2472
- uniqueConstraints: Record<string, {
2473
- name: string;
2474
- columns: string[];
2475
- }>;
2476
- }>;
2477
- id: string;
2478
- prevId: string;
2479
- version: "5";
2480
- dialect: "mysql";
2481
- _meta: {
2482
- columns: Record<string, string>;
2483
- tables: Record<string, string>;
2484
- };
2485
- }, {
2486
- internal?: {
2487
- tables: Record<string, {
2488
- columns: Record<string, {
2489
- isDefaultAnExpression?: boolean | undefined;
2490
- } | undefined>;
2491
- } | undefined>;
2492
- } | undefined;
2493
- tables: Record<string, {
2494
- uniqueConstraints?: Record<string, {
2495
- name: string;
2496
- columns: string[];
2497
- }> | undefined;
2498
- name: string;
2499
- columns: Record<string, {
2500
- default?: any;
2501
- onUpdate?: any;
2502
- autoincrement?: boolean | undefined;
2503
- name: string;
2504
- type: string;
2505
- primaryKey: boolean;
2506
- notNull: boolean;
2507
- }>;
2508
- indexes: Record<string, {
2509
- using?: "btree" | "hash" | undefined;
2510
- algorithm?: "default" | "inplace" | "copy" | undefined;
2511
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2512
- name: string;
2513
- columns: string[];
2514
- isUnique: boolean;
2515
- }>;
2516
- foreignKeys: Record<string, {
2517
- onUpdate?: string | undefined;
2518
- onDelete?: string | undefined;
2519
- name: string;
2520
- tableFrom: string;
2521
- columnsFrom: string[];
2522
- tableTo: string;
2523
- columnsTo: string[];
2524
- }>;
2525
- compositePrimaryKeys: Record<string, {
2526
- name: string;
2527
- columns: string[];
2528
- }>;
2529
- }>;
2530
- id: string;
2531
- prevId: string;
2532
- version: "5";
2533
- dialect: "mysql";
2534
- _meta: {
2535
- columns: Record<string, string>;
2536
- tables: Record<string, string>;
2537
- };
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
- default?: any;
2554
- onUpdate?: any;
2555
- autoincrement?: boolean | undefined;
2556
- name: string;
2557
- type: string;
2558
- primaryKey: boolean;
2559
- notNull: boolean;
2560
- }, {
2561
- default?: any;
2562
- onUpdate?: any;
2563
- autoincrement?: boolean | undefined;
2564
- name: string;
2565
- type: string;
2566
- primaryKey: boolean;
2567
- notNull: boolean;
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
- default?: any;
2577
- onUpdate?: any;
2578
- autoincrement?: boolean | undefined;
2579
- name: string;
2580
- type: string;
2581
- primaryKey: boolean;
2582
- notNull: boolean;
2583
- }>;
2584
- indexes: Record<string, string>;
2585
- foreignKeys: Record<string, string>;
2586
- compositePrimaryKeys: Record<string, string>;
2587
- uniqueConstraints: Record<string, string>;
2588
- }, {
2589
- uniqueConstraints?: Record<string, string> | undefined;
2590
- name: string;
2591
- columns: Record<string, {
2592
- default?: any;
2593
- onUpdate?: any;
2594
- autoincrement?: boolean | undefined;
2595
- name: string;
2596
- type: string;
2597
- primaryKey: boolean;
2598
- notNull: boolean;
2599
- }>;
2600
- indexes: Record<string, string>;
2601
- foreignKeys: Record<string, string>;
2602
- compositePrimaryKeys: Record<string, string>;
2603
- }>>;
2604
- }, "strict", import("zod").ZodTypeAny, {
2605
- tables: Record<string, {
2606
- name: string;
2607
- columns: Record<string, {
2608
- default?: any;
2609
- onUpdate?: any;
2610
- autoincrement?: boolean | undefined;
2611
- name: string;
2612
- type: string;
2613
- primaryKey: boolean;
2614
- notNull: boolean;
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
- uniqueConstraints?: Record<string, string> | undefined;
2626
- name: string;
2627
- columns: Record<string, {
2628
- default?: any;
2629
- onUpdate?: any;
2630
- autoincrement?: boolean | undefined;
2631
- name: string;
2632
- type: string;
2633
- primaryKey: boolean;
2634
- notNull: boolean;
2635
- }>;
2636
- indexes: Record<string, string>;
2637
- foreignKeys: Record<string, string>;
2638
- compositePrimaryKeys: Record<string, string>;
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
- default?: any;
2659
- onUpdate?: any;
2660
- autoincrement?: boolean | undefined;
2661
- name: string;
2662
- type: string;
2663
- primaryKey: boolean;
2664
- notNull: boolean;
2665
- }, {
2666
- default?: any;
2667
- onUpdate?: any;
2668
- autoincrement?: boolean | undefined;
2669
- name: string;
2670
- type: string;
2671
- primaryKey: boolean;
2672
- notNull: boolean;
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
- schema?: string | undefined;
2678
- name: string;
2679
- columns: Record<string, {
2680
- default?: any;
2681
- onUpdate?: any;
2682
- autoincrement?: boolean | undefined;
2683
- name: string;
2684
- type: string;
2685
- primaryKey: boolean;
2686
- notNull: boolean;
2687
- }>;
2688
- indexes: Record<string, string>;
2689
- foreignKeys: Record<string, string>;
2690
- }, {
2691
- schema?: string | undefined;
2692
- name: string;
2693
- columns: Record<string, {
2694
- default?: any;
2695
- onUpdate?: any;
2696
- autoincrement?: boolean | undefined;
2697
- name: string;
2698
- type: string;
2699
- primaryKey: boolean;
2700
- notNull: boolean;
2701
- }>;
2702
- indexes: Record<string, string>;
2703
- foreignKeys: Record<string, string>;
2704
- }>>;
2705
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2706
- }, "strict", import("zod").ZodTypeAny, {
2707
- tables: Record<string, {
2708
- schema?: string | undefined;
2709
- name: string;
2710
- columns: Record<string, {
2711
- default?: any;
2712
- onUpdate?: any;
2713
- autoincrement?: boolean | undefined;
2714
- name: string;
2715
- type: string;
2716
- primaryKey: boolean;
2717
- notNull: boolean;
2718
- }>;
2719
- indexes: Record<string, string>;
2720
- foreignKeys: Record<string, string>;
2721
- }>;
2722
- version: "4";
2723
- dialect: "mysql";
2724
- schemas: Record<string, string>;
2725
- }, {
2726
- tables: Record<string, {
2727
- schema?: string | undefined;
2728
- name: string;
2729
- columns: Record<string, {
2730
- default?: any;
2731
- onUpdate?: any;
2732
- autoincrement?: boolean | undefined;
2733
- name: string;
2734
- type: string;
2735
- primaryKey: boolean;
2736
- notNull: boolean;
2737
- }>;
2738
- indexes: Record<string, string>;
2739
- foreignKeys: Record<string, string>;
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").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
- default?: any;
2788
- onUpdate?: any;
2789
- autoincrement?: boolean | undefined;
2790
- name: string;
2791
- type: string;
2792
- primaryKey: boolean;
2793
- notNull: boolean;
2794
- }, {
2795
- default?: any;
2796
- onUpdate?: any;
2797
- autoincrement?: boolean | undefined;
2798
- name: string;
2799
- type: string;
2800
- primaryKey: boolean;
2801
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
2812
- algorithm?: "default" | "inplace" | "copy" | undefined;
2813
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2814
- name: string;
2815
- columns: string[];
2816
- isUnique: boolean;
2817
- }, {
2818
- using?: "btree" | "hash" | undefined;
2819
- algorithm?: "default" | "inplace" | "copy" | undefined;
2820
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2821
- name: string;
2822
- columns: string[];
2823
- isUnique: boolean;
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
- onUpdate?: string | undefined;
2835
- onDelete?: string | undefined;
2836
- name: string;
2837
- tableFrom: string;
2838
- columnsFrom: string[];
2839
- tableTo: string;
2840
- columnsTo: string[];
2841
- }, {
2842
- onUpdate?: string | undefined;
2843
- onDelete?: string | undefined;
2844
- name: string;
2845
- tableFrom: string;
2846
- columnsFrom: string[];
2847
- tableTo: string;
2848
- columnsTo: string[];
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
- default?: any;
2874
- onUpdate?: any;
2875
- autoincrement?: boolean | undefined;
2876
- name: string;
2877
- type: string;
2878
- primaryKey: boolean;
2879
- notNull: boolean;
2880
- }>;
2881
- indexes: Record<string, {
2882
- using?: "btree" | "hash" | undefined;
2883
- algorithm?: "default" | "inplace" | "copy" | undefined;
2884
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2885
- name: string;
2886
- columns: string[];
2887
- isUnique: boolean;
2888
- }>;
2889
- foreignKeys: Record<string, {
2890
- onUpdate?: string | undefined;
2891
- onDelete?: string | undefined;
2892
- name: string;
2893
- tableFrom: string;
2894
- columnsFrom: string[];
2895
- tableTo: string;
2896
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
2908
- name: string;
2909
- columns: string[];
2910
- }> | undefined;
2911
- name: string;
2912
- columns: Record<string, {
2913
- default?: any;
2914
- onUpdate?: any;
2915
- autoincrement?: boolean | undefined;
2916
- name: string;
2917
- type: string;
2918
- primaryKey: boolean;
2919
- notNull: boolean;
2920
- }>;
2921
- indexes: Record<string, {
2922
- using?: "btree" | "hash" | undefined;
2923
- algorithm?: "default" | "inplace" | "copy" | undefined;
2924
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2925
- name: string;
2926
- columns: string[];
2927
- isUnique: boolean;
2928
- }>;
2929
- foreignKeys: Record<string, {
2930
- onUpdate?: string | undefined;
2931
- onDelete?: string | undefined;
2932
- name: string;
2933
- tableFrom: string;
2934
- columnsFrom: string[];
2935
- tableTo: string;
2936
- columnsTo: string[];
2937
- }>;
2938
- compositePrimaryKeys: Record<string, {
2939
- name: string;
2940
- columns: string[];
2941
- }>;
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
- internal?: {
2989
- tables: Record<string, {
2990
- columns: Record<string, {
2991
- isDefaultAnExpression?: boolean | undefined;
2992
- } | undefined>;
2993
- } | undefined>;
2994
- } | undefined;
2995
- tables: Record<string, {
2996
- name: string;
2997
- columns: Record<string, {
2998
- default?: any;
2999
- onUpdate?: any;
3000
- autoincrement?: boolean | undefined;
3001
- name: string;
3002
- type: string;
3003
- primaryKey: boolean;
3004
- notNull: boolean;
3005
- }>;
3006
- indexes: Record<string, {
3007
- using?: "btree" | "hash" | undefined;
3008
- algorithm?: "default" | "inplace" | "copy" | undefined;
3009
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3010
- name: string;
3011
- columns: string[];
3012
- isUnique: boolean;
3013
- }>;
3014
- foreignKeys: Record<string, {
3015
- onUpdate?: string | undefined;
3016
- onDelete?: string | undefined;
3017
- name: string;
3018
- tableFrom: string;
3019
- columnsFrom: string[];
3020
- tableTo: string;
3021
- columnsTo: string[];
3022
- }>;
3023
- compositePrimaryKeys: Record<string, {
3024
- name: string;
3025
- columns: string[];
3026
- }>;
3027
- uniqueConstraints: Record<string, {
3028
- name: string;
3029
- columns: string[];
3030
- }>;
3031
- }>;
3032
- id: string;
3033
- prevId: string;
3034
- version: "5";
3035
- dialect: "mysql";
3036
- _meta: {
3037
- columns: Record<string, string>;
3038
- tables: Record<string, string>;
3039
- };
3040
- }, {
3041
- internal?: {
3042
- tables: Record<string, {
3043
- columns: Record<string, {
3044
- isDefaultAnExpression?: boolean | undefined;
3045
- } | undefined>;
3046
- } | undefined>;
3047
- } | undefined;
3048
- tables: Record<string, {
3049
- uniqueConstraints?: Record<string, {
3050
- name: string;
3051
- columns: string[];
3052
- }> | undefined;
3053
- name: string;
3054
- columns: Record<string, {
3055
- default?: any;
3056
- onUpdate?: any;
3057
- autoincrement?: boolean | undefined;
3058
- name: string;
3059
- type: string;
3060
- primaryKey: boolean;
3061
- notNull: boolean;
3062
- }>;
3063
- indexes: Record<string, {
3064
- using?: "btree" | "hash" | undefined;
3065
- algorithm?: "default" | "inplace" | "copy" | undefined;
3066
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3067
- name: string;
3068
- columns: string[];
3069
- isUnique: boolean;
3070
- }>;
3071
- foreignKeys: Record<string, {
3072
- onUpdate?: string | undefined;
3073
- onDelete?: string | undefined;
3074
- name: string;
3075
- tableFrom: string;
3076
- columnsFrom: string[];
3077
- tableTo: string;
3078
- columnsTo: string[];
3079
- }>;
3080
- compositePrimaryKeys: Record<string, {
3081
- name: string;
3082
- columns: string[];
3083
- }>;
3084
- }>;
3085
- id: string;
3086
- prevId: string;
3087
- version: "5";
3088
- dialect: "mysql";
3089
- _meta: {
3090
- columns: Record<string, string>;
3091
- tables: Record<string, string>;
3092
- };
3093
- }>;
3094
- export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").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
- default?: any;
3109
- onUpdate?: any;
3110
- autoincrement?: boolean | undefined;
3111
- name: string;
3112
- type: string;
3113
- primaryKey: boolean;
3114
- notNull: boolean;
3115
- }, {
3116
- default?: any;
3117
- onUpdate?: any;
3118
- autoincrement?: boolean | undefined;
3119
- name: string;
3120
- type: string;
3121
- primaryKey: boolean;
3122
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
3133
- algorithm?: "default" | "inplace" | "copy" | undefined;
3134
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3135
- name: string;
3136
- columns: string[];
3137
- isUnique: boolean;
3138
- }, {
3139
- using?: "btree" | "hash" | undefined;
3140
- algorithm?: "default" | "inplace" | "copy" | undefined;
3141
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3142
- name: string;
3143
- columns: string[];
3144
- isUnique: boolean;
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
- onUpdate?: string | undefined;
3156
- onDelete?: string | undefined;
3157
- name: string;
3158
- tableFrom: string;
3159
- columnsFrom: string[];
3160
- tableTo: string;
3161
- columnsTo: string[];
3162
- }, {
3163
- onUpdate?: string | undefined;
3164
- onDelete?: string | undefined;
3165
- name: string;
3166
- tableFrom: string;
3167
- columnsFrom: string[];
3168
- tableTo: string;
3169
- columnsTo: string[];
3170
- }>>;
3171
- }, "strict", import("zod").ZodTypeAny, {
3172
- name: string;
3173
- columns: Record<string, {
3174
- default?: any;
3175
- onUpdate?: any;
3176
- autoincrement?: boolean | undefined;
3177
- name: string;
3178
- type: string;
3179
- primaryKey: boolean;
3180
- notNull: boolean;
3181
- }>;
3182
- indexes: Record<string, {
3183
- using?: "btree" | "hash" | undefined;
3184
- algorithm?: "default" | "inplace" | "copy" | undefined;
3185
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3186
- name: string;
3187
- columns: string[];
3188
- isUnique: boolean;
3189
- }>;
3190
- foreignKeys: Record<string, {
3191
- onUpdate?: string | undefined;
3192
- onDelete?: string | undefined;
3193
- name: string;
3194
- tableFrom: string;
3195
- columnsFrom: string[];
3196
- tableTo: string;
3197
- columnsTo: string[];
3198
- }>;
3199
- }, {
3200
- name: string;
3201
- columns: Record<string, {
3202
- default?: any;
3203
- onUpdate?: any;
3204
- autoincrement?: boolean | undefined;
3205
- name: string;
3206
- type: string;
3207
- primaryKey: boolean;
3208
- notNull: boolean;
3209
- }>;
3210
- indexes: Record<string, {
3211
- using?: "btree" | "hash" | undefined;
3212
- algorithm?: "default" | "inplace" | "copy" | undefined;
3213
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3214
- name: string;
3215
- columns: string[];
3216
- isUnique: boolean;
3217
- }>;
3218
- foreignKeys: Record<string, {
3219
- onUpdate?: string | undefined;
3220
- onDelete?: string | undefined;
3221
- name: string;
3222
- tableFrom: string;
3223
- columnsFrom: string[];
3224
- tableTo: string;
3225
- columnsTo: string[];
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
- default?: any;
3236
- onUpdate?: any;
3237
- autoincrement?: boolean | undefined;
3238
- name: string;
3239
- type: string;
3240
- primaryKey: boolean;
3241
- notNull: boolean;
3242
- }>;
3243
- indexes: Record<string, {
3244
- using?: "btree" | "hash" | undefined;
3245
- algorithm?: "default" | "inplace" | "copy" | undefined;
3246
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3247
- name: string;
3248
- columns: string[];
3249
- isUnique: boolean;
3250
- }>;
3251
- foreignKeys: Record<string, {
3252
- onUpdate?: string | undefined;
3253
- onDelete?: string | undefined;
3254
- name: string;
3255
- tableFrom: string;
3256
- columnsFrom: string[];
3257
- tableTo: string;
3258
- columnsTo: string[];
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
- default?: any;
3270
- onUpdate?: any;
3271
- autoincrement?: boolean | undefined;
3272
- name: string;
3273
- type: string;
3274
- primaryKey: boolean;
3275
- notNull: boolean;
3276
- }>;
3277
- indexes: Record<string, {
3278
- using?: "btree" | "hash" | undefined;
3279
- algorithm?: "default" | "inplace" | "copy" | undefined;
3280
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3281
- name: string;
3282
- columns: string[];
3283
- isUnique: boolean;
3284
- }>;
3285
- foreignKeys: Record<string, {
3286
- onUpdate?: string | undefined;
3287
- onDelete?: string | undefined;
3288
- name: string;
3289
- tableFrom: string;
3290
- columnsFrom: string[];
3291
- tableTo: string;
3292
- columnsTo: string[];
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").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
- default?: any;
3316
- onUpdate?: any;
3317
- autoincrement?: boolean | undefined;
3318
- name: string;
3319
- type: string;
3320
- primaryKey: boolean;
3321
- notNull: boolean;
3322
- }, {
3323
- default?: any;
3324
- onUpdate?: any;
3325
- autoincrement?: boolean | undefined;
3326
- name: string;
3327
- type: string;
3328
- primaryKey: boolean;
3329
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
3340
- algorithm?: "default" | "inplace" | "copy" | undefined;
3341
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3342
- name: string;
3343
- columns: string[];
3344
- isUnique: boolean;
3345
- }, {
3346
- using?: "btree" | "hash" | undefined;
3347
- algorithm?: "default" | "inplace" | "copy" | undefined;
3348
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3349
- name: string;
3350
- columns: string[];
3351
- isUnique: boolean;
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
- onUpdate?: string | undefined;
3363
- onDelete?: string | undefined;
3364
- name: string;
3365
- tableFrom: string;
3366
- columnsFrom: string[];
3367
- tableTo: string;
3368
- columnsTo: string[];
3369
- }, {
3370
- onUpdate?: string | undefined;
3371
- onDelete?: string | undefined;
3372
- name: string;
3373
- tableFrom: string;
3374
- columnsFrom: string[];
3375
- tableTo: string;
3376
- columnsTo: string[];
3377
- }>>;
3378
- }, "strict", import("zod").ZodTypeAny, {
3379
- schema?: string | undefined;
3380
- name: string;
3381
- columns: Record<string, {
3382
- default?: any;
3383
- onUpdate?: any;
3384
- autoincrement?: boolean | undefined;
3385
- name: string;
3386
- type: string;
3387
- primaryKey: boolean;
3388
- notNull: boolean;
3389
- }>;
3390
- indexes: Record<string, {
3391
- using?: "btree" | "hash" | undefined;
3392
- algorithm?: "default" | "inplace" | "copy" | undefined;
3393
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3394
- name: string;
3395
- columns: string[];
3396
- isUnique: boolean;
3397
- }>;
3398
- foreignKeys: Record<string, {
3399
- onUpdate?: string | undefined;
3400
- onDelete?: string | undefined;
3401
- name: string;
3402
- tableFrom: string;
3403
- columnsFrom: string[];
3404
- tableTo: string;
3405
- columnsTo: string[];
3406
- }>;
3407
- }, {
3408
- schema?: string | undefined;
3409
- name: string;
3410
- columns: Record<string, {
3411
- default?: any;
3412
- onUpdate?: any;
3413
- autoincrement?: boolean | undefined;
3414
- name: string;
3415
- type: string;
3416
- primaryKey: boolean;
3417
- notNull: boolean;
3418
- }>;
3419
- indexes: Record<string, {
3420
- using?: "btree" | "hash" | undefined;
3421
- algorithm?: "default" | "inplace" | "copy" | undefined;
3422
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3423
- name: string;
3424
- columns: string[];
3425
- isUnique: boolean;
3426
- }>;
3427
- foreignKeys: Record<string, {
3428
- onUpdate?: string | undefined;
3429
- onDelete?: string | undefined;
3430
- name: string;
3431
- tableFrom: string;
3432
- columnsFrom: string[];
3433
- tableTo: string;
3434
- columnsTo: string[];
3435
- }>;
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
- schema?: string | undefined;
3444
- name: string;
3445
- columns: Record<string, {
3446
- default?: any;
3447
- onUpdate?: any;
3448
- autoincrement?: boolean | undefined;
3449
- name: string;
3450
- type: string;
3451
- primaryKey: boolean;
3452
- notNull: boolean;
3453
- }>;
3454
- indexes: Record<string, {
3455
- using?: "btree" | "hash" | undefined;
3456
- algorithm?: "default" | "inplace" | "copy" | undefined;
3457
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3458
- name: string;
3459
- columns: string[];
3460
- isUnique: boolean;
3461
- }>;
3462
- foreignKeys: Record<string, {
3463
- onUpdate?: string | undefined;
3464
- onDelete?: string | undefined;
3465
- name: string;
3466
- tableFrom: string;
3467
- columnsFrom: string[];
3468
- tableTo: string;
3469
- columnsTo: string[];
3470
- }>;
3471
- }>;
3472
- id: string;
3473
- prevId: string;
3474
- version: "4";
3475
- dialect: "mysql";
3476
- schemas: Record<string, string>;
3477
- }, {
3478
- tables: Record<string, {
3479
- schema?: string | undefined;
3480
- name: string;
3481
- columns: Record<string, {
3482
- default?: any;
3483
- onUpdate?: any;
3484
- autoincrement?: boolean | undefined;
3485
- name: string;
3486
- type: string;
3487
- primaryKey: boolean;
3488
- notNull: boolean;
3489
- }>;
3490
- indexes: Record<string, {
3491
- using?: "btree" | "hash" | undefined;
3492
- algorithm?: "default" | "inplace" | "copy" | undefined;
3493
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3494
- name: string;
3495
- columns: string[];
3496
- isUnique: boolean;
3497
- }>;
3498
- foreignKeys: Record<string, {
3499
- onUpdate?: string | undefined;
3500
- onDelete?: string | undefined;
3501
- name: string;
3502
- tableFrom: string;
3503
- columnsFrom: string[];
3504
- tableTo: string;
3505
- columnsTo: string[];
3506
- }>;
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").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
- default?: any;
3529
- onUpdate?: any;
3530
- autoincrement?: boolean | undefined;
3531
- name: string;
3532
- type: string;
3533
- primaryKey: boolean;
3534
- notNull: boolean;
3535
- }, {
3536
- default?: any;
3537
- onUpdate?: any;
3538
- autoincrement?: boolean | undefined;
3539
- name: string;
3540
- type: string;
3541
- primaryKey: boolean;
3542
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
3553
- algorithm?: "default" | "inplace" | "copy" | undefined;
3554
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3555
- name: string;
3556
- columns: string[];
3557
- isUnique: boolean;
3558
- }, {
3559
- using?: "btree" | "hash" | undefined;
3560
- algorithm?: "default" | "inplace" | "copy" | undefined;
3561
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3562
- name: string;
3563
- columns: string[];
3564
- isUnique: boolean;
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
- onUpdate?: string | undefined;
3576
- onDelete?: string | undefined;
3577
- name: string;
3578
- tableFrom: string;
3579
- columnsFrom: string[];
3580
- tableTo: string;
3581
- columnsTo: string[];
3582
- }, {
3583
- onUpdate?: string | undefined;
3584
- onDelete?: string | undefined;
3585
- name: string;
3586
- tableFrom: string;
3587
- columnsFrom: string[];
3588
- tableTo: string;
3589
- columnsTo: string[];
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
- default?: any;
3615
- onUpdate?: any;
3616
- autoincrement?: boolean | undefined;
3617
- name: string;
3618
- type: string;
3619
- primaryKey: boolean;
3620
- notNull: boolean;
3621
- }>;
3622
- indexes: Record<string, {
3623
- using?: "btree" | "hash" | undefined;
3624
- algorithm?: "default" | "inplace" | "copy" | undefined;
3625
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3626
- name: string;
3627
- columns: string[];
3628
- isUnique: boolean;
3629
- }>;
3630
- foreignKeys: Record<string, {
3631
- onUpdate?: string | undefined;
3632
- onDelete?: string | undefined;
3633
- name: string;
3634
- tableFrom: string;
3635
- columnsFrom: string[];
3636
- tableTo: string;
3637
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
3649
- name: string;
3650
- columns: string[];
3651
- }> | undefined;
3652
- name: string;
3653
- columns: Record<string, {
3654
- default?: any;
3655
- onUpdate?: any;
3656
- autoincrement?: boolean | undefined;
3657
- name: string;
3658
- type: string;
3659
- primaryKey: boolean;
3660
- notNull: boolean;
3661
- }>;
3662
- indexes: Record<string, {
3663
- using?: "btree" | "hash" | undefined;
3664
- algorithm?: "default" | "inplace" | "copy" | undefined;
3665
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3666
- name: string;
3667
- columns: string[];
3668
- isUnique: boolean;
3669
- }>;
3670
- foreignKeys: Record<string, {
3671
- onUpdate?: string | undefined;
3672
- onDelete?: string | undefined;
3673
- name: string;
3674
- tableFrom: string;
3675
- columnsFrom: string[];
3676
- tableTo: string;
3677
- columnsTo: string[];
3678
- }>;
3679
- compositePrimaryKeys: Record<string, {
3680
- name: string;
3681
- columns: string[];
3682
- }>;
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
- internal?: {
3734
- tables: Record<string, {
3735
- columns: Record<string, {
3736
- isDefaultAnExpression?: boolean | undefined;
3737
- } | undefined>;
3738
- } | undefined>;
3739
- } | undefined;
3740
- tables: Record<string, {
3741
- name: string;
3742
- columns: Record<string, {
3743
- default?: any;
3744
- onUpdate?: any;
3745
- autoincrement?: boolean | undefined;
3746
- name: string;
3747
- type: string;
3748
- primaryKey: boolean;
3749
- notNull: boolean;
3750
- }>;
3751
- indexes: Record<string, {
3752
- using?: "btree" | "hash" | undefined;
3753
- algorithm?: "default" | "inplace" | "copy" | undefined;
3754
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3755
- name: string;
3756
- columns: string[];
3757
- isUnique: boolean;
3758
- }>;
3759
- foreignKeys: Record<string, {
3760
- onUpdate?: string | undefined;
3761
- onDelete?: string | undefined;
3762
- name: string;
3763
- tableFrom: string;
3764
- columnsFrom: string[];
3765
- tableTo: string;
3766
- columnsTo: string[];
3767
- }>;
3768
- compositePrimaryKeys: Record<string, {
3769
- name: string;
3770
- columns: string[];
3771
- }>;
3772
- uniqueConstraints: Record<string, {
3773
- name: string;
3774
- columns: string[];
3775
- }>;
3776
- }>;
3777
- id: string;
3778
- prevId: string;
3779
- version: "5";
3780
- dialect: "mysql";
3781
- schemas: Record<string, string>;
3782
- _meta: {
3783
- columns: Record<string, string>;
3784
- tables: Record<string, string>;
3785
- schemas: Record<string, string>;
3786
- };
3787
- }, {
3788
- internal?: {
3789
- tables: Record<string, {
3790
- columns: Record<string, {
3791
- isDefaultAnExpression?: boolean | undefined;
3792
- } | undefined>;
3793
- } | undefined>;
3794
- } | undefined;
3795
- tables: Record<string, {
3796
- uniqueConstraints?: Record<string, {
3797
- name: string;
3798
- columns: string[];
3799
- }> | undefined;
3800
- name: string;
3801
- columns: Record<string, {
3802
- default?: any;
3803
- onUpdate?: any;
3804
- autoincrement?: boolean | undefined;
3805
- name: string;
3806
- type: string;
3807
- primaryKey: boolean;
3808
- notNull: boolean;
3809
- }>;
3810
- indexes: Record<string, {
3811
- using?: "btree" | "hash" | undefined;
3812
- algorithm?: "default" | "inplace" | "copy" | undefined;
3813
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3814
- name: string;
3815
- columns: string[];
3816
- isUnique: boolean;
3817
- }>;
3818
- foreignKeys: Record<string, {
3819
- onUpdate?: string | undefined;
3820
- onDelete?: string | undefined;
3821
- name: string;
3822
- tableFrom: string;
3823
- columnsFrom: string[];
3824
- tableTo: string;
3825
- columnsTo: string[];
3826
- }>;
3827
- compositePrimaryKeys: Record<string, {
3828
- name: string;
3829
- columns: string[];
3830
- }>;
3831
- }>;
3832
- id: string;
3833
- prevId: string;
3834
- version: "5";
3835
- dialect: "mysql";
3836
- schemas: Record<string, string>;
3837
- _meta: {
3838
- columns: Record<string, string>;
3839
- tables: Record<string, string>;
3840
- schemas: Record<string, string>;
3841
- };
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
- default?: any;
3858
- onUpdate?: any;
3859
- autoincrement?: boolean | undefined;
3860
- name: string;
3861
- type: string;
3862
- primaryKey: boolean;
3863
- notNull: boolean;
3864
- }, {
3865
- default?: any;
3866
- onUpdate?: any;
3867
- autoincrement?: boolean | undefined;
3868
- name: string;
3869
- type: string;
3870
- primaryKey: boolean;
3871
- notNull: boolean;
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
- default?: any;
3881
- onUpdate?: any;
3882
- autoincrement?: boolean | undefined;
3883
- name: string;
3884
- type: string;
3885
- primaryKey: boolean;
3886
- notNull: boolean;
3887
- }>;
3888
- indexes: Record<string, string>;
3889
- foreignKeys: Record<string, string>;
3890
- compositePrimaryKeys: Record<string, string>;
3891
- uniqueConstraints: Record<string, string>;
3892
- }, {
3893
- uniqueConstraints?: Record<string, string> | undefined;
3894
- name: string;
3895
- columns: Record<string, {
3896
- default?: any;
3897
- onUpdate?: any;
3898
- autoincrement?: boolean | undefined;
3899
- name: string;
3900
- type: string;
3901
- primaryKey: boolean;
3902
- notNull: boolean;
3903
- }>;
3904
- indexes: Record<string, string>;
3905
- foreignKeys: Record<string, string>;
3906
- compositePrimaryKeys: Record<string, string>;
3907
- }>>;
3908
- }, "strict", import("zod").ZodTypeAny, {
3909
- tables: Record<string, {
3910
- name: string;
3911
- columns: Record<string, {
3912
- default?: any;
3913
- onUpdate?: any;
3914
- autoincrement?: boolean | undefined;
3915
- name: string;
3916
- type: string;
3917
- primaryKey: boolean;
3918
- notNull: boolean;
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
- uniqueConstraints?: Record<string, string> | undefined;
3930
- name: string;
3931
- columns: Record<string, {
3932
- default?: any;
3933
- onUpdate?: any;
3934
- autoincrement?: boolean | undefined;
3935
- name: string;
3936
- type: string;
3937
- primaryKey: boolean;
3938
- notNull: boolean;
3939
- }>;
3940
- indexes: Record<string, string>;
3941
- foreignKeys: Record<string, string>;
3942
- compositePrimaryKeys: Record<string, string>;
3943
- }>;
3944
- version: "5";
3945
- dialect: "mysql";
3946
- }>;
3947
- export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").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
- default?: any;
3962
- onUpdate?: any;
3963
- autoincrement?: boolean | undefined;
3964
- name: string;
3965
- type: string;
3966
- primaryKey: boolean;
3967
- notNull: boolean;
3968
- }, {
3969
- default?: any;
3970
- onUpdate?: any;
3971
- autoincrement?: boolean | undefined;
3972
- name: string;
3973
- type: string;
3974
- primaryKey: boolean;
3975
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
3986
- algorithm?: "default" | "inplace" | "copy" | undefined;
3987
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3988
- name: string;
3989
- columns: string[];
3990
- isUnique: boolean;
3991
- }, {
3992
- using?: "btree" | "hash" | undefined;
3993
- algorithm?: "default" | "inplace" | "copy" | undefined;
3994
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3995
- name: string;
3996
- columns: string[];
3997
- isUnique: boolean;
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
- onUpdate?: string | undefined;
4009
- onDelete?: string | undefined;
4010
- name: string;
4011
- tableFrom: string;
4012
- columnsFrom: string[];
4013
- tableTo: string;
4014
- columnsTo: string[];
4015
- }, {
4016
- onUpdate?: string | undefined;
4017
- onDelete?: string | undefined;
4018
- name: string;
4019
- tableFrom: string;
4020
- columnsFrom: string[];
4021
- tableTo: string;
4022
- columnsTo: string[];
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
- default?: any;
4048
- onUpdate?: any;
4049
- autoincrement?: boolean | undefined;
4050
- name: string;
4051
- type: string;
4052
- primaryKey: boolean;
4053
- notNull: boolean;
4054
- }>;
4055
- indexes: Record<string, {
4056
- using?: "btree" | "hash" | undefined;
4057
- algorithm?: "default" | "inplace" | "copy" | undefined;
4058
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4059
- name: string;
4060
- columns: string[];
4061
- isUnique: boolean;
4062
- }>;
4063
- foreignKeys: Record<string, {
4064
- onUpdate?: string | undefined;
4065
- onDelete?: string | undefined;
4066
- name: string;
4067
- tableFrom: string;
4068
- columnsFrom: string[];
4069
- tableTo: string;
4070
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
4082
- name: string;
4083
- columns: string[];
4084
- }> | undefined;
4085
- name: string;
4086
- columns: Record<string, {
4087
- default?: any;
4088
- onUpdate?: any;
4089
- autoincrement?: boolean | undefined;
4090
- name: string;
4091
- type: string;
4092
- primaryKey: boolean;
4093
- notNull: boolean;
4094
- }>;
4095
- indexes: Record<string, {
4096
- using?: "btree" | "hash" | undefined;
4097
- algorithm?: "default" | "inplace" | "copy" | undefined;
4098
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4099
- name: string;
4100
- columns: string[];
4101
- isUnique: boolean;
4102
- }>;
4103
- foreignKeys: Record<string, {
4104
- onUpdate?: string | undefined;
4105
- onDelete?: string | undefined;
4106
- name: string;
4107
- tableFrom: string;
4108
- columnsFrom: string[];
4109
- tableTo: string;
4110
- columnsTo: string[];
4111
- }>;
4112
- compositePrimaryKeys: Record<string, {
4113
- name: string;
4114
- columns: string[];
4115
- }>;
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
- internal?: {
4167
- tables: Record<string, {
4168
- columns: Record<string, {
4169
- isDefaultAnExpression?: boolean | undefined;
4170
- } | undefined>;
4171
- } | undefined>;
4172
- } | undefined;
4173
- tables: Record<string, {
4174
- name: string;
4175
- columns: Record<string, {
4176
- default?: any;
4177
- onUpdate?: any;
4178
- autoincrement?: boolean | undefined;
4179
- name: string;
4180
- type: string;
4181
- primaryKey: boolean;
4182
- notNull: boolean;
4183
- }>;
4184
- indexes: Record<string, {
4185
- using?: "btree" | "hash" | undefined;
4186
- algorithm?: "default" | "inplace" | "copy" | undefined;
4187
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4188
- name: string;
4189
- columns: string[];
4190
- isUnique: boolean;
4191
- }>;
4192
- foreignKeys: Record<string, {
4193
- onUpdate?: string | undefined;
4194
- onDelete?: string | undefined;
4195
- name: string;
4196
- tableFrom: string;
4197
- columnsFrom: string[];
4198
- tableTo: string;
4199
- columnsTo: string[];
4200
- }>;
4201
- compositePrimaryKeys: Record<string, {
4202
- name: string;
4203
- columns: string[];
4204
- }>;
4205
- uniqueConstraints: Record<string, {
4206
- name: string;
4207
- columns: string[];
4208
- }>;
4209
- }>;
4210
- id: string;
4211
- prevId: string;
4212
- version: "5";
4213
- dialect: "mysql";
4214
- schemas: Record<string, string>;
4215
- _meta: {
4216
- columns: Record<string, string>;
4217
- tables: Record<string, string>;
4218
- schemas: Record<string, string>;
4219
- };
4220
- }, {
4221
- internal?: {
4222
- tables: Record<string, {
4223
- columns: Record<string, {
4224
- isDefaultAnExpression?: boolean | undefined;
4225
- } | undefined>;
4226
- } | undefined>;
4227
- } | undefined;
4228
- tables: Record<string, {
4229
- uniqueConstraints?: Record<string, {
4230
- name: string;
4231
- columns: string[];
4232
- }> | undefined;
4233
- name: string;
4234
- columns: Record<string, {
4235
- default?: any;
4236
- onUpdate?: any;
4237
- autoincrement?: boolean | undefined;
4238
- name: string;
4239
- type: string;
4240
- primaryKey: boolean;
4241
- notNull: boolean;
4242
- }>;
4243
- indexes: Record<string, {
4244
- using?: "btree" | "hash" | undefined;
4245
- algorithm?: "default" | "inplace" | "copy" | undefined;
4246
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4247
- name: string;
4248
- columns: string[];
4249
- isUnique: boolean;
4250
- }>;
4251
- foreignKeys: Record<string, {
4252
- onUpdate?: string | undefined;
4253
- onDelete?: string | undefined;
4254
- name: string;
4255
- tableFrom: string;
4256
- columnsFrom: string[];
4257
- tableTo: string;
4258
- columnsTo: string[];
4259
- }>;
4260
- compositePrimaryKeys: Record<string, {
4261
- name: string;
4262
- columns: string[];
4263
- }>;
4264
- }>;
4265
- id: string;
4266
- prevId: string;
4267
- version: "5";
4268
- dialect: "mysql";
4269
- schemas: Record<string, string>;
4270
- _meta: {
4271
- columns: Record<string, string>;
4272
- tables: Record<string, string>;
4273
- schemas: Record<string, string>;
4274
- };
4275
- }>, import("zod").ZodObject<import("zod").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
- default?: any;
4290
- onUpdate?: any;
4291
- autoincrement?: boolean | undefined;
4292
- name: string;
4293
- type: string;
4294
- primaryKey: boolean;
4295
- notNull: boolean;
4296
- }, {
4297
- default?: any;
4298
- onUpdate?: any;
4299
- autoincrement?: boolean | undefined;
4300
- name: string;
4301
- type: string;
4302
- primaryKey: boolean;
4303
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
4314
- algorithm?: "default" | "inplace" | "copy" | undefined;
4315
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4316
- name: string;
4317
- columns: string[];
4318
- isUnique: boolean;
4319
- }, {
4320
- using?: "btree" | "hash" | undefined;
4321
- algorithm?: "default" | "inplace" | "copy" | undefined;
4322
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4323
- name: string;
4324
- columns: string[];
4325
- isUnique: boolean;
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
- onUpdate?: string | undefined;
4337
- onDelete?: string | undefined;
4338
- name: string;
4339
- tableFrom: string;
4340
- columnsFrom: string[];
4341
- tableTo: string;
4342
- columnsTo: string[];
4343
- }, {
4344
- onUpdate?: string | undefined;
4345
- onDelete?: string | undefined;
4346
- name: string;
4347
- tableFrom: string;
4348
- columnsFrom: string[];
4349
- tableTo: string;
4350
- columnsTo: string[];
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
- default?: any;
4376
- onUpdate?: any;
4377
- autoincrement?: boolean | undefined;
4378
- name: string;
4379
- type: string;
4380
- primaryKey: boolean;
4381
- notNull: boolean;
4382
- }>;
4383
- indexes: Record<string, {
4384
- using?: "btree" | "hash" | undefined;
4385
- algorithm?: "default" | "inplace" | "copy" | undefined;
4386
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4387
- name: string;
4388
- columns: string[];
4389
- isUnique: boolean;
4390
- }>;
4391
- foreignKeys: Record<string, {
4392
- onUpdate?: string | undefined;
4393
- onDelete?: string | undefined;
4394
- name: string;
4395
- tableFrom: string;
4396
- columnsFrom: string[];
4397
- tableTo: string;
4398
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
4410
- name: string;
4411
- columns: string[];
4412
- }> | undefined;
4413
- name: string;
4414
- columns: Record<string, {
4415
- default?: any;
4416
- onUpdate?: any;
4417
- autoincrement?: boolean | undefined;
4418
- name: string;
4419
- type: string;
4420
- primaryKey: boolean;
4421
- notNull: boolean;
4422
- }>;
4423
- indexes: Record<string, {
4424
- using?: "btree" | "hash" | undefined;
4425
- algorithm?: "default" | "inplace" | "copy" | undefined;
4426
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4427
- name: string;
4428
- columns: string[];
4429
- isUnique: boolean;
4430
- }>;
4431
- foreignKeys: Record<string, {
4432
- onUpdate?: string | undefined;
4433
- onDelete?: string | undefined;
4434
- name: string;
4435
- tableFrom: string;
4436
- columnsFrom: string[];
4437
- tableTo: string;
4438
- columnsTo: string[];
4439
- }>;
4440
- compositePrimaryKeys: Record<string, {
4441
- name: string;
4442
- columns: string[];
4443
- }>;
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
- internal?: {
4491
- tables: Record<string, {
4492
- columns: Record<string, {
4493
- isDefaultAnExpression?: boolean | undefined;
4494
- } | undefined>;
4495
- } | undefined>;
4496
- } | undefined;
4497
- tables: Record<string, {
4498
- name: string;
4499
- columns: Record<string, {
4500
- default?: any;
4501
- onUpdate?: any;
4502
- autoincrement?: boolean | undefined;
4503
- name: string;
4504
- type: string;
4505
- primaryKey: boolean;
4506
- notNull: boolean;
4507
- }>;
4508
- indexes: Record<string, {
4509
- using?: "btree" | "hash" | undefined;
4510
- algorithm?: "default" | "inplace" | "copy" | undefined;
4511
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4512
- name: string;
4513
- columns: string[];
4514
- isUnique: boolean;
4515
- }>;
4516
- foreignKeys: Record<string, {
4517
- onUpdate?: string | undefined;
4518
- onDelete?: string | undefined;
4519
- name: string;
4520
- tableFrom: string;
4521
- columnsFrom: string[];
4522
- tableTo: string;
4523
- columnsTo: string[];
4524
- }>;
4525
- compositePrimaryKeys: Record<string, {
4526
- name: string;
4527
- columns: string[];
4528
- }>;
4529
- uniqueConstraints: Record<string, {
4530
- name: string;
4531
- columns: string[];
4532
- }>;
4533
- }>;
4534
- id: string;
4535
- prevId: string;
4536
- version: "5";
4537
- dialect: "mysql";
4538
- _meta: {
4539
- columns: Record<string, string>;
4540
- tables: Record<string, string>;
4541
- };
4542
- }, {
4543
- internal?: {
4544
- tables: Record<string, {
4545
- columns: Record<string, {
4546
- isDefaultAnExpression?: boolean | undefined;
4547
- } | undefined>;
4548
- } | undefined>;
4549
- } | undefined;
4550
- tables: Record<string, {
4551
- uniqueConstraints?: Record<string, {
4552
- name: string;
4553
- columns: string[];
4554
- }> | undefined;
4555
- name: string;
4556
- columns: Record<string, {
4557
- default?: any;
4558
- onUpdate?: any;
4559
- autoincrement?: boolean | undefined;
4560
- name: string;
4561
- type: string;
4562
- primaryKey: boolean;
4563
- notNull: boolean;
4564
- }>;
4565
- indexes: Record<string, {
4566
- using?: "btree" | "hash" | undefined;
4567
- algorithm?: "default" | "inplace" | "copy" | undefined;
4568
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4569
- name: string;
4570
- columns: string[];
4571
- isUnique: boolean;
4572
- }>;
4573
- foreignKeys: Record<string, {
4574
- onUpdate?: string | undefined;
4575
- onDelete?: string | undefined;
4576
- name: string;
4577
- tableFrom: string;
4578
- columnsFrom: string[];
4579
- tableTo: string;
4580
- columnsTo: string[];
4581
- }>;
4582
- compositePrimaryKeys: Record<string, {
4583
- name: string;
4584
- columns: string[];
4585
- }>;
4586
- }>;
4587
- id: string;
4588
- prevId: string;
4589
- version: "5";
4590
- dialect: "mysql";
4591
- _meta: {
4592
- columns: Record<string, string>;
4593
- tables: Record<string, string>;
4594
- };
4595
- }>]>;
4596
- export declare const dryMySql: {
4597
- internal?: {
4598
- tables: Record<string, {
4599
- columns: Record<string, {
4600
- isDefaultAnExpression?: boolean | undefined;
4601
- } | undefined>;
4602
- } | undefined>;
4603
- } | undefined;
4604
- tables: Record<string, {
4605
- name: string;
4606
- columns: Record<string, {
4607
- default?: any;
4608
- onUpdate?: any;
4609
- autoincrement?: boolean | undefined;
4610
- name: string;
4611
- type: string;
4612
- primaryKey: boolean;
4613
- notNull: boolean;
4614
- }>;
4615
- indexes: Record<string, {
4616
- using?: "btree" | "hash" | undefined;
4617
- algorithm?: "default" | "inplace" | "copy" | undefined;
4618
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4619
- name: string;
4620
- columns: string[];
4621
- isUnique: boolean;
4622
- }>;
4623
- foreignKeys: Record<string, {
4624
- onUpdate?: string | undefined;
4625
- onDelete?: string | undefined;
4626
- name: string;
4627
- tableFrom: string;
4628
- columnsFrom: string[];
4629
- tableTo: string;
4630
- columnsTo: string[];
4631
- }>;
4632
- compositePrimaryKeys: Record<string, {
4633
- name: string;
4634
- columns: string[];
4635
- }>;
4636
- uniqueConstraints: Record<string, {
4637
- name: string;
4638
- columns: string[];
4639
- }>;
4640
- }>;
4641
- id: string;
4642
- prevId: string;
4643
- version: "5";
4644
- dialect: "mysql";
4645
- _meta: {
4646
- columns: Record<string, string>;
4647
- tables: Record<string, string>;
4648
- };
4649
- };
4650
- export {};