drizzle-kit 0.20.17-b08243d → 0.20.17-b4f119e

Sign up to get free protection for your applications and to get access to all the features.
Files changed (22) hide show
  1. package/bin.cjs +26342 -25481
  2. package/cli/commands/migrate.d.ts +39 -39
  3. package/cli/commands/mysqlIntrospect.d.ts +8 -8
  4. package/cli/commands/pgIntrospect.d.ts +7 -7
  5. package/cli/commands/sqliteIntrospect.d.ts +12 -12
  6. package/cli/validations/cli.d.ts +13 -13
  7. package/cli/validations/common.d.ts +27 -27
  8. package/cli/validations/mysql.d.ts +4 -4
  9. package/cli/validations/outputs.d.ts +0 -1
  10. package/cli/validations/pg.d.ts +4 -4
  11. package/package.json +1 -1
  12. package/payload.js +1037 -433
  13. package/payload.mjs +844 -240
  14. package/schemaValidator.d.ts +215 -215
  15. package/serializer/mysqlSchema.d.ts +892 -892
  16. package/serializer/pgSchema.d.ts +734 -734
  17. package/serializer/sqliteSchema.d.ts +457 -457
  18. package/snapshotsDiffer.d.ts +314 -314
  19. package/utils-studio.js +939 -833
  20. package/utils-studio.mjs +912 -806
  21. package/utils.js +839 -214
  22. package/utils.mjs +814 -189
package/serializer/mysqlSchema.d.ts CHANGED
@@ -7,19 +7,19 @@ declare const index: import("zod").ZodObject<{
7
7
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
8
8
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
9
9
  }, "strict", import("zod").ZodTypeAny, {
10
- using?: "btree" | "hash" | undefined;
11
- algorithm?: "default" | "inplace" | "copy" | undefined;
12
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
13
10
  name: string;
14
11
  columns: string[];
15
12
  isUnique: boolean;
16
- }, {
17
13
  using?: "btree" | "hash" | undefined;
18
14
  algorithm?: "default" | "inplace" | "copy" | undefined;
19
15
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
16
+ }, {
20
17
  name: string;
21
18
  columns: string[];
22
19
  isUnique: boolean;
20
+ using?: "btree" | "hash" | undefined;
21
+ algorithm?: "default" | "inplace" | "copy" | undefined;
22
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
23
23
  }>;
24
24
  declare const fk: import("zod").ZodObject<{
25
25
  name: import("zod").ZodString;
@@ -30,21 +30,21 @@ declare const fk: import("zod").ZodObject<{
30
30
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
31
31
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
32
32
  }, "strict", import("zod").ZodTypeAny, {
33
- onUpdate?: string | undefined;
34
- onDelete?: string | undefined;
35
33
  name: string;
36
34
  tableFrom: string;
37
35
  columnsFrom: string[];
38
36
  tableTo: string;
39
37
  columnsTo: string[];
40
- }, {
41
38
  onUpdate?: string | undefined;
42
39
  onDelete?: string | undefined;
40
+ }, {
43
41
  name: string;
44
42
  tableFrom: string;
45
43
  columnsFrom: string[];
46
44
  tableTo: string;
47
45
  columnsTo: string[];
46
+ onUpdate?: string | undefined;
47
+ onDelete?: string | undefined;
48
48
  }>;
49
49
  declare const column: import("zod").ZodObject<{
50
50
  name: import("zod").ZodString;
@@ -55,21 +55,21 @@ declare const column: import("zod").ZodObject<{
55
55
  default: import("zod").ZodOptional<import("zod").ZodAny>;
56
56
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
57
57
  }, "strict", import("zod").ZodTypeAny, {
58
- default?: any;
59
- onUpdate?: any;
60
- autoincrement?: boolean | undefined;
61
58
  name: string;
62
59
  type: string;
63
60
  primaryKey: boolean;
64
61
  notNull: boolean;
65
- }, {
66
62
  default?: any;
67
63
  onUpdate?: any;
68
64
  autoincrement?: boolean | undefined;
65
+ }, {
69
66
  name: string;
70
67
  type: string;
71
68
  primaryKey: boolean;
72
69
  notNull: boolean;
70
+ default?: any;
71
+ onUpdate?: any;
72
+ autoincrement?: boolean | undefined;
73
73
  }>;
74
74
  declare const compositePK: import("zod").ZodObject<{
75
75
  name: import("zod").ZodString;
@@ -103,21 +103,21 @@ declare const tableV4: import("zod").ZodObject<{
103
103
  default: import("zod").ZodOptional<import("zod").ZodAny>;
104
104
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
105
105
  }, "strict", import("zod").ZodTypeAny, {
106
- default?: any;
107
- onUpdate?: any;
108
- autoincrement?: boolean | undefined;
109
106
  name: string;
110
107
  type: string;
111
108
  primaryKey: boolean;
112
109
  notNull: boolean;
113
- }, {
114
110
  default?: any;
115
111
  onUpdate?: any;
116
112
  autoincrement?: boolean | undefined;
113
+ }, {
117
114
  name: string;
118
115
  type: string;
119
116
  primaryKey: boolean;
120
117
  notNull: boolean;
118
+ default?: any;
119
+ onUpdate?: any;
120
+ autoincrement?: boolean | undefined;
121
121
  }>>;
122
122
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
123
123
  name: import("zod").ZodString;
@@ -127,19 +127,19 @@ declare const tableV4: import("zod").ZodObject<{
127
127
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
128
128
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
129
129
  }, "strict", import("zod").ZodTypeAny, {
130
- using?: "btree" | "hash" | undefined;
131
- algorithm?: "default" | "inplace" | "copy" | undefined;
132
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
133
130
  name: string;
134
131
  columns: string[];
135
132
  isUnique: boolean;
136
- }, {
137
133
  using?: "btree" | "hash" | undefined;
138
134
  algorithm?: "default" | "inplace" | "copy" | undefined;
139
135
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
136
+ }, {
140
137
  name: string;
141
138
  columns: string[];
142
139
  isUnique: boolean;
140
+ using?: "btree" | "hash" | undefined;
141
+ algorithm?: "default" | "inplace" | "copy" | undefined;
142
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
143
143
  }>>;
144
144
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
145
145
  name: import("zod").ZodString;
@@ -150,80 +150,80 @@ declare const tableV4: import("zod").ZodObject<{
150
150
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
151
151
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
152
152
  }, "strict", import("zod").ZodTypeAny, {
153
- onUpdate?: string | undefined;
154
- onDelete?: string | undefined;
155
153
  name: string;
156
154
  tableFrom: string;
157
155
  columnsFrom: string[];
158
156
  tableTo: string;
159
157
  columnsTo: string[];
160
- }, {
161
158
  onUpdate?: string | undefined;
162
159
  onDelete?: string | undefined;
160
+ }, {
163
161
  name: string;
164
162
  tableFrom: string;
165
163
  columnsFrom: string[];
166
164
  tableTo: string;
167
165
  columnsTo: string[];
166
+ onUpdate?: string | undefined;
167
+ onDelete?: string | undefined;
168
168
  }>>;
169
169
  }, "strict", import("zod").ZodTypeAny, {
170
- schema?: string | undefined;
171
170
  name: string;
172
171
  columns: Record<string, {
173
- default?: any;
174
- onUpdate?: any;
175
- autoincrement?: boolean | undefined;
176
172
  name: string;
177
173
  type: string;
178
174
  primaryKey: boolean;
179
175
  notNull: boolean;
176
+ default?: any;
177
+ onUpdate?: any;
178
+ autoincrement?: boolean | undefined;
180
179
  }>;
181
180
  indexes: Record<string, {
182
- using?: "btree" | "hash" | undefined;
183
- algorithm?: "default" | "inplace" | "copy" | undefined;
184
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
185
181
  name: string;
186
182
  columns: string[];
187
183
  isUnique: boolean;
184
+ using?: "btree" | "hash" | undefined;
185
+ algorithm?: "default" | "inplace" | "copy" | undefined;
186
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
188
187
  }>;
189
188
  foreignKeys: Record<string, {
190
- onUpdate?: string | undefined;
191
- onDelete?: string | undefined;
192
189
  name: string;
193
190
  tableFrom: string;
194
191
  columnsFrom: string[];
195
192
  tableTo: string;
196
193
  columnsTo: string[];
194
+ onUpdate?: string | undefined;
195
+ onDelete?: string | undefined;
197
196
  }>;
198
- }, {
199
197
  schema?: string | undefined;
198
+ }, {
200
199
  name: string;
201
200
  columns: Record<string, {
202
- default?: any;
203
- onUpdate?: any;
204
- autoincrement?: boolean | undefined;
205
201
  name: string;
206
202
  type: string;
207
203
  primaryKey: boolean;
208
204
  notNull: boolean;
205
+ default?: any;
206
+ onUpdate?: any;
207
+ autoincrement?: boolean | undefined;
209
208
  }>;
210
209
  indexes: Record<string, {
211
- using?: "btree" | "hash" | undefined;
212
- algorithm?: "default" | "inplace" | "copy" | undefined;
213
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
214
210
  name: string;
215
211
  columns: string[];
216
212
  isUnique: boolean;
213
+ using?: "btree" | "hash" | undefined;
214
+ algorithm?: "default" | "inplace" | "copy" | undefined;
215
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
217
216
  }>;
218
217
  foreignKeys: Record<string, {
219
- onUpdate?: string | undefined;
220
- onDelete?: string | undefined;
221
218
  name: string;
222
219
  tableFrom: string;
223
220
  columnsFrom: string[];
224
221
  tableTo: string;
225
222
  columnsTo: string[];
223
+ onUpdate?: string | undefined;
224
+ onDelete?: string | undefined;
226
225
  }>;
226
+ schema?: string | undefined;
227
227
  }>;
228
228
  declare const table: import("zod").ZodObject<{
229
229
  name: import("zod").ZodString;
@@ -236,21 +236,21 @@ declare const table: import("zod").ZodObject<{
236
236
  default: import("zod").ZodOptional<import("zod").ZodAny>;
237
237
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
238
238
  }, "strict", import("zod").ZodTypeAny, {
239
- default?: any;
240
- onUpdate?: any;
241
- autoincrement?: boolean | undefined;
242
239
  name: string;
243
240
  type: string;
244
241
  primaryKey: boolean;
245
242
  notNull: boolean;
246
- }, {
247
243
  default?: any;
248
244
  onUpdate?: any;
249
245
  autoincrement?: boolean | undefined;
246
+ }, {
250
247
  name: string;
251
248
  type: string;
252
249
  primaryKey: boolean;
253
250
  notNull: boolean;
251
+ default?: any;
252
+ onUpdate?: any;
253
+ autoincrement?: boolean | undefined;
254
254
  }>>;
255
255
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
256
256
  name: import("zod").ZodString;
@@ -260,19 +260,19 @@ declare const table: import("zod").ZodObject<{
260
260
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
261
261
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
262
262
  }, "strict", import("zod").ZodTypeAny, {
263
- using?: "btree" | "hash" | undefined;
264
- algorithm?: "default" | "inplace" | "copy" | undefined;
265
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
266
263
  name: string;
267
264
  columns: string[];
268
265
  isUnique: boolean;
269
- }, {
270
266
  using?: "btree" | "hash" | undefined;
271
267
  algorithm?: "default" | "inplace" | "copy" | undefined;
272
268
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
269
+ }, {
273
270
  name: string;
274
271
  columns: string[];
275
272
  isUnique: boolean;
273
+ using?: "btree" | "hash" | undefined;
274
+ algorithm?: "default" | "inplace" | "copy" | undefined;
275
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
276
276
  }>>;
277
277
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
278
278
  name: import("zod").ZodString;
@@ -283,21 +283,21 @@ declare const table: import("zod").ZodObject<{
283
283
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
284
284
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
285
285
  }, "strict", import("zod").ZodTypeAny, {
286
- onUpdate?: string | undefined;
287
- onDelete?: string | undefined;
288
286
  name: string;
289
287
  tableFrom: string;
290
288
  columnsFrom: string[];
291
289
  tableTo: string;
292
290
  columnsTo: string[];
293
- }, {
294
291
  onUpdate?: string | undefined;
295
292
  onDelete?: string | undefined;
293
+ }, {
296
294
  name: string;
297
295
  tableFrom: string;
298
296
  columnsFrom: string[];
299
297
  tableTo: string;
300
298
  columnsTo: string[];
299
+ onUpdate?: string | undefined;
300
+ onDelete?: string | undefined;
301
301
  }>>;
302
302
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
303
303
  name: import("zod").ZodString;
@@ -322,30 +322,30 @@ declare const table: import("zod").ZodObject<{
322
322
  }, "strict", import("zod").ZodTypeAny, {
323
323
  name: string;
324
324
  columns: Record<string, {
325
- default?: any;
326
- onUpdate?: any;
327
- autoincrement?: boolean | undefined;
328
325
  name: string;
329
326
  type: string;
330
327
  primaryKey: boolean;
331
328
  notNull: boolean;
329
+ default?: any;
330
+ onUpdate?: any;
331
+ autoincrement?: boolean | undefined;
332
332
  }>;
333
333
  indexes: Record<string, {
334
- using?: "btree" | "hash" | undefined;
335
- algorithm?: "default" | "inplace" | "copy" | undefined;
336
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
337
334
  name: string;
338
335
  columns: string[];
339
336
  isUnique: boolean;
337
+ using?: "btree" | "hash" | undefined;
338
+ algorithm?: "default" | "inplace" | "copy" | undefined;
339
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
340
340
  }>;
341
341
  foreignKeys: Record<string, {
342
- onUpdate?: string | undefined;
343
- onDelete?: string | undefined;
344
342
  name: string;
345
343
  tableFrom: string;
346
344
  columnsFrom: string[];
347
345
  tableTo: string;
348
346
  columnsTo: string[];
347
+ onUpdate?: string | undefined;
348
+ onDelete?: string | undefined;
349
349
  }>;
350
350
  compositePrimaryKeys: Record<string, {
351
351
  name: string;
@@ -356,41 +356,41 @@ declare const table: import("zod").ZodObject<{
356
356
  columns: string[];
357
357
  }>;
358
358
  }, {
359
- uniqueConstraints?: Record<string, {
360
- name: string;
361
- columns: string[];
362
- }> | undefined;
363
359
  name: string;
364
360
  columns: Record<string, {
365
- default?: any;
366
- onUpdate?: any;
367
- autoincrement?: boolean | undefined;
368
361
  name: string;
369
362
  type: string;
370
363
  primaryKey: boolean;
371
364
  notNull: boolean;
365
+ default?: any;
366
+ onUpdate?: any;
367
+ autoincrement?: boolean | undefined;
372
368
  }>;
373
369
  indexes: Record<string, {
374
- using?: "btree" | "hash" | undefined;
375
- algorithm?: "default" | "inplace" | "copy" | undefined;
376
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
377
370
  name: string;
378
371
  columns: string[];
379
372
  isUnique: boolean;
373
+ using?: "btree" | "hash" | undefined;
374
+ algorithm?: "default" | "inplace" | "copy" | undefined;
375
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
380
376
  }>;
381
377
  foreignKeys: Record<string, {
382
- onUpdate?: string | undefined;
383
- onDelete?: string | undefined;
384
378
  name: string;
385
379
  tableFrom: string;
386
380
  columnsFrom: string[];
387
381
  tableTo: string;
388
382
  columnsTo: string[];
383
+ onUpdate?: string | undefined;
384
+ onDelete?: string | undefined;
389
385
  }>;
390
386
  compositePrimaryKeys: Record<string, {
391
387
  name: string;
392
388
  columns: string[];
393
389
  }>;
390
+ uniqueConstraints?: Record<string, {
391
+ name: string;
392
+ columns: string[];
393
+ }> | undefined;
394
394
  }>;
395
395
  export declare const kitInternals: import("zod").ZodOptional<import("zod").ZodObject<{
396
396
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
@@ -438,21 +438,21 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
438
438
  default: import("zod").ZodOptional<import("zod").ZodAny>;
439
439
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
440
440
  }, "strict", import("zod").ZodTypeAny, {
441
- default?: any;
442
- onUpdate?: any;
443
- autoincrement?: boolean | undefined;
444
441
  name: string;
445
442
  type: string;
446
443
  primaryKey: boolean;
447
444
  notNull: boolean;
448
- }, {
449
445
  default?: any;
450
446
  onUpdate?: any;
451
447
  autoincrement?: boolean | undefined;
448
+ }, {
452
449
  name: string;
453
450
  type: string;
454
451
  primaryKey: boolean;
455
452
  notNull: boolean;
453
+ default?: any;
454
+ onUpdate?: any;
455
+ autoincrement?: boolean | undefined;
456
456
  }>>;
457
457
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
458
458
  name: import("zod").ZodString;
@@ -462,19 +462,19 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
462
462
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
463
463
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
464
464
  }, "strict", import("zod").ZodTypeAny, {
465
- using?: "btree" | "hash" | undefined;
466
- algorithm?: "default" | "inplace" | "copy" | undefined;
467
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
468
465
  name: string;
469
466
  columns: string[];
470
467
  isUnique: boolean;
471
- }, {
472
468
  using?: "btree" | "hash" | undefined;
473
469
  algorithm?: "default" | "inplace" | "copy" | undefined;
474
470
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
471
+ }, {
475
472
  name: string;
476
473
  columns: string[];
477
474
  isUnique: boolean;
475
+ using?: "btree" | "hash" | undefined;
476
+ algorithm?: "default" | "inplace" | "copy" | undefined;
477
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
478
478
  }>>;
479
479
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
480
480
  name: import("zod").ZodString;
@@ -485,107 +485,107 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
485
485
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
486
486
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
487
487
  }, "strict", import("zod").ZodTypeAny, {
488
- onUpdate?: string | undefined;
489
- onDelete?: string | undefined;
490
488
  name: string;
491
489
  tableFrom: string;
492
490
  columnsFrom: string[];
493
491
  tableTo: string;
494
492
  columnsTo: string[];
495
- }, {
496
493
  onUpdate?: string | undefined;
497
494
  onDelete?: string | undefined;
495
+ }, {
498
496
  name: string;
499
497
  tableFrom: string;
500
498
  columnsFrom: string[];
501
499
  tableTo: string;
502
500
  columnsTo: string[];
501
+ onUpdate?: string | undefined;
502
+ onDelete?: string | undefined;
503
503
  }>>;
504
504
  }, "strict", import("zod").ZodTypeAny, {
505
505
  name: string;
506
506
  columns: Record<string, {
507
- default?: any;
508
- onUpdate?: any;
509
- autoincrement?: boolean | undefined;
510
507
  name: string;
511
508
  type: string;
512
509
  primaryKey: boolean;
513
510
  notNull: boolean;
511
+ default?: any;
512
+ onUpdate?: any;
513
+ autoincrement?: boolean | undefined;
514
514
  }>;
515
515
  indexes: Record<string, {
516
- using?: "btree" | "hash" | undefined;
517
- algorithm?: "default" | "inplace" | "copy" | undefined;
518
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
519
516
  name: string;
520
517
  columns: string[];
521
518
  isUnique: boolean;
519
+ using?: "btree" | "hash" | undefined;
520
+ algorithm?: "default" | "inplace" | "copy" | undefined;
521
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
522
522
  }>;
523
523
  foreignKeys: Record<string, {
524
- onUpdate?: string | undefined;
525
- onDelete?: string | undefined;
526
524
  name: string;
527
525
  tableFrom: string;
528
526
  columnsFrom: string[];
529
527
  tableTo: string;
530
528
  columnsTo: string[];
529
+ onUpdate?: string | undefined;
530
+ onDelete?: string | undefined;
531
531
  }>;
532
532
  }, {
533
533
  name: string;
534
534
  columns: Record<string, {
535
- default?: any;
536
- onUpdate?: any;
537
- autoincrement?: boolean | undefined;
538
535
  name: string;
539
536
  type: string;
540
537
  primaryKey: boolean;
541
538
  notNull: boolean;
539
+ default?: any;
540
+ onUpdate?: any;
541
+ autoincrement?: boolean | undefined;
542
542
  }>;
543
543
  indexes: Record<string, {
544
- using?: "btree" | "hash" | undefined;
545
- algorithm?: "default" | "inplace" | "copy" | undefined;
546
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
547
544
  name: string;
548
545
  columns: string[];
549
546
  isUnique: boolean;
547
+ using?: "btree" | "hash" | undefined;
548
+ algorithm?: "default" | "inplace" | "copy" | undefined;
549
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
550
550
  }>;
551
551
  foreignKeys: Record<string, {
552
- onUpdate?: string | undefined;
553
- onDelete?: string | undefined;
554
552
  name: string;
555
553
  tableFrom: string;
556
554
  columnsFrom: string[];
557
555
  tableTo: string;
558
556
  columnsTo: string[];
557
+ onUpdate?: string | undefined;
558
+ onDelete?: string | undefined;
559
559
  }>;
560
560
  }>>;
561
561
  }, "strict", import("zod").ZodTypeAny, {
562
562
  tables: Record<string, {
563
563
  name: string;
564
564
  columns: Record<string, {
565
- default?: any;
566
- onUpdate?: any;
567
- autoincrement?: boolean | undefined;
568
565
  name: string;
569
566
  type: string;
570
567
  primaryKey: boolean;
571
568
  notNull: boolean;
569
+ default?: any;
570
+ onUpdate?: any;
571
+ autoincrement?: boolean | undefined;
572
572
  }>;
573
573
  indexes: Record<string, {
574
- using?: "btree" | "hash" | undefined;
575
- algorithm?: "default" | "inplace" | "copy" | undefined;
576
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
577
574
  name: string;
578
575
  columns: string[];
579
576
  isUnique: boolean;
577
+ using?: "btree" | "hash" | undefined;
578
+ algorithm?: "default" | "inplace" | "copy" | undefined;
579
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
580
580
  }>;
581
581
  foreignKeys: Record<string, {
582
- onUpdate?: string | undefined;
583
- onDelete?: string | undefined;
584
582
  name: string;
585
583
  tableFrom: string;
586
584
  columnsFrom: string[];
587
585
  tableTo: string;
588
586
  columnsTo: string[];
587
+ onUpdate?: string | undefined;
588
+ onDelete?: string | undefined;
589
589
  }>;
590
590
  }>;
591
591
  version: "3";
@@ -594,30 +594,30 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
594
594
  tables: Record<string, {
595
595
  name: string;
596
596
  columns: Record<string, {
597
- default?: any;
598
- onUpdate?: any;
599
- autoincrement?: boolean | undefined;
600
597
  name: string;
601
598
  type: string;
602
599
  primaryKey: boolean;
603
600
  notNull: boolean;
601
+ default?: any;
602
+ onUpdate?: any;
603
+ autoincrement?: boolean | undefined;
604
604
  }>;
605
605
  indexes: Record<string, {
606
- using?: "btree" | "hash" | undefined;
607
- algorithm?: "default" | "inplace" | "copy" | undefined;
608
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
609
606
  name: string;
610
607
  columns: string[];
611
608
  isUnique: boolean;
609
+ using?: "btree" | "hash" | undefined;
610
+ algorithm?: "default" | "inplace" | "copy" | undefined;
611
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
612
612
  }>;
613
613
  foreignKeys: Record<string, {
614
- onUpdate?: string | undefined;
615
- onDelete?: string | undefined;
616
614
  name: string;
617
615
  tableFrom: string;
618
616
  columnsFrom: string[];
619
617
  tableTo: string;
620
618
  columnsTo: string[];
619
+ onUpdate?: string | undefined;
620
+ onDelete?: string | undefined;
621
621
  }>;
622
622
  }>;
623
623
  version: "3";
@@ -638,21 +638,21 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
638
638
  default: import("zod").ZodOptional<import("zod").ZodAny>;
639
639
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
640
640
  }, "strict", import("zod").ZodTypeAny, {
641
- default?: any;
642
- onUpdate?: any;
643
- autoincrement?: boolean | undefined;
644
641
  name: string;
645
642
  type: string;
646
643
  primaryKey: boolean;
647
644
  notNull: boolean;
648
- }, {
649
645
  default?: any;
650
646
  onUpdate?: any;
651
647
  autoincrement?: boolean | undefined;
648
+ }, {
652
649
  name: string;
653
650
  type: string;
654
651
  primaryKey: boolean;
655
652
  notNull: boolean;
653
+ default?: any;
654
+ onUpdate?: any;
655
+ autoincrement?: boolean | undefined;
656
656
  }>>;
657
657
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
658
658
  name: import("zod").ZodString;
@@ -662,19 +662,19 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
662
662
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
663
663
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
664
664
  }, "strict", import("zod").ZodTypeAny, {
665
- using?: "btree" | "hash" | undefined;
666
- algorithm?: "default" | "inplace" | "copy" | undefined;
667
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
668
665
  name: string;
669
666
  columns: string[];
670
667
  isUnique: boolean;
671
- }, {
672
668
  using?: "btree" | "hash" | undefined;
673
669
  algorithm?: "default" | "inplace" | "copy" | undefined;
674
670
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
671
+ }, {
675
672
  name: string;
676
673
  columns: string[];
677
674
  isUnique: boolean;
675
+ using?: "btree" | "hash" | undefined;
676
+ algorithm?: "default" | "inplace" | "copy" | undefined;
677
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
678
678
  }>>;
679
679
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
680
680
  name: import("zod").ZodString;
@@ -685,146 +685,146 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
685
685
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
686
686
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
687
687
  }, "strict", import("zod").ZodTypeAny, {
688
- onUpdate?: string | undefined;
689
- onDelete?: string | undefined;
690
688
  name: string;
691
689
  tableFrom: string;
692
690
  columnsFrom: string[];
693
691
  tableTo: string;
694
692
  columnsTo: string[];
695
- }, {
696
693
  onUpdate?: string | undefined;
697
694
  onDelete?: string | undefined;
695
+ }, {
698
696
  name: string;
699
697
  tableFrom: string;
700
698
  columnsFrom: string[];
701
699
  tableTo: string;
702
700
  columnsTo: string[];
701
+ onUpdate?: string | undefined;
702
+ onDelete?: string | undefined;
703
703
  }>>;
704
704
  }, "strict", import("zod").ZodTypeAny, {
705
- schema?: string | undefined;
706
705
  name: string;
707
706
  columns: Record<string, {
708
- default?: any;
709
- onUpdate?: any;
710
- autoincrement?: boolean | undefined;
711
707
  name: string;
712
708
  type: string;
713
709
  primaryKey: boolean;
714
710
  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;
711
+ default?: any;
712
+ onUpdate?: any;
713
+ autoincrement?: boolean | undefined;
714
+ }>;
715
+ indexes: Record<string, {
720
716
  name: string;
721
717
  columns: string[];
722
718
  isUnique: boolean;
719
+ using?: "btree" | "hash" | undefined;
720
+ algorithm?: "default" | "inplace" | "copy" | undefined;
721
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
723
722
  }>;
724
723
  foreignKeys: Record<string, {
725
- onUpdate?: string | undefined;
726
- onDelete?: string | undefined;
727
724
  name: string;
728
725
  tableFrom: string;
729
726
  columnsFrom: string[];
730
727
  tableTo: string;
731
728
  columnsTo: string[];
729
+ onUpdate?: string | undefined;
730
+ onDelete?: string | undefined;
732
731
  }>;
733
- }, {
734
732
  schema?: string | undefined;
733
+ }, {
735
734
  name: string;
736
735
  columns: Record<string, {
737
- default?: any;
738
- onUpdate?: any;
739
- autoincrement?: boolean | undefined;
740
736
  name: string;
741
737
  type: string;
742
738
  primaryKey: boolean;
743
739
  notNull: boolean;
740
+ default?: any;
741
+ onUpdate?: any;
742
+ autoincrement?: boolean | undefined;
744
743
  }>;
745
744
  indexes: Record<string, {
746
- using?: "btree" | "hash" | undefined;
747
- algorithm?: "default" | "inplace" | "copy" | undefined;
748
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
749
745
  name: string;
750
746
  columns: string[];
751
747
  isUnique: boolean;
748
+ using?: "btree" | "hash" | undefined;
749
+ algorithm?: "default" | "inplace" | "copy" | undefined;
750
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
752
751
  }>;
753
752
  foreignKeys: Record<string, {
754
- onUpdate?: string | undefined;
755
- onDelete?: string | undefined;
756
753
  name: string;
757
754
  tableFrom: string;
758
755
  columnsFrom: string[];
759
756
  tableTo: string;
760
757
  columnsTo: string[];
758
+ onUpdate?: string | undefined;
759
+ onDelete?: string | undefined;
761
760
  }>;
761
+ schema?: string | undefined;
762
762
  }>>;
763
763
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
764
764
  }, "strict", import("zod").ZodTypeAny, {
765
765
  tables: Record<string, {
766
- schema?: string | undefined;
767
766
  name: string;
768
767
  columns: Record<string, {
769
- default?: any;
770
- onUpdate?: any;
771
- autoincrement?: boolean | undefined;
772
768
  name: string;
773
769
  type: string;
774
770
  primaryKey: boolean;
775
771
  notNull: boolean;
772
+ default?: any;
773
+ onUpdate?: any;
774
+ autoincrement?: boolean | undefined;
776
775
  }>;
777
776
  indexes: Record<string, {
778
- using?: "btree" | "hash" | undefined;
779
- algorithm?: "default" | "inplace" | "copy" | undefined;
780
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
781
777
  name: string;
782
778
  columns: string[];
783
779
  isUnique: boolean;
780
+ using?: "btree" | "hash" | undefined;
781
+ algorithm?: "default" | "inplace" | "copy" | undefined;
782
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
784
783
  }>;
785
784
  foreignKeys: Record<string, {
786
- onUpdate?: string | undefined;
787
- onDelete?: string | undefined;
788
785
  name: string;
789
786
  tableFrom: string;
790
787
  columnsFrom: string[];
791
788
  tableTo: string;
792
789
  columnsTo: string[];
790
+ onUpdate?: string | undefined;
791
+ onDelete?: string | undefined;
793
792
  }>;
793
+ schema?: string | undefined;
794
794
  }>;
795
795
  version: "4";
796
796
  dialect: "mysql";
797
797
  schemas: Record<string, string>;
798
798
  }, {
799
799
  tables: Record<string, {
800
- schema?: string | undefined;
801
800
  name: string;
802
801
  columns: Record<string, {
803
- default?: any;
804
- onUpdate?: any;
805
- autoincrement?: boolean | undefined;
806
802
  name: string;
807
803
  type: string;
808
804
  primaryKey: boolean;
809
805
  notNull: boolean;
806
+ default?: any;
807
+ onUpdate?: any;
808
+ autoincrement?: boolean | undefined;
810
809
  }>;
811
810
  indexes: Record<string, {
812
- using?: "btree" | "hash" | undefined;
813
- algorithm?: "default" | "inplace" | "copy" | undefined;
814
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
815
811
  name: string;
816
812
  columns: string[];
817
813
  isUnique: boolean;
814
+ using?: "btree" | "hash" | undefined;
815
+ algorithm?: "default" | "inplace" | "copy" | undefined;
816
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
818
817
  }>;
819
818
  foreignKeys: Record<string, {
820
- onUpdate?: string | undefined;
821
- onDelete?: string | undefined;
822
819
  name: string;
823
820
  tableFrom: string;
824
821
  columnsFrom: string[];
825
822
  tableTo: string;
826
823
  columnsTo: string[];
824
+ onUpdate?: string | undefined;
825
+ onDelete?: string | undefined;
827
826
  }>;
827
+ schema?: string | undefined;
828
828
  }>;
829
829
  version: "4";
830
830
  dialect: "mysql";
@@ -844,21 +844,21 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
844
844
  default: import("zod").ZodOptional<import("zod").ZodAny>;
845
845
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
846
846
  }, "strict", import("zod").ZodTypeAny, {
847
- default?: any;
848
- onUpdate?: any;
849
- autoincrement?: boolean | undefined;
850
847
  name: string;
851
848
  type: string;
852
849
  primaryKey: boolean;
853
850
  notNull: boolean;
854
- }, {
855
851
  default?: any;
856
852
  onUpdate?: any;
857
853
  autoincrement?: boolean | undefined;
854
+ }, {
858
855
  name: string;
859
856
  type: string;
860
857
  primaryKey: boolean;
861
858
  notNull: boolean;
859
+ default?: any;
860
+ onUpdate?: any;
861
+ autoincrement?: boolean | undefined;
862
862
  }>>;
863
863
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
864
864
  name: import("zod").ZodString;
@@ -868,19 +868,19 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
868
868
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
869
869
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
870
870
  }, "strict", import("zod").ZodTypeAny, {
871
- using?: "btree" | "hash" | undefined;
872
- algorithm?: "default" | "inplace" | "copy" | undefined;
873
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
874
871
  name: string;
875
872
  columns: string[];
876
873
  isUnique: boolean;
877
- }, {
878
874
  using?: "btree" | "hash" | undefined;
879
875
  algorithm?: "default" | "inplace" | "copy" | undefined;
880
876
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
877
+ }, {
881
878
  name: string;
882
879
  columns: string[];
883
880
  isUnique: boolean;
881
+ using?: "btree" | "hash" | undefined;
882
+ algorithm?: "default" | "inplace" | "copy" | undefined;
883
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
884
884
  }>>;
885
885
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
886
886
  name: import("zod").ZodString;
@@ -891,21 +891,21 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
891
891
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
892
892
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
893
893
  }, "strict", import("zod").ZodTypeAny, {
894
- onUpdate?: string | undefined;
895
- onDelete?: string | undefined;
896
894
  name: string;
897
895
  tableFrom: string;
898
896
  columnsFrom: string[];
899
897
  tableTo: string;
900
898
  columnsTo: string[];
901
- }, {
902
899
  onUpdate?: string | undefined;
903
900
  onDelete?: string | undefined;
901
+ }, {
904
902
  name: string;
905
903
  tableFrom: string;
906
904
  columnsFrom: string[];
907
905
  tableTo: string;
908
906
  columnsTo: string[];
907
+ onUpdate?: string | undefined;
908
+ onDelete?: string | undefined;
909
909
  }>>;
910
910
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
911
911
  name: import("zod").ZodString;
@@ -930,30 +930,30 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
930
930
  }, "strict", import("zod").ZodTypeAny, {
931
931
  name: string;
932
932
  columns: Record<string, {
933
- default?: any;
934
- onUpdate?: any;
935
- autoincrement?: boolean | undefined;
936
933
  name: string;
937
934
  type: string;
938
935
  primaryKey: boolean;
939
936
  notNull: boolean;
937
+ default?: any;
938
+ onUpdate?: any;
939
+ autoincrement?: boolean | undefined;
940
940
  }>;
941
941
  indexes: Record<string, {
942
- using?: "btree" | "hash" | undefined;
943
- algorithm?: "default" | "inplace" | "copy" | undefined;
944
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
945
942
  name: string;
946
943
  columns: string[];
947
944
  isUnique: boolean;
945
+ using?: "btree" | "hash" | undefined;
946
+ algorithm?: "default" | "inplace" | "copy" | undefined;
947
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
948
948
  }>;
949
949
  foreignKeys: Record<string, {
950
- onUpdate?: string | undefined;
951
- onDelete?: string | undefined;
952
950
  name: string;
953
951
  tableFrom: string;
954
952
  columnsFrom: string[];
955
953
  tableTo: string;
956
954
  columnsTo: string[];
955
+ onUpdate?: string | undefined;
956
+ onDelete?: string | undefined;
957
957
  }>;
958
958
  compositePrimaryKeys: Record<string, {
959
959
  name: string;
@@ -964,41 +964,41 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
964
964
  columns: string[];
965
965
  }>;
966
966
  }, {
967
- uniqueConstraints?: Record<string, {
968
- name: string;
969
- columns: string[];
970
- }> | undefined;
971
967
  name: string;
972
968
  columns: Record<string, {
973
- default?: any;
974
- onUpdate?: any;
975
- autoincrement?: boolean | undefined;
976
969
  name: string;
977
970
  type: string;
978
971
  primaryKey: boolean;
979
972
  notNull: boolean;
973
+ default?: any;
974
+ onUpdate?: any;
975
+ autoincrement?: boolean | undefined;
980
976
  }>;
981
977
  indexes: Record<string, {
982
- using?: "btree" | "hash" | undefined;
983
- algorithm?: "default" | "inplace" | "copy" | undefined;
984
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
985
978
  name: string;
986
979
  columns: string[];
987
980
  isUnique: boolean;
981
+ using?: "btree" | "hash" | undefined;
982
+ algorithm?: "default" | "inplace" | "copy" | undefined;
983
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
988
984
  }>;
989
985
  foreignKeys: Record<string, {
990
- onUpdate?: string | undefined;
991
- onDelete?: string | undefined;
992
986
  name: string;
993
987
  tableFrom: string;
994
988
  columnsFrom: string[];
995
989
  tableTo: string;
996
990
  columnsTo: string[];
991
+ onUpdate?: string | undefined;
992
+ onDelete?: string | undefined;
997
993
  }>;
998
994
  compositePrimaryKeys: Record<string, {
999
995
  name: string;
1000
996
  columns: string[];
1001
997
  }>;
998
+ uniqueConstraints?: Record<string, {
999
+ name: string;
1000
+ columns: string[];
1001
+ }> | undefined;
1002
1002
  }>>;
1003
1003
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1004
1004
  _meta: import("zod").ZodObject<{
@@ -1046,40 +1046,33 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
1046
1046
  } | undefined>;
1047
1047
  }>>;
1048
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
1049
  tables: Record<string, {
1057
1050
  name: string;
1058
1051
  columns: Record<string, {
1059
- default?: any;
1060
- onUpdate?: any;
1061
- autoincrement?: boolean | undefined;
1062
1052
  name: string;
1063
1053
  type: string;
1064
1054
  primaryKey: boolean;
1065
1055
  notNull: boolean;
1056
+ default?: any;
1057
+ onUpdate?: any;
1058
+ autoincrement?: boolean | undefined;
1066
1059
  }>;
1067
1060
  indexes: Record<string, {
1068
- using?: "btree" | "hash" | undefined;
1069
- algorithm?: "default" | "inplace" | "copy" | undefined;
1070
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1071
1061
  name: string;
1072
1062
  columns: string[];
1073
1063
  isUnique: boolean;
1064
+ using?: "btree" | "hash" | undefined;
1065
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1066
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1074
1067
  }>;
1075
1068
  foreignKeys: Record<string, {
1076
- onUpdate?: string | undefined;
1077
- onDelete?: string | undefined;
1078
1069
  name: string;
1079
1070
  tableFrom: string;
1080
1071
  columnsFrom: string[];
1081
1072
  tableTo: string;
1082
1073
  columnsTo: string[];
1074
+ onUpdate?: string | undefined;
1075
+ onDelete?: string | undefined;
1083
1076
  }>;
1084
1077
  compositePrimaryKeys: Record<string, {
1085
1078
  name: string;
@@ -1098,7 +1091,6 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
1098
1091
  tables: Record<string, string>;
1099
1092
  schemas: Record<string, string>;
1100
1093
  };
1101
- }, {
1102
1094
  internal?: {
1103
1095
  tables: Record<string, {
1104
1096
  columns: Record<string, {
@@ -1106,42 +1098,43 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
1106
1098
  } | undefined>;
1107
1099
  } | undefined>;
1108
1100
  } | undefined;
1101
+ }, {
1109
1102
  tables: Record<string, {
1110
- uniqueConstraints?: Record<string, {
1111
- name: string;
1112
- columns: string[];
1113
- }> | undefined;
1114
1103
  name: string;
1115
1104
  columns: Record<string, {
1116
- default?: any;
1117
- onUpdate?: any;
1118
- autoincrement?: boolean | undefined;
1119
1105
  name: string;
1120
1106
  type: string;
1121
1107
  primaryKey: boolean;
1122
1108
  notNull: boolean;
1109
+ default?: any;
1110
+ onUpdate?: any;
1111
+ autoincrement?: boolean | undefined;
1123
1112
  }>;
1124
1113
  indexes: Record<string, {
1125
- using?: "btree" | "hash" | undefined;
1126
- algorithm?: "default" | "inplace" | "copy" | undefined;
1127
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1128
1114
  name: string;
1129
1115
  columns: string[];
1130
1116
  isUnique: boolean;
1117
+ using?: "btree" | "hash" | undefined;
1118
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1119
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1131
1120
  }>;
1132
1121
  foreignKeys: Record<string, {
1133
- onUpdate?: string | undefined;
1134
- onDelete?: string | undefined;
1135
1122
  name: string;
1136
1123
  tableFrom: string;
1137
1124
  columnsFrom: string[];
1138
1125
  tableTo: string;
1139
1126
  columnsTo: string[];
1127
+ onUpdate?: string | undefined;
1128
+ onDelete?: string | undefined;
1140
1129
  }>;
1141
1130
  compositePrimaryKeys: Record<string, {
1142
1131
  name: string;
1143
1132
  columns: string[];
1144
1133
  }>;
1134
+ uniqueConstraints?: Record<string, {
1135
+ name: string;
1136
+ columns: string[];
1137
+ }> | undefined;
1145
1138
  }>;
1146
1139
  version: "5";
1147
1140
  dialect: "mysql";
@@ -1151,6 +1144,13 @@ export declare const schemaInternalV5: import("zod").ZodObject<{
1151
1144
  tables: Record<string, string>;
1152
1145
  schemas: Record<string, string>;
1153
1146
  };
1147
+ internal?: {
1148
+ tables: Record<string, {
1149
+ columns: Record<string, {
1150
+ isDefaultAnExpression?: boolean | undefined;
1151
+ } | undefined>;
1152
+ } | undefined>;
1153
+ } | undefined;
1154
1154
  }>;
1155
1155
  export declare const schemaInternal: import("zod").ZodObject<{
1156
1156
  version: import("zod").ZodLiteral<"5">;
@@ -1166,21 +1166,21 @@ export declare const schemaInternal: import("zod").ZodObject<{
1166
1166
  default: import("zod").ZodOptional<import("zod").ZodAny>;
1167
1167
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
1168
1168
  }, "strict", import("zod").ZodTypeAny, {
1169
- default?: any;
1170
- onUpdate?: any;
1171
- autoincrement?: boolean | undefined;
1172
1169
  name: string;
1173
1170
  type: string;
1174
1171
  primaryKey: boolean;
1175
1172
  notNull: boolean;
1176
- }, {
1177
1173
  default?: any;
1178
1174
  onUpdate?: any;
1179
1175
  autoincrement?: boolean | undefined;
1176
+ }, {
1180
1177
  name: string;
1181
1178
  type: string;
1182
1179
  primaryKey: boolean;
1183
1180
  notNull: boolean;
1181
+ default?: any;
1182
+ onUpdate?: any;
1183
+ autoincrement?: boolean | undefined;
1184
1184
  }>>;
1185
1185
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1186
1186
  name: import("zod").ZodString;
@@ -1190,19 +1190,19 @@ export declare const schemaInternal: import("zod").ZodObject<{
1190
1190
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
1191
1191
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
1192
1192
  }, "strict", import("zod").ZodTypeAny, {
1193
- using?: "btree" | "hash" | undefined;
1194
- algorithm?: "default" | "inplace" | "copy" | undefined;
1195
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1196
1193
  name: string;
1197
1194
  columns: string[];
1198
1195
  isUnique: boolean;
1199
- }, {
1200
1196
  using?: "btree" | "hash" | undefined;
1201
1197
  algorithm?: "default" | "inplace" | "copy" | undefined;
1202
1198
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1199
+ }, {
1203
1200
  name: string;
1204
1201
  columns: string[];
1205
1202
  isUnique: boolean;
1203
+ using?: "btree" | "hash" | undefined;
1204
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1205
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1206
1206
  }>>;
1207
1207
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1208
1208
  name: import("zod").ZodString;
@@ -1213,21 +1213,21 @@ export declare const schemaInternal: import("zod").ZodObject<{
1213
1213
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1214
1214
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1215
1215
  }, "strict", import("zod").ZodTypeAny, {
1216
- onUpdate?: string | undefined;
1217
- onDelete?: string | undefined;
1218
1216
  name: string;
1219
1217
  tableFrom: string;
1220
1218
  columnsFrom: string[];
1221
1219
  tableTo: string;
1222
1220
  columnsTo: string[];
1223
- }, {
1224
1221
  onUpdate?: string | undefined;
1225
1222
  onDelete?: string | undefined;
1223
+ }, {
1226
1224
  name: string;
1227
1225
  tableFrom: string;
1228
1226
  columnsFrom: string[];
1229
1227
  tableTo: string;
1230
1228
  columnsTo: string[];
1229
+ onUpdate?: string | undefined;
1230
+ onDelete?: string | undefined;
1231
1231
  }>>;
1232
1232
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1233
1233
  name: import("zod").ZodString;
@@ -1252,30 +1252,30 @@ export declare const schemaInternal: import("zod").ZodObject<{
1252
1252
  }, "strict", import("zod").ZodTypeAny, {
1253
1253
  name: string;
1254
1254
  columns: Record<string, {
1255
- default?: any;
1256
- onUpdate?: any;
1257
- autoincrement?: boolean | undefined;
1258
1255
  name: string;
1259
1256
  type: string;
1260
1257
  primaryKey: boolean;
1261
1258
  notNull: boolean;
1259
+ default?: any;
1260
+ onUpdate?: any;
1261
+ autoincrement?: boolean | undefined;
1262
1262
  }>;
1263
1263
  indexes: Record<string, {
1264
- using?: "btree" | "hash" | undefined;
1265
- algorithm?: "default" | "inplace" | "copy" | undefined;
1266
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1267
1264
  name: string;
1268
1265
  columns: string[];
1269
1266
  isUnique: boolean;
1267
+ using?: "btree" | "hash" | undefined;
1268
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1269
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1270
1270
  }>;
1271
1271
  foreignKeys: Record<string, {
1272
- onUpdate?: string | undefined;
1273
- onDelete?: string | undefined;
1274
1272
  name: string;
1275
1273
  tableFrom: string;
1276
1274
  columnsFrom: string[];
1277
1275
  tableTo: string;
1278
1276
  columnsTo: string[];
1277
+ onUpdate?: string | undefined;
1278
+ onDelete?: string | undefined;
1279
1279
  }>;
1280
1280
  compositePrimaryKeys: Record<string, {
1281
1281
  name: string;
@@ -1286,41 +1286,41 @@ export declare const schemaInternal: import("zod").ZodObject<{
1286
1286
  columns: string[];
1287
1287
  }>;
1288
1288
  }, {
1289
- uniqueConstraints?: Record<string, {
1290
- name: string;
1291
- columns: string[];
1292
- }> | undefined;
1293
1289
  name: string;
1294
1290
  columns: Record<string, {
1295
- default?: any;
1296
- onUpdate?: any;
1297
- autoincrement?: boolean | undefined;
1298
1291
  name: string;
1299
1292
  type: string;
1300
1293
  primaryKey: boolean;
1301
1294
  notNull: boolean;
1295
+ default?: any;
1296
+ onUpdate?: any;
1297
+ autoincrement?: boolean | undefined;
1302
1298
  }>;
1303
1299
  indexes: Record<string, {
1304
- using?: "btree" | "hash" | undefined;
1305
- algorithm?: "default" | "inplace" | "copy" | undefined;
1306
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1307
1300
  name: string;
1308
1301
  columns: string[];
1309
1302
  isUnique: boolean;
1303
+ using?: "btree" | "hash" | undefined;
1304
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1305
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1310
1306
  }>;
1311
1307
  foreignKeys: Record<string, {
1312
- onUpdate?: string | undefined;
1313
- onDelete?: string | undefined;
1314
1308
  name: string;
1315
1309
  tableFrom: string;
1316
1310
  columnsFrom: string[];
1317
1311
  tableTo: string;
1318
1312
  columnsTo: string[];
1313
+ onUpdate?: string | undefined;
1314
+ onDelete?: string | undefined;
1319
1315
  }>;
1320
1316
  compositePrimaryKeys: Record<string, {
1321
1317
  name: string;
1322
1318
  columns: string[];
1323
1319
  }>;
1320
+ uniqueConstraints?: Record<string, {
1321
+ name: string;
1322
+ columns: string[];
1323
+ }> | undefined;
1324
1324
  }>>;
1325
1325
  _meta: import("zod").ZodObject<{
1326
1326
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -1364,40 +1364,33 @@ export declare const schemaInternal: import("zod").ZodObject<{
1364
1364
  } | undefined>;
1365
1365
  }>>;
1366
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
1367
  tables: Record<string, {
1375
1368
  name: string;
1376
1369
  columns: Record<string, {
1377
- default?: any;
1378
- onUpdate?: any;
1379
- autoincrement?: boolean | undefined;
1380
1370
  name: string;
1381
1371
  type: string;
1382
1372
  primaryKey: boolean;
1383
1373
  notNull: boolean;
1374
+ default?: any;
1375
+ onUpdate?: any;
1376
+ autoincrement?: boolean | undefined;
1384
1377
  }>;
1385
1378
  indexes: Record<string, {
1386
- using?: "btree" | "hash" | undefined;
1387
- algorithm?: "default" | "inplace" | "copy" | undefined;
1388
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1389
1379
  name: string;
1390
1380
  columns: string[];
1391
1381
  isUnique: boolean;
1382
+ using?: "btree" | "hash" | undefined;
1383
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1384
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1392
1385
  }>;
1393
1386
  foreignKeys: Record<string, {
1394
- onUpdate?: string | undefined;
1395
- onDelete?: string | undefined;
1396
1387
  name: string;
1397
1388
  tableFrom: string;
1398
1389
  columnsFrom: string[];
1399
1390
  tableTo: string;
1400
1391
  columnsTo: string[];
1392
+ onUpdate?: string | undefined;
1393
+ onDelete?: string | undefined;
1401
1394
  }>;
1402
1395
  compositePrimaryKeys: Record<string, {
1403
1396
  name: string;
@@ -1414,7 +1407,6 @@ export declare const schemaInternal: import("zod").ZodObject<{
1414
1407
  columns: Record<string, string>;
1415
1408
  tables: Record<string, string>;
1416
1409
  };
1417
- }, {
1418
1410
  internal?: {
1419
1411
  tables: Record<string, {
1420
1412
  columns: Record<string, {
@@ -1422,42 +1414,43 @@ export declare const schemaInternal: import("zod").ZodObject<{
1422
1414
  } | undefined>;
1423
1415
  } | undefined>;
1424
1416
  } | undefined;
1417
+ }, {
1425
1418
  tables: Record<string, {
1426
- uniqueConstraints?: Record<string, {
1427
- name: string;
1428
- columns: string[];
1429
- }> | undefined;
1430
1419
  name: string;
1431
1420
  columns: Record<string, {
1432
- default?: any;
1433
- onUpdate?: any;
1434
- autoincrement?: boolean | undefined;
1435
1421
  name: string;
1436
1422
  type: string;
1437
1423
  primaryKey: boolean;
1438
1424
  notNull: boolean;
1425
+ default?: any;
1426
+ onUpdate?: any;
1427
+ autoincrement?: boolean | undefined;
1439
1428
  }>;
1440
1429
  indexes: Record<string, {
1441
- using?: "btree" | "hash" | undefined;
1442
- algorithm?: "default" | "inplace" | "copy" | undefined;
1443
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1444
1430
  name: string;
1445
1431
  columns: string[];
1446
1432
  isUnique: boolean;
1433
+ using?: "btree" | "hash" | undefined;
1434
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1435
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1447
1436
  }>;
1448
1437
  foreignKeys: Record<string, {
1449
- onUpdate?: string | undefined;
1450
- onDelete?: string | undefined;
1451
1438
  name: string;
1452
1439
  tableFrom: string;
1453
1440
  columnsFrom: string[];
1454
1441
  tableTo: string;
1455
1442
  columnsTo: string[];
1443
+ onUpdate?: string | undefined;
1444
+ onDelete?: string | undefined;
1456
1445
  }>;
1457
1446
  compositePrimaryKeys: Record<string, {
1458
1447
  name: string;
1459
1448
  columns: string[];
1460
1449
  }>;
1450
+ uniqueConstraints?: Record<string, {
1451
+ name: string;
1452
+ columns: string[];
1453
+ }> | undefined;
1461
1454
  }>;
1462
1455
  version: "5";
1463
1456
  dialect: "mysql";
@@ -1465,8 +1458,15 @@ export declare const schemaInternal: import("zod").ZodObject<{
1465
1458
  columns: Record<string, string>;
1466
1459
  tables: Record<string, string>;
1467
1460
  };
1461
+ internal?: {
1462
+ tables: Record<string, {
1463
+ columns: Record<string, {
1464
+ isDefaultAnExpression?: boolean | undefined;
1465
+ } | undefined>;
1466
+ } | undefined>;
1467
+ } | undefined;
1468
1468
  }>;
1469
- export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
1469
+ export declare const schemaV3: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
1470
1470
  version: import("zod").ZodLiteral<"3">;
1471
1471
  dialect: import("zod").ZodLiteral<"mysql">;
1472
1472
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1480,21 +1480,21 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1480
1480
  default: import("zod").ZodOptional<import("zod").ZodAny>;
1481
1481
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
1482
1482
  }, "strict", import("zod").ZodTypeAny, {
1483
- default?: any;
1484
- onUpdate?: any;
1485
- autoincrement?: boolean | undefined;
1486
1483
  name: string;
1487
1484
  type: string;
1488
1485
  primaryKey: boolean;
1489
1486
  notNull: boolean;
1490
- }, {
1491
1487
  default?: any;
1492
1488
  onUpdate?: any;
1493
1489
  autoincrement?: boolean | undefined;
1490
+ }, {
1494
1491
  name: string;
1495
1492
  type: string;
1496
1493
  primaryKey: boolean;
1497
1494
  notNull: boolean;
1495
+ default?: any;
1496
+ onUpdate?: any;
1497
+ autoincrement?: boolean | undefined;
1498
1498
  }>>;
1499
1499
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1500
1500
  name: import("zod").ZodString;
@@ -1504,19 +1504,19 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1504
1504
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
1505
1505
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
1506
1506
  }, "strict", import("zod").ZodTypeAny, {
1507
- using?: "btree" | "hash" | undefined;
1508
- algorithm?: "default" | "inplace" | "copy" | undefined;
1509
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1510
1507
  name: string;
1511
1508
  columns: string[];
1512
1509
  isUnique: boolean;
1513
- }, {
1514
1510
  using?: "btree" | "hash" | undefined;
1515
1511
  algorithm?: "default" | "inplace" | "copy" | undefined;
1516
1512
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1513
+ }, {
1517
1514
  name: string;
1518
1515
  columns: string[];
1519
1516
  isUnique: boolean;
1517
+ using?: "btree" | "hash" | undefined;
1518
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1519
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1520
1520
  }>>;
1521
1521
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1522
1522
  name: import("zod").ZodString;
@@ -1527,77 +1527,77 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1527
1527
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1528
1528
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1529
1529
  }, "strict", import("zod").ZodTypeAny, {
1530
- onUpdate?: string | undefined;
1531
- onDelete?: string | undefined;
1532
1530
  name: string;
1533
1531
  tableFrom: string;
1534
1532
  columnsFrom: string[];
1535
1533
  tableTo: string;
1536
1534
  columnsTo: string[];
1537
- }, {
1538
1535
  onUpdate?: string | undefined;
1539
1536
  onDelete?: string | undefined;
1537
+ }, {
1540
1538
  name: string;
1541
1539
  tableFrom: string;
1542
1540
  columnsFrom: string[];
1543
1541
  tableTo: string;
1544
1542
  columnsTo: string[];
1543
+ onUpdate?: string | undefined;
1544
+ onDelete?: string | undefined;
1545
1545
  }>>;
1546
1546
  }, "strict", import("zod").ZodTypeAny, {
1547
1547
  name: string;
1548
1548
  columns: Record<string, {
1549
- default?: any;
1550
- onUpdate?: any;
1551
- autoincrement?: boolean | undefined;
1552
1549
  name: string;
1553
1550
  type: string;
1554
1551
  primaryKey: boolean;
1555
1552
  notNull: boolean;
1553
+ default?: any;
1554
+ onUpdate?: any;
1555
+ autoincrement?: boolean | undefined;
1556
1556
  }>;
1557
1557
  indexes: Record<string, {
1558
- using?: "btree" | "hash" | undefined;
1559
- algorithm?: "default" | "inplace" | "copy" | undefined;
1560
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1561
1558
  name: string;
1562
1559
  columns: string[];
1563
1560
  isUnique: boolean;
1561
+ using?: "btree" | "hash" | undefined;
1562
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1563
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1564
1564
  }>;
1565
1565
  foreignKeys: Record<string, {
1566
- onUpdate?: string | undefined;
1567
- onDelete?: string | undefined;
1568
1566
  name: string;
1569
1567
  tableFrom: string;
1570
1568
  columnsFrom: string[];
1571
1569
  tableTo: string;
1572
1570
  columnsTo: string[];
1571
+ onUpdate?: string | undefined;
1572
+ onDelete?: string | undefined;
1573
1573
  }>;
1574
1574
  }, {
1575
1575
  name: string;
1576
1576
  columns: Record<string, {
1577
- default?: any;
1578
- onUpdate?: any;
1579
- autoincrement?: boolean | undefined;
1580
1577
  name: string;
1581
1578
  type: string;
1582
1579
  primaryKey: boolean;
1583
1580
  notNull: boolean;
1581
+ default?: any;
1582
+ onUpdate?: any;
1583
+ autoincrement?: boolean | undefined;
1584
1584
  }>;
1585
1585
  indexes: Record<string, {
1586
- using?: "btree" | "hash" | undefined;
1587
- algorithm?: "default" | "inplace" | "copy" | undefined;
1588
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1589
1586
  name: string;
1590
1587
  columns: string[];
1591
1588
  isUnique: boolean;
1589
+ using?: "btree" | "hash" | undefined;
1590
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1591
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1592
1592
  }>;
1593
1593
  foreignKeys: Record<string, {
1594
- onUpdate?: string | undefined;
1595
- onDelete?: string | undefined;
1596
1594
  name: string;
1597
1595
  tableFrom: string;
1598
1596
  columnsFrom: string[];
1599
1597
  tableTo: string;
1600
1598
  columnsTo: string[];
1599
+ onUpdate?: string | undefined;
1600
+ onDelete?: string | undefined;
1601
1601
  }>;
1602
1602
  }>>;
1603
1603
  }, {
@@ -1607,30 +1607,30 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1607
1607
  tables: Record<string, {
1608
1608
  name: string;
1609
1609
  columns: Record<string, {
1610
- default?: any;
1611
- onUpdate?: any;
1612
- autoincrement?: boolean | undefined;
1613
1610
  name: string;
1614
1611
  type: string;
1615
1612
  primaryKey: boolean;
1616
1613
  notNull: boolean;
1614
+ default?: any;
1615
+ onUpdate?: any;
1616
+ autoincrement?: boolean | undefined;
1617
1617
  }>;
1618
1618
  indexes: Record<string, {
1619
- using?: "btree" | "hash" | undefined;
1620
- algorithm?: "default" | "inplace" | "copy" | undefined;
1621
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1622
1619
  name: string;
1623
1620
  columns: string[];
1624
1621
  isUnique: boolean;
1622
+ using?: "btree" | "hash" | undefined;
1623
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1624
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1625
1625
  }>;
1626
1626
  foreignKeys: Record<string, {
1627
- onUpdate?: string | undefined;
1628
- onDelete?: string | undefined;
1629
1627
  name: string;
1630
1628
  tableFrom: string;
1631
1629
  columnsFrom: string[];
1632
1630
  tableTo: string;
1633
1631
  columnsTo: string[];
1632
+ onUpdate?: string | undefined;
1633
+ onDelete?: string | undefined;
1634
1634
  }>;
1635
1635
  }>;
1636
1636
  id: string;
@@ -1641,30 +1641,30 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1641
1641
  tables: Record<string, {
1642
1642
  name: string;
1643
1643
  columns: Record<string, {
1644
- default?: any;
1645
- onUpdate?: any;
1646
- autoincrement?: boolean | undefined;
1647
1644
  name: string;
1648
1645
  type: string;
1649
1646
  primaryKey: boolean;
1650
1647
  notNull: boolean;
1648
+ default?: any;
1649
+ onUpdate?: any;
1650
+ autoincrement?: boolean | undefined;
1651
1651
  }>;
1652
1652
  indexes: Record<string, {
1653
- using?: "btree" | "hash" | undefined;
1654
- algorithm?: "default" | "inplace" | "copy" | undefined;
1655
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1656
1653
  name: string;
1657
1654
  columns: string[];
1658
1655
  isUnique: boolean;
1656
+ using?: "btree" | "hash" | undefined;
1657
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1658
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1659
1659
  }>;
1660
1660
  foreignKeys: Record<string, {
1661
- onUpdate?: string | undefined;
1662
- onDelete?: string | undefined;
1663
1661
  name: string;
1664
1662
  tableFrom: string;
1665
1663
  columnsFrom: string[];
1666
1664
  tableTo: string;
1667
1665
  columnsTo: string[];
1666
+ onUpdate?: string | undefined;
1667
+ onDelete?: string | undefined;
1668
1668
  }>;
1669
1669
  }>;
1670
1670
  id: string;
@@ -1672,7 +1672,7 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1672
1672
  version: "3";
1673
1673
  dialect: "mysql";
1674
1674
  }>;
1675
- export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
1675
+ export declare const schemaV4: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
1676
1676
  version: import("zod").ZodLiteral<"4">;
1677
1677
  dialect: import("zod").ZodLiteral<"mysql">;
1678
1678
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1687,21 +1687,21 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1687
1687
  default: import("zod").ZodOptional<import("zod").ZodAny>;
1688
1688
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
1689
1689
  }, "strict", import("zod").ZodTypeAny, {
1690
- default?: any;
1691
- onUpdate?: any;
1692
- autoincrement?: boolean | undefined;
1693
1690
  name: string;
1694
1691
  type: string;
1695
1692
  primaryKey: boolean;
1696
1693
  notNull: boolean;
1697
- }, {
1698
1694
  default?: any;
1699
1695
  onUpdate?: any;
1700
1696
  autoincrement?: boolean | undefined;
1697
+ }, {
1701
1698
  name: string;
1702
1699
  type: string;
1703
1700
  primaryKey: boolean;
1704
1701
  notNull: boolean;
1702
+ default?: any;
1703
+ onUpdate?: any;
1704
+ autoincrement?: boolean | undefined;
1705
1705
  }>>;
1706
1706
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1707
1707
  name: import("zod").ZodString;
@@ -1711,19 +1711,19 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1711
1711
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
1712
1712
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
1713
1713
  }, "strict", import("zod").ZodTypeAny, {
1714
- using?: "btree" | "hash" | undefined;
1715
- algorithm?: "default" | "inplace" | "copy" | undefined;
1716
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1717
1714
  name: string;
1718
1715
  columns: string[];
1719
1716
  isUnique: boolean;
1720
- }, {
1721
1717
  using?: "btree" | "hash" | undefined;
1722
1718
  algorithm?: "default" | "inplace" | "copy" | undefined;
1723
1719
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1720
+ }, {
1724
1721
  name: string;
1725
1722
  columns: string[];
1726
1723
  isUnique: boolean;
1724
+ using?: "btree" | "hash" | undefined;
1725
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1726
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1727
1727
  }>>;
1728
1728
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1729
1729
  name: import("zod").ZodString;
@@ -1734,80 +1734,80 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1734
1734
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1735
1735
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1736
1736
  }, "strict", import("zod").ZodTypeAny, {
1737
- onUpdate?: string | undefined;
1738
- onDelete?: string | undefined;
1739
1737
  name: string;
1740
1738
  tableFrom: string;
1741
1739
  columnsFrom: string[];
1742
1740
  tableTo: string;
1743
1741
  columnsTo: string[];
1744
- }, {
1745
1742
  onUpdate?: string | undefined;
1746
1743
  onDelete?: string | undefined;
1744
+ }, {
1747
1745
  name: string;
1748
1746
  tableFrom: string;
1749
1747
  columnsFrom: string[];
1750
1748
  tableTo: string;
1751
1749
  columnsTo: string[];
1750
+ onUpdate?: string | undefined;
1751
+ onDelete?: string | undefined;
1752
1752
  }>>;
1753
1753
  }, "strict", import("zod").ZodTypeAny, {
1754
- schema?: string | undefined;
1755
1754
  name: string;
1756
1755
  columns: Record<string, {
1757
- default?: any;
1758
- onUpdate?: any;
1759
- autoincrement?: boolean | undefined;
1760
1756
  name: string;
1761
1757
  type: string;
1762
1758
  primaryKey: boolean;
1763
1759
  notNull: boolean;
1760
+ default?: any;
1761
+ onUpdate?: any;
1762
+ autoincrement?: boolean | undefined;
1764
1763
  }>;
1765
1764
  indexes: Record<string, {
1766
- using?: "btree" | "hash" | undefined;
1767
- algorithm?: "default" | "inplace" | "copy" | undefined;
1768
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1769
1765
  name: string;
1770
1766
  columns: string[];
1771
1767
  isUnique: boolean;
1768
+ using?: "btree" | "hash" | undefined;
1769
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1770
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1772
1771
  }>;
1773
1772
  foreignKeys: Record<string, {
1774
- onUpdate?: string | undefined;
1775
- onDelete?: string | undefined;
1776
1773
  name: string;
1777
1774
  tableFrom: string;
1778
1775
  columnsFrom: string[];
1779
1776
  tableTo: string;
1780
1777
  columnsTo: string[];
1778
+ onUpdate?: string | undefined;
1779
+ onDelete?: string | undefined;
1781
1780
  }>;
1782
- }, {
1783
1781
  schema?: string | undefined;
1782
+ }, {
1784
1783
  name: string;
1785
1784
  columns: Record<string, {
1786
- default?: any;
1787
- onUpdate?: any;
1788
- autoincrement?: boolean | undefined;
1789
1785
  name: string;
1790
1786
  type: string;
1791
1787
  primaryKey: boolean;
1792
1788
  notNull: boolean;
1789
+ default?: any;
1790
+ onUpdate?: any;
1791
+ autoincrement?: boolean | undefined;
1793
1792
  }>;
1794
1793
  indexes: Record<string, {
1795
- using?: "btree" | "hash" | undefined;
1796
- algorithm?: "default" | "inplace" | "copy" | undefined;
1797
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1798
1794
  name: string;
1799
1795
  columns: string[];
1800
1796
  isUnique: boolean;
1797
+ using?: "btree" | "hash" | undefined;
1798
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1799
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1801
1800
  }>;
1802
1801
  foreignKeys: Record<string, {
1803
- onUpdate?: string | undefined;
1804
- onDelete?: string | undefined;
1805
1802
  name: string;
1806
1803
  tableFrom: string;
1807
1804
  columnsFrom: string[];
1808
1805
  tableTo: string;
1809
1806
  columnsTo: string[];
1807
+ onUpdate?: string | undefined;
1808
+ onDelete?: string | undefined;
1810
1809
  }>;
1810
+ schema?: string | undefined;
1811
1811
  }>>;
1812
1812
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1813
1813
  }, {
@@ -1815,34 +1815,34 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1815
1815
  prevId: import("zod").ZodString;
1816
1816
  }>, "strip", import("zod").ZodTypeAny, {
1817
1817
  tables: Record<string, {
1818
- schema?: string | undefined;
1819
1818
  name: string;
1820
1819
  columns: Record<string, {
1821
- default?: any;
1822
- onUpdate?: any;
1823
- autoincrement?: boolean | undefined;
1824
1820
  name: string;
1825
1821
  type: string;
1826
1822
  primaryKey: boolean;
1827
1823
  notNull: boolean;
1824
+ default?: any;
1825
+ onUpdate?: any;
1826
+ autoincrement?: boolean | undefined;
1828
1827
  }>;
1829
1828
  indexes: Record<string, {
1830
- using?: "btree" | "hash" | undefined;
1831
- algorithm?: "default" | "inplace" | "copy" | undefined;
1832
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1833
1829
  name: string;
1834
1830
  columns: string[];
1835
1831
  isUnique: boolean;
1832
+ using?: "btree" | "hash" | undefined;
1833
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1834
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1836
1835
  }>;
1837
1836
  foreignKeys: Record<string, {
1838
- onUpdate?: string | undefined;
1839
- onDelete?: string | undefined;
1840
1837
  name: string;
1841
1838
  tableFrom: string;
1842
1839
  columnsFrom: string[];
1843
1840
  tableTo: string;
1844
1841
  columnsTo: string[];
1842
+ onUpdate?: string | undefined;
1843
+ onDelete?: string | undefined;
1845
1844
  }>;
1845
+ schema?: string | undefined;
1846
1846
  }>;
1847
1847
  id: string;
1848
1848
  prevId: string;
@@ -1851,34 +1851,34 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1851
1851
  schemas: Record<string, string>;
1852
1852
  }, {
1853
1853
  tables: Record<string, {
1854
- schema?: string | undefined;
1855
1854
  name: string;
1856
1855
  columns: Record<string, {
1857
- default?: any;
1858
- onUpdate?: any;
1859
- autoincrement?: boolean | undefined;
1860
1856
  name: string;
1861
1857
  type: string;
1862
1858
  primaryKey: boolean;
1863
1859
  notNull: boolean;
1860
+ default?: any;
1861
+ onUpdate?: any;
1862
+ autoincrement?: boolean | undefined;
1864
1863
  }>;
1865
1864
  indexes: Record<string, {
1866
- using?: "btree" | "hash" | undefined;
1867
- algorithm?: "default" | "inplace" | "copy" | undefined;
1868
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1869
1865
  name: string;
1870
1866
  columns: string[];
1871
1867
  isUnique: boolean;
1868
+ using?: "btree" | "hash" | undefined;
1869
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1870
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1872
1871
  }>;
1873
1872
  foreignKeys: Record<string, {
1874
- onUpdate?: string | undefined;
1875
- onDelete?: string | undefined;
1876
1873
  name: string;
1877
1874
  tableFrom: string;
1878
1875
  columnsFrom: string[];
1879
1876
  tableTo: string;
1880
1877
  columnsTo: string[];
1878
+ onUpdate?: string | undefined;
1879
+ onDelete?: string | undefined;
1881
1880
  }>;
1881
+ schema?: string | undefined;
1882
1882
  }>;
1883
1883
  id: string;
1884
1884
  prevId: string;
@@ -1886,7 +1886,7 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1886
1886
  dialect: "mysql";
1887
1887
  schemas: Record<string, string>;
1888
1888
  }>;
1889
- export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape<{
1889
+ export declare const schemaV5: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
1890
1890
  version: import("zod").ZodLiteral<"5">;
1891
1891
  dialect: import("zod").ZodLiteral<"mysql">;
1892
1892
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1900,21 +1900,21 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape
1900
1900
  default: import("zod").ZodOptional<import("zod").ZodAny>;
1901
1901
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
1902
1902
  }, "strict", import("zod").ZodTypeAny, {
1903
- default?: any;
1904
- onUpdate?: any;
1905
- autoincrement?: boolean | undefined;
1906
1903
  name: string;
1907
1904
  type: string;
1908
1905
  primaryKey: boolean;
1909
1906
  notNull: boolean;
1910
- }, {
1911
1907
  default?: any;
1912
1908
  onUpdate?: any;
1913
1909
  autoincrement?: boolean | undefined;
1910
+ }, {
1914
1911
  name: string;
1915
1912
  type: string;
1916
1913
  primaryKey: boolean;
1917
1914
  notNull: boolean;
1915
+ default?: any;
1916
+ onUpdate?: any;
1917
+ autoincrement?: boolean | undefined;
1918
1918
  }>>;
1919
1919
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1920
1920
  name: import("zod").ZodString;
@@ -1924,19 +1924,19 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape
1924
1924
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
1925
1925
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
1926
1926
  }, "strict", import("zod").ZodTypeAny, {
1927
- using?: "btree" | "hash" | undefined;
1928
- algorithm?: "default" | "inplace" | "copy" | undefined;
1929
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1930
1927
  name: string;
1931
1928
  columns: string[];
1932
1929
  isUnique: boolean;
1933
- }, {
1934
1930
  using?: "btree" | "hash" | undefined;
1935
1931
  algorithm?: "default" | "inplace" | "copy" | undefined;
1936
1932
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1933
+ }, {
1937
1934
  name: string;
1938
1935
  columns: string[];
1939
1936
  isUnique: boolean;
1937
+ using?: "btree" | "hash" | undefined;
1938
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1939
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1940
1940
  }>>;
1941
1941
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1942
1942
  name: import("zod").ZodString;
@@ -1947,21 +1947,21 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape
1947
1947
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1948
1948
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1949
1949
  }, "strict", import("zod").ZodTypeAny, {
1950
- onUpdate?: string | undefined;
1951
- onDelete?: string | undefined;
1952
1950
  name: string;
1953
1951
  tableFrom: string;
1954
1952
  columnsFrom: string[];
1955
1953
  tableTo: string;
1956
1954
  columnsTo: string[];
1957
- }, {
1958
1955
  onUpdate?: string | undefined;
1959
1956
  onDelete?: string | undefined;
1957
+ }, {
1960
1958
  name: string;
1961
1959
  tableFrom: string;
1962
1960
  columnsFrom: string[];
1963
1961
  tableTo: string;
1964
1962
  columnsTo: string[];
1963
+ onUpdate?: string | undefined;
1964
+ onDelete?: string | undefined;
1965
1965
  }>>;
1966
1966
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1967
1967
  name: import("zod").ZodString;
@@ -1986,30 +1986,30 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape
1986
1986
  }, "strict", import("zod").ZodTypeAny, {
1987
1987
  name: string;
1988
1988
  columns: Record<string, {
1989
- default?: any;
1990
- onUpdate?: any;
1991
- autoincrement?: boolean | undefined;
1992
1989
  name: string;
1993
1990
  type: string;
1994
1991
  primaryKey: boolean;
1995
1992
  notNull: boolean;
1993
+ default?: any;
1994
+ onUpdate?: any;
1995
+ autoincrement?: boolean | undefined;
1996
1996
  }>;
1997
1997
  indexes: Record<string, {
1998
- using?: "btree" | "hash" | undefined;
1999
- algorithm?: "default" | "inplace" | "copy" | undefined;
2000
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2001
1998
  name: string;
2002
1999
  columns: string[];
2003
2000
  isUnique: boolean;
2001
+ using?: "btree" | "hash" | undefined;
2002
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2003
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2004
2004
  }>;
2005
2005
  foreignKeys: Record<string, {
2006
- onUpdate?: string | undefined;
2007
- onDelete?: string | undefined;
2008
2006
  name: string;
2009
2007
  tableFrom: string;
2010
2008
  columnsFrom: string[];
2011
2009
  tableTo: string;
2012
2010
  columnsTo: string[];
2011
+ onUpdate?: string | undefined;
2012
+ onDelete?: string | undefined;
2013
2013
  }>;
2014
2014
  compositePrimaryKeys: Record<string, {
2015
2015
  name: string;
@@ -2020,41 +2020,41 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape
2020
2020
  columns: string[];
2021
2021
  }>;
2022
2022
  }, {
2023
- uniqueConstraints?: Record<string, {
2024
- name: string;
2025
- columns: string[];
2026
- }> | undefined;
2027
2023
  name: string;
2028
2024
  columns: Record<string, {
2029
- default?: any;
2030
- onUpdate?: any;
2031
- autoincrement?: boolean | undefined;
2032
2025
  name: string;
2033
2026
  type: string;
2034
2027
  primaryKey: boolean;
2035
2028
  notNull: boolean;
2029
+ default?: any;
2030
+ onUpdate?: any;
2031
+ autoincrement?: boolean | undefined;
2036
2032
  }>;
2037
2033
  indexes: Record<string, {
2038
- using?: "btree" | "hash" | undefined;
2039
- algorithm?: "default" | "inplace" | "copy" | undefined;
2040
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2041
2034
  name: string;
2042
2035
  columns: string[];
2043
2036
  isUnique: boolean;
2037
+ using?: "btree" | "hash" | undefined;
2038
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2039
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2044
2040
  }>;
2045
2041
  foreignKeys: Record<string, {
2046
- onUpdate?: string | undefined;
2047
- onDelete?: string | undefined;
2048
2042
  name: string;
2049
2043
  tableFrom: string;
2050
2044
  columnsFrom: string[];
2051
2045
  tableTo: string;
2052
2046
  columnsTo: string[];
2047
+ onUpdate?: string | undefined;
2048
+ onDelete?: string | undefined;
2053
2049
  }>;
2054
2050
  compositePrimaryKeys: Record<string, {
2055
2051
  name: string;
2056
2052
  columns: string[];
2057
2053
  }>;
2054
+ uniqueConstraints?: Record<string, {
2055
+ name: string;
2056
+ columns: string[];
2057
+ }> | undefined;
2058
2058
  }>>;
2059
2059
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2060
2060
  _meta: import("zod").ZodObject<{
@@ -2105,40 +2105,33 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape
2105
2105
  id: import("zod").ZodString;
2106
2106
  prevId: import("zod").ZodString;
2107
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
2108
  tables: Record<string, {
2116
2109
  name: string;
2117
2110
  columns: Record<string, {
2118
- default?: any;
2119
- onUpdate?: any;
2120
- autoincrement?: boolean | undefined;
2121
2111
  name: string;
2122
2112
  type: string;
2123
2113
  primaryKey: boolean;
2124
2114
  notNull: boolean;
2115
+ default?: any;
2116
+ onUpdate?: any;
2117
+ autoincrement?: boolean | undefined;
2125
2118
  }>;
2126
2119
  indexes: Record<string, {
2127
- using?: "btree" | "hash" | undefined;
2128
- algorithm?: "default" | "inplace" | "copy" | undefined;
2129
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2130
2120
  name: string;
2131
2121
  columns: string[];
2132
2122
  isUnique: boolean;
2123
+ using?: "btree" | "hash" | undefined;
2124
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2125
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2133
2126
  }>;
2134
2127
  foreignKeys: Record<string, {
2135
- onUpdate?: string | undefined;
2136
- onDelete?: string | undefined;
2137
2128
  name: string;
2138
2129
  tableFrom: string;
2139
2130
  columnsFrom: string[];
2140
2131
  tableTo: string;
2141
2132
  columnsTo: string[];
2133
+ onUpdate?: string | undefined;
2134
+ onDelete?: string | undefined;
2142
2135
  }>;
2143
2136
  compositePrimaryKeys: Record<string, {
2144
2137
  name: string;
@@ -2159,7 +2152,6 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape
2159
2152
  tables: Record<string, string>;
2160
2153
  schemas: Record<string, string>;
2161
2154
  };
2162
- }, {
2163
2155
  internal?: {
2164
2156
  tables: Record<string, {
2165
2157
  columns: Record<string, {
@@ -2167,42 +2159,43 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape
2167
2159
  } | undefined>;
2168
2160
  } | undefined>;
2169
2161
  } | undefined;
2162
+ }, {
2170
2163
  tables: Record<string, {
2171
- uniqueConstraints?: Record<string, {
2172
- name: string;
2173
- columns: string[];
2174
- }> | undefined;
2175
2164
  name: string;
2176
2165
  columns: Record<string, {
2177
- default?: any;
2178
- onUpdate?: any;
2179
- autoincrement?: boolean | undefined;
2180
2166
  name: string;
2181
2167
  type: string;
2182
2168
  primaryKey: boolean;
2183
2169
  notNull: boolean;
2170
+ default?: any;
2171
+ onUpdate?: any;
2172
+ autoincrement?: boolean | undefined;
2184
2173
  }>;
2185
2174
  indexes: Record<string, {
2186
- using?: "btree" | "hash" | undefined;
2187
- algorithm?: "default" | "inplace" | "copy" | undefined;
2188
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2189
2175
  name: string;
2190
2176
  columns: string[];
2191
2177
  isUnique: boolean;
2178
+ using?: "btree" | "hash" | undefined;
2179
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2180
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2192
2181
  }>;
2193
2182
  foreignKeys: Record<string, {
2194
- onUpdate?: string | undefined;
2195
- onDelete?: string | undefined;
2196
2183
  name: string;
2197
2184
  tableFrom: string;
2198
2185
  columnsFrom: string[];
2199
2186
  tableTo: string;
2200
2187
  columnsTo: string[];
2188
+ onUpdate?: string | undefined;
2189
+ onDelete?: string | undefined;
2201
2190
  }>;
2202
2191
  compositePrimaryKeys: Record<string, {
2203
2192
  name: string;
2204
2193
  columns: string[];
2205
2194
  }>;
2195
+ uniqueConstraints?: Record<string, {
2196
+ name: string;
2197
+ columns: string[];
2198
+ }> | undefined;
2206
2199
  }>;
2207
2200
  id: string;
2208
2201
  prevId: string;
@@ -2214,8 +2207,15 @@ export declare const schemaV5: import("zod").ZodObject<import("zod").extendShape
2214
2207
  tables: Record<string, string>;
2215
2208
  schemas: Record<string, string>;
2216
2209
  };
2210
+ internal?: {
2211
+ tables: Record<string, {
2212
+ columns: Record<string, {
2213
+ isDefaultAnExpression?: boolean | undefined;
2214
+ } | undefined>;
2215
+ } | undefined>;
2216
+ } | undefined;
2217
2217
  }>;
2218
- export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2218
+ export declare const schema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
2219
2219
  version: import("zod").ZodLiteral<"5">;
2220
2220
  dialect: import("zod").ZodLiteral<"mysql">;
2221
2221
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -2229,21 +2229,21 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2229
2229
  default: import("zod").ZodOptional<import("zod").ZodAny>;
2230
2230
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2231
2231
  }, "strict", import("zod").ZodTypeAny, {
2232
- default?: any;
2233
- onUpdate?: any;
2234
- autoincrement?: boolean | undefined;
2235
2232
  name: string;
2236
2233
  type: string;
2237
2234
  primaryKey: boolean;
2238
2235
  notNull: boolean;
2239
- }, {
2240
2236
  default?: any;
2241
2237
  onUpdate?: any;
2242
2238
  autoincrement?: boolean | undefined;
2239
+ }, {
2243
2240
  name: string;
2244
2241
  type: string;
2245
2242
  primaryKey: boolean;
2246
2243
  notNull: boolean;
2244
+ default?: any;
2245
+ onUpdate?: any;
2246
+ autoincrement?: boolean | undefined;
2247
2247
  }>>;
2248
2248
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2249
2249
  name: import("zod").ZodString;
@@ -2253,19 +2253,19 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2253
2253
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
2254
2254
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
2255
2255
  }, "strict", import("zod").ZodTypeAny, {
2256
- using?: "btree" | "hash" | undefined;
2257
- algorithm?: "default" | "inplace" | "copy" | undefined;
2258
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2259
2256
  name: string;
2260
2257
  columns: string[];
2261
2258
  isUnique: boolean;
2262
- }, {
2263
2259
  using?: "btree" | "hash" | undefined;
2264
2260
  algorithm?: "default" | "inplace" | "copy" | undefined;
2265
2261
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2262
+ }, {
2266
2263
  name: string;
2267
2264
  columns: string[];
2268
2265
  isUnique: boolean;
2266
+ using?: "btree" | "hash" | undefined;
2267
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2268
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2269
2269
  }>>;
2270
2270
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2271
2271
  name: import("zod").ZodString;
@@ -2276,21 +2276,21 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2276
2276
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2277
2277
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2278
2278
  }, "strict", import("zod").ZodTypeAny, {
2279
- onUpdate?: string | undefined;
2280
- onDelete?: string | undefined;
2281
2279
  name: string;
2282
2280
  tableFrom: string;
2283
2281
  columnsFrom: string[];
2284
2282
  tableTo: string;
2285
2283
  columnsTo: string[];
2286
- }, {
2287
2284
  onUpdate?: string | undefined;
2288
2285
  onDelete?: string | undefined;
2286
+ }, {
2289
2287
  name: string;
2290
2288
  tableFrom: string;
2291
2289
  columnsFrom: string[];
2292
2290
  tableTo: string;
2293
2291
  columnsTo: string[];
2292
+ onUpdate?: string | undefined;
2293
+ onDelete?: string | undefined;
2294
2294
  }>>;
2295
2295
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2296
2296
  name: import("zod").ZodString;
@@ -2315,30 +2315,30 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2315
2315
  }, "strict", import("zod").ZodTypeAny, {
2316
2316
  name: string;
2317
2317
  columns: Record<string, {
2318
- default?: any;
2319
- onUpdate?: any;
2320
- autoincrement?: boolean | undefined;
2321
2318
  name: string;
2322
2319
  type: string;
2323
2320
  primaryKey: boolean;
2324
2321
  notNull: boolean;
2322
+ default?: any;
2323
+ onUpdate?: any;
2324
+ autoincrement?: boolean | undefined;
2325
2325
  }>;
2326
2326
  indexes: Record<string, {
2327
- using?: "btree" | "hash" | undefined;
2328
- algorithm?: "default" | "inplace" | "copy" | undefined;
2329
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2330
2327
  name: string;
2331
2328
  columns: string[];
2332
2329
  isUnique: boolean;
2330
+ using?: "btree" | "hash" | undefined;
2331
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2332
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2333
2333
  }>;
2334
2334
  foreignKeys: Record<string, {
2335
- onUpdate?: string | undefined;
2336
- onDelete?: string | undefined;
2337
2335
  name: string;
2338
2336
  tableFrom: string;
2339
2337
  columnsFrom: string[];
2340
2338
  tableTo: string;
2341
2339
  columnsTo: string[];
2340
+ onUpdate?: string | undefined;
2341
+ onDelete?: string | undefined;
2342
2342
  }>;
2343
2343
  compositePrimaryKeys: Record<string, {
2344
2344
  name: string;
@@ -2349,41 +2349,41 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2349
2349
  columns: string[];
2350
2350
  }>;
2351
2351
  }, {
2352
- uniqueConstraints?: Record<string, {
2353
- name: string;
2354
- columns: string[];
2355
- }> | undefined;
2356
2352
  name: string;
2357
2353
  columns: Record<string, {
2358
- default?: any;
2359
- onUpdate?: any;
2360
- autoincrement?: boolean | undefined;
2361
2354
  name: string;
2362
2355
  type: string;
2363
2356
  primaryKey: boolean;
2364
2357
  notNull: boolean;
2358
+ default?: any;
2359
+ onUpdate?: any;
2360
+ autoincrement?: boolean | undefined;
2365
2361
  }>;
2366
2362
  indexes: Record<string, {
2367
- using?: "btree" | "hash" | undefined;
2368
- algorithm?: "default" | "inplace" | "copy" | undefined;
2369
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2370
2363
  name: string;
2371
2364
  columns: string[];
2372
2365
  isUnique: boolean;
2366
+ using?: "btree" | "hash" | undefined;
2367
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2368
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2373
2369
  }>;
2374
2370
  foreignKeys: Record<string, {
2375
- onUpdate?: string | undefined;
2376
- onDelete?: string | undefined;
2377
2371
  name: string;
2378
2372
  tableFrom: string;
2379
2373
  columnsFrom: string[];
2380
2374
  tableTo: string;
2381
2375
  columnsTo: string[];
2376
+ onUpdate?: string | undefined;
2377
+ onDelete?: string | undefined;
2382
2378
  }>;
2383
2379
  compositePrimaryKeys: Record<string, {
2384
2380
  name: string;
2385
2381
  columns: string[];
2386
2382
  }>;
2383
+ uniqueConstraints?: Record<string, {
2384
+ name: string;
2385
+ columns: string[];
2386
+ }> | undefined;
2387
2387
  }>>;
2388
2388
  _meta: import("zod").ZodObject<{
2389
2389
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -2430,40 +2430,33 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2430
2430
  id: import("zod").ZodString;
2431
2431
  prevId: import("zod").ZodString;
2432
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
2433
  tables: Record<string, {
2441
2434
  name: string;
2442
2435
  columns: Record<string, {
2443
- default?: any;
2444
- onUpdate?: any;
2445
- autoincrement?: boolean | undefined;
2446
2436
  name: string;
2447
2437
  type: string;
2448
2438
  primaryKey: boolean;
2449
2439
  notNull: boolean;
2440
+ default?: any;
2441
+ onUpdate?: any;
2442
+ autoincrement?: boolean | undefined;
2450
2443
  }>;
2451
2444
  indexes: Record<string, {
2452
- using?: "btree" | "hash" | undefined;
2453
- algorithm?: "default" | "inplace" | "copy" | undefined;
2454
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2455
2445
  name: string;
2456
2446
  columns: string[];
2457
2447
  isUnique: boolean;
2448
+ using?: "btree" | "hash" | undefined;
2449
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2450
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2458
2451
  }>;
2459
2452
  foreignKeys: Record<string, {
2460
- onUpdate?: string | undefined;
2461
- onDelete?: string | undefined;
2462
2453
  name: string;
2463
2454
  tableFrom: string;
2464
2455
  columnsFrom: string[];
2465
2456
  tableTo: string;
2466
2457
  columnsTo: string[];
2458
+ onUpdate?: string | undefined;
2459
+ onDelete?: string | undefined;
2467
2460
  }>;
2468
2461
  compositePrimaryKeys: Record<string, {
2469
2462
  name: string;
@@ -2482,7 +2475,6 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2482
2475
  columns: Record<string, string>;
2483
2476
  tables: Record<string, string>;
2484
2477
  };
2485
- }, {
2486
2478
  internal?: {
2487
2479
  tables: Record<string, {
2488
2480
  columns: Record<string, {
@@ -2490,42 +2482,43 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2490
2482
  } | undefined>;
2491
2483
  } | undefined>;
2492
2484
  } | undefined;
2485
+ }, {
2493
2486
  tables: Record<string, {
2494
- uniqueConstraints?: Record<string, {
2495
- name: string;
2496
- columns: string[];
2497
- }> | undefined;
2498
2487
  name: string;
2499
2488
  columns: Record<string, {
2500
- default?: any;
2501
- onUpdate?: any;
2502
- autoincrement?: boolean | undefined;
2503
2489
  name: string;
2504
2490
  type: string;
2505
2491
  primaryKey: boolean;
2506
2492
  notNull: boolean;
2493
+ default?: any;
2494
+ onUpdate?: any;
2495
+ autoincrement?: boolean | undefined;
2507
2496
  }>;
2508
2497
  indexes: Record<string, {
2509
- using?: "btree" | "hash" | undefined;
2510
- algorithm?: "default" | "inplace" | "copy" | undefined;
2511
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2512
2498
  name: string;
2513
2499
  columns: string[];
2514
2500
  isUnique: boolean;
2501
+ using?: "btree" | "hash" | undefined;
2502
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2503
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2515
2504
  }>;
2516
2505
  foreignKeys: Record<string, {
2517
- onUpdate?: string | undefined;
2518
- onDelete?: string | undefined;
2519
2506
  name: string;
2520
2507
  tableFrom: string;
2521
2508
  columnsFrom: string[];
2522
2509
  tableTo: string;
2523
2510
  columnsTo: string[];
2511
+ onUpdate?: string | undefined;
2512
+ onDelete?: string | undefined;
2524
2513
  }>;
2525
2514
  compositePrimaryKeys: Record<string, {
2526
2515
  name: string;
2527
2516
  columns: string[];
2528
2517
  }>;
2518
+ uniqueConstraints?: Record<string, {
2519
+ name: string;
2520
+ columns: string[];
2521
+ }> | undefined;
2529
2522
  }>;
2530
2523
  id: string;
2531
2524
  prevId: string;
@@ -2535,6 +2528,13 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
2535
2528
  columns: Record<string, string>;
2536
2529
  tables: Record<string, string>;
2537
2530
  };
2531
+ internal?: {
2532
+ tables: Record<string, {
2533
+ columns: Record<string, {
2534
+ isDefaultAnExpression?: boolean | undefined;
2535
+ } | undefined>;
2536
+ } | undefined>;
2537
+ } | undefined;
2538
2538
  }>;
2539
2539
  export declare const schemaSquashed: import("zod").ZodObject<{
2540
2540
  version: import("zod").ZodLiteral<"5">;
@@ -2550,21 +2550,21 @@ export declare const schemaSquashed: import("zod").ZodObject<{
2550
2550
  default: import("zod").ZodOptional<import("zod").ZodAny>;
2551
2551
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2552
2552
  }, "strict", import("zod").ZodTypeAny, {
2553
- default?: any;
2554
- onUpdate?: any;
2555
- autoincrement?: boolean | undefined;
2556
2553
  name: string;
2557
2554
  type: string;
2558
2555
  primaryKey: boolean;
2559
2556
  notNull: boolean;
2560
- }, {
2561
2557
  default?: any;
2562
2558
  onUpdate?: any;
2563
2559
  autoincrement?: boolean | undefined;
2560
+ }, {
2564
2561
  name: string;
2565
2562
  type: string;
2566
2563
  primaryKey: boolean;
2567
2564
  notNull: boolean;
2565
+ default?: any;
2566
+ onUpdate?: any;
2567
+ autoincrement?: boolean | undefined;
2568
2568
  }>>;
2569
2569
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2570
2570
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -2573,45 +2573,45 @@ export declare const schemaSquashed: import("zod").ZodObject<{
2573
2573
  }, "strict", import("zod").ZodTypeAny, {
2574
2574
  name: string;
2575
2575
  columns: Record<string, {
2576
- default?: any;
2577
- onUpdate?: any;
2578
- autoincrement?: boolean | undefined;
2579
2576
  name: string;
2580
2577
  type: string;
2581
2578
  primaryKey: boolean;
2582
2579
  notNull: boolean;
2580
+ default?: any;
2581
+ onUpdate?: any;
2582
+ autoincrement?: boolean | undefined;
2583
2583
  }>;
2584
2584
  indexes: Record<string, string>;
2585
2585
  foreignKeys: Record<string, string>;
2586
2586
  compositePrimaryKeys: Record<string, string>;
2587
2587
  uniqueConstraints: Record<string, string>;
2588
2588
  }, {
2589
- uniqueConstraints?: Record<string, string> | undefined;
2590
2589
  name: string;
2591
2590
  columns: Record<string, {
2592
- default?: any;
2593
- onUpdate?: any;
2594
- autoincrement?: boolean | undefined;
2595
2591
  name: string;
2596
2592
  type: string;
2597
2593
  primaryKey: boolean;
2598
2594
  notNull: boolean;
2595
+ default?: any;
2596
+ onUpdate?: any;
2597
+ autoincrement?: boolean | undefined;
2599
2598
  }>;
2600
2599
  indexes: Record<string, string>;
2601
2600
  foreignKeys: Record<string, string>;
2602
2601
  compositePrimaryKeys: Record<string, string>;
2602
+ uniqueConstraints?: Record<string, string> | undefined;
2603
2603
  }>>;
2604
2604
  }, "strict", import("zod").ZodTypeAny, {
2605
2605
  tables: Record<string, {
2606
2606
  name: string;
2607
2607
  columns: Record<string, {
2608
- default?: any;
2609
- onUpdate?: any;
2610
- autoincrement?: boolean | undefined;
2611
2608
  name: string;
2612
2609
  type: string;
2613
2610
  primaryKey: boolean;
2614
2611
  notNull: boolean;
2612
+ default?: any;
2613
+ onUpdate?: any;
2614
+ autoincrement?: boolean | undefined;
2615
2615
  }>;
2616
2616
  indexes: Record<string, string>;
2617
2617
  foreignKeys: Record<string, string>;
@@ -2622,20 +2622,20 @@ export declare const schemaSquashed: import("zod").ZodObject<{
2622
2622
  dialect: "mysql";
2623
2623
  }, {
2624
2624
  tables: Record<string, {
2625
- uniqueConstraints?: Record<string, string> | undefined;
2626
2625
  name: string;
2627
2626
  columns: Record<string, {
2628
- default?: any;
2629
- onUpdate?: any;
2630
- autoincrement?: boolean | undefined;
2631
2627
  name: string;
2632
2628
  type: string;
2633
2629
  primaryKey: boolean;
2634
2630
  notNull: boolean;
2631
+ default?: any;
2632
+ onUpdate?: any;
2633
+ autoincrement?: boolean | undefined;
2635
2634
  }>;
2636
2635
  indexes: Record<string, string>;
2637
2636
  foreignKeys: Record<string, string>;
2638
2637
  compositePrimaryKeys: Record<string, string>;
2638
+ uniqueConstraints?: Record<string, string> | undefined;
2639
2639
  }>;
2640
2640
  version: "5";
2641
2641
  dialect: "mysql";
@@ -2655,88 +2655,88 @@ export declare const schemaSquashedV4: import("zod").ZodObject<{
2655
2655
  default: import("zod").ZodOptional<import("zod").ZodAny>;
2656
2656
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2657
2657
  }, "strict", import("zod").ZodTypeAny, {
2658
- default?: any;
2659
- onUpdate?: any;
2660
- autoincrement?: boolean | undefined;
2661
2658
  name: string;
2662
2659
  type: string;
2663
2660
  primaryKey: boolean;
2664
2661
  notNull: boolean;
2665
- }, {
2666
2662
  default?: any;
2667
2663
  onUpdate?: any;
2668
2664
  autoincrement?: boolean | undefined;
2665
+ }, {
2669
2666
  name: string;
2670
2667
  type: string;
2671
2668
  primaryKey: boolean;
2672
2669
  notNull: boolean;
2670
+ default?: any;
2671
+ onUpdate?: any;
2672
+ autoincrement?: boolean | undefined;
2673
2673
  }>>;
2674
2674
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2675
2675
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2676
2676
  }, "strict", import("zod").ZodTypeAny, {
2677
- schema?: string | undefined;
2678
2677
  name: string;
2679
2678
  columns: Record<string, {
2680
- default?: any;
2681
- onUpdate?: any;
2682
- autoincrement?: boolean | undefined;
2683
2679
  name: string;
2684
2680
  type: string;
2685
2681
  primaryKey: boolean;
2686
2682
  notNull: boolean;
2683
+ default?: any;
2684
+ onUpdate?: any;
2685
+ autoincrement?: boolean | undefined;
2687
2686
  }>;
2688
2687
  indexes: Record<string, string>;
2689
2688
  foreignKeys: Record<string, string>;
2690
- }, {
2691
2689
  schema?: string | undefined;
2690
+ }, {
2692
2691
  name: string;
2693
2692
  columns: Record<string, {
2694
- default?: any;
2695
- onUpdate?: any;
2696
- autoincrement?: boolean | undefined;
2697
2693
  name: string;
2698
2694
  type: string;
2699
2695
  primaryKey: boolean;
2700
2696
  notNull: boolean;
2697
+ default?: any;
2698
+ onUpdate?: any;
2699
+ autoincrement?: boolean | undefined;
2701
2700
  }>;
2702
2701
  indexes: Record<string, string>;
2703
2702
  foreignKeys: Record<string, string>;
2703
+ schema?: string | undefined;
2704
2704
  }>>;
2705
2705
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2706
2706
  }, "strict", import("zod").ZodTypeAny, {
2707
2707
  tables: Record<string, {
2708
- schema?: string | undefined;
2709
2708
  name: string;
2710
2709
  columns: Record<string, {
2711
- default?: any;
2712
- onUpdate?: any;
2713
- autoincrement?: boolean | undefined;
2714
2710
  name: string;
2715
2711
  type: string;
2716
2712
  primaryKey: boolean;
2717
2713
  notNull: boolean;
2714
+ default?: any;
2715
+ onUpdate?: any;
2716
+ autoincrement?: boolean | undefined;
2718
2717
  }>;
2719
2718
  indexes: Record<string, string>;
2720
2719
  foreignKeys: Record<string, string>;
2720
+ schema?: string | undefined;
2721
2721
  }>;
2722
2722
  version: "4";
2723
2723
  dialect: "mysql";
2724
2724
  schemas: Record<string, string>;
2725
2725
  }, {
2726
2726
  tables: Record<string, {
2727
- schema?: string | undefined;
2728
2727
  name: string;
2729
2728
  columns: Record<string, {
2730
- default?: any;
2731
- onUpdate?: any;
2732
- autoincrement?: boolean | undefined;
2733
2729
  name: string;
2734
2730
  type: string;
2735
2731
  primaryKey: boolean;
2736
2732
  notNull: boolean;
2733
+ default?: any;
2734
+ onUpdate?: any;
2735
+ autoincrement?: boolean | undefined;
2737
2736
  }>;
2738
2737
  indexes: Record<string, string>;
2739
2738
  foreignKeys: Record<string, string>;
2739
+ schema?: string | undefined;
2740
2740
  }>;
2741
2741
  version: "4";
2742
2742
  dialect: "mysql";
@@ -2770,7 +2770,7 @@ export declare const MySqlSquasher: {
2770
2770
  };
2771
2771
  export declare const squashMysqlSchemeV4: (json: MySqlSchemaV4) => MySqlSchemaSquashedV4;
2772
2772
  export declare const squashMysqlScheme: (json: MySqlSchema) => MySqlSchemaSquashed;
2773
- export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendShape<{
2773
+ export declare const mysqlSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
2774
2774
  version: import("zod").ZodLiteral<"5">;
2775
2775
  dialect: import("zod").ZodLiteral<"mysql">;
2776
2776
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -2784,21 +2784,21 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2784
2784
  default: import("zod").ZodOptional<import("zod").ZodAny>;
2785
2785
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
2786
2786
  }, "strict", import("zod").ZodTypeAny, {
2787
- default?: any;
2788
- onUpdate?: any;
2789
- autoincrement?: boolean | undefined;
2790
2787
  name: string;
2791
2788
  type: string;
2792
2789
  primaryKey: boolean;
2793
2790
  notNull: boolean;
2794
- }, {
2795
2791
  default?: any;
2796
2792
  onUpdate?: any;
2797
2793
  autoincrement?: boolean | undefined;
2794
+ }, {
2798
2795
  name: string;
2799
2796
  type: string;
2800
2797
  primaryKey: boolean;
2801
2798
  notNull: boolean;
2799
+ default?: any;
2800
+ onUpdate?: any;
2801
+ autoincrement?: boolean | undefined;
2802
2802
  }>>;
2803
2803
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2804
2804
  name: import("zod").ZodString;
@@ -2808,19 +2808,19 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2808
2808
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
2809
2809
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
2810
2810
  }, "strict", import("zod").ZodTypeAny, {
2811
- using?: "btree" | "hash" | undefined;
2812
- algorithm?: "default" | "inplace" | "copy" | undefined;
2813
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2814
2811
  name: string;
2815
2812
  columns: string[];
2816
2813
  isUnique: boolean;
2817
- }, {
2818
2814
  using?: "btree" | "hash" | undefined;
2819
2815
  algorithm?: "default" | "inplace" | "copy" | undefined;
2820
2816
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2817
+ }, {
2821
2818
  name: string;
2822
2819
  columns: string[];
2823
2820
  isUnique: boolean;
2821
+ using?: "btree" | "hash" | undefined;
2822
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2823
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2824
2824
  }>>;
2825
2825
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2826
2826
  name: import("zod").ZodString;
@@ -2831,21 +2831,21 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2831
2831
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2832
2832
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2833
2833
  }, "strict", import("zod").ZodTypeAny, {
2834
- onUpdate?: string | undefined;
2835
- onDelete?: string | undefined;
2836
2834
  name: string;
2837
2835
  tableFrom: string;
2838
2836
  columnsFrom: string[];
2839
2837
  tableTo: string;
2840
2838
  columnsTo: string[];
2841
- }, {
2842
2839
  onUpdate?: string | undefined;
2843
2840
  onDelete?: string | undefined;
2841
+ }, {
2844
2842
  name: string;
2845
2843
  tableFrom: string;
2846
2844
  columnsFrom: string[];
2847
2845
  tableTo: string;
2848
2846
  columnsTo: string[];
2847
+ onUpdate?: string | undefined;
2848
+ onDelete?: string | undefined;
2849
2849
  }>>;
2850
2850
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2851
2851
  name: import("zod").ZodString;
@@ -2870,30 +2870,30 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2870
2870
  }, "strict", import("zod").ZodTypeAny, {
2871
2871
  name: string;
2872
2872
  columns: Record<string, {
2873
- default?: any;
2874
- onUpdate?: any;
2875
- autoincrement?: boolean | undefined;
2876
2873
  name: string;
2877
2874
  type: string;
2878
2875
  primaryKey: boolean;
2879
2876
  notNull: boolean;
2877
+ default?: any;
2878
+ onUpdate?: any;
2879
+ autoincrement?: boolean | undefined;
2880
2880
  }>;
2881
2881
  indexes: Record<string, {
2882
- using?: "btree" | "hash" | undefined;
2883
- algorithm?: "default" | "inplace" | "copy" | undefined;
2884
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2885
2882
  name: string;
2886
2883
  columns: string[];
2887
2884
  isUnique: boolean;
2885
+ using?: "btree" | "hash" | undefined;
2886
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2887
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2888
2888
  }>;
2889
2889
  foreignKeys: Record<string, {
2890
- onUpdate?: string | undefined;
2891
- onDelete?: string | undefined;
2892
2890
  name: string;
2893
2891
  tableFrom: string;
2894
2892
  columnsFrom: string[];
2895
2893
  tableTo: string;
2896
2894
  columnsTo: string[];
2895
+ onUpdate?: string | undefined;
2896
+ onDelete?: string | undefined;
2897
2897
  }>;
2898
2898
  compositePrimaryKeys: Record<string, {
2899
2899
  name: string;
@@ -2904,41 +2904,41 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2904
2904
  columns: string[];
2905
2905
  }>;
2906
2906
  }, {
2907
- uniqueConstraints?: Record<string, {
2908
- name: string;
2909
- columns: string[];
2910
- }> | undefined;
2911
2907
  name: string;
2912
2908
  columns: Record<string, {
2913
- default?: any;
2914
- onUpdate?: any;
2915
- autoincrement?: boolean | undefined;
2916
2909
  name: string;
2917
2910
  type: string;
2918
2911
  primaryKey: boolean;
2919
2912
  notNull: boolean;
2913
+ default?: any;
2914
+ onUpdate?: any;
2915
+ autoincrement?: boolean | undefined;
2920
2916
  }>;
2921
2917
  indexes: Record<string, {
2922
- using?: "btree" | "hash" | undefined;
2923
- algorithm?: "default" | "inplace" | "copy" | undefined;
2924
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2925
2918
  name: string;
2926
2919
  columns: string[];
2927
2920
  isUnique: boolean;
2921
+ using?: "btree" | "hash" | undefined;
2922
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2923
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2928
2924
  }>;
2929
2925
  foreignKeys: Record<string, {
2930
- onUpdate?: string | undefined;
2931
- onDelete?: string | undefined;
2932
2926
  name: string;
2933
2927
  tableFrom: string;
2934
2928
  columnsFrom: string[];
2935
2929
  tableTo: string;
2936
2930
  columnsTo: string[];
2931
+ onUpdate?: string | undefined;
2932
+ onDelete?: string | undefined;
2937
2933
  }>;
2938
2934
  compositePrimaryKeys: Record<string, {
2939
2935
  name: string;
2940
2936
  columns: string[];
2941
2937
  }>;
2938
+ uniqueConstraints?: Record<string, {
2939
+ name: string;
2940
+ columns: string[];
2941
+ }> | undefined;
2942
2942
  }>>;
2943
2943
  _meta: import("zod").ZodObject<{
2944
2944
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -2985,40 +2985,33 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
2985
2985
  id: import("zod").ZodString;
2986
2986
  prevId: import("zod").ZodString;
2987
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
2988
  tables: Record<string, {
2996
2989
  name: string;
2997
2990
  columns: Record<string, {
2998
- default?: any;
2999
- onUpdate?: any;
3000
- autoincrement?: boolean | undefined;
3001
2991
  name: string;
3002
2992
  type: string;
3003
2993
  primaryKey: boolean;
3004
2994
  notNull: boolean;
2995
+ default?: any;
2996
+ onUpdate?: any;
2997
+ autoincrement?: boolean | undefined;
3005
2998
  }>;
3006
2999
  indexes: Record<string, {
3007
- using?: "btree" | "hash" | undefined;
3008
- algorithm?: "default" | "inplace" | "copy" | undefined;
3009
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3010
3000
  name: string;
3011
3001
  columns: string[];
3012
3002
  isUnique: boolean;
3003
+ using?: "btree" | "hash" | undefined;
3004
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3005
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3013
3006
  }>;
3014
3007
  foreignKeys: Record<string, {
3015
- onUpdate?: string | undefined;
3016
- onDelete?: string | undefined;
3017
3008
  name: string;
3018
3009
  tableFrom: string;
3019
3010
  columnsFrom: string[];
3020
3011
  tableTo: string;
3021
3012
  columnsTo: string[];
3013
+ onUpdate?: string | undefined;
3014
+ onDelete?: string | undefined;
3022
3015
  }>;
3023
3016
  compositePrimaryKeys: Record<string, {
3024
3017
  name: string;
@@ -3037,7 +3030,6 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
3037
3030
  columns: Record<string, string>;
3038
3031
  tables: Record<string, string>;
3039
3032
  };
3040
- }, {
3041
3033
  internal?: {
3042
3034
  tables: Record<string, {
3043
3035
  columns: Record<string, {
@@ -3045,42 +3037,43 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
3045
3037
  } | undefined>;
3046
3038
  } | undefined>;
3047
3039
  } | undefined;
3040
+ }, {
3048
3041
  tables: Record<string, {
3049
- uniqueConstraints?: Record<string, {
3050
- name: string;
3051
- columns: string[];
3052
- }> | undefined;
3053
3042
  name: string;
3054
3043
  columns: Record<string, {
3055
- default?: any;
3056
- onUpdate?: any;
3057
- autoincrement?: boolean | undefined;
3058
3044
  name: string;
3059
3045
  type: string;
3060
3046
  primaryKey: boolean;
3061
3047
  notNull: boolean;
3048
+ default?: any;
3049
+ onUpdate?: any;
3050
+ autoincrement?: boolean | undefined;
3062
3051
  }>;
3063
3052
  indexes: Record<string, {
3064
- using?: "btree" | "hash" | undefined;
3065
- algorithm?: "default" | "inplace" | "copy" | undefined;
3066
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3067
3053
  name: string;
3068
3054
  columns: string[];
3069
3055
  isUnique: boolean;
3056
+ using?: "btree" | "hash" | undefined;
3057
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3058
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3070
3059
  }>;
3071
3060
  foreignKeys: Record<string, {
3072
- onUpdate?: string | undefined;
3073
- onDelete?: string | undefined;
3074
3061
  name: string;
3075
3062
  tableFrom: string;
3076
3063
  columnsFrom: string[];
3077
3064
  tableTo: string;
3078
3065
  columnsTo: string[];
3066
+ onUpdate?: string | undefined;
3067
+ onDelete?: string | undefined;
3079
3068
  }>;
3080
3069
  compositePrimaryKeys: Record<string, {
3081
3070
  name: string;
3082
3071
  columns: string[];
3083
3072
  }>;
3073
+ uniqueConstraints?: Record<string, {
3074
+ name: string;
3075
+ columns: string[];
3076
+ }> | undefined;
3084
3077
  }>;
3085
3078
  id: string;
3086
3079
  prevId: string;
@@ -3090,8 +3083,15 @@ export declare const mysqlSchema: import("zod").ZodObject<import("zod").extendSh
3090
3083
  columns: Record<string, string>;
3091
3084
  tables: Record<string, string>;
3092
3085
  };
3086
+ internal?: {
3087
+ tables: Record<string, {
3088
+ columns: Record<string, {
3089
+ isDefaultAnExpression?: boolean | undefined;
3090
+ } | undefined>;
3091
+ } | undefined>;
3092
+ } | undefined;
3093
3093
  }>;
3094
- export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
3094
+ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
3095
3095
  version: import("zod").ZodLiteral<"3">;
3096
3096
  dialect: import("zod").ZodLiteral<"mysql">;
3097
3097
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -3105,21 +3105,21 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
3105
3105
  default: import("zod").ZodOptional<import("zod").ZodAny>;
3106
3106
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
3107
3107
  }, "strict", import("zod").ZodTypeAny, {
3108
- default?: any;
3109
- onUpdate?: any;
3110
- autoincrement?: boolean | undefined;
3111
3108
  name: string;
3112
3109
  type: string;
3113
3110
  primaryKey: boolean;
3114
3111
  notNull: boolean;
3115
- }, {
3116
3112
  default?: any;
3117
3113
  onUpdate?: any;
3118
3114
  autoincrement?: boolean | undefined;
3115
+ }, {
3119
3116
  name: string;
3120
3117
  type: string;
3121
3118
  primaryKey: boolean;
3122
3119
  notNull: boolean;
3120
+ default?: any;
3121
+ onUpdate?: any;
3122
+ autoincrement?: boolean | undefined;
3123
3123
  }>>;
3124
3124
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3125
3125
  name: import("zod").ZodString;
@@ -3129,19 +3129,19 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
3129
3129
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
3130
3130
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
3131
3131
  }, "strict", import("zod").ZodTypeAny, {
3132
- using?: "btree" | "hash" | undefined;
3133
- algorithm?: "default" | "inplace" | "copy" | undefined;
3134
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3135
3132
  name: string;
3136
3133
  columns: string[];
3137
3134
  isUnique: boolean;
3138
- }, {
3139
3135
  using?: "btree" | "hash" | undefined;
3140
3136
  algorithm?: "default" | "inplace" | "copy" | undefined;
3141
3137
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3138
+ }, {
3142
3139
  name: string;
3143
3140
  columns: string[];
3144
3141
  isUnique: boolean;
3142
+ using?: "btree" | "hash" | undefined;
3143
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3144
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3145
3145
  }>>;
3146
3146
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3147
3147
  name: import("zod").ZodString;
@@ -3152,77 +3152,77 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
3152
3152
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3153
3153
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3154
3154
  }, "strict", import("zod").ZodTypeAny, {
3155
- onUpdate?: string | undefined;
3156
- onDelete?: string | undefined;
3157
3155
  name: string;
3158
3156
  tableFrom: string;
3159
3157
  columnsFrom: string[];
3160
3158
  tableTo: string;
3161
3159
  columnsTo: string[];
3162
- }, {
3163
3160
  onUpdate?: string | undefined;
3164
3161
  onDelete?: string | undefined;
3162
+ }, {
3165
3163
  name: string;
3166
3164
  tableFrom: string;
3167
3165
  columnsFrom: string[];
3168
3166
  tableTo: string;
3169
3167
  columnsTo: string[];
3168
+ onUpdate?: string | undefined;
3169
+ onDelete?: string | undefined;
3170
3170
  }>>;
3171
3171
  }, "strict", import("zod").ZodTypeAny, {
3172
3172
  name: string;
3173
3173
  columns: Record<string, {
3174
- default?: any;
3175
- onUpdate?: any;
3176
- autoincrement?: boolean | undefined;
3177
3174
  name: string;
3178
3175
  type: string;
3179
3176
  primaryKey: boolean;
3180
3177
  notNull: boolean;
3178
+ default?: any;
3179
+ onUpdate?: any;
3180
+ autoincrement?: boolean | undefined;
3181
3181
  }>;
3182
3182
  indexes: Record<string, {
3183
- using?: "btree" | "hash" | undefined;
3184
- algorithm?: "default" | "inplace" | "copy" | undefined;
3185
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3186
3183
  name: string;
3187
3184
  columns: string[];
3188
3185
  isUnique: boolean;
3186
+ using?: "btree" | "hash" | undefined;
3187
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3188
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3189
3189
  }>;
3190
3190
  foreignKeys: Record<string, {
3191
- onUpdate?: string | undefined;
3192
- onDelete?: string | undefined;
3193
3191
  name: string;
3194
3192
  tableFrom: string;
3195
3193
  columnsFrom: string[];
3196
3194
  tableTo: string;
3197
3195
  columnsTo: string[];
3196
+ onUpdate?: string | undefined;
3197
+ onDelete?: string | undefined;
3198
3198
  }>;
3199
3199
  }, {
3200
3200
  name: string;
3201
3201
  columns: Record<string, {
3202
- default?: any;
3203
- onUpdate?: any;
3204
- autoincrement?: boolean | undefined;
3205
3202
  name: string;
3206
3203
  type: string;
3207
3204
  primaryKey: boolean;
3208
3205
  notNull: boolean;
3206
+ default?: any;
3207
+ onUpdate?: any;
3208
+ autoincrement?: boolean | undefined;
3209
3209
  }>;
3210
3210
  indexes: Record<string, {
3211
- using?: "btree" | "hash" | undefined;
3212
- algorithm?: "default" | "inplace" | "copy" | undefined;
3213
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3214
3211
  name: string;
3215
3212
  columns: string[];
3216
3213
  isUnique: boolean;
3214
+ using?: "btree" | "hash" | undefined;
3215
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3216
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3217
3217
  }>;
3218
3218
  foreignKeys: Record<string, {
3219
- onUpdate?: string | undefined;
3220
- onDelete?: string | undefined;
3221
3219
  name: string;
3222
3220
  tableFrom: string;
3223
3221
  columnsFrom: string[];
3224
3222
  tableTo: string;
3225
3223
  columnsTo: string[];
3224
+ onUpdate?: string | undefined;
3225
+ onDelete?: string | undefined;
3226
3226
  }>;
3227
3227
  }>>;
3228
3228
  }, {
@@ -3232,30 +3232,30 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
3232
3232
  tables: Record<string, {
3233
3233
  name: string;
3234
3234
  columns: Record<string, {
3235
- default?: any;
3236
- onUpdate?: any;
3237
- autoincrement?: boolean | undefined;
3238
3235
  name: string;
3239
3236
  type: string;
3240
3237
  primaryKey: boolean;
3241
3238
  notNull: boolean;
3239
+ default?: any;
3240
+ onUpdate?: any;
3241
+ autoincrement?: boolean | undefined;
3242
3242
  }>;
3243
3243
  indexes: Record<string, {
3244
- using?: "btree" | "hash" | undefined;
3245
- algorithm?: "default" | "inplace" | "copy" | undefined;
3246
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3247
3244
  name: string;
3248
3245
  columns: string[];
3249
3246
  isUnique: boolean;
3247
+ using?: "btree" | "hash" | undefined;
3248
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3249
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3250
3250
  }>;
3251
3251
  foreignKeys: Record<string, {
3252
- onUpdate?: string | undefined;
3253
- onDelete?: string | undefined;
3254
3252
  name: string;
3255
3253
  tableFrom: string;
3256
3254
  columnsFrom: string[];
3257
3255
  tableTo: string;
3258
3256
  columnsTo: string[];
3257
+ onUpdate?: string | undefined;
3258
+ onDelete?: string | undefined;
3259
3259
  }>;
3260
3260
  }>;
3261
3261
  id: string;
@@ -3266,30 +3266,30 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
3266
3266
  tables: Record<string, {
3267
3267
  name: string;
3268
3268
  columns: Record<string, {
3269
- default?: any;
3270
- onUpdate?: any;
3271
- autoincrement?: boolean | undefined;
3272
3269
  name: string;
3273
3270
  type: string;
3274
3271
  primaryKey: boolean;
3275
3272
  notNull: boolean;
3273
+ default?: any;
3274
+ onUpdate?: any;
3275
+ autoincrement?: boolean | undefined;
3276
3276
  }>;
3277
- indexes: Record<string, {
3278
- using?: "btree" | "hash" | undefined;
3279
- algorithm?: "default" | "inplace" | "copy" | undefined;
3280
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3277
+ indexes: Record<string, {
3281
3278
  name: string;
3282
3279
  columns: string[];
3283
3280
  isUnique: boolean;
3281
+ using?: "btree" | "hash" | undefined;
3282
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3283
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3284
3284
  }>;
3285
3285
  foreignKeys: Record<string, {
3286
- onUpdate?: string | undefined;
3287
- onDelete?: string | undefined;
3288
3286
  name: string;
3289
3287
  tableFrom: string;
3290
3288
  columnsFrom: string[];
3291
3289
  tableTo: string;
3292
3290
  columnsTo: string[];
3291
+ onUpdate?: string | undefined;
3292
+ onDelete?: string | undefined;
3293
3293
  }>;
3294
3294
  }>;
3295
3295
  id: string;
@@ -3297,7 +3297,7 @@ export declare const mysqlSchemaV3: import("zod").ZodObject<import("zod").extend
3297
3297
  version: "3";
3298
3298
  dialect: "mysql";
3299
3299
  }>;
3300
- export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
3300
+ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
3301
3301
  version: import("zod").ZodLiteral<"4">;
3302
3302
  dialect: import("zod").ZodLiteral<"mysql">;
3303
3303
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -3312,21 +3312,21 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
3312
3312
  default: import("zod").ZodOptional<import("zod").ZodAny>;
3313
3313
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
3314
3314
  }, "strict", import("zod").ZodTypeAny, {
3315
- default?: any;
3316
- onUpdate?: any;
3317
- autoincrement?: boolean | undefined;
3318
3315
  name: string;
3319
3316
  type: string;
3320
3317
  primaryKey: boolean;
3321
3318
  notNull: boolean;
3322
- }, {
3323
3319
  default?: any;
3324
3320
  onUpdate?: any;
3325
3321
  autoincrement?: boolean | undefined;
3322
+ }, {
3326
3323
  name: string;
3327
3324
  type: string;
3328
3325
  primaryKey: boolean;
3329
3326
  notNull: boolean;
3327
+ default?: any;
3328
+ onUpdate?: any;
3329
+ autoincrement?: boolean | undefined;
3330
3330
  }>>;
3331
3331
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3332
3332
  name: import("zod").ZodString;
@@ -3336,19 +3336,19 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
3336
3336
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
3337
3337
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
3338
3338
  }, "strict", import("zod").ZodTypeAny, {
3339
- using?: "btree" | "hash" | undefined;
3340
- algorithm?: "default" | "inplace" | "copy" | undefined;
3341
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3342
3339
  name: string;
3343
3340
  columns: string[];
3344
3341
  isUnique: boolean;
3345
- }, {
3346
3342
  using?: "btree" | "hash" | undefined;
3347
3343
  algorithm?: "default" | "inplace" | "copy" | undefined;
3348
3344
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3345
+ }, {
3349
3346
  name: string;
3350
3347
  columns: string[];
3351
3348
  isUnique: boolean;
3349
+ using?: "btree" | "hash" | undefined;
3350
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3351
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3352
3352
  }>>;
3353
3353
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3354
3354
  name: import("zod").ZodString;
@@ -3359,80 +3359,80 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
3359
3359
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3360
3360
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3361
3361
  }, "strict", import("zod").ZodTypeAny, {
3362
- onUpdate?: string | undefined;
3363
- onDelete?: string | undefined;
3364
3362
  name: string;
3365
3363
  tableFrom: string;
3366
3364
  columnsFrom: string[];
3367
3365
  tableTo: string;
3368
3366
  columnsTo: string[];
3369
- }, {
3370
3367
  onUpdate?: string | undefined;
3371
3368
  onDelete?: string | undefined;
3369
+ }, {
3372
3370
  name: string;
3373
3371
  tableFrom: string;
3374
3372
  columnsFrom: string[];
3375
3373
  tableTo: string;
3376
3374
  columnsTo: string[];
3375
+ onUpdate?: string | undefined;
3376
+ onDelete?: string | undefined;
3377
3377
  }>>;
3378
3378
  }, "strict", import("zod").ZodTypeAny, {
3379
- schema?: string | undefined;
3380
3379
  name: string;
3381
3380
  columns: Record<string, {
3382
- default?: any;
3383
- onUpdate?: any;
3384
- autoincrement?: boolean | undefined;
3385
3381
  name: string;
3386
3382
  type: string;
3387
3383
  primaryKey: boolean;
3388
3384
  notNull: boolean;
3385
+ default?: any;
3386
+ onUpdate?: any;
3387
+ autoincrement?: boolean | undefined;
3389
3388
  }>;
3390
3389
  indexes: Record<string, {
3391
- using?: "btree" | "hash" | undefined;
3392
- algorithm?: "default" | "inplace" | "copy" | undefined;
3393
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3394
3390
  name: string;
3395
3391
  columns: string[];
3396
3392
  isUnique: boolean;
3393
+ using?: "btree" | "hash" | undefined;
3394
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3395
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3397
3396
  }>;
3398
3397
  foreignKeys: Record<string, {
3399
- onUpdate?: string | undefined;
3400
- onDelete?: string | undefined;
3401
3398
  name: string;
3402
3399
  tableFrom: string;
3403
3400
  columnsFrom: string[];
3404
3401
  tableTo: string;
3405
3402
  columnsTo: string[];
3403
+ onUpdate?: string | undefined;
3404
+ onDelete?: string | undefined;
3406
3405
  }>;
3407
- }, {
3408
3406
  schema?: string | undefined;
3407
+ }, {
3409
3408
  name: string;
3410
3409
  columns: Record<string, {
3411
- default?: any;
3412
- onUpdate?: any;
3413
- autoincrement?: boolean | undefined;
3414
3410
  name: string;
3415
3411
  type: string;
3416
3412
  primaryKey: boolean;
3417
3413
  notNull: boolean;
3414
+ default?: any;
3415
+ onUpdate?: any;
3416
+ autoincrement?: boolean | undefined;
3418
3417
  }>;
3419
3418
  indexes: Record<string, {
3420
- using?: "btree" | "hash" | undefined;
3421
- algorithm?: "default" | "inplace" | "copy" | undefined;
3422
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3423
3419
  name: string;
3424
3420
  columns: string[];
3425
3421
  isUnique: boolean;
3422
+ using?: "btree" | "hash" | undefined;
3423
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3424
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3426
3425
  }>;
3427
3426
  foreignKeys: Record<string, {
3428
- onUpdate?: string | undefined;
3429
- onDelete?: string | undefined;
3430
3427
  name: string;
3431
3428
  tableFrom: string;
3432
3429
  columnsFrom: string[];
3433
3430
  tableTo: string;
3434
3431
  columnsTo: string[];
3432
+ onUpdate?: string | undefined;
3433
+ onDelete?: string | undefined;
3435
3434
  }>;
3435
+ schema?: string | undefined;
3436
3436
  }>>;
3437
3437
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3438
3438
  }, {
@@ -3440,34 +3440,34 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
3440
3440
  prevId: import("zod").ZodString;
3441
3441
  }>, "strip", import("zod").ZodTypeAny, {
3442
3442
  tables: Record<string, {
3443
- schema?: string | undefined;
3444
3443
  name: string;
3445
3444
  columns: Record<string, {
3446
- default?: any;
3447
- onUpdate?: any;
3448
- autoincrement?: boolean | undefined;
3449
3445
  name: string;
3450
3446
  type: string;
3451
3447
  primaryKey: boolean;
3452
3448
  notNull: boolean;
3449
+ default?: any;
3450
+ onUpdate?: any;
3451
+ autoincrement?: boolean | undefined;
3453
3452
  }>;
3454
3453
  indexes: Record<string, {
3455
- using?: "btree" | "hash" | undefined;
3456
- algorithm?: "default" | "inplace" | "copy" | undefined;
3457
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3458
3454
  name: string;
3459
3455
  columns: string[];
3460
3456
  isUnique: boolean;
3457
+ using?: "btree" | "hash" | undefined;
3458
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3459
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3461
3460
  }>;
3462
3461
  foreignKeys: Record<string, {
3463
- onUpdate?: string | undefined;
3464
- onDelete?: string | undefined;
3465
3462
  name: string;
3466
3463
  tableFrom: string;
3467
3464
  columnsFrom: string[];
3468
3465
  tableTo: string;
3469
3466
  columnsTo: string[];
3467
+ onUpdate?: string | undefined;
3468
+ onDelete?: string | undefined;
3470
3469
  }>;
3470
+ schema?: string | undefined;
3471
3471
  }>;
3472
3472
  id: string;
3473
3473
  prevId: string;
@@ -3476,34 +3476,34 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
3476
3476
  schemas: Record<string, string>;
3477
3477
  }, {
3478
3478
  tables: Record<string, {
3479
- schema?: string | undefined;
3480
3479
  name: string;
3481
3480
  columns: Record<string, {
3482
- default?: any;
3483
- onUpdate?: any;
3484
- autoincrement?: boolean | undefined;
3485
3481
  name: string;
3486
3482
  type: string;
3487
3483
  primaryKey: boolean;
3488
3484
  notNull: boolean;
3485
+ default?: any;
3486
+ onUpdate?: any;
3487
+ autoincrement?: boolean | undefined;
3489
3488
  }>;
3490
3489
  indexes: Record<string, {
3491
- using?: "btree" | "hash" | undefined;
3492
- algorithm?: "default" | "inplace" | "copy" | undefined;
3493
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3494
3490
  name: string;
3495
3491
  columns: string[];
3496
3492
  isUnique: boolean;
3493
+ using?: "btree" | "hash" | undefined;
3494
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3495
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3497
3496
  }>;
3498
3497
  foreignKeys: Record<string, {
3499
- onUpdate?: string | undefined;
3500
- onDelete?: string | undefined;
3501
3498
  name: string;
3502
3499
  tableFrom: string;
3503
3500
  columnsFrom: string[];
3504
3501
  tableTo: string;
3505
3502
  columnsTo: string[];
3503
+ onUpdate?: string | undefined;
3504
+ onDelete?: string | undefined;
3506
3505
  }>;
3506
+ schema?: string | undefined;
3507
3507
  }>;
3508
3508
  id: string;
3509
3509
  prevId: string;
@@ -3511,7 +3511,7 @@ export declare const mysqlSchemaV4: import("zod").ZodObject<import("zod").extend
3511
3511
  dialect: "mysql";
3512
3512
  schemas: Record<string, string>;
3513
3513
  }>;
3514
- export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extendShape<{
3514
+ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
3515
3515
  version: import("zod").ZodLiteral<"5">;
3516
3516
  dialect: import("zod").ZodLiteral<"mysql">;
3517
3517
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -3525,21 +3525,21 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extend
3525
3525
  default: import("zod").ZodOptional<import("zod").ZodAny>;
3526
3526
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
3527
3527
  }, "strict", import("zod").ZodTypeAny, {
3528
- default?: any;
3529
- onUpdate?: any;
3530
- autoincrement?: boolean | undefined;
3531
3528
  name: string;
3532
3529
  type: string;
3533
3530
  primaryKey: boolean;
3534
3531
  notNull: boolean;
3535
- }, {
3536
3532
  default?: any;
3537
3533
  onUpdate?: any;
3538
3534
  autoincrement?: boolean | undefined;
3535
+ }, {
3539
3536
  name: string;
3540
3537
  type: string;
3541
3538
  primaryKey: boolean;
3542
3539
  notNull: boolean;
3540
+ default?: any;
3541
+ onUpdate?: any;
3542
+ autoincrement?: boolean | undefined;
3543
3543
  }>>;
3544
3544
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3545
3545
  name: import("zod").ZodString;
@@ -3549,19 +3549,19 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extend
3549
3549
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
3550
3550
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
3551
3551
  }, "strict", import("zod").ZodTypeAny, {
3552
- using?: "btree" | "hash" | undefined;
3553
- algorithm?: "default" | "inplace" | "copy" | undefined;
3554
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3555
3552
  name: string;
3556
3553
  columns: string[];
3557
3554
  isUnique: boolean;
3558
- }, {
3559
3555
  using?: "btree" | "hash" | undefined;
3560
3556
  algorithm?: "default" | "inplace" | "copy" | undefined;
3561
3557
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3558
+ }, {
3562
3559
  name: string;
3563
3560
  columns: string[];
3564
3561
  isUnique: boolean;
3562
+ using?: "btree" | "hash" | undefined;
3563
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3564
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3565
3565
  }>>;
3566
3566
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3567
3567
  name: import("zod").ZodString;
@@ -3572,21 +3572,21 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extend
3572
3572
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3573
3573
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3574
3574
  }, "strict", import("zod").ZodTypeAny, {
3575
- onUpdate?: string | undefined;
3576
- onDelete?: string | undefined;
3577
3575
  name: string;
3578
3576
  tableFrom: string;
3579
3577
  columnsFrom: string[];
3580
3578
  tableTo: string;
3581
3579
  columnsTo: string[];
3582
- }, {
3583
3580
  onUpdate?: string | undefined;
3584
3581
  onDelete?: string | undefined;
3582
+ }, {
3585
3583
  name: string;
3586
3584
  tableFrom: string;
3587
3585
  columnsFrom: string[];
3588
3586
  tableTo: string;
3589
3587
  columnsTo: string[];
3588
+ onUpdate?: string | undefined;
3589
+ onDelete?: string | undefined;
3590
3590
  }>>;
3591
3591
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3592
3592
  name: import("zod").ZodString;
@@ -3611,30 +3611,30 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extend
3611
3611
  }, "strict", import("zod").ZodTypeAny, {
3612
3612
  name: string;
3613
3613
  columns: Record<string, {
3614
- default?: any;
3615
- onUpdate?: any;
3616
- autoincrement?: boolean | undefined;
3617
3614
  name: string;
3618
3615
  type: string;
3619
3616
  primaryKey: boolean;
3620
3617
  notNull: boolean;
3618
+ default?: any;
3619
+ onUpdate?: any;
3620
+ autoincrement?: boolean | undefined;
3621
3621
  }>;
3622
3622
  indexes: Record<string, {
3623
- using?: "btree" | "hash" | undefined;
3624
- algorithm?: "default" | "inplace" | "copy" | undefined;
3625
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3626
3623
  name: string;
3627
3624
  columns: string[];
3628
3625
  isUnique: boolean;
3626
+ using?: "btree" | "hash" | undefined;
3627
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3628
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3629
3629
  }>;
3630
3630
  foreignKeys: Record<string, {
3631
- onUpdate?: string | undefined;
3632
- onDelete?: string | undefined;
3633
3631
  name: string;
3634
3632
  tableFrom: string;
3635
3633
  columnsFrom: string[];
3636
3634
  tableTo: string;
3637
3635
  columnsTo: string[];
3636
+ onUpdate?: string | undefined;
3637
+ onDelete?: string | undefined;
3638
3638
  }>;
3639
3639
  compositePrimaryKeys: Record<string, {
3640
3640
  name: string;
@@ -3645,41 +3645,41 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extend
3645
3645
  columns: string[];
3646
3646
  }>;
3647
3647
  }, {
3648
- uniqueConstraints?: Record<string, {
3649
- name: string;
3650
- columns: string[];
3651
- }> | undefined;
3652
3648
  name: string;
3653
3649
  columns: Record<string, {
3654
- default?: any;
3655
- onUpdate?: any;
3656
- autoincrement?: boolean | undefined;
3657
3650
  name: string;
3658
3651
  type: string;
3659
3652
  primaryKey: boolean;
3660
3653
  notNull: boolean;
3654
+ default?: any;
3655
+ onUpdate?: any;
3656
+ autoincrement?: boolean | undefined;
3661
3657
  }>;
3662
3658
  indexes: Record<string, {
3663
- using?: "btree" | "hash" | undefined;
3664
- algorithm?: "default" | "inplace" | "copy" | undefined;
3665
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3666
3659
  name: string;
3667
3660
  columns: string[];
3668
3661
  isUnique: boolean;
3662
+ using?: "btree" | "hash" | undefined;
3663
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3664
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3669
3665
  }>;
3670
3666
  foreignKeys: Record<string, {
3671
- onUpdate?: string | undefined;
3672
- onDelete?: string | undefined;
3673
3667
  name: string;
3674
3668
  tableFrom: string;
3675
3669
  columnsFrom: string[];
3676
3670
  tableTo: string;
3677
3671
  columnsTo: string[];
3672
+ onUpdate?: string | undefined;
3673
+ onDelete?: string | undefined;
3678
3674
  }>;
3679
3675
  compositePrimaryKeys: Record<string, {
3680
3676
  name: string;
3681
3677
  columns: string[];
3682
3678
  }>;
3679
+ uniqueConstraints?: Record<string, {
3680
+ name: string;
3681
+ columns: string[];
3682
+ }> | undefined;
3683
3683
  }>>;
3684
3684
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3685
3685
  _meta: import("zod").ZodObject<{
@@ -3730,40 +3730,33 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extend
3730
3730
  id: import("zod").ZodString;
3731
3731
  prevId: import("zod").ZodString;
3732
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
3733
  tables: Record<string, {
3741
3734
  name: string;
3742
3735
  columns: Record<string, {
3743
- default?: any;
3744
- onUpdate?: any;
3745
- autoincrement?: boolean | undefined;
3746
3736
  name: string;
3747
3737
  type: string;
3748
3738
  primaryKey: boolean;
3749
3739
  notNull: boolean;
3740
+ default?: any;
3741
+ onUpdate?: any;
3742
+ autoincrement?: boolean | undefined;
3750
3743
  }>;
3751
3744
  indexes: Record<string, {
3752
- using?: "btree" | "hash" | undefined;
3753
- algorithm?: "default" | "inplace" | "copy" | undefined;
3754
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3755
3745
  name: string;
3756
3746
  columns: string[];
3757
3747
  isUnique: boolean;
3748
+ using?: "btree" | "hash" | undefined;
3749
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3750
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3758
3751
  }>;
3759
3752
  foreignKeys: Record<string, {
3760
- onUpdate?: string | undefined;
3761
- onDelete?: string | undefined;
3762
3753
  name: string;
3763
3754
  tableFrom: string;
3764
3755
  columnsFrom: string[];
3765
3756
  tableTo: string;
3766
3757
  columnsTo: string[];
3758
+ onUpdate?: string | undefined;
3759
+ onDelete?: string | undefined;
3767
3760
  }>;
3768
3761
  compositePrimaryKeys: Record<string, {
3769
3762
  name: string;
@@ -3784,7 +3777,6 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extend
3784
3777
  tables: Record<string, string>;
3785
3778
  schemas: Record<string, string>;
3786
3779
  };
3787
- }, {
3788
3780
  internal?: {
3789
3781
  tables: Record<string, {
3790
3782
  columns: Record<string, {
@@ -3792,42 +3784,43 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extend
3792
3784
  } | undefined>;
3793
3785
  } | undefined>;
3794
3786
  } | undefined;
3787
+ }, {
3795
3788
  tables: Record<string, {
3796
- uniqueConstraints?: Record<string, {
3797
- name: string;
3798
- columns: string[];
3799
- }> | undefined;
3800
3789
  name: string;
3801
3790
  columns: Record<string, {
3802
- default?: any;
3803
- onUpdate?: any;
3804
- autoincrement?: boolean | undefined;
3805
3791
  name: string;
3806
3792
  type: string;
3807
3793
  primaryKey: boolean;
3808
3794
  notNull: boolean;
3795
+ default?: any;
3796
+ onUpdate?: any;
3797
+ autoincrement?: boolean | undefined;
3809
3798
  }>;
3810
3799
  indexes: Record<string, {
3811
- using?: "btree" | "hash" | undefined;
3812
- algorithm?: "default" | "inplace" | "copy" | undefined;
3813
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3814
3800
  name: string;
3815
3801
  columns: string[];
3816
3802
  isUnique: boolean;
3803
+ using?: "btree" | "hash" | undefined;
3804
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3805
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3817
3806
  }>;
3818
3807
  foreignKeys: Record<string, {
3819
- onUpdate?: string | undefined;
3820
- onDelete?: string | undefined;
3821
3808
  name: string;
3822
3809
  tableFrom: string;
3823
3810
  columnsFrom: string[];
3824
3811
  tableTo: string;
3825
3812
  columnsTo: string[];
3813
+ onUpdate?: string | undefined;
3814
+ onDelete?: string | undefined;
3826
3815
  }>;
3827
3816
  compositePrimaryKeys: Record<string, {
3828
3817
  name: string;
3829
3818
  columns: string[];
3830
3819
  }>;
3820
+ uniqueConstraints?: Record<string, {
3821
+ name: string;
3822
+ columns: string[];
3823
+ }> | undefined;
3831
3824
  }>;
3832
3825
  id: string;
3833
3826
  prevId: string;
@@ -3839,6 +3832,13 @@ export declare const mysqlSchemaV5: import("zod").ZodObject<import("zod").extend
3839
3832
  tables: Record<string, string>;
3840
3833
  schemas: Record<string, string>;
3841
3834
  };
3835
+ internal?: {
3836
+ tables: Record<string, {
3837
+ columns: Record<string, {
3838
+ isDefaultAnExpression?: boolean | undefined;
3839
+ } | undefined>;
3840
+ } | undefined>;
3841
+ } | undefined;
3842
3842
  }>;
3843
3843
  export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
3844
3844
  version: import("zod").ZodLiteral<"5">;
@@ -3854,21 +3854,21 @@ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
3854
3854
  default: import("zod").ZodOptional<import("zod").ZodAny>;
3855
3855
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
3856
3856
  }, "strict", import("zod").ZodTypeAny, {
3857
- default?: any;
3858
- onUpdate?: any;
3859
- autoincrement?: boolean | undefined;
3860
3857
  name: string;
3861
3858
  type: string;
3862
3859
  primaryKey: boolean;
3863
3860
  notNull: boolean;
3864
- }, {
3865
3861
  default?: any;
3866
3862
  onUpdate?: any;
3867
3863
  autoincrement?: boolean | undefined;
3864
+ }, {
3868
3865
  name: string;
3869
3866
  type: string;
3870
3867
  primaryKey: boolean;
3871
3868
  notNull: boolean;
3869
+ default?: any;
3870
+ onUpdate?: any;
3871
+ autoincrement?: boolean | undefined;
3872
3872
  }>>;
3873
3873
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3874
3874
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -3877,45 +3877,45 @@ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
3877
3877
  }, "strict", import("zod").ZodTypeAny, {
3878
3878
  name: string;
3879
3879
  columns: Record<string, {
3880
- default?: any;
3881
- onUpdate?: any;
3882
- autoincrement?: boolean | undefined;
3883
3880
  name: string;
3884
3881
  type: string;
3885
3882
  primaryKey: boolean;
3886
3883
  notNull: boolean;
3884
+ default?: any;
3885
+ onUpdate?: any;
3886
+ autoincrement?: boolean | undefined;
3887
3887
  }>;
3888
3888
  indexes: Record<string, string>;
3889
3889
  foreignKeys: Record<string, string>;
3890
3890
  compositePrimaryKeys: Record<string, string>;
3891
3891
  uniqueConstraints: Record<string, string>;
3892
3892
  }, {
3893
- uniqueConstraints?: Record<string, string> | undefined;
3894
3893
  name: string;
3895
3894
  columns: Record<string, {
3896
- default?: any;
3897
- onUpdate?: any;
3898
- autoincrement?: boolean | undefined;
3899
3895
  name: string;
3900
3896
  type: string;
3901
3897
  primaryKey: boolean;
3902
3898
  notNull: boolean;
3899
+ default?: any;
3900
+ onUpdate?: any;
3901
+ autoincrement?: boolean | undefined;
3903
3902
  }>;
3904
3903
  indexes: Record<string, string>;
3905
3904
  foreignKeys: Record<string, string>;
3906
3905
  compositePrimaryKeys: Record<string, string>;
3906
+ uniqueConstraints?: Record<string, string> | undefined;
3907
3907
  }>>;
3908
3908
  }, "strict", import("zod").ZodTypeAny, {
3909
3909
  tables: Record<string, {
3910
3910
  name: string;
3911
3911
  columns: Record<string, {
3912
- default?: any;
3913
- onUpdate?: any;
3914
- autoincrement?: boolean | undefined;
3915
3912
  name: string;
3916
3913
  type: string;
3917
3914
  primaryKey: boolean;
3918
3915
  notNull: boolean;
3916
+ default?: any;
3917
+ onUpdate?: any;
3918
+ autoincrement?: boolean | undefined;
3919
3919
  }>;
3920
3920
  indexes: Record<string, string>;
3921
3921
  foreignKeys: Record<string, string>;
@@ -3926,25 +3926,25 @@ export declare const mysqlSchemaSquashed: import("zod").ZodObject<{
3926
3926
  dialect: "mysql";
3927
3927
  }, {
3928
3928
  tables: Record<string, {
3929
- uniqueConstraints?: Record<string, string> | undefined;
3930
3929
  name: string;
3931
3930
  columns: Record<string, {
3932
- default?: any;
3933
- onUpdate?: any;
3934
- autoincrement?: boolean | undefined;
3935
3931
  name: string;
3936
3932
  type: string;
3937
3933
  primaryKey: boolean;
3938
3934
  notNull: boolean;
3935
+ default?: any;
3936
+ onUpdate?: any;
3937
+ autoincrement?: boolean | undefined;
3939
3938
  }>;
3940
3939
  indexes: Record<string, string>;
3941
3940
  foreignKeys: Record<string, string>;
3942
3941
  compositePrimaryKeys: Record<string, string>;
3942
+ uniqueConstraints?: Record<string, string> | undefined;
3943
3943
  }>;
3944
3944
  version: "5";
3945
3945
  dialect: "mysql";
3946
3946
  }>;
3947
- export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
3947
+ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
3948
3948
  version: import("zod").ZodLiteral<"5">;
3949
3949
  dialect: import("zod").ZodLiteral<"mysql">;
3950
3950
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -3958,21 +3958,21 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3958
3958
  default: import("zod").ZodOptional<import("zod").ZodAny>;
3959
3959
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
3960
3960
  }, "strict", import("zod").ZodTypeAny, {
3961
- default?: any;
3962
- onUpdate?: any;
3963
- autoincrement?: boolean | undefined;
3964
3961
  name: string;
3965
3962
  type: string;
3966
3963
  primaryKey: boolean;
3967
3964
  notNull: boolean;
3968
- }, {
3969
3965
  default?: any;
3970
3966
  onUpdate?: any;
3971
3967
  autoincrement?: boolean | undefined;
3968
+ }, {
3972
3969
  name: string;
3973
3970
  type: string;
3974
3971
  primaryKey: boolean;
3975
3972
  notNull: boolean;
3973
+ default?: any;
3974
+ onUpdate?: any;
3975
+ autoincrement?: boolean | undefined;
3976
3976
  }>>;
3977
3977
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3978
3978
  name: import("zod").ZodString;
@@ -3982,19 +3982,19 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
3982
3982
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
3983
3983
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
3984
3984
  }, "strict", import("zod").ZodTypeAny, {
3985
- using?: "btree" | "hash" | undefined;
3986
- algorithm?: "default" | "inplace" | "copy" | undefined;
3987
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3988
3985
  name: string;
3989
3986
  columns: string[];
3990
3987
  isUnique: boolean;
3991
- }, {
3992
3988
  using?: "btree" | "hash" | undefined;
3993
3989
  algorithm?: "default" | "inplace" | "copy" | undefined;
3994
3990
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3991
+ }, {
3995
3992
  name: string;
3996
3993
  columns: string[];
3997
3994
  isUnique: boolean;
3995
+ using?: "btree" | "hash" | undefined;
3996
+ algorithm?: "default" | "inplace" | "copy" | undefined;
3997
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
3998
3998
  }>>;
3999
3999
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4000
4000
  name: import("zod").ZodString;
@@ -4005,21 +4005,21 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4005
4005
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
4006
4006
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
4007
4007
  }, "strict", import("zod").ZodTypeAny, {
4008
- onUpdate?: string | undefined;
4009
- onDelete?: string | undefined;
4010
4008
  name: string;
4011
4009
  tableFrom: string;
4012
4010
  columnsFrom: string[];
4013
4011
  tableTo: string;
4014
4012
  columnsTo: string[];
4015
- }, {
4016
4013
  onUpdate?: string | undefined;
4017
4014
  onDelete?: string | undefined;
4015
+ }, {
4018
4016
  name: string;
4019
4017
  tableFrom: string;
4020
4018
  columnsFrom: string[];
4021
4019
  tableTo: string;
4022
4020
  columnsTo: string[];
4021
+ onUpdate?: string | undefined;
4022
+ onDelete?: string | undefined;
4023
4023
  }>>;
4024
4024
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4025
4025
  name: import("zod").ZodString;
@@ -4044,30 +4044,30 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4044
4044
  }, "strict", import("zod").ZodTypeAny, {
4045
4045
  name: string;
4046
4046
  columns: Record<string, {
4047
- default?: any;
4048
- onUpdate?: any;
4049
- autoincrement?: boolean | undefined;
4050
4047
  name: string;
4051
4048
  type: string;
4052
4049
  primaryKey: boolean;
4053
4050
  notNull: boolean;
4051
+ default?: any;
4052
+ onUpdate?: any;
4053
+ autoincrement?: boolean | undefined;
4054
4054
  }>;
4055
4055
  indexes: Record<string, {
4056
- using?: "btree" | "hash" | undefined;
4057
- algorithm?: "default" | "inplace" | "copy" | undefined;
4058
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4059
4056
  name: string;
4060
4057
  columns: string[];
4061
4058
  isUnique: boolean;
4059
+ using?: "btree" | "hash" | undefined;
4060
+ algorithm?: "default" | "inplace" | "copy" | undefined;
4061
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4062
4062
  }>;
4063
4063
  foreignKeys: Record<string, {
4064
- onUpdate?: string | undefined;
4065
- onDelete?: string | undefined;
4066
4064
  name: string;
4067
4065
  tableFrom: string;
4068
4066
  columnsFrom: string[];
4069
4067
  tableTo: string;
4070
4068
  columnsTo: string[];
4069
+ onUpdate?: string | undefined;
4070
+ onDelete?: string | undefined;
4071
4071
  }>;
4072
4072
  compositePrimaryKeys: Record<string, {
4073
4073
  name: string;
@@ -4078,41 +4078,41 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4078
4078
  columns: string[];
4079
4079
  }>;
4080
4080
  }, {
4081
- uniqueConstraints?: Record<string, {
4082
- name: string;
4083
- columns: string[];
4084
- }> | undefined;
4085
4081
  name: string;
4086
4082
  columns: Record<string, {
4087
- default?: any;
4088
- onUpdate?: any;
4089
- autoincrement?: boolean | undefined;
4090
4083
  name: string;
4091
4084
  type: string;
4092
4085
  primaryKey: boolean;
4093
4086
  notNull: boolean;
4087
+ default?: any;
4088
+ onUpdate?: any;
4089
+ autoincrement?: boolean | undefined;
4094
4090
  }>;
4095
4091
  indexes: Record<string, {
4096
- using?: "btree" | "hash" | undefined;
4097
- algorithm?: "default" | "inplace" | "copy" | undefined;
4098
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4099
4092
  name: string;
4100
4093
  columns: string[];
4101
4094
  isUnique: boolean;
4095
+ using?: "btree" | "hash" | undefined;
4096
+ algorithm?: "default" | "inplace" | "copy" | undefined;
4097
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4102
4098
  }>;
4103
4099
  foreignKeys: Record<string, {
4104
- onUpdate?: string | undefined;
4105
- onDelete?: string | undefined;
4106
4100
  name: string;
4107
4101
  tableFrom: string;
4108
4102
  columnsFrom: string[];
4109
4103
  tableTo: string;
4110
4104
  columnsTo: string[];
4105
+ onUpdate?: string | undefined;
4106
+ onDelete?: string | undefined;
4111
4107
  }>;
4112
4108
  compositePrimaryKeys: Record<string, {
4113
4109
  name: string;
4114
4110
  columns: string[];
4115
4111
  }>;
4112
+ uniqueConstraints?: Record<string, {
4113
+ name: string;
4114
+ columns: string[];
4115
+ }> | undefined;
4116
4116
  }>>;
4117
4117
  schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
4118
4118
  _meta: import("zod").ZodObject<{
@@ -4163,40 +4163,33 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4163
4163
  id: import("zod").ZodString;
4164
4164
  prevId: import("zod").ZodString;
4165
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
4166
  tables: Record<string, {
4174
4167
  name: string;
4175
4168
  columns: Record<string, {
4176
- default?: any;
4177
- onUpdate?: any;
4178
- autoincrement?: boolean | undefined;
4179
4169
  name: string;
4180
4170
  type: string;
4181
4171
  primaryKey: boolean;
4182
4172
  notNull: boolean;
4173
+ default?: any;
4174
+ onUpdate?: any;
4175
+ autoincrement?: boolean | undefined;
4183
4176
  }>;
4184
4177
  indexes: Record<string, {
4185
- using?: "btree" | "hash" | undefined;
4186
- algorithm?: "default" | "inplace" | "copy" | undefined;
4187
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4188
4178
  name: string;
4189
4179
  columns: string[];
4190
4180
  isUnique: boolean;
4181
+ using?: "btree" | "hash" | undefined;
4182
+ algorithm?: "default" | "inplace" | "copy" | undefined;
4183
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4191
4184
  }>;
4192
4185
  foreignKeys: Record<string, {
4193
- onUpdate?: string | undefined;
4194
- onDelete?: string | undefined;
4195
4186
  name: string;
4196
4187
  tableFrom: string;
4197
4188
  columnsFrom: string[];
4198
4189
  tableTo: string;
4199
4190
  columnsTo: string[];
4191
+ onUpdate?: string | undefined;
4192
+ onDelete?: string | undefined;
4200
4193
  }>;
4201
4194
  compositePrimaryKeys: Record<string, {
4202
4195
  name: string;
@@ -4217,7 +4210,6 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4217
4210
  tables: Record<string, string>;
4218
4211
  schemas: Record<string, string>;
4219
4212
  };
4220
- }, {
4221
4213
  internal?: {
4222
4214
  tables: Record<string, {
4223
4215
  columns: Record<string, {
@@ -4225,42 +4217,43 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4225
4217
  } | undefined>;
4226
4218
  } | undefined>;
4227
4219
  } | undefined;
4220
+ }, {
4228
4221
  tables: Record<string, {
4229
- uniqueConstraints?: Record<string, {
4230
- name: string;
4231
- columns: string[];
4232
- }> | undefined;
4233
4222
  name: string;
4234
4223
  columns: Record<string, {
4235
- default?: any;
4236
- onUpdate?: any;
4237
- autoincrement?: boolean | undefined;
4238
4224
  name: string;
4239
4225
  type: string;
4240
4226
  primaryKey: boolean;
4241
4227
  notNull: boolean;
4228
+ default?: any;
4229
+ onUpdate?: any;
4230
+ autoincrement?: boolean | undefined;
4242
4231
  }>;
4243
4232
  indexes: Record<string, {
4244
- using?: "btree" | "hash" | undefined;
4245
- algorithm?: "default" | "inplace" | "copy" | undefined;
4246
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4247
4233
  name: string;
4248
4234
  columns: string[];
4249
4235
  isUnique: boolean;
4236
+ using?: "btree" | "hash" | undefined;
4237
+ algorithm?: "default" | "inplace" | "copy" | undefined;
4238
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4250
4239
  }>;
4251
4240
  foreignKeys: Record<string, {
4252
- onUpdate?: string | undefined;
4253
- onDelete?: string | undefined;
4254
4241
  name: string;
4255
4242
  tableFrom: string;
4256
4243
  columnsFrom: string[];
4257
4244
  tableTo: string;
4258
4245
  columnsTo: string[];
4246
+ onUpdate?: string | undefined;
4247
+ onDelete?: string | undefined;
4259
4248
  }>;
4260
4249
  compositePrimaryKeys: Record<string, {
4261
4250
  name: string;
4262
4251
  columns: string[];
4263
4252
  }>;
4253
+ uniqueConstraints?: Record<string, {
4254
+ name: string;
4255
+ columns: string[];
4256
+ }> | undefined;
4264
4257
  }>;
4265
4258
  id: string;
4266
4259
  prevId: string;
@@ -4272,7 +4265,14 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4272
4265
  tables: Record<string, string>;
4273
4266
  schemas: Record<string, string>;
4274
4267
  };
4275
- }>, import("zod").ZodObject<import("zod").extendShape<{
4268
+ internal?: {
4269
+ tables: Record<string, {
4270
+ columns: Record<string, {
4271
+ isDefaultAnExpression?: boolean | undefined;
4272
+ } | undefined>;
4273
+ } | undefined>;
4274
+ } | undefined;
4275
+ }>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
4276
4276
  version: import("zod").ZodLiteral<"5">;
4277
4277
  dialect: import("zod").ZodLiteral<"mysql">;
4278
4278
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -4286,21 +4286,21 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4286
4286
  default: import("zod").ZodOptional<import("zod").ZodAny>;
4287
4287
  onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
4288
4288
  }, "strict", import("zod").ZodTypeAny, {
4289
- default?: any;
4290
- onUpdate?: any;
4291
- autoincrement?: boolean | undefined;
4292
4289
  name: string;
4293
4290
  type: string;
4294
4291
  primaryKey: boolean;
4295
4292
  notNull: boolean;
4296
- }, {
4297
4293
  default?: any;
4298
4294
  onUpdate?: any;
4299
4295
  autoincrement?: boolean | undefined;
4296
+ }, {
4300
4297
  name: string;
4301
4298
  type: string;
4302
4299
  primaryKey: boolean;
4303
4300
  notNull: boolean;
4301
+ default?: any;
4302
+ onUpdate?: any;
4303
+ autoincrement?: boolean | undefined;
4304
4304
  }>>;
4305
4305
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4306
4306
  name: import("zod").ZodString;
@@ -4310,19 +4310,19 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4310
4310
  algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
4311
4311
  lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
4312
4312
  }, "strict", import("zod").ZodTypeAny, {
4313
- using?: "btree" | "hash" | undefined;
4314
- algorithm?: "default" | "inplace" | "copy" | undefined;
4315
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4316
4313
  name: string;
4317
4314
  columns: string[];
4318
4315
  isUnique: boolean;
4319
- }, {
4320
4316
  using?: "btree" | "hash" | undefined;
4321
4317
  algorithm?: "default" | "inplace" | "copy" | undefined;
4322
4318
  lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4319
+ }, {
4323
4320
  name: string;
4324
4321
  columns: string[];
4325
4322
  isUnique: boolean;
4323
+ using?: "btree" | "hash" | undefined;
4324
+ algorithm?: "default" | "inplace" | "copy" | undefined;
4325
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4326
4326
  }>>;
4327
4327
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4328
4328
  name: import("zod").ZodString;
@@ -4333,21 +4333,21 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4333
4333
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
4334
4334
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
4335
4335
  }, "strict", import("zod").ZodTypeAny, {
4336
- onUpdate?: string | undefined;
4337
- onDelete?: string | undefined;
4338
4336
  name: string;
4339
4337
  tableFrom: string;
4340
4338
  columnsFrom: string[];
4341
4339
  tableTo: string;
4342
4340
  columnsTo: string[];
4343
- }, {
4344
4341
  onUpdate?: string | undefined;
4345
4342
  onDelete?: string | undefined;
4343
+ }, {
4346
4344
  name: string;
4347
4345
  tableFrom: string;
4348
4346
  columnsFrom: string[];
4349
4347
  tableTo: string;
4350
4348
  columnsTo: string[];
4349
+ onUpdate?: string | undefined;
4350
+ onDelete?: string | undefined;
4351
4351
  }>>;
4352
4352
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
4353
4353
  name: import("zod").ZodString;
@@ -4372,30 +4372,30 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4372
4372
  }, "strict", import("zod").ZodTypeAny, {
4373
4373
  name: string;
4374
4374
  columns: Record<string, {
4375
- default?: any;
4376
- onUpdate?: any;
4377
- autoincrement?: boolean | undefined;
4378
4375
  name: string;
4379
4376
  type: string;
4380
4377
  primaryKey: boolean;
4381
4378
  notNull: boolean;
4379
+ default?: any;
4380
+ onUpdate?: any;
4381
+ autoincrement?: boolean | undefined;
4382
4382
  }>;
4383
4383
  indexes: Record<string, {
4384
- using?: "btree" | "hash" | undefined;
4385
- algorithm?: "default" | "inplace" | "copy" | undefined;
4386
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4387
4384
  name: string;
4388
4385
  columns: string[];
4389
4386
  isUnique: boolean;
4387
+ using?: "btree" | "hash" | undefined;
4388
+ algorithm?: "default" | "inplace" | "copy" | undefined;
4389
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4390
4390
  }>;
4391
4391
  foreignKeys: Record<string, {
4392
- onUpdate?: string | undefined;
4393
- onDelete?: string | undefined;
4394
4392
  name: string;
4395
4393
  tableFrom: string;
4396
4394
  columnsFrom: string[];
4397
4395
  tableTo: string;
4398
4396
  columnsTo: string[];
4397
+ onUpdate?: string | undefined;
4398
+ onDelete?: string | undefined;
4399
4399
  }>;
4400
4400
  compositePrimaryKeys: Record<string, {
4401
4401
  name: string;
@@ -4406,41 +4406,41 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4406
4406
  columns: string[];
4407
4407
  }>;
4408
4408
  }, {
4409
- uniqueConstraints?: Record<string, {
4410
- name: string;
4411
- columns: string[];
4412
- }> | undefined;
4413
4409
  name: string;
4414
4410
  columns: Record<string, {
4415
- default?: any;
4416
- onUpdate?: any;
4417
- autoincrement?: boolean | undefined;
4418
4411
  name: string;
4419
4412
  type: string;
4420
4413
  primaryKey: boolean;
4421
4414
  notNull: boolean;
4415
+ default?: any;
4416
+ onUpdate?: any;
4417
+ autoincrement?: boolean | undefined;
4422
4418
  }>;
4423
4419
  indexes: Record<string, {
4424
- using?: "btree" | "hash" | undefined;
4425
- algorithm?: "default" | "inplace" | "copy" | undefined;
4426
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4427
4420
  name: string;
4428
4421
  columns: string[];
4429
4422
  isUnique: boolean;
4423
+ using?: "btree" | "hash" | undefined;
4424
+ algorithm?: "default" | "inplace" | "copy" | undefined;
4425
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4430
4426
  }>;
4431
4427
  foreignKeys: Record<string, {
4432
- onUpdate?: string | undefined;
4433
- onDelete?: string | undefined;
4434
4428
  name: string;
4435
4429
  tableFrom: string;
4436
4430
  columnsFrom: string[];
4437
4431
  tableTo: string;
4438
4432
  columnsTo: string[];
4433
+ onUpdate?: string | undefined;
4434
+ onDelete?: string | undefined;
4439
4435
  }>;
4440
4436
  compositePrimaryKeys: Record<string, {
4441
4437
  name: string;
4442
4438
  columns: string[];
4443
4439
  }>;
4440
+ uniqueConstraints?: Record<string, {
4441
+ name: string;
4442
+ columns: string[];
4443
+ }> | undefined;
4444
4444
  }>>;
4445
4445
  _meta: import("zod").ZodObject<{
4446
4446
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -4487,40 +4487,33 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4487
4487
  id: import("zod").ZodString;
4488
4488
  prevId: import("zod").ZodString;
4489
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
4490
  tables: Record<string, {
4498
4491
  name: string;
4499
4492
  columns: Record<string, {
4500
- default?: any;
4501
- onUpdate?: any;
4502
- autoincrement?: boolean | undefined;
4503
4493
  name: string;
4504
4494
  type: string;
4505
4495
  primaryKey: boolean;
4506
4496
  notNull: boolean;
4497
+ default?: any;
4498
+ onUpdate?: any;
4499
+ autoincrement?: boolean | undefined;
4507
4500
  }>;
4508
4501
  indexes: Record<string, {
4509
- using?: "btree" | "hash" | undefined;
4510
- algorithm?: "default" | "inplace" | "copy" | undefined;
4511
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4512
4502
  name: string;
4513
4503
  columns: string[];
4514
4504
  isUnique: boolean;
4505
+ using?: "btree" | "hash" | undefined;
4506
+ algorithm?: "default" | "inplace" | "copy" | undefined;
4507
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4515
4508
  }>;
4516
4509
  foreignKeys: Record<string, {
4517
- onUpdate?: string | undefined;
4518
- onDelete?: string | undefined;
4519
4510
  name: string;
4520
4511
  tableFrom: string;
4521
4512
  columnsFrom: string[];
4522
4513
  tableTo: string;
4523
4514
  columnsTo: string[];
4515
+ onUpdate?: string | undefined;
4516
+ onDelete?: string | undefined;
4524
4517
  }>;
4525
4518
  compositePrimaryKeys: Record<string, {
4526
4519
  name: string;
@@ -4539,7 +4532,6 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4539
4532
  columns: Record<string, string>;
4540
4533
  tables: Record<string, string>;
4541
4534
  };
4542
- }, {
4543
4535
  internal?: {
4544
4536
  tables: Record<string, {
4545
4537
  columns: Record<string, {
@@ -4547,42 +4539,43 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4547
4539
  } | undefined>;
4548
4540
  } | undefined>;
4549
4541
  } | undefined;
4542
+ }, {
4550
4543
  tables: Record<string, {
4551
- uniqueConstraints?: Record<string, {
4552
- name: string;
4553
- columns: string[];
4554
- }> | undefined;
4555
4544
  name: string;
4556
4545
  columns: Record<string, {
4557
- default?: any;
4558
- onUpdate?: any;
4559
- autoincrement?: boolean | undefined;
4560
4546
  name: string;
4561
4547
  type: string;
4562
4548
  primaryKey: boolean;
4563
4549
  notNull: boolean;
4550
+ default?: any;
4551
+ onUpdate?: any;
4552
+ autoincrement?: boolean | undefined;
4564
4553
  }>;
4565
4554
  indexes: Record<string, {
4566
- using?: "btree" | "hash" | undefined;
4567
- algorithm?: "default" | "inplace" | "copy" | undefined;
4568
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4569
4555
  name: string;
4570
4556
  columns: string[];
4571
4557
  isUnique: boolean;
4558
+ using?: "btree" | "hash" | undefined;
4559
+ algorithm?: "default" | "inplace" | "copy" | undefined;
4560
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4572
4561
  }>;
4573
4562
  foreignKeys: Record<string, {
4574
- onUpdate?: string | undefined;
4575
- onDelete?: string | undefined;
4576
4563
  name: string;
4577
4564
  tableFrom: string;
4578
4565
  columnsFrom: string[];
4579
4566
  tableTo: string;
4580
4567
  columnsTo: string[];
4568
+ onUpdate?: string | undefined;
4569
+ onDelete?: string | undefined;
4581
4570
  }>;
4582
4571
  compositePrimaryKeys: Record<string, {
4583
4572
  name: string;
4584
4573
  columns: string[];
4585
4574
  }>;
4575
+ uniqueConstraints?: Record<string, {
4576
+ name: string;
4577
+ columns: string[];
4578
+ }> | undefined;
4586
4579
  }>;
4587
4580
  id: string;
4588
4581
  prevId: string;
@@ -4592,8 +4585,6 @@ export declare const backwardCompatibleMysqlSchema: import("zod").ZodUnion<[impo
4592
4585
  columns: Record<string, string>;
4593
4586
  tables: Record<string, string>;
4594
4587
  };
4595
- }>]>;
4596
- export declare const dryMySql: {
4597
4588
  internal?: {
4598
4589
  tables: Record<string, {
4599
4590
  columns: Record<string, {
@@ -4601,33 +4592,35 @@ export declare const dryMySql: {
4601
4592
  } | undefined>;
4602
4593
  } | undefined>;
4603
4594
  } | undefined;
4595
+ }>]>;
4596
+ export declare const dryMySql: {
4604
4597
  tables: Record<string, {
4605
4598
  name: string;
4606
4599
  columns: Record<string, {
4607
- default?: any;
4608
- onUpdate?: any;
4609
- autoincrement?: boolean | undefined;
4610
4600
  name: string;
4611
4601
  type: string;
4612
4602
  primaryKey: boolean;
4613
4603
  notNull: boolean;
4604
+ default?: any;
4605
+ onUpdate?: any;
4606
+ autoincrement?: boolean | undefined;
4614
4607
  }>;
4615
4608
  indexes: Record<string, {
4616
- using?: "btree" | "hash" | undefined;
4617
- algorithm?: "default" | "inplace" | "copy" | undefined;
4618
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4619
4609
  name: string;
4620
4610
  columns: string[];
4621
4611
  isUnique: boolean;
4612
+ using?: "btree" | "hash" | undefined;
4613
+ algorithm?: "default" | "inplace" | "copy" | undefined;
4614
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
4622
4615
  }>;
4623
4616
  foreignKeys: Record<string, {
4624
- onUpdate?: string | undefined;
4625
- onDelete?: string | undefined;
4626
4617
  name: string;
4627
4618
  tableFrom: string;
4628
4619
  columnsFrom: string[];
4629
4620
  tableTo: string;
4630
4621
  columnsTo: string[];
4622
+ onUpdate?: string | undefined;
4623
+ onDelete?: string | undefined;
4631
4624
  }>;
4632
4625
  compositePrimaryKeys: Record<string, {
4633
4626
  name: string;
@@ -4646,5 +4639,12 @@ export declare const dryMySql: {
4646
4639
  columns: Record<string, string>;
4647
4640
  tables: Record<string, string>;
4648
4641
  };
4642
+ internal?: {
4643
+ tables: Record<string, {
4644
+ columns: Record<string, {
4645
+ isDefaultAnExpression?: boolean | undefined;
4646
+ } | undefined>;
4647
+ } | undefined>;
4648
+ } | undefined;
4649
4649
  };
4650
4650
  export {};