drizzle-kit 0.20.17-9d75ea5 → 0.20.17-a2979a1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (26) hide show
  1. package/bin.cjs +26299 -25536
  2. package/cli/commands/migrate.d.ts +41 -41
  3. package/cli/commands/mysqlIntrospect.d.ts +8 -8
  4. package/cli/commands/pgIntrospect.d.ts +8 -8
  5. package/cli/commands/sqliteIntrospect.d.ts +12 -12
  6. package/cli/commands/utils.d.ts +2 -2
  7. package/cli/validations/cli.d.ts +28 -28
  8. package/cli/validations/common.d.ts +35 -35
  9. package/cli/validations/mysql.d.ts +4 -4
  10. package/cli/validations/outputs.d.ts +2 -1
  11. package/cli/validations/pg.d.ts +4 -4
  12. package/index.d.mts +48 -2
  13. package/index.d.ts +48 -2
  14. package/package.json +1 -1
  15. package/payload.js +1079 -475
  16. package/payload.mjs +886 -282
  17. package/schemaValidator.d.ts +222 -222
  18. package/serializer/mysqlSchema.d.ts +892 -892
  19. package/serializer/pgSchema.d.ts +749 -749
  20. package/serializer/sqliteSchema.d.ts +457 -457
  21. package/serializer/studio.d.ts +1 -1
  22. package/snapshotsDiffer.d.ts +316 -315
  23. package/utils-studio.js +947 -841
  24. package/utils-studio.mjs +920 -814
  25. package/utils.js +844 -219
  26. package/utils.mjs +819 -194
package/serializer/sqliteSchema.d.ts CHANGED
@@ -5,15 +5,15 @@ declare const index: import("zod").ZodObject<{
5
5
  where: import("zod").ZodOptional<import("zod").ZodString>;
6
6
  isUnique: import("zod").ZodBoolean;
7
7
  }, "strict", import("zod").ZodTypeAny, {
8
- where?: string | undefined;
9
8
  name: string;
10
9
  columns: string[];
11
10
  isUnique: boolean;
12
- }, {
13
11
  where?: string | undefined;
12
+ }, {
14
13
  name: string;
15
14
  columns: string[];
16
15
  isUnique: boolean;
16
+ where?: string | undefined;
17
17
  }>;
18
18
  declare const fk: import("zod").ZodObject<{
19
19
  name: import("zod").ZodString;
@@ -24,31 +24,31 @@ declare const fk: import("zod").ZodObject<{
24
24
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
25
25
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
26
26
  }, "strict", import("zod").ZodTypeAny, {
27
- onUpdate?: string | undefined;
28
- onDelete?: string | undefined;
29
27
  name: string;
30
28
  tableFrom: string;
31
29
  columnsFrom: string[];
32
30
  tableTo: string;
33
31
  columnsTo: string[];
34
- }, {
35
32
  onUpdate?: string | undefined;
36
33
  onDelete?: string | undefined;
34
+ }, {
37
35
  name: string;
38
36
  tableFrom: string;
39
37
  columnsFrom: string[];
40
38
  tableTo: string;
41
39
  columnsTo: string[];
40
+ onUpdate?: string | undefined;
41
+ onDelete?: string | undefined;
42
42
  }>;
43
43
  declare const compositePK: import("zod").ZodObject<{
44
44
  columns: import("zod").ZodArray<import("zod").ZodString, "many">;
45
45
  name: import("zod").ZodOptional<import("zod").ZodString>;
46
46
  }, "strict", import("zod").ZodTypeAny, {
47
- name?: string | undefined;
48
47
  columns: string[];
49
- }, {
50
48
  name?: string | undefined;
49
+ }, {
51
50
  columns: string[];
51
+ name?: string | undefined;
52
52
  }>;
53
53
  declare const column: import("zod").ZodObject<{
54
54
  name: import("zod").ZodString;
@@ -58,19 +58,19 @@ declare const column: import("zod").ZodObject<{
58
58
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
59
59
  default: import("zod").ZodOptional<import("zod").ZodAny>;
60
60
  }, "strict", import("zod").ZodTypeAny, {
61
- default?: any;
62
- autoincrement?: boolean | undefined;
63
61
  name: string;
64
62
  type: string;
65
63
  primaryKey: boolean;
66
64
  notNull: boolean;
67
- }, {
68
65
  default?: any;
69
66
  autoincrement?: boolean | undefined;
67
+ }, {
70
68
  name: string;
71
69
  type: string;
72
70
  primaryKey: boolean;
73
71
  notNull: boolean;
72
+ default?: any;
73
+ autoincrement?: boolean | undefined;
74
74
  }>;
75
75
  declare const uniqueConstraint: import("zod").ZodObject<{
76
76
  name: import("zod").ZodString;
@@ -92,19 +92,19 @@ declare const table: import("zod").ZodObject<{
92
92
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
93
93
  default: import("zod").ZodOptional<import("zod").ZodAny>;
94
94
  }, "strict", import("zod").ZodTypeAny, {
95
- default?: any;
96
- autoincrement?: boolean | undefined;
97
95
  name: string;
98
96
  type: string;
99
97
  primaryKey: boolean;
100
98
  notNull: boolean;
101
- }, {
102
99
  default?: any;
103
100
  autoincrement?: boolean | undefined;
101
+ }, {
104
102
  name: string;
105
103
  type: string;
106
104
  primaryKey: boolean;
107
105
  notNull: boolean;
106
+ default?: any;
107
+ autoincrement?: boolean | undefined;
108
108
  }>>;
109
109
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
110
110
  name: import("zod").ZodString;
@@ -112,15 +112,15 @@ declare const table: import("zod").ZodObject<{
112
112
  where: import("zod").ZodOptional<import("zod").ZodString>;
113
113
  isUnique: import("zod").ZodBoolean;
114
114
  }, "strict", import("zod").ZodTypeAny, {
115
- where?: string | undefined;
116
115
  name: string;
117
116
  columns: string[];
118
117
  isUnique: boolean;
119
- }, {
120
118
  where?: string | undefined;
119
+ }, {
121
120
  name: string;
122
121
  columns: string[];
123
122
  isUnique: boolean;
123
+ where?: string | undefined;
124
124
  }>>;
125
125
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
126
126
  name: import("zod").ZodString;
@@ -131,31 +131,31 @@ declare const table: import("zod").ZodObject<{
131
131
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
132
132
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
133
133
  }, "strict", import("zod").ZodTypeAny, {
134
- onUpdate?: string | undefined;
135
- onDelete?: string | undefined;
136
134
  name: string;
137
135
  tableFrom: string;
138
136
  columnsFrom: string[];
139
137
  tableTo: string;
140
138
  columnsTo: string[];
141
- }, {
142
139
  onUpdate?: string | undefined;
143
140
  onDelete?: string | undefined;
141
+ }, {
144
142
  name: string;
145
143
  tableFrom: string;
146
144
  columnsFrom: string[];
147
145
  tableTo: string;
148
146
  columnsTo: string[];
147
+ onUpdate?: string | undefined;
148
+ onDelete?: string | undefined;
149
149
  }>>;
150
150
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
151
151
  columns: import("zod").ZodArray<import("zod").ZodString, "many">;
152
152
  name: import("zod").ZodOptional<import("zod").ZodString>;
153
153
  }, "strict", import("zod").ZodTypeAny, {
154
- name?: string | undefined;
155
154
  columns: string[];
156
- }, {
157
155
  name?: string | undefined;
156
+ }, {
158
157
  columns: string[];
158
+ name?: string | undefined;
159
159
  }>>;
160
160
  uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
161
161
  name: import("zod").ZodString;
@@ -170,69 +170,69 @@ declare const table: import("zod").ZodObject<{
170
170
  }, "strict", import("zod").ZodTypeAny, {
171
171
  name: string;
172
172
  columns: Record<string, {
173
- default?: any;
174
- autoincrement?: boolean | undefined;
175
173
  name: string;
176
174
  type: string;
177
175
  primaryKey: boolean;
178
176
  notNull: boolean;
177
+ default?: any;
178
+ autoincrement?: boolean | undefined;
179
179
  }>;
180
180
  indexes: Record<string, {
181
- where?: string | undefined;
182
181
  name: string;
183
182
  columns: string[];
184
183
  isUnique: boolean;
184
+ where?: string | undefined;
185
185
  }>;
186
186
  foreignKeys: Record<string, {
187
- onUpdate?: string | undefined;
188
- onDelete?: string | undefined;
189
187
  name: string;
190
188
  tableFrom: string;
191
189
  columnsFrom: string[];
192
190
  tableTo: string;
193
191
  columnsTo: string[];
192
+ onUpdate?: string | undefined;
193
+ onDelete?: string | undefined;
194
194
  }>;
195
195
  compositePrimaryKeys: Record<string, {
196
- name?: string | undefined;
197
196
  columns: string[];
197
+ name?: string | undefined;
198
198
  }>;
199
199
  uniqueConstraints: Record<string, {
200
200
  name: string;
201
201
  columns: string[];
202
202
  }>;
203
203
  }, {
204
- uniqueConstraints?: Record<string, {
205
- name: string;
206
- columns: string[];
207
- }> | undefined;
208
204
  name: string;
209
205
  columns: Record<string, {
210
- default?: any;
211
- autoincrement?: boolean | undefined;
212
206
  name: string;
213
207
  type: string;
214
208
  primaryKey: boolean;
215
209
  notNull: boolean;
210
+ default?: any;
211
+ autoincrement?: boolean | undefined;
216
212
  }>;
217
213
  indexes: Record<string, {
218
- where?: string | undefined;
219
214
  name: string;
220
215
  columns: string[];
221
216
  isUnique: boolean;
217
+ where?: string | undefined;
222
218
  }>;
223
219
  foreignKeys: Record<string, {
224
- onUpdate?: string | undefined;
225
- onDelete?: string | undefined;
226
220
  name: string;
227
221
  tableFrom: string;
228
222
  columnsFrom: string[];
229
223
  tableTo: string;
230
224
  columnsTo: string[];
225
+ onUpdate?: string | undefined;
226
+ onDelete?: string | undefined;
231
227
  }>;
232
228
  compositePrimaryKeys: Record<string, {
233
- name?: string | undefined;
234
229
  columns: string[];
230
+ name?: string | undefined;
235
231
  }>;
232
+ uniqueConstraints?: Record<string, {
233
+ name: string;
234
+ columns: string[];
235
+ }> | undefined;
236
236
  }>;
237
237
  declare const dialect: import("zod").ZodEnum<["sqlite"]>;
238
238
  export declare const schemaInternalV3: import("zod").ZodObject<{
@@ -248,19 +248,19 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
248
248
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
249
249
  default: import("zod").ZodOptional<import("zod").ZodAny>;
250
250
  }, "strict", import("zod").ZodTypeAny, {
251
- default?: any;
252
- autoincrement?: boolean | undefined;
253
251
  name: string;
254
252
  type: string;
255
253
  primaryKey: boolean;
256
254
  notNull: boolean;
257
- }, {
258
255
  default?: any;
259
256
  autoincrement?: boolean | undefined;
257
+ }, {
260
258
  name: string;
261
259
  type: string;
262
260
  primaryKey: boolean;
263
261
  notNull: boolean;
262
+ default?: any;
263
+ autoincrement?: boolean | undefined;
264
264
  }>>;
265
265
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
266
266
  name: import("zod").ZodString;
@@ -268,15 +268,15 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
268
268
  where: import("zod").ZodOptional<import("zod").ZodString>;
269
269
  isUnique: import("zod").ZodBoolean;
270
270
  }, "strict", import("zod").ZodTypeAny, {
271
- where?: string | undefined;
272
271
  name: string;
273
272
  columns: string[];
274
273
  isUnique: boolean;
275
- }, {
276
274
  where?: string | undefined;
275
+ }, {
277
276
  name: string;
278
277
  columns: string[];
279
278
  isUnique: boolean;
279
+ where?: string | undefined;
280
280
  }>>;
281
281
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
282
282
  name: import("zod").ZodString;
@@ -287,71 +287,71 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
287
287
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
288
288
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
289
289
  }, "strict", import("zod").ZodTypeAny, {
290
- onUpdate?: string | undefined;
291
- onDelete?: string | undefined;
292
290
  name: string;
293
291
  tableFrom: string;
294
292
  columnsFrom: string[];
295
293
  tableTo: string;
296
294
  columnsTo: string[];
297
- }, {
298
295
  onUpdate?: string | undefined;
299
296
  onDelete?: string | undefined;
297
+ }, {
300
298
  name: string;
301
299
  tableFrom: string;
302
300
  columnsFrom: string[];
303
301
  tableTo: string;
304
302
  columnsTo: string[];
303
+ onUpdate?: string | undefined;
304
+ onDelete?: string | undefined;
305
305
  }>>;
306
306
  }, "strict", import("zod").ZodTypeAny, {
307
307
  name: string;
308
308
  columns: Record<string, {
309
- default?: any;
310
- autoincrement?: boolean | undefined;
311
309
  name: string;
312
310
  type: string;
313
311
  primaryKey: boolean;
314
312
  notNull: boolean;
313
+ default?: any;
314
+ autoincrement?: boolean | undefined;
315
315
  }>;
316
316
  indexes: Record<string, {
317
- where?: string | undefined;
318
317
  name: string;
319
318
  columns: string[];
320
319
  isUnique: boolean;
320
+ where?: string | undefined;
321
321
  }>;
322
322
  foreignKeys: Record<string, {
323
- onUpdate?: string | undefined;
324
- onDelete?: string | undefined;
325
323
  name: string;
326
324
  tableFrom: string;
327
325
  columnsFrom: string[];
328
326
  tableTo: string;
329
327
  columnsTo: string[];
328
+ onUpdate?: string | undefined;
329
+ onDelete?: string | undefined;
330
330
  }>;
331
331
  }, {
332
332
  name: string;
333
333
  columns: Record<string, {
334
- default?: any;
335
- autoincrement?: boolean | undefined;
336
334
  name: string;
337
335
  type: string;
338
336
  primaryKey: boolean;
339
337
  notNull: boolean;
338
+ default?: any;
339
+ autoincrement?: boolean | undefined;
340
340
  }>;
341
341
  indexes: Record<string, {
342
- where?: string | undefined;
343
342
  name: string;
344
343
  columns: string[];
345
344
  isUnique: boolean;
345
+ where?: string | undefined;
346
346
  }>;
347
347
  foreignKeys: Record<string, {
348
- onUpdate?: string | undefined;
349
- onDelete?: string | undefined;
350
348
  name: string;
351
349
  tableFrom: string;
352
350
  columnsFrom: string[];
353
351
  tableTo: string;
354
352
  columnsTo: string[];
353
+ onUpdate?: string | undefined;
354
+ onDelete?: string | undefined;
355
355
  }>;
356
356
  }>>;
357
357
  enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
@@ -359,27 +359,27 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
359
359
  tables: Record<string, {
360
360
  name: string;
361
361
  columns: Record<string, {
362
- default?: any;
363
- autoincrement?: boolean | undefined;
364
362
  name: string;
365
363
  type: string;
366
364
  primaryKey: boolean;
367
365
  notNull: boolean;
366
+ default?: any;
367
+ autoincrement?: boolean | undefined;
368
368
  }>;
369
369
  indexes: Record<string, {
370
- where?: string | undefined;
371
370
  name: string;
372
371
  columns: string[];
373
372
  isUnique: boolean;
373
+ where?: string | undefined;
374
374
  }>;
375
375
  foreignKeys: Record<string, {
376
- onUpdate?: string | undefined;
377
- onDelete?: string | undefined;
378
376
  name: string;
379
377
  tableFrom: string;
380
378
  columnsFrom: string[];
381
379
  tableTo: string;
382
380
  columnsTo: string[];
381
+ onUpdate?: string | undefined;
382
+ onDelete?: string | undefined;
383
383
  }>;
384
384
  }>;
385
385
  version: "3";
@@ -389,27 +389,27 @@ export declare const schemaInternalV3: import("zod").ZodObject<{
389
389
  tables: Record<string, {
390
390
  name: string;
391
391
  columns: Record<string, {
392
- default?: any;
393
- autoincrement?: boolean | undefined;
394
392
  name: string;
395
393
  type: string;
396
394
  primaryKey: boolean;
397
395
  notNull: boolean;
396
+ default?: any;
397
+ autoincrement?: boolean | undefined;
398
398
  }>;
399
399
  indexes: Record<string, {
400
- where?: string | undefined;
401
400
  name: string;
402
401
  columns: string[];
403
402
  isUnique: boolean;
403
+ where?: string | undefined;
404
404
  }>;
405
405
  foreignKeys: Record<string, {
406
- onUpdate?: string | undefined;
407
- onDelete?: string | undefined;
408
406
  name: string;
409
407
  tableFrom: string;
410
408
  columnsFrom: string[];
411
409
  tableTo: string;
412
410
  columnsTo: string[];
411
+ onUpdate?: string | undefined;
412
+ onDelete?: string | undefined;
413
413
  }>;
414
414
  }>;
415
415
  version: "3";
@@ -429,19 +429,19 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
429
429
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
430
430
  default: import("zod").ZodOptional<import("zod").ZodAny>;
431
431
  }, "strict", import("zod").ZodTypeAny, {
432
- default?: any;
433
- autoincrement?: boolean | undefined;
434
432
  name: string;
435
433
  type: string;
436
434
  primaryKey: boolean;
437
435
  notNull: boolean;
438
- }, {
439
436
  default?: any;
440
437
  autoincrement?: boolean | undefined;
438
+ }, {
441
439
  name: string;
442
440
  type: string;
443
441
  primaryKey: boolean;
444
442
  notNull: boolean;
443
+ default?: any;
444
+ autoincrement?: boolean | undefined;
445
445
  }>>;
446
446
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
447
447
  name: import("zod").ZodString;
@@ -449,15 +449,15 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
449
449
  where: import("zod").ZodOptional<import("zod").ZodString>;
450
450
  isUnique: import("zod").ZodBoolean;
451
451
  }, "strict", import("zod").ZodTypeAny, {
452
- where?: string | undefined;
453
452
  name: string;
454
453
  columns: string[];
455
454
  isUnique: boolean;
456
- }, {
457
455
  where?: string | undefined;
456
+ }, {
458
457
  name: string;
459
458
  columns: string[];
460
459
  isUnique: boolean;
460
+ where?: string | undefined;
461
461
  }>>;
462
462
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
463
463
  name: import("zod").ZodString;
@@ -468,31 +468,31 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
468
468
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
469
469
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
470
470
  }, "strict", import("zod").ZodTypeAny, {
471
- onUpdate?: string | undefined;
472
- onDelete?: string | undefined;
473
471
  name: string;
474
472
  tableFrom: string;
475
473
  columnsFrom: string[];
476
474
  tableTo: string;
477
475
  columnsTo: string[];
478
- }, {
479
476
  onUpdate?: string | undefined;
480
477
  onDelete?: string | undefined;
478
+ }, {
481
479
  name: string;
482
480
  tableFrom: string;
483
481
  columnsFrom: string[];
484
482
  tableTo: string;
485
483
  columnsTo: string[];
484
+ onUpdate?: string | undefined;
485
+ onDelete?: string | undefined;
486
486
  }>>;
487
487
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
488
488
  columns: import("zod").ZodArray<import("zod").ZodString, "many">;
489
489
  name: import("zod").ZodOptional<import("zod").ZodString>;
490
490
  }, "strict", import("zod").ZodTypeAny, {
491
- name?: string | undefined;
492
491
  columns: string[];
493
- }, {
494
492
  name?: string | undefined;
493
+ }, {
495
494
  columns: string[];
495
+ name?: string | undefined;
496
496
  }>>;
497
497
  uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
498
498
  name: import("zod").ZodString;
@@ -507,100 +507,100 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
507
507
  }, "strict", import("zod").ZodTypeAny, {
508
508
  name: string;
509
509
  columns: Record<string, {
510
- default?: any;
511
- autoincrement?: boolean | undefined;
512
510
  name: string;
513
511
  type: string;
514
512
  primaryKey: boolean;
515
513
  notNull: boolean;
514
+ default?: any;
515
+ autoincrement?: boolean | undefined;
516
516
  }>;
517
517
  indexes: Record<string, {
518
- where?: string | undefined;
519
518
  name: string;
520
519
  columns: string[];
521
520
  isUnique: boolean;
521
+ where?: string | 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
  compositePrimaryKeys: Record<string, {
533
- name?: string | undefined;
534
533
  columns: string[];
534
+ name?: string | undefined;
535
535
  }>;
536
536
  uniqueConstraints: Record<string, {
537
537
  name: string;
538
538
  columns: string[];
539
539
  }>;
540
540
  }, {
541
- uniqueConstraints?: Record<string, {
542
- name: string;
543
- columns: string[];
544
- }> | undefined;
545
541
  name: string;
546
542
  columns: Record<string, {
547
- default?: any;
548
- autoincrement?: boolean | undefined;
549
543
  name: string;
550
544
  type: string;
551
545
  primaryKey: boolean;
552
546
  notNull: boolean;
547
+ default?: any;
548
+ autoincrement?: boolean | undefined;
553
549
  }>;
554
550
  indexes: Record<string, {
555
- where?: string | undefined;
556
551
  name: string;
557
552
  columns: string[];
558
553
  isUnique: boolean;
554
+ where?: string | undefined;
559
555
  }>;
560
556
  foreignKeys: Record<string, {
561
- onUpdate?: string | undefined;
562
- onDelete?: string | undefined;
563
557
  name: string;
564
558
  tableFrom: string;
565
559
  columnsFrom: string[];
566
560
  tableTo: string;
567
561
  columnsTo: string[];
562
+ onUpdate?: string | undefined;
563
+ onDelete?: string | undefined;
568
564
  }>;
569
565
  compositePrimaryKeys: Record<string, {
570
- name?: string | undefined;
571
566
  columns: string[];
567
+ name?: string | undefined;
572
568
  }>;
569
+ uniqueConstraints?: Record<string, {
570
+ name: string;
571
+ columns: string[];
572
+ }> | undefined;
573
573
  }>>;
574
574
  enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
575
575
  }, "strict", import("zod").ZodTypeAny, {
576
576
  tables: Record<string, {
577
577
  name: string;
578
578
  columns: Record<string, {
579
- default?: any;
580
- autoincrement?: boolean | undefined;
581
579
  name: string;
582
580
  type: string;
583
581
  primaryKey: boolean;
584
582
  notNull: boolean;
583
+ default?: any;
584
+ autoincrement?: boolean | undefined;
585
585
  }>;
586
586
  indexes: Record<string, {
587
- where?: string | undefined;
588
587
  name: string;
589
588
  columns: string[];
590
589
  isUnique: boolean;
590
+ where?: string | undefined;
591
591
  }>;
592
592
  foreignKeys: Record<string, {
593
- onUpdate?: string | undefined;
594
- onDelete?: string | undefined;
595
593
  name: string;
596
594
  tableFrom: string;
597
595
  columnsFrom: string[];
598
596
  tableTo: string;
599
597
  columnsTo: string[];
598
+ onUpdate?: string | undefined;
599
+ onDelete?: string | undefined;
600
600
  }>;
601
601
  compositePrimaryKeys: Record<string, {
602
- name?: string | undefined;
603
602
  columns: string[];
603
+ name?: string | undefined;
604
604
  }>;
605
605
  uniqueConstraints: Record<string, {
606
606
  name: string;
@@ -612,38 +612,38 @@ export declare const schemaInternalV4: import("zod").ZodObject<{
612
612
  enums: {};
613
613
  }, {
614
614
  tables: Record<string, {
615
- uniqueConstraints?: Record<string, {
616
- name: string;
617
- columns: string[];
618
- }> | undefined;
619
615
  name: string;
620
616
  columns: Record<string, {
621
- default?: any;
622
- autoincrement?: boolean | undefined;
623
617
  name: string;
624
618
  type: string;
625
619
  primaryKey: boolean;
626
620
  notNull: boolean;
621
+ default?: any;
622
+ autoincrement?: boolean | undefined;
627
623
  }>;
628
624
  indexes: Record<string, {
629
- where?: string | undefined;
630
625
  name: string;
631
626
  columns: string[];
632
627
  isUnique: boolean;
628
+ where?: string | undefined;
633
629
  }>;
634
630
  foreignKeys: Record<string, {
635
- onUpdate?: string | undefined;
636
- onDelete?: string | undefined;
637
631
  name: string;
638
632
  tableFrom: string;
639
633
  columnsFrom: string[];
640
634
  tableTo: string;
641
635
  columnsTo: string[];
636
+ onUpdate?: string | undefined;
637
+ onDelete?: string | undefined;
642
638
  }>;
643
639
  compositePrimaryKeys: Record<string, {
644
- name?: string | undefined;
645
640
  columns: string[];
641
+ name?: string | undefined;
646
642
  }>;
643
+ uniqueConstraints?: Record<string, {
644
+ name: string;
645
+ columns: string[];
646
+ }> | undefined;
647
647
  }>;
648
648
  version: "4";
649
649
  dialect: "sqlite";
@@ -662,19 +662,19 @@ export declare const schemaInternal: import("zod").ZodObject<{
662
662
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
663
663
  default: import("zod").ZodOptional<import("zod").ZodAny>;
664
664
  }, "strict", import("zod").ZodTypeAny, {
665
- default?: any;
666
- autoincrement?: boolean | undefined;
667
665
  name: string;
668
666
  type: string;
669
667
  primaryKey: boolean;
670
668
  notNull: boolean;
671
- }, {
672
669
  default?: any;
673
670
  autoincrement?: boolean | undefined;
671
+ }, {
674
672
  name: string;
675
673
  type: string;
676
674
  primaryKey: boolean;
677
675
  notNull: boolean;
676
+ default?: any;
677
+ autoincrement?: boolean | undefined;
678
678
  }>>;
679
679
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
680
680
  name: import("zod").ZodString;
@@ -682,15 +682,15 @@ export declare const schemaInternal: import("zod").ZodObject<{
682
682
  where: import("zod").ZodOptional<import("zod").ZodString>;
683
683
  isUnique: import("zod").ZodBoolean;
684
684
  }, "strict", import("zod").ZodTypeAny, {
685
- where?: string | undefined;
686
685
  name: string;
687
686
  columns: string[];
688
687
  isUnique: boolean;
689
- }, {
690
688
  where?: string | undefined;
689
+ }, {
691
690
  name: string;
692
691
  columns: string[];
693
692
  isUnique: boolean;
693
+ where?: string | undefined;
694
694
  }>>;
695
695
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
696
696
  name: import("zod").ZodString;
@@ -701,31 +701,31 @@ export declare const schemaInternal: import("zod").ZodObject<{
701
701
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
702
702
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
703
703
  }, "strict", import("zod").ZodTypeAny, {
704
- onUpdate?: string | undefined;
705
- onDelete?: string | undefined;
706
704
  name: string;
707
705
  tableFrom: string;
708
706
  columnsFrom: string[];
709
707
  tableTo: string;
710
708
  columnsTo: string[];
711
- }, {
712
709
  onUpdate?: string | undefined;
713
710
  onDelete?: string | undefined;
711
+ }, {
714
712
  name: string;
715
713
  tableFrom: string;
716
714
  columnsFrom: string[];
717
715
  tableTo: string;
718
716
  columnsTo: string[];
717
+ onUpdate?: string | undefined;
718
+ onDelete?: string | undefined;
719
719
  }>>;
720
720
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
721
721
  columns: import("zod").ZodArray<import("zod").ZodString, "many">;
722
722
  name: import("zod").ZodOptional<import("zod").ZodString>;
723
723
  }, "strict", import("zod").ZodTypeAny, {
724
- name?: string | undefined;
725
724
  columns: string[];
726
- }, {
727
725
  name?: string | undefined;
726
+ }, {
728
727
  columns: string[];
728
+ name?: string | undefined;
729
729
  }>>;
730
730
  uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
731
731
  name: import("zod").ZodString;
@@ -740,69 +740,69 @@ export declare const schemaInternal: import("zod").ZodObject<{
740
740
  }, "strict", import("zod").ZodTypeAny, {
741
741
  name: string;
742
742
  columns: Record<string, {
743
- default?: any;
744
- autoincrement?: boolean | undefined;
745
743
  name: string;
746
744
  type: string;
747
745
  primaryKey: boolean;
748
746
  notNull: boolean;
747
+ default?: any;
748
+ autoincrement?: boolean | undefined;
749
749
  }>;
750
750
  indexes: Record<string, {
751
- where?: string | undefined;
752
751
  name: string;
753
752
  columns: string[];
754
753
  isUnique: boolean;
754
+ where?: string | undefined;
755
755
  }>;
756
756
  foreignKeys: Record<string, {
757
- onUpdate?: string | undefined;
758
- onDelete?: string | undefined;
759
757
  name: string;
760
758
  tableFrom: string;
761
759
  columnsFrom: string[];
762
760
  tableTo: string;
763
761
  columnsTo: string[];
762
+ onUpdate?: string | undefined;
763
+ onDelete?: string | undefined;
764
764
  }>;
765
765
  compositePrimaryKeys: Record<string, {
766
- name?: string | undefined;
767
766
  columns: string[];
767
+ name?: string | undefined;
768
768
  }>;
769
769
  uniqueConstraints: Record<string, {
770
770
  name: string;
771
771
  columns: string[];
772
772
  }>;
773
773
  }, {
774
- uniqueConstraints?: Record<string, {
775
- name: string;
776
- columns: string[];
777
- }> | undefined;
778
774
  name: string;
779
775
  columns: Record<string, {
780
- default?: any;
781
- autoincrement?: boolean | undefined;
782
776
  name: string;
783
777
  type: string;
784
778
  primaryKey: boolean;
785
779
  notNull: boolean;
780
+ default?: any;
781
+ autoincrement?: boolean | undefined;
786
782
  }>;
787
783
  indexes: Record<string, {
788
- where?: string | undefined;
789
784
  name: string;
790
785
  columns: string[];
791
786
  isUnique: boolean;
787
+ where?: string | undefined;
792
788
  }>;
793
789
  foreignKeys: Record<string, {
794
- onUpdate?: string | undefined;
795
- onDelete?: string | undefined;
796
790
  name: string;
797
791
  tableFrom: string;
798
792
  columnsFrom: string[];
799
793
  tableTo: string;
800
794
  columnsTo: string[];
795
+ onUpdate?: string | undefined;
796
+ onDelete?: string | undefined;
801
797
  }>;
802
798
  compositePrimaryKeys: Record<string, {
803
- name?: string | undefined;
804
799
  columns: string[];
800
+ name?: string | undefined;
805
801
  }>;
802
+ uniqueConstraints?: Record<string, {
803
+ name: string;
804
+ columns: string[];
805
+ }> | undefined;
806
806
  }>>;
807
807
  enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
808
808
  _meta: import("zod").ZodObject<{
@@ -819,31 +819,31 @@ export declare const schemaInternal: import("zod").ZodObject<{
819
819
  tables: Record<string, {
820
820
  name: string;
821
821
  columns: Record<string, {
822
- default?: any;
823
- autoincrement?: boolean | undefined;
824
822
  name: string;
825
823
  type: string;
826
824
  primaryKey: boolean;
827
825
  notNull: boolean;
826
+ default?: any;
827
+ autoincrement?: boolean | undefined;
828
828
  }>;
829
829
  indexes: Record<string, {
830
- where?: string | undefined;
831
830
  name: string;
832
831
  columns: string[];
833
832
  isUnique: boolean;
833
+ where?: string | undefined;
834
834
  }>;
835
835
  foreignKeys: Record<string, {
836
- onUpdate?: string | undefined;
837
- onDelete?: string | undefined;
838
836
  name: string;
839
837
  tableFrom: string;
840
838
  columnsFrom: string[];
841
839
  tableTo: string;
842
840
  columnsTo: string[];
841
+ onUpdate?: string | undefined;
842
+ onDelete?: string | undefined;
843
843
  }>;
844
844
  compositePrimaryKeys: Record<string, {
845
- name?: string | undefined;
846
845
  columns: string[];
846
+ name?: string | undefined;
847
847
  }>;
848
848
  uniqueConstraints: Record<string, {
849
849
  name: string;
@@ -859,38 +859,38 @@ export declare const schemaInternal: import("zod").ZodObject<{
859
859
  enums: {};
860
860
  }, {
861
861
  tables: Record<string, {
862
- uniqueConstraints?: Record<string, {
863
- name: string;
864
- columns: string[];
865
- }> | undefined;
866
862
  name: string;
867
863
  columns: Record<string, {
868
- default?: any;
869
- autoincrement?: boolean | undefined;
870
864
  name: string;
871
865
  type: string;
872
866
  primaryKey: boolean;
873
867
  notNull: boolean;
868
+ default?: any;
869
+ autoincrement?: boolean | undefined;
874
870
  }>;
875
871
  indexes: Record<string, {
876
- where?: string | undefined;
877
872
  name: string;
878
873
  columns: string[];
879
874
  isUnique: boolean;
875
+ where?: string | undefined;
880
876
  }>;
881
877
  foreignKeys: Record<string, {
882
- onUpdate?: string | undefined;
883
- onDelete?: string | undefined;
884
878
  name: string;
885
879
  tableFrom: string;
886
880
  columnsFrom: string[];
887
881
  tableTo: string;
888
882
  columnsTo: string[];
883
+ onUpdate?: string | undefined;
884
+ onDelete?: string | undefined;
889
885
  }>;
890
886
  compositePrimaryKeys: Record<string, {
891
- name?: string | undefined;
892
887
  columns: string[];
888
+ name?: string | undefined;
893
889
  }>;
890
+ uniqueConstraints?: Record<string, {
891
+ name: string;
892
+ columns: string[];
893
+ }> | undefined;
894
894
  }>;
895
895
  version: "5";
896
896
  dialect: "sqlite";
@@ -900,7 +900,7 @@ export declare const schemaInternal: import("zod").ZodObject<{
900
900
  };
901
901
  enums: {};
902
902
  }>;
903
- export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
903
+ export declare const schemaV3: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
904
904
  version: import("zod").ZodLiteral<"3">;
905
905
  dialect: import("zod").ZodEnum<["sqlite"]>;
906
906
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -913,19 +913,19 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
913
913
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
914
914
  default: import("zod").ZodOptional<import("zod").ZodAny>;
915
915
  }, "strict", import("zod").ZodTypeAny, {
916
- default?: any;
917
- autoincrement?: boolean | undefined;
918
916
  name: string;
919
917
  type: string;
920
918
  primaryKey: boolean;
921
919
  notNull: boolean;
922
- }, {
923
920
  default?: any;
924
921
  autoincrement?: boolean | undefined;
922
+ }, {
925
923
  name: string;
926
924
  type: string;
927
925
  primaryKey: boolean;
928
926
  notNull: boolean;
927
+ default?: any;
928
+ autoincrement?: boolean | undefined;
929
929
  }>>;
930
930
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
931
931
  name: import("zod").ZodString;
@@ -933,15 +933,15 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
933
933
  where: import("zod").ZodOptional<import("zod").ZodString>;
934
934
  isUnique: import("zod").ZodBoolean;
935
935
  }, "strict", import("zod").ZodTypeAny, {
936
- where?: string | undefined;
937
936
  name: string;
938
937
  columns: string[];
939
938
  isUnique: boolean;
940
- }, {
941
939
  where?: string | undefined;
940
+ }, {
942
941
  name: string;
943
942
  columns: string[];
944
943
  isUnique: boolean;
944
+ where?: string | undefined;
945
945
  }>>;
946
946
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
947
947
  name: import("zod").ZodString;
@@ -952,71 +952,71 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
952
952
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
953
953
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
954
954
  }, "strict", import("zod").ZodTypeAny, {
955
- onUpdate?: string | undefined;
956
- onDelete?: string | undefined;
957
955
  name: string;
958
956
  tableFrom: string;
959
957
  columnsFrom: string[];
960
958
  tableTo: string;
961
959
  columnsTo: string[];
962
- }, {
963
960
  onUpdate?: string | undefined;
964
961
  onDelete?: string | undefined;
962
+ }, {
965
963
  name: string;
966
964
  tableFrom: string;
967
965
  columnsFrom: string[];
968
966
  tableTo: string;
969
967
  columnsTo: string[];
968
+ onUpdate?: string | undefined;
969
+ onDelete?: string | undefined;
970
970
  }>>;
971
971
  }, "strict", import("zod").ZodTypeAny, {
972
972
  name: string;
973
973
  columns: Record<string, {
974
- default?: any;
975
- autoincrement?: boolean | undefined;
976
974
  name: string;
977
975
  type: string;
978
976
  primaryKey: boolean;
979
977
  notNull: boolean;
978
+ default?: any;
979
+ autoincrement?: boolean | undefined;
980
980
  }>;
981
981
  indexes: Record<string, {
982
- where?: string | undefined;
983
982
  name: string;
984
983
  columns: string[];
985
984
  isUnique: boolean;
985
+ where?: string | undefined;
986
986
  }>;
987
987
  foreignKeys: Record<string, {
988
- onUpdate?: string | undefined;
989
- onDelete?: string | undefined;
990
988
  name: string;
991
989
  tableFrom: string;
992
990
  columnsFrom: string[];
993
991
  tableTo: string;
994
992
  columnsTo: string[];
993
+ onUpdate?: string | undefined;
994
+ onDelete?: string | undefined;
995
995
  }>;
996
996
  }, {
997
997
  name: string;
998
998
  columns: Record<string, {
999
- default?: any;
1000
- autoincrement?: boolean | undefined;
1001
999
  name: string;
1002
1000
  type: string;
1003
1001
  primaryKey: boolean;
1004
1002
  notNull: boolean;
1003
+ default?: any;
1004
+ autoincrement?: boolean | undefined;
1005
1005
  }>;
1006
1006
  indexes: Record<string, {
1007
- where?: string | undefined;
1008
1007
  name: string;
1009
1008
  columns: string[];
1010
1009
  isUnique: boolean;
1010
+ where?: string | undefined;
1011
1011
  }>;
1012
1012
  foreignKeys: Record<string, {
1013
- onUpdate?: string | undefined;
1014
- onDelete?: string | undefined;
1015
1013
  name: string;
1016
1014
  tableFrom: string;
1017
1015
  columnsFrom: string[];
1018
1016
  tableTo: string;
1019
1017
  columnsTo: string[];
1018
+ onUpdate?: string | undefined;
1019
+ onDelete?: string | undefined;
1020
1020
  }>;
1021
1021
  }>>;
1022
1022
  enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
@@ -1027,27 +1027,27 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1027
1027
  tables: Record<string, {
1028
1028
  name: string;
1029
1029
  columns: Record<string, {
1030
- default?: any;
1031
- autoincrement?: boolean | undefined;
1032
1030
  name: string;
1033
1031
  type: string;
1034
1032
  primaryKey: boolean;
1035
1033
  notNull: boolean;
1034
+ default?: any;
1035
+ autoincrement?: boolean | undefined;
1036
1036
  }>;
1037
1037
  indexes: Record<string, {
1038
- where?: string | undefined;
1039
1038
  name: string;
1040
1039
  columns: string[];
1041
1040
  isUnique: boolean;
1041
+ where?: string | undefined;
1042
1042
  }>;
1043
1043
  foreignKeys: Record<string, {
1044
- onUpdate?: string | undefined;
1045
- onDelete?: string | undefined;
1046
1044
  name: string;
1047
1045
  tableFrom: string;
1048
1046
  columnsFrom: string[];
1049
1047
  tableTo: string;
1050
1048
  columnsTo: string[];
1049
+ onUpdate?: string | undefined;
1050
+ onDelete?: string | undefined;
1051
1051
  }>;
1052
1052
  }>;
1053
1053
  id: string;
@@ -1059,27 +1059,27 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1059
1059
  tables: Record<string, {
1060
1060
  name: string;
1061
1061
  columns: Record<string, {
1062
- default?: any;
1063
- autoincrement?: boolean | undefined;
1064
1062
  name: string;
1065
1063
  type: string;
1066
1064
  primaryKey: boolean;
1067
1065
  notNull: boolean;
1066
+ default?: any;
1067
+ autoincrement?: boolean | undefined;
1068
1068
  }>;
1069
1069
  indexes: Record<string, {
1070
- where?: string | undefined;
1071
1070
  name: string;
1072
1071
  columns: string[];
1073
1072
  isUnique: boolean;
1073
+ where?: string | undefined;
1074
1074
  }>;
1075
1075
  foreignKeys: Record<string, {
1076
- onUpdate?: string | undefined;
1077
- onDelete?: string | undefined;
1078
1076
  name: string;
1079
1077
  tableFrom: string;
1080
1078
  columnsFrom: string[];
1081
1079
  tableTo: string;
1082
1080
  columnsTo: string[];
1081
+ onUpdate?: string | undefined;
1082
+ onDelete?: string | undefined;
1083
1083
  }>;
1084
1084
  }>;
1085
1085
  id: string;
@@ -1088,7 +1088,7 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape
1088
1088
  dialect: "sqlite";
1089
1089
  enums: {};
1090
1090
  }>;
1091
- export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
1091
+ export declare const schemaV4: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
1092
1092
  version: import("zod").ZodLiteral<"4">;
1093
1093
  dialect: import("zod").ZodEnum<["sqlite"]>;
1094
1094
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1101,19 +1101,19 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1101
1101
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1102
1102
  default: import("zod").ZodOptional<import("zod").ZodAny>;
1103
1103
  }, "strict", import("zod").ZodTypeAny, {
1104
- default?: any;
1105
- autoincrement?: boolean | undefined;
1106
1104
  name: string;
1107
1105
  type: string;
1108
1106
  primaryKey: boolean;
1109
1107
  notNull: boolean;
1110
- }, {
1111
1108
  default?: any;
1112
1109
  autoincrement?: boolean | undefined;
1110
+ }, {
1113
1111
  name: string;
1114
1112
  type: string;
1115
1113
  primaryKey: boolean;
1116
1114
  notNull: boolean;
1115
+ default?: any;
1116
+ autoincrement?: boolean | undefined;
1117
1117
  }>>;
1118
1118
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1119
1119
  name: import("zod").ZodString;
@@ -1121,15 +1121,15 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1121
1121
  where: import("zod").ZodOptional<import("zod").ZodString>;
1122
1122
  isUnique: import("zod").ZodBoolean;
1123
1123
  }, "strict", import("zod").ZodTypeAny, {
1124
- where?: string | undefined;
1125
1124
  name: string;
1126
1125
  columns: string[];
1127
1126
  isUnique: boolean;
1128
- }, {
1129
1127
  where?: string | undefined;
1128
+ }, {
1130
1129
  name: string;
1131
1130
  columns: string[];
1132
1131
  isUnique: boolean;
1132
+ where?: string | undefined;
1133
1133
  }>>;
1134
1134
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1135
1135
  name: import("zod").ZodString;
@@ -1140,31 +1140,31 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1140
1140
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1141
1141
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1142
1142
  }, "strict", import("zod").ZodTypeAny, {
1143
- onUpdate?: string | undefined;
1144
- onDelete?: string | undefined;
1145
1143
  name: string;
1146
1144
  tableFrom: string;
1147
1145
  columnsFrom: string[];
1148
1146
  tableTo: string;
1149
1147
  columnsTo: string[];
1150
- }, {
1151
1148
  onUpdate?: string | undefined;
1152
1149
  onDelete?: string | undefined;
1150
+ }, {
1153
1151
  name: string;
1154
1152
  tableFrom: string;
1155
1153
  columnsFrom: string[];
1156
1154
  tableTo: string;
1157
1155
  columnsTo: string[];
1156
+ onUpdate?: string | undefined;
1157
+ onDelete?: string | undefined;
1158
1158
  }>>;
1159
1159
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1160
1160
  columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1161
1161
  name: import("zod").ZodOptional<import("zod").ZodString>;
1162
1162
  }, "strict", import("zod").ZodTypeAny, {
1163
- name?: string | undefined;
1164
1163
  columns: string[];
1165
- }, {
1166
1164
  name?: string | undefined;
1165
+ }, {
1167
1166
  columns: string[];
1167
+ name?: string | undefined;
1168
1168
  }>>;
1169
1169
  uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1170
1170
  name: import("zod").ZodString;
@@ -1179,69 +1179,69 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1179
1179
  }, "strict", import("zod").ZodTypeAny, {
1180
1180
  name: string;
1181
1181
  columns: Record<string, {
1182
- default?: any;
1183
- autoincrement?: boolean | undefined;
1184
1182
  name: string;
1185
1183
  type: string;
1186
1184
  primaryKey: boolean;
1187
1185
  notNull: boolean;
1186
+ default?: any;
1187
+ autoincrement?: boolean | undefined;
1188
1188
  }>;
1189
1189
  indexes: Record<string, {
1190
- where?: string | undefined;
1191
1190
  name: string;
1192
1191
  columns: string[];
1193
1192
  isUnique: boolean;
1193
+ where?: string | undefined;
1194
1194
  }>;
1195
1195
  foreignKeys: Record<string, {
1196
- onUpdate?: string | undefined;
1197
- onDelete?: string | undefined;
1198
1196
  name: string;
1199
1197
  tableFrom: string;
1200
1198
  columnsFrom: string[];
1201
1199
  tableTo: string;
1202
1200
  columnsTo: string[];
1201
+ onUpdate?: string | undefined;
1202
+ onDelete?: string | undefined;
1203
1203
  }>;
1204
1204
  compositePrimaryKeys: Record<string, {
1205
- name?: string | undefined;
1206
1205
  columns: string[];
1206
+ name?: string | undefined;
1207
1207
  }>;
1208
1208
  uniqueConstraints: Record<string, {
1209
1209
  name: string;
1210
1210
  columns: string[];
1211
1211
  }>;
1212
1212
  }, {
1213
- uniqueConstraints?: Record<string, {
1214
- name: string;
1215
- columns: string[];
1216
- }> | undefined;
1217
1213
  name: string;
1218
1214
  columns: Record<string, {
1219
- default?: any;
1220
- autoincrement?: boolean | undefined;
1221
1215
  name: string;
1222
1216
  type: string;
1223
1217
  primaryKey: boolean;
1224
1218
  notNull: boolean;
1219
+ default?: any;
1220
+ autoincrement?: boolean | undefined;
1225
1221
  }>;
1226
1222
  indexes: Record<string, {
1227
- where?: string | undefined;
1228
1223
  name: string;
1229
1224
  columns: string[];
1230
1225
  isUnique: boolean;
1226
+ where?: string | undefined;
1231
1227
  }>;
1232
1228
  foreignKeys: Record<string, {
1233
- onUpdate?: string | undefined;
1234
- onDelete?: string | undefined;
1235
1229
  name: string;
1236
1230
  tableFrom: string;
1237
1231
  columnsFrom: string[];
1238
1232
  tableTo: string;
1239
1233
  columnsTo: string[];
1234
+ onUpdate?: string | undefined;
1235
+ onDelete?: string | undefined;
1240
1236
  }>;
1241
1237
  compositePrimaryKeys: Record<string, {
1242
- name?: string | undefined;
1243
1238
  columns: string[];
1239
+ name?: string | undefined;
1244
1240
  }>;
1241
+ uniqueConstraints?: Record<string, {
1242
+ name: string;
1243
+ columns: string[];
1244
+ }> | undefined;
1245
1245
  }>>;
1246
1246
  enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
1247
1247
  }, {
@@ -1251,31 +1251,31 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1251
1251
  tables: Record<string, {
1252
1252
  name: string;
1253
1253
  columns: Record<string, {
1254
- default?: any;
1255
- autoincrement?: boolean | undefined;
1256
1254
  name: string;
1257
1255
  type: string;
1258
1256
  primaryKey: boolean;
1259
1257
  notNull: boolean;
1258
+ default?: any;
1259
+ autoincrement?: boolean | undefined;
1260
1260
  }>;
1261
1261
  indexes: Record<string, {
1262
- where?: string | undefined;
1263
1262
  name: string;
1264
1263
  columns: string[];
1265
1264
  isUnique: boolean;
1265
+ where?: string | undefined;
1266
1266
  }>;
1267
1267
  foreignKeys: Record<string, {
1268
- onUpdate?: string | undefined;
1269
- onDelete?: string | undefined;
1270
1268
  name: string;
1271
1269
  tableFrom: string;
1272
1270
  columnsFrom: string[];
1273
1271
  tableTo: string;
1274
1272
  columnsTo: string[];
1273
+ onUpdate?: string | undefined;
1274
+ onDelete?: string | undefined;
1275
1275
  }>;
1276
1276
  compositePrimaryKeys: Record<string, {
1277
- name?: string | undefined;
1278
1277
  columns: string[];
1278
+ name?: string | undefined;
1279
1279
  }>;
1280
1280
  uniqueConstraints: Record<string, {
1281
1281
  name: string;
@@ -1289,38 +1289,38 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1289
1289
  enums: {};
1290
1290
  }, {
1291
1291
  tables: Record<string, {
1292
- uniqueConstraints?: Record<string, {
1293
- name: string;
1294
- columns: string[];
1295
- }> | undefined;
1296
1292
  name: string;
1297
1293
  columns: Record<string, {
1298
- default?: any;
1299
- autoincrement?: boolean | undefined;
1300
1294
  name: string;
1301
1295
  type: string;
1302
1296
  primaryKey: boolean;
1303
1297
  notNull: boolean;
1298
+ default?: any;
1299
+ autoincrement?: boolean | undefined;
1304
1300
  }>;
1305
1301
  indexes: Record<string, {
1306
- where?: string | undefined;
1307
1302
  name: string;
1308
1303
  columns: string[];
1309
1304
  isUnique: boolean;
1305
+ where?: string | 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
- name?: string | undefined;
1322
1317
  columns: string[];
1318
+ name?: string | undefined;
1323
1319
  }>;
1320
+ uniqueConstraints?: Record<string, {
1321
+ name: string;
1322
+ columns: string[];
1323
+ }> | undefined;
1324
1324
  }>;
1325
1325
  id: string;
1326
1326
  prevId: string;
@@ -1328,7 +1328,7 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape
1328
1328
  dialect: "sqlite";
1329
1329
  enums: {};
1330
1330
  }>;
1331
- export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1331
+ export declare const schema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
1332
1332
  version: import("zod").ZodLiteral<"5">;
1333
1333
  dialect: import("zod").ZodEnum<["sqlite"]>;
1334
1334
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1341,19 +1341,19 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1341
1341
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1342
1342
  default: import("zod").ZodOptional<import("zod").ZodAny>;
1343
1343
  }, "strict", import("zod").ZodTypeAny, {
1344
- default?: any;
1345
- autoincrement?: boolean | undefined;
1346
1344
  name: string;
1347
1345
  type: string;
1348
1346
  primaryKey: boolean;
1349
1347
  notNull: boolean;
1350
- }, {
1351
1348
  default?: any;
1352
1349
  autoincrement?: boolean | undefined;
1350
+ }, {
1353
1351
  name: string;
1354
1352
  type: string;
1355
1353
  primaryKey: boolean;
1356
1354
  notNull: boolean;
1355
+ default?: any;
1356
+ autoincrement?: boolean | undefined;
1357
1357
  }>>;
1358
1358
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1359
1359
  name: import("zod").ZodString;
@@ -1361,15 +1361,15 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1361
1361
  where: import("zod").ZodOptional<import("zod").ZodString>;
1362
1362
  isUnique: import("zod").ZodBoolean;
1363
1363
  }, "strict", import("zod").ZodTypeAny, {
1364
- where?: string | undefined;
1365
1364
  name: string;
1366
1365
  columns: string[];
1367
1366
  isUnique: boolean;
1368
- }, {
1369
1367
  where?: string | undefined;
1368
+ }, {
1370
1369
  name: string;
1371
1370
  columns: string[];
1372
1371
  isUnique: boolean;
1372
+ where?: string | undefined;
1373
1373
  }>>;
1374
1374
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1375
1375
  name: import("zod").ZodString;
@@ -1380,31 +1380,31 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1380
1380
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1381
1381
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1382
1382
  }, "strict", import("zod").ZodTypeAny, {
1383
- onUpdate?: string | undefined;
1384
- onDelete?: string | undefined;
1385
1383
  name: string;
1386
1384
  tableFrom: string;
1387
1385
  columnsFrom: string[];
1388
1386
  tableTo: string;
1389
1387
  columnsTo: string[];
1390
- }, {
1391
1388
  onUpdate?: string | undefined;
1392
1389
  onDelete?: string | undefined;
1390
+ }, {
1393
1391
  name: string;
1394
1392
  tableFrom: string;
1395
1393
  columnsFrom: string[];
1396
1394
  tableTo: string;
1397
1395
  columnsTo: string[];
1396
+ onUpdate?: string | undefined;
1397
+ onDelete?: string | undefined;
1398
1398
  }>>;
1399
1399
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1400
1400
  columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1401
1401
  name: import("zod").ZodOptional<import("zod").ZodString>;
1402
1402
  }, "strict", import("zod").ZodTypeAny, {
1403
- name?: string | undefined;
1404
1403
  columns: string[];
1405
- }, {
1406
1404
  name?: string | undefined;
1405
+ }, {
1407
1406
  columns: string[];
1407
+ name?: string | undefined;
1408
1408
  }>>;
1409
1409
  uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1410
1410
  name: import("zod").ZodString;
@@ -1419,69 +1419,69 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1419
1419
  }, "strict", import("zod").ZodTypeAny, {
1420
1420
  name: string;
1421
1421
  columns: Record<string, {
1422
- default?: any;
1423
- autoincrement?: boolean | undefined;
1424
1422
  name: string;
1425
1423
  type: string;
1426
1424
  primaryKey: boolean;
1427
1425
  notNull: boolean;
1426
+ default?: any;
1427
+ autoincrement?: boolean | undefined;
1428
1428
  }>;
1429
1429
  indexes: Record<string, {
1430
- where?: string | undefined;
1431
1430
  name: string;
1432
1431
  columns: string[];
1433
1432
  isUnique: boolean;
1433
+ where?: string | undefined;
1434
1434
  }>;
1435
1435
  foreignKeys: Record<string, {
1436
- onUpdate?: string | undefined;
1437
- onDelete?: string | undefined;
1438
1436
  name: string;
1439
1437
  tableFrom: string;
1440
1438
  columnsFrom: string[];
1441
1439
  tableTo: string;
1442
1440
  columnsTo: string[];
1441
+ onUpdate?: string | undefined;
1442
+ onDelete?: string | undefined;
1443
1443
  }>;
1444
1444
  compositePrimaryKeys: Record<string, {
1445
- name?: string | undefined;
1446
1445
  columns: string[];
1446
+ name?: string | undefined;
1447
1447
  }>;
1448
1448
  uniqueConstraints: Record<string, {
1449
1449
  name: string;
1450
1450
  columns: string[];
1451
1451
  }>;
1452
1452
  }, {
1453
- uniqueConstraints?: Record<string, {
1454
- name: string;
1455
- columns: string[];
1456
- }> | undefined;
1457
1453
  name: string;
1458
1454
  columns: Record<string, {
1459
- default?: any;
1460
- autoincrement?: boolean | undefined;
1461
1455
  name: string;
1462
1456
  type: string;
1463
1457
  primaryKey: boolean;
1464
1458
  notNull: boolean;
1459
+ default?: any;
1460
+ autoincrement?: boolean | undefined;
1465
1461
  }>;
1466
1462
  indexes: Record<string, {
1467
- where?: string | undefined;
1468
1463
  name: string;
1469
1464
  columns: string[];
1470
1465
  isUnique: boolean;
1466
+ where?: string | undefined;
1471
1467
  }>;
1472
1468
  foreignKeys: Record<string, {
1473
- onUpdate?: string | undefined;
1474
- onDelete?: string | undefined;
1475
1469
  name: string;
1476
1470
  tableFrom: string;
1477
1471
  columnsFrom: string[];
1478
1472
  tableTo: string;
1479
1473
  columnsTo: string[];
1474
+ onUpdate?: string | undefined;
1475
+ onDelete?: string | undefined;
1480
1476
  }>;
1481
1477
  compositePrimaryKeys: Record<string, {
1482
- name?: string | undefined;
1483
1478
  columns: string[];
1479
+ name?: string | undefined;
1484
1480
  }>;
1481
+ uniqueConstraints?: Record<string, {
1482
+ name: string;
1483
+ columns: string[];
1484
+ }> | undefined;
1485
1485
  }>>;
1486
1486
  enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
1487
1487
  _meta: import("zod").ZodObject<{
@@ -1501,31 +1501,31 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1501
1501
  tables: Record<string, {
1502
1502
  name: string;
1503
1503
  columns: Record<string, {
1504
- default?: any;
1505
- autoincrement?: boolean | undefined;
1506
1504
  name: string;
1507
1505
  type: string;
1508
1506
  primaryKey: boolean;
1509
1507
  notNull: boolean;
1508
+ default?: any;
1509
+ autoincrement?: boolean | undefined;
1510
1510
  }>;
1511
1511
  indexes: Record<string, {
1512
- where?: string | undefined;
1513
1512
  name: string;
1514
1513
  columns: string[];
1515
1514
  isUnique: boolean;
1515
+ where?: string | undefined;
1516
1516
  }>;
1517
1517
  foreignKeys: Record<string, {
1518
- onUpdate?: string | undefined;
1519
- onDelete?: string | undefined;
1520
1518
  name: string;
1521
1519
  tableFrom: string;
1522
1520
  columnsFrom: string[];
1523
1521
  tableTo: string;
1524
1522
  columnsTo: string[];
1523
+ onUpdate?: string | undefined;
1524
+ onDelete?: string | undefined;
1525
1525
  }>;
1526
1526
  compositePrimaryKeys: Record<string, {
1527
- name?: string | undefined;
1528
1527
  columns: string[];
1528
+ name?: string | undefined;
1529
1529
  }>;
1530
1530
  uniqueConstraints: Record<string, {
1531
1531
  name: string;
@@ -1543,38 +1543,38 @@ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1543
1543
  enums: {};
1544
1544
  }, {
1545
1545
  tables: Record<string, {
1546
- uniqueConstraints?: Record<string, {
1547
- name: string;
1548
- columns: string[];
1549
- }> | undefined;
1550
1546
  name: string;
1551
1547
  columns: Record<string, {
1552
- default?: any;
1553
- autoincrement?: boolean | undefined;
1554
1548
  name: string;
1555
1549
  type: string;
1556
1550
  primaryKey: boolean;
1557
1551
  notNull: boolean;
1552
+ default?: any;
1553
+ autoincrement?: boolean | undefined;
1558
1554
  }>;
1559
1555
  indexes: Record<string, {
1560
- where?: string | undefined;
1561
1556
  name: string;
1562
1557
  columns: string[];
1563
1558
  isUnique: boolean;
1559
+ where?: string | undefined;
1564
1560
  }>;
1565
1561
  foreignKeys: Record<string, {
1566
- onUpdate?: string | undefined;
1567
- onDelete?: string | undefined;
1568
1562
  name: string;
1569
1563
  tableFrom: string;
1570
1564
  columnsFrom: string[];
1571
1565
  tableTo: string;
1572
1566
  columnsTo: string[];
1567
+ onUpdate?: string | undefined;
1568
+ onDelete?: string | undefined;
1573
1569
  }>;
1574
1570
  compositePrimaryKeys: Record<string, {
1575
- name?: string | undefined;
1576
1571
  columns: string[];
1572
+ name?: string | undefined;
1577
1573
  }>;
1574
+ uniqueConstraints?: Record<string, {
1575
+ name: string;
1576
+ columns: string[];
1577
+ }> | undefined;
1578
1578
  }>;
1579
1579
  id: string;
1580
1580
  prevId: string;
@@ -1599,19 +1599,19 @@ export declare const schemaSquashed: import("zod").ZodObject<{
1599
1599
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1600
1600
  default: import("zod").ZodOptional<import("zod").ZodAny>;
1601
1601
  }, "strict", import("zod").ZodTypeAny, {
1602
- default?: any;
1603
- autoincrement?: boolean | undefined;
1604
1602
  name: string;
1605
1603
  type: string;
1606
1604
  primaryKey: boolean;
1607
1605
  notNull: boolean;
1608
- }, {
1609
1606
  default?: any;
1610
1607
  autoincrement?: boolean | undefined;
1608
+ }, {
1611
1609
  name: string;
1612
1610
  type: string;
1613
1611
  primaryKey: boolean;
1614
1612
  notNull: boolean;
1613
+ default?: any;
1614
+ autoincrement?: boolean | undefined;
1615
1615
  }>>;
1616
1616
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1617
1617
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -1620,44 +1620,43 @@ export declare const schemaSquashed: import("zod").ZodObject<{
1620
1620
  }, "strict", import("zod").ZodTypeAny, {
1621
1621
  name: string;
1622
1622
  columns: Record<string, {
1623
- default?: any;
1624
- autoincrement?: boolean | undefined;
1625
1623
  name: string;
1626
1624
  type: string;
1627
1625
  primaryKey: boolean;
1628
1626
  notNull: boolean;
1627
+ default?: any;
1628
+ autoincrement?: boolean | undefined;
1629
1629
  }>;
1630
1630
  indexes: Record<string, string>;
1631
1631
  foreignKeys: Record<string, string>;
1632
1632
  compositePrimaryKeys: Record<string, string>;
1633
1633
  uniqueConstraints: Record<string, string>;
1634
1634
  }, {
1635
- uniqueConstraints?: Record<string, string> | undefined;
1636
1635
  name: string;
1637
1636
  columns: Record<string, {
1638
- default?: any;
1639
- autoincrement?: boolean | undefined;
1640
1637
  name: string;
1641
1638
  type: string;
1642
1639
  primaryKey: boolean;
1643
1640
  notNull: boolean;
1641
+ default?: any;
1642
+ autoincrement?: boolean | undefined;
1644
1643
  }>;
1645
1644
  indexes: Record<string, string>;
1646
1645
  foreignKeys: Record<string, string>;
1647
1646
  compositePrimaryKeys: Record<string, string>;
1647
+ uniqueConstraints?: Record<string, string> | undefined;
1648
1648
  }>>;
1649
1649
  enums: import("zod").ZodAny;
1650
1650
  }, "strict", import("zod").ZodTypeAny, {
1651
- enums?: any;
1652
1651
  tables: Record<string, {
1653
1652
  name: string;
1654
1653
  columns: Record<string, {
1655
- default?: any;
1656
- autoincrement?: boolean | undefined;
1657
1654
  name: string;
1658
1655
  type: string;
1659
1656
  primaryKey: boolean;
1660
1657
  notNull: boolean;
1658
+ default?: any;
1659
+ autoincrement?: boolean | undefined;
1661
1660
  }>;
1662
1661
  indexes: Record<string, string>;
1663
1662
  foreignKeys: Record<string, string>;
@@ -1666,25 +1665,26 @@ export declare const schemaSquashed: import("zod").ZodObject<{
1666
1665
  }>;
1667
1666
  version: "5";
1668
1667
  dialect: "sqlite";
1669
- }, {
1670
1668
  enums?: any;
1669
+ }, {
1671
1670
  tables: Record<string, {
1672
- uniqueConstraints?: Record<string, string> | undefined;
1673
1671
  name: string;
1674
1672
  columns: Record<string, {
1675
- default?: any;
1676
- autoincrement?: boolean | undefined;
1677
1673
  name: string;
1678
1674
  type: string;
1679
1675
  primaryKey: boolean;
1680
1676
  notNull: boolean;
1677
+ default?: any;
1678
+ autoincrement?: boolean | undefined;
1681
1679
  }>;
1682
1680
  indexes: Record<string, string>;
1683
1681
  foreignKeys: Record<string, string>;
1684
1682
  compositePrimaryKeys: Record<string, string>;
1683
+ uniqueConstraints?: Record<string, string> | undefined;
1685
1684
  }>;
1686
1685
  version: "5";
1687
1686
  dialect: "sqlite";
1687
+ enums?: any;
1688
1688
  }>;
1689
1689
  export type Dialect = TypeOf<typeof dialect>;
1690
1690
  export type Column = TypeOf<typeof column>;
@@ -1713,31 +1713,31 @@ export declare const drySQLite: {
1713
1713
  tables: Record<string, {
1714
1714
  name: string;
1715
1715
  columns: Record<string, {
1716
- default?: any;
1717
- autoincrement?: boolean | undefined;
1718
1716
  name: string;
1719
1717
  type: string;
1720
1718
  primaryKey: boolean;
1721
1719
  notNull: boolean;
1720
+ default?: any;
1721
+ autoincrement?: boolean | undefined;
1722
1722
  }>;
1723
1723
  indexes: Record<string, {
1724
- where?: string | undefined;
1725
1724
  name: string;
1726
1725
  columns: string[];
1727
1726
  isUnique: boolean;
1727
+ where?: string | undefined;
1728
1728
  }>;
1729
1729
  foreignKeys: Record<string, {
1730
- onUpdate?: string | undefined;
1731
- onDelete?: string | undefined;
1732
1730
  name: string;
1733
1731
  tableFrom: string;
1734
1732
  columnsFrom: string[];
1735
1733
  tableTo: string;
1736
1734
  columnsTo: string[];
1735
+ onUpdate?: string | undefined;
1736
+ onDelete?: string | undefined;
1737
1737
  }>;
1738
1738
  compositePrimaryKeys: Record<string, {
1739
- name?: string | undefined;
1740
1739
  columns: string[];
1740
+ name?: string | undefined;
1741
1741
  }>;
1742
1742
  uniqueConstraints: Record<string, {
1743
1743
  name: string;
@@ -1754,7 +1754,7 @@ export declare const drySQLite: {
1754
1754
  };
1755
1755
  enums: {};
1756
1756
  };
1757
- export declare const sqliteSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
1757
+ export declare const sqliteSchemaV3: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
1758
1758
  version: import("zod").ZodLiteral<"3">;
1759
1759
  dialect: import("zod").ZodEnum<["sqlite"]>;
1760
1760
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1767,19 +1767,19 @@ export declare const sqliteSchemaV3: import("zod").ZodObject<import("zod").exten
1767
1767
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1768
1768
  default: import("zod").ZodOptional<import("zod").ZodAny>;
1769
1769
  }, "strict", import("zod").ZodTypeAny, {
1770
- default?: any;
1771
- autoincrement?: boolean | undefined;
1772
1770
  name: string;
1773
1771
  type: string;
1774
1772
  primaryKey: boolean;
1775
1773
  notNull: boolean;
1776
- }, {
1777
1774
  default?: any;
1778
1775
  autoincrement?: boolean | undefined;
1776
+ }, {
1779
1777
  name: string;
1780
1778
  type: string;
1781
1779
  primaryKey: boolean;
1782
1780
  notNull: boolean;
1781
+ default?: any;
1782
+ autoincrement?: boolean | undefined;
1783
1783
  }>>;
1784
1784
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1785
1785
  name: import("zod").ZodString;
@@ -1787,15 +1787,15 @@ export declare const sqliteSchemaV3: import("zod").ZodObject<import("zod").exten
1787
1787
  where: import("zod").ZodOptional<import("zod").ZodString>;
1788
1788
  isUnique: import("zod").ZodBoolean;
1789
1789
  }, "strict", import("zod").ZodTypeAny, {
1790
- where?: string | undefined;
1791
1790
  name: string;
1792
1791
  columns: string[];
1793
1792
  isUnique: boolean;
1794
- }, {
1795
1793
  where?: string | undefined;
1794
+ }, {
1796
1795
  name: string;
1797
1796
  columns: string[];
1798
1797
  isUnique: boolean;
1798
+ where?: string | undefined;
1799
1799
  }>>;
1800
1800
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1801
1801
  name: import("zod").ZodString;
@@ -1806,71 +1806,71 @@ export declare const sqliteSchemaV3: import("zod").ZodObject<import("zod").exten
1806
1806
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1807
1807
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1808
1808
  }, "strict", import("zod").ZodTypeAny, {
1809
- onUpdate?: string | undefined;
1810
- onDelete?: string | undefined;
1811
1809
  name: string;
1812
1810
  tableFrom: string;
1813
1811
  columnsFrom: string[];
1814
1812
  tableTo: string;
1815
1813
  columnsTo: string[];
1816
- }, {
1817
1814
  onUpdate?: string | undefined;
1818
1815
  onDelete?: string | undefined;
1816
+ }, {
1819
1817
  name: string;
1820
1818
  tableFrom: string;
1821
1819
  columnsFrom: string[];
1822
1820
  tableTo: string;
1823
1821
  columnsTo: string[];
1822
+ onUpdate?: string | undefined;
1823
+ onDelete?: string | undefined;
1824
1824
  }>>;
1825
1825
  }, "strict", import("zod").ZodTypeAny, {
1826
1826
  name: string;
1827
1827
  columns: Record<string, {
1828
- default?: any;
1829
- autoincrement?: boolean | undefined;
1830
1828
  name: string;
1831
1829
  type: string;
1832
1830
  primaryKey: boolean;
1833
1831
  notNull: boolean;
1832
+ default?: any;
1833
+ autoincrement?: boolean | undefined;
1834
1834
  }>;
1835
1835
  indexes: Record<string, {
1836
- where?: string | undefined;
1837
1836
  name: string;
1838
1837
  columns: string[];
1839
1838
  isUnique: boolean;
1839
+ where?: string | undefined;
1840
1840
  }>;
1841
1841
  foreignKeys: Record<string, {
1842
- onUpdate?: string | undefined;
1843
- onDelete?: string | undefined;
1844
1842
  name: string;
1845
1843
  tableFrom: string;
1846
1844
  columnsFrom: string[];
1847
1845
  tableTo: string;
1848
1846
  columnsTo: string[];
1847
+ onUpdate?: string | undefined;
1848
+ onDelete?: string | undefined;
1849
1849
  }>;
1850
1850
  }, {
1851
1851
  name: string;
1852
1852
  columns: Record<string, {
1853
- default?: any;
1854
- autoincrement?: boolean | undefined;
1855
1853
  name: string;
1856
1854
  type: string;
1857
1855
  primaryKey: boolean;
1858
1856
  notNull: boolean;
1857
+ default?: any;
1858
+ autoincrement?: boolean | undefined;
1859
1859
  }>;
1860
1860
  indexes: Record<string, {
1861
- where?: string | undefined;
1862
1861
  name: string;
1863
1862
  columns: string[];
1864
1863
  isUnique: boolean;
1864
+ where?: string | undefined;
1865
1865
  }>;
1866
1866
  foreignKeys: Record<string, {
1867
- onUpdate?: string | undefined;
1868
- onDelete?: string | undefined;
1869
1867
  name: string;
1870
1868
  tableFrom: string;
1871
1869
  columnsFrom: string[];
1872
1870
  tableTo: string;
1873
1871
  columnsTo: string[];
1872
+ onUpdate?: string | undefined;
1873
+ onDelete?: string | undefined;
1874
1874
  }>;
1875
1875
  }>>;
1876
1876
  enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
@@ -1881,27 +1881,27 @@ export declare const sqliteSchemaV3: import("zod").ZodObject<import("zod").exten
1881
1881
  tables: Record<string, {
1882
1882
  name: string;
1883
1883
  columns: Record<string, {
1884
- default?: any;
1885
- autoincrement?: boolean | undefined;
1886
1884
  name: string;
1887
1885
  type: string;
1888
1886
  primaryKey: boolean;
1889
1887
  notNull: boolean;
1888
+ default?: any;
1889
+ autoincrement?: boolean | undefined;
1890
1890
  }>;
1891
1891
  indexes: Record<string, {
1892
- where?: string | undefined;
1893
1892
  name: string;
1894
1893
  columns: string[];
1895
1894
  isUnique: boolean;
1895
+ where?: string | undefined;
1896
1896
  }>;
1897
1897
  foreignKeys: Record<string, {
1898
- onUpdate?: string | undefined;
1899
- onDelete?: string | undefined;
1900
1898
  name: string;
1901
1899
  tableFrom: string;
1902
1900
  columnsFrom: string[];
1903
1901
  tableTo: string;
1904
1902
  columnsTo: string[];
1903
+ onUpdate?: string | undefined;
1904
+ onDelete?: string | undefined;
1905
1905
  }>;
1906
1906
  }>;
1907
1907
  id: string;
@@ -1913,27 +1913,27 @@ export declare const sqliteSchemaV3: import("zod").ZodObject<import("zod").exten
1913
1913
  tables: Record<string, {
1914
1914
  name: string;
1915
1915
  columns: Record<string, {
1916
- default?: any;
1917
- autoincrement?: boolean | undefined;
1918
1916
  name: string;
1919
1917
  type: string;
1920
1918
  primaryKey: boolean;
1921
1919
  notNull: boolean;
1920
+ default?: any;
1921
+ autoincrement?: boolean | undefined;
1922
1922
  }>;
1923
1923
  indexes: Record<string, {
1924
- where?: string | undefined;
1925
1924
  name: string;
1926
1925
  columns: string[];
1927
1926
  isUnique: boolean;
1927
+ where?: string | undefined;
1928
1928
  }>;
1929
1929
  foreignKeys: Record<string, {
1930
- onUpdate?: string | undefined;
1931
- onDelete?: string | undefined;
1932
1930
  name: string;
1933
1931
  tableFrom: string;
1934
1932
  columnsFrom: string[];
1935
1933
  tableTo: string;
1936
1934
  columnsTo: string[];
1935
+ onUpdate?: string | undefined;
1936
+ onDelete?: string | undefined;
1937
1937
  }>;
1938
1938
  }>;
1939
1939
  id: string;
@@ -1942,7 +1942,7 @@ export declare const sqliteSchemaV3: import("zod").ZodObject<import("zod").exten
1942
1942
  dialect: "sqlite";
1943
1943
  enums: {};
1944
1944
  }>;
1945
- export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
1945
+ export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
1946
1946
  version: import("zod").ZodLiteral<"4">;
1947
1947
  dialect: import("zod").ZodEnum<["sqlite"]>;
1948
1948
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -1955,19 +1955,19 @@ export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").exten
1955
1955
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1956
1956
  default: import("zod").ZodOptional<import("zod").ZodAny>;
1957
1957
  }, "strict", import("zod").ZodTypeAny, {
1958
- default?: any;
1959
- autoincrement?: boolean | undefined;
1960
1958
  name: string;
1961
1959
  type: string;
1962
1960
  primaryKey: boolean;
1963
1961
  notNull: boolean;
1964
- }, {
1965
1962
  default?: any;
1966
1963
  autoincrement?: boolean | undefined;
1964
+ }, {
1967
1965
  name: string;
1968
1966
  type: string;
1969
1967
  primaryKey: boolean;
1970
1968
  notNull: boolean;
1969
+ default?: any;
1970
+ autoincrement?: boolean | undefined;
1971
1971
  }>>;
1972
1972
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1973
1973
  name: import("zod").ZodString;
@@ -1975,15 +1975,15 @@ export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").exten
1975
1975
  where: import("zod").ZodOptional<import("zod").ZodString>;
1976
1976
  isUnique: import("zod").ZodBoolean;
1977
1977
  }, "strict", import("zod").ZodTypeAny, {
1978
- where?: string | undefined;
1979
1978
  name: string;
1980
1979
  columns: string[];
1981
1980
  isUnique: boolean;
1982
- }, {
1983
1981
  where?: string | undefined;
1982
+ }, {
1984
1983
  name: string;
1985
1984
  columns: string[];
1986
1985
  isUnique: boolean;
1986
+ where?: string | undefined;
1987
1987
  }>>;
1988
1988
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1989
1989
  name: import("zod").ZodString;
@@ -1994,31 +1994,31 @@ export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").exten
1994
1994
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1995
1995
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1996
1996
  }, "strict", import("zod").ZodTypeAny, {
1997
- onUpdate?: string | undefined;
1998
- onDelete?: string | undefined;
1999
1997
  name: string;
2000
1998
  tableFrom: string;
2001
1999
  columnsFrom: string[];
2002
2000
  tableTo: string;
2003
2001
  columnsTo: string[];
2004
- }, {
2005
2002
  onUpdate?: string | undefined;
2006
2003
  onDelete?: string | undefined;
2004
+ }, {
2007
2005
  name: string;
2008
2006
  tableFrom: string;
2009
2007
  columnsFrom: string[];
2010
2008
  tableTo: string;
2011
2009
  columnsTo: string[];
2010
+ onUpdate?: string | undefined;
2011
+ onDelete?: string | undefined;
2012
2012
  }>>;
2013
2013
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2014
2014
  columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2015
2015
  name: import("zod").ZodOptional<import("zod").ZodString>;
2016
2016
  }, "strict", import("zod").ZodTypeAny, {
2017
- name?: string | undefined;
2018
2017
  columns: string[];
2019
- }, {
2020
2018
  name?: string | undefined;
2019
+ }, {
2021
2020
  columns: string[];
2021
+ name?: string | undefined;
2022
2022
  }>>;
2023
2023
  uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2024
2024
  name: import("zod").ZodString;
@@ -2033,69 +2033,69 @@ export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").exten
2033
2033
  }, "strict", import("zod").ZodTypeAny, {
2034
2034
  name: string;
2035
2035
  columns: Record<string, {
2036
- default?: any;
2037
- autoincrement?: boolean | undefined;
2038
2036
  name: string;
2039
2037
  type: string;
2040
2038
  primaryKey: boolean;
2041
2039
  notNull: boolean;
2040
+ default?: any;
2041
+ autoincrement?: boolean | undefined;
2042
2042
  }>;
2043
2043
  indexes: Record<string, {
2044
- where?: string | undefined;
2045
2044
  name: string;
2046
2045
  columns: string[];
2047
2046
  isUnique: boolean;
2047
+ where?: string | undefined;
2048
2048
  }>;
2049
2049
  foreignKeys: Record<string, {
2050
- onUpdate?: string | undefined;
2051
- onDelete?: string | undefined;
2052
2050
  name: string;
2053
2051
  tableFrom: string;
2054
2052
  columnsFrom: string[];
2055
2053
  tableTo: string;
2056
2054
  columnsTo: string[];
2055
+ onUpdate?: string | undefined;
2056
+ onDelete?: string | undefined;
2057
2057
  }>;
2058
2058
  compositePrimaryKeys: Record<string, {
2059
- name?: string | undefined;
2060
2059
  columns: string[];
2060
+ name?: string | undefined;
2061
2061
  }>;
2062
2062
  uniqueConstraints: Record<string, {
2063
2063
  name: string;
2064
2064
  columns: string[];
2065
2065
  }>;
2066
2066
  }, {
2067
- uniqueConstraints?: Record<string, {
2068
- name: string;
2069
- columns: string[];
2070
- }> | undefined;
2071
2067
  name: string;
2072
2068
  columns: Record<string, {
2073
- default?: any;
2074
- autoincrement?: boolean | undefined;
2075
2069
  name: string;
2076
2070
  type: string;
2077
2071
  primaryKey: boolean;
2078
2072
  notNull: boolean;
2073
+ default?: any;
2074
+ autoincrement?: boolean | undefined;
2079
2075
  }>;
2080
2076
  indexes: Record<string, {
2081
- where?: string | undefined;
2082
2077
  name: string;
2083
2078
  columns: string[];
2084
2079
  isUnique: boolean;
2080
+ where?: string | undefined;
2085
2081
  }>;
2086
2082
  foreignKeys: Record<string, {
2087
- onUpdate?: string | undefined;
2088
- onDelete?: string | undefined;
2089
2083
  name: string;
2090
2084
  tableFrom: string;
2091
2085
  columnsFrom: string[];
2092
2086
  tableTo: string;
2093
2087
  columnsTo: string[];
2088
+ onUpdate?: string | undefined;
2089
+ onDelete?: string | undefined;
2094
2090
  }>;
2095
2091
  compositePrimaryKeys: Record<string, {
2096
- name?: string | undefined;
2097
2092
  columns: string[];
2093
+ name?: string | undefined;
2098
2094
  }>;
2095
+ uniqueConstraints?: Record<string, {
2096
+ name: string;
2097
+ columns: string[];
2098
+ }> | undefined;
2099
2099
  }>>;
2100
2100
  enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
2101
2101
  }, {
@@ -2105,31 +2105,31 @@ export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").exten
2105
2105
  tables: Record<string, {
2106
2106
  name: string;
2107
2107
  columns: Record<string, {
2108
- default?: any;
2109
- autoincrement?: boolean | undefined;
2110
2108
  name: string;
2111
2109
  type: string;
2112
2110
  primaryKey: boolean;
2113
2111
  notNull: boolean;
2112
+ default?: any;
2113
+ autoincrement?: boolean | undefined;
2114
2114
  }>;
2115
2115
  indexes: Record<string, {
2116
- where?: string | undefined;
2117
2116
  name: string;
2118
2117
  columns: string[];
2119
2118
  isUnique: boolean;
2119
+ where?: string | undefined;
2120
2120
  }>;
2121
2121
  foreignKeys: Record<string, {
2122
- onUpdate?: string | undefined;
2123
- onDelete?: string | undefined;
2124
2122
  name: string;
2125
2123
  tableFrom: string;
2126
2124
  columnsFrom: string[];
2127
2125
  tableTo: string;
2128
2126
  columnsTo: string[];
2127
+ onUpdate?: string | undefined;
2128
+ onDelete?: string | undefined;
2129
2129
  }>;
2130
2130
  compositePrimaryKeys: Record<string, {
2131
- name?: string | undefined;
2132
2131
  columns: string[];
2132
+ name?: string | undefined;
2133
2133
  }>;
2134
2134
  uniqueConstraints: Record<string, {
2135
2135
  name: string;
@@ -2143,38 +2143,38 @@ export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").exten
2143
2143
  enums: {};
2144
2144
  }, {
2145
2145
  tables: Record<string, {
2146
- uniqueConstraints?: Record<string, {
2147
- name: string;
2148
- columns: string[];
2149
- }> | undefined;
2150
2146
  name: string;
2151
2147
  columns: Record<string, {
2152
- default?: any;
2153
- autoincrement?: boolean | undefined;
2154
2148
  name: string;
2155
2149
  type: string;
2156
2150
  primaryKey: boolean;
2157
2151
  notNull: boolean;
2152
+ default?: any;
2153
+ autoincrement?: boolean | undefined;
2158
2154
  }>;
2159
2155
  indexes: Record<string, {
2160
- where?: string | undefined;
2161
2156
  name: string;
2162
2157
  columns: string[];
2163
2158
  isUnique: boolean;
2159
+ where?: string | undefined;
2164
2160
  }>;
2165
2161
  foreignKeys: Record<string, {
2166
- onUpdate?: string | undefined;
2167
- onDelete?: string | undefined;
2168
2162
  name: string;
2169
2163
  tableFrom: string;
2170
2164
  columnsFrom: string[];
2171
2165
  tableTo: string;
2172
2166
  columnsTo: string[];
2167
+ onUpdate?: string | undefined;
2168
+ onDelete?: string | undefined;
2173
2169
  }>;
2174
2170
  compositePrimaryKeys: Record<string, {
2175
- name?: string | undefined;
2176
2171
  columns: string[];
2172
+ name?: string | undefined;
2177
2173
  }>;
2174
+ uniqueConstraints?: Record<string, {
2175
+ name: string;
2176
+ columns: string[];
2177
+ }> | undefined;
2178
2178
  }>;
2179
2179
  id: string;
2180
2180
  prevId: string;
@@ -2182,7 +2182,7 @@ export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").exten
2182
2182
  dialect: "sqlite";
2183
2183
  enums: {};
2184
2184
  }>;
2185
- export declare const sqliteSchema: import("zod").ZodObject<import("zod").extendShape<{
2185
+ export declare const sqliteSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
2186
2186
  version: import("zod").ZodLiteral<"5">;
2187
2187
  dialect: import("zod").ZodEnum<["sqlite"]>;
2188
2188
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -2195,19 +2195,19 @@ export declare const sqliteSchema: import("zod").ZodObject<import("zod").extendS
2195
2195
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2196
2196
  default: import("zod").ZodOptional<import("zod").ZodAny>;
2197
2197
  }, "strict", import("zod").ZodTypeAny, {
2198
- default?: any;
2199
- autoincrement?: boolean | undefined;
2200
2198
  name: string;
2201
2199
  type: string;
2202
2200
  primaryKey: boolean;
2203
2201
  notNull: boolean;
2204
- }, {
2205
2202
  default?: any;
2206
2203
  autoincrement?: boolean | undefined;
2204
+ }, {
2207
2205
  name: string;
2208
2206
  type: string;
2209
2207
  primaryKey: boolean;
2210
2208
  notNull: boolean;
2209
+ default?: any;
2210
+ autoincrement?: boolean | undefined;
2211
2211
  }>>;
2212
2212
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2213
2213
  name: import("zod").ZodString;
@@ -2215,15 +2215,15 @@ export declare const sqliteSchema: import("zod").ZodObject<import("zod").extendS
2215
2215
  where: import("zod").ZodOptional<import("zod").ZodString>;
2216
2216
  isUnique: import("zod").ZodBoolean;
2217
2217
  }, "strict", import("zod").ZodTypeAny, {
2218
- where?: string | undefined;
2219
2218
  name: string;
2220
2219
  columns: string[];
2221
2220
  isUnique: boolean;
2222
- }, {
2223
2221
  where?: string | undefined;
2222
+ }, {
2224
2223
  name: string;
2225
2224
  columns: string[];
2226
2225
  isUnique: boolean;
2226
+ where?: string | undefined;
2227
2227
  }>>;
2228
2228
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2229
2229
  name: import("zod").ZodString;
@@ -2234,31 +2234,31 @@ export declare const sqliteSchema: import("zod").ZodObject<import("zod").extendS
2234
2234
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2235
2235
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2236
2236
  }, "strict", import("zod").ZodTypeAny, {
2237
- onUpdate?: string | undefined;
2238
- onDelete?: string | undefined;
2239
2237
  name: string;
2240
2238
  tableFrom: string;
2241
2239
  columnsFrom: string[];
2242
2240
  tableTo: string;
2243
2241
  columnsTo: string[];
2244
- }, {
2245
2242
  onUpdate?: string | undefined;
2246
2243
  onDelete?: string | undefined;
2244
+ }, {
2247
2245
  name: string;
2248
2246
  tableFrom: string;
2249
2247
  columnsFrom: string[];
2250
2248
  tableTo: string;
2251
2249
  columnsTo: string[];
2250
+ onUpdate?: string | undefined;
2251
+ onDelete?: string | undefined;
2252
2252
  }>>;
2253
2253
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2254
2254
  columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2255
2255
  name: import("zod").ZodOptional<import("zod").ZodString>;
2256
2256
  }, "strict", import("zod").ZodTypeAny, {
2257
- name?: string | undefined;
2258
2257
  columns: string[];
2259
- }, {
2260
2258
  name?: string | undefined;
2259
+ }, {
2261
2260
  columns: string[];
2261
+ name?: string | undefined;
2262
2262
  }>>;
2263
2263
  uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2264
2264
  name: import("zod").ZodString;
@@ -2273,69 +2273,69 @@ export declare const sqliteSchema: import("zod").ZodObject<import("zod").extendS
2273
2273
  }, "strict", import("zod").ZodTypeAny, {
2274
2274
  name: string;
2275
2275
  columns: Record<string, {
2276
- default?: any;
2277
- autoincrement?: boolean | undefined;
2278
2276
  name: string;
2279
2277
  type: string;
2280
2278
  primaryKey: boolean;
2281
2279
  notNull: boolean;
2280
+ default?: any;
2281
+ autoincrement?: boolean | undefined;
2282
2282
  }>;
2283
2283
  indexes: Record<string, {
2284
- where?: string | undefined;
2285
2284
  name: string;
2286
2285
  columns: string[];
2287
2286
  isUnique: boolean;
2287
+ where?: string | undefined;
2288
2288
  }>;
2289
2289
  foreignKeys: Record<string, {
2290
- onUpdate?: string | undefined;
2291
- onDelete?: string | undefined;
2292
2290
  name: string;
2293
2291
  tableFrom: string;
2294
2292
  columnsFrom: string[];
2295
2293
  tableTo: string;
2296
2294
  columnsTo: string[];
2295
+ onUpdate?: string | undefined;
2296
+ onDelete?: string | undefined;
2297
2297
  }>;
2298
2298
  compositePrimaryKeys: Record<string, {
2299
- name?: string | undefined;
2300
2299
  columns: string[];
2300
+ name?: string | undefined;
2301
2301
  }>;
2302
2302
  uniqueConstraints: Record<string, {
2303
2303
  name: string;
2304
2304
  columns: string[];
2305
2305
  }>;
2306
2306
  }, {
2307
- uniqueConstraints?: Record<string, {
2308
- name: string;
2309
- columns: string[];
2310
- }> | undefined;
2311
2307
  name: string;
2312
2308
  columns: Record<string, {
2313
- default?: any;
2314
- autoincrement?: boolean | undefined;
2315
2309
  name: string;
2316
2310
  type: string;
2317
2311
  primaryKey: boolean;
2318
2312
  notNull: boolean;
2313
+ default?: any;
2314
+ autoincrement?: boolean | undefined;
2319
2315
  }>;
2320
2316
  indexes: Record<string, {
2321
- where?: string | undefined;
2322
2317
  name: string;
2323
2318
  columns: string[];
2324
2319
  isUnique: boolean;
2320
+ where?: string | undefined;
2325
2321
  }>;
2326
2322
  foreignKeys: Record<string, {
2327
- onUpdate?: string | undefined;
2328
- onDelete?: string | undefined;
2329
2323
  name: string;
2330
2324
  tableFrom: string;
2331
2325
  columnsFrom: string[];
2332
2326
  tableTo: string;
2333
2327
  columnsTo: string[];
2328
+ onUpdate?: string | undefined;
2329
+ onDelete?: string | undefined;
2334
2330
  }>;
2335
2331
  compositePrimaryKeys: Record<string, {
2336
- name?: string | undefined;
2337
2332
  columns: string[];
2333
+ name?: string | undefined;
2338
2334
  }>;
2335
+ uniqueConstraints?: Record<string, {
2336
+ name: string;
2337
+ columns: string[];
2338
+ }> | undefined;
2339
2339
  }>>;
2340
2340
  enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
2341
2341
  _meta: import("zod").ZodObject<{
@@ -2355,31 +2355,31 @@ export declare const sqliteSchema: import("zod").ZodObject<import("zod").extendS
2355
2355
  tables: Record<string, {
2356
2356
  name: string;
2357
2357
  columns: Record<string, {
2358
- default?: any;
2359
- autoincrement?: boolean | undefined;
2360
2358
  name: string;
2361
2359
  type: string;
2362
2360
  primaryKey: boolean;
2363
2361
  notNull: boolean;
2362
+ default?: any;
2363
+ autoincrement?: boolean | undefined;
2364
2364
  }>;
2365
2365
  indexes: Record<string, {
2366
- where?: string | undefined;
2367
2366
  name: string;
2368
2367
  columns: string[];
2369
2368
  isUnique: boolean;
2369
+ where?: string | undefined;
2370
2370
  }>;
2371
2371
  foreignKeys: Record<string, {
2372
- onUpdate?: string | undefined;
2373
- onDelete?: string | undefined;
2374
2372
  name: string;
2375
2373
  tableFrom: string;
2376
2374
  columnsFrom: string[];
2377
2375
  tableTo: string;
2378
2376
  columnsTo: string[];
2377
+ onUpdate?: string | undefined;
2378
+ onDelete?: string | undefined;
2379
2379
  }>;
2380
2380
  compositePrimaryKeys: Record<string, {
2381
- name?: string | undefined;
2382
2381
  columns: string[];
2382
+ name?: string | undefined;
2383
2383
  }>;
2384
2384
  uniqueConstraints: Record<string, {
2385
2385
  name: string;
@@ -2397,38 +2397,38 @@ export declare const sqliteSchema: import("zod").ZodObject<import("zod").extendS
2397
2397
  enums: {};
2398
2398
  }, {
2399
2399
  tables: Record<string, {
2400
- uniqueConstraints?: Record<string, {
2401
- name: string;
2402
- columns: string[];
2403
- }> | undefined;
2404
2400
  name: string;
2405
2401
  columns: Record<string, {
2406
- default?: any;
2407
- autoincrement?: boolean | undefined;
2408
2402
  name: string;
2409
2403
  type: string;
2410
2404
  primaryKey: boolean;
2411
2405
  notNull: boolean;
2406
+ default?: any;
2407
+ autoincrement?: boolean | undefined;
2412
2408
  }>;
2413
2409
  indexes: Record<string, {
2414
- where?: string | undefined;
2415
2410
  name: string;
2416
2411
  columns: string[];
2417
2412
  isUnique: boolean;
2413
+ where?: string | undefined;
2418
2414
  }>;
2419
2415
  foreignKeys: Record<string, {
2420
- onUpdate?: string | undefined;
2421
- onDelete?: string | undefined;
2422
2416
  name: string;
2423
2417
  tableFrom: string;
2424
2418
  columnsFrom: string[];
2425
2419
  tableTo: string;
2426
2420
  columnsTo: string[];
2421
+ onUpdate?: string | undefined;
2422
+ onDelete?: string | undefined;
2427
2423
  }>;
2428
2424
  compositePrimaryKeys: Record<string, {
2429
- name?: string | undefined;
2430
2425
  columns: string[];
2426
+ name?: string | undefined;
2431
2427
  }>;
2428
+ uniqueConstraints?: Record<string, {
2429
+ name: string;
2430
+ columns: string[];
2431
+ }> | undefined;
2432
2432
  }>;
2433
2433
  id: string;
2434
2434
  prevId: string;
@@ -2453,19 +2453,19 @@ export declare const SQLiteSchemaSquashed: import("zod").ZodObject<{
2453
2453
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2454
2454
  default: import("zod").ZodOptional<import("zod").ZodAny>;
2455
2455
  }, "strict", import("zod").ZodTypeAny, {
2456
- default?: any;
2457
- autoincrement?: boolean | undefined;
2458
2456
  name: string;
2459
2457
  type: string;
2460
2458
  primaryKey: boolean;
2461
2459
  notNull: boolean;
2462
- }, {
2463
2460
  default?: any;
2464
2461
  autoincrement?: boolean | undefined;
2462
+ }, {
2465
2463
  name: string;
2466
2464
  type: string;
2467
2465
  primaryKey: boolean;
2468
2466
  notNull: boolean;
2467
+ default?: any;
2468
+ autoincrement?: boolean | undefined;
2469
2469
  }>>;
2470
2470
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2471
2471
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
@@ -2474,44 +2474,43 @@ export declare const SQLiteSchemaSquashed: import("zod").ZodObject<{
2474
2474
  }, "strict", import("zod").ZodTypeAny, {
2475
2475
  name: string;
2476
2476
  columns: Record<string, {
2477
- default?: any;
2478
- autoincrement?: boolean | undefined;
2479
2477
  name: string;
2480
2478
  type: string;
2481
2479
  primaryKey: boolean;
2482
2480
  notNull: boolean;
2481
+ default?: any;
2482
+ autoincrement?: boolean | undefined;
2483
2483
  }>;
2484
2484
  indexes: Record<string, string>;
2485
2485
  foreignKeys: Record<string, string>;
2486
2486
  compositePrimaryKeys: Record<string, string>;
2487
2487
  uniqueConstraints: Record<string, string>;
2488
2488
  }, {
2489
- uniqueConstraints?: Record<string, string> | undefined;
2490
2489
  name: string;
2491
2490
  columns: Record<string, {
2492
- default?: any;
2493
- autoincrement?: boolean | undefined;
2494
2491
  name: string;
2495
2492
  type: string;
2496
2493
  primaryKey: boolean;
2497
2494
  notNull: boolean;
2495
+ default?: any;
2496
+ autoincrement?: boolean | undefined;
2498
2497
  }>;
2499
2498
  indexes: Record<string, string>;
2500
2499
  foreignKeys: Record<string, string>;
2501
2500
  compositePrimaryKeys: Record<string, string>;
2501
+ uniqueConstraints?: Record<string, string> | undefined;
2502
2502
  }>>;
2503
2503
  enums: import("zod").ZodAny;
2504
2504
  }, "strict", import("zod").ZodTypeAny, {
2505
- enums?: any;
2506
2505
  tables: Record<string, {
2507
2506
  name: string;
2508
2507
  columns: Record<string, {
2509
- default?: any;
2510
- autoincrement?: boolean | undefined;
2511
2508
  name: string;
2512
2509
  type: string;
2513
2510
  primaryKey: boolean;
2514
2511
  notNull: boolean;
2512
+ default?: any;
2513
+ autoincrement?: boolean | undefined;
2515
2514
  }>;
2516
2515
  indexes: Record<string, string>;
2517
2516
  foreignKeys: Record<string, string>;
@@ -2520,27 +2519,28 @@ export declare const SQLiteSchemaSquashed: import("zod").ZodObject<{
2520
2519
  }>;
2521
2520
  version: "5";
2522
2521
  dialect: "sqlite";
2523
- }, {
2524
2522
  enums?: any;
2523
+ }, {
2525
2524
  tables: Record<string, {
2526
- uniqueConstraints?: Record<string, string> | undefined;
2527
2525
  name: string;
2528
2526
  columns: Record<string, {
2529
- default?: any;
2530
- autoincrement?: boolean | undefined;
2531
2527
  name: string;
2532
2528
  type: string;
2533
2529
  primaryKey: boolean;
2534
2530
  notNull: boolean;
2531
+ default?: any;
2532
+ autoincrement?: boolean | undefined;
2535
2533
  }>;
2536
2534
  indexes: Record<string, string>;
2537
2535
  foreignKeys: Record<string, string>;
2538
2536
  compositePrimaryKeys: Record<string, string>;
2537
+ uniqueConstraints?: Record<string, string> | undefined;
2539
2538
  }>;
2540
2539
  version: "5";
2541
2540
  dialect: "sqlite";
2541
+ enums?: any;
2542
2542
  }>;
2543
- export declare const backwardCompatibleSqliteSchema: import("zod").ZodObject<import("zod").extendShape<{
2543
+ export declare const backwardCompatibleSqliteSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
2544
2544
  version: import("zod").ZodLiteral<"5">;
2545
2545
  dialect: import("zod").ZodEnum<["sqlite"]>;
2546
2546
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
@@ -2553,19 +2553,19 @@ export declare const backwardCompatibleSqliteSchema: import("zod").ZodObject<imp
2553
2553
  autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2554
2554
  default: import("zod").ZodOptional<import("zod").ZodAny>;
2555
2555
  }, "strict", import("zod").ZodTypeAny, {
2556
- default?: any;
2557
- autoincrement?: boolean | undefined;
2558
2556
  name: string;
2559
2557
  type: string;
2560
2558
  primaryKey: boolean;
2561
2559
  notNull: boolean;
2562
- }, {
2563
2560
  default?: any;
2564
2561
  autoincrement?: boolean | undefined;
2562
+ }, {
2565
2563
  name: string;
2566
2564
  type: string;
2567
2565
  primaryKey: boolean;
2568
2566
  notNull: boolean;
2567
+ default?: any;
2568
+ autoincrement?: boolean | undefined;
2569
2569
  }>>;
2570
2570
  indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2571
2571
  name: import("zod").ZodString;
@@ -2573,15 +2573,15 @@ export declare const backwardCompatibleSqliteSchema: import("zod").ZodObject<imp
2573
2573
  where: import("zod").ZodOptional<import("zod").ZodString>;
2574
2574
  isUnique: import("zod").ZodBoolean;
2575
2575
  }, "strict", import("zod").ZodTypeAny, {
2576
- where?: string | undefined;
2577
2576
  name: string;
2578
2577
  columns: string[];
2579
2578
  isUnique: boolean;
2580
- }, {
2581
2579
  where?: string | undefined;
2580
+ }, {
2582
2581
  name: string;
2583
2582
  columns: string[];
2584
2583
  isUnique: boolean;
2584
+ where?: string | undefined;
2585
2585
  }>>;
2586
2586
  foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2587
2587
  name: import("zod").ZodString;
@@ -2592,31 +2592,31 @@ export declare const backwardCompatibleSqliteSchema: import("zod").ZodObject<imp
2592
2592
  onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2593
2593
  onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2594
2594
  }, "strict", import("zod").ZodTypeAny, {
2595
- onUpdate?: string | undefined;
2596
- onDelete?: string | undefined;
2597
2595
  name: string;
2598
2596
  tableFrom: string;
2599
2597
  columnsFrom: string[];
2600
2598
  tableTo: string;
2601
2599
  columnsTo: string[];
2602
- }, {
2603
2600
  onUpdate?: string | undefined;
2604
2601
  onDelete?: string | undefined;
2602
+ }, {
2605
2603
  name: string;
2606
2604
  tableFrom: string;
2607
2605
  columnsFrom: string[];
2608
2606
  tableTo: string;
2609
2607
  columnsTo: string[];
2608
+ onUpdate?: string | undefined;
2609
+ onDelete?: string | undefined;
2610
2610
  }>>;
2611
2611
  compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2612
2612
  columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2613
2613
  name: import("zod").ZodOptional<import("zod").ZodString>;
2614
2614
  }, "strict", import("zod").ZodTypeAny, {
2615
- name?: string | undefined;
2616
2615
  columns: string[];
2617
- }, {
2618
2616
  name?: string | undefined;
2617
+ }, {
2619
2618
  columns: string[];
2619
+ name?: string | undefined;
2620
2620
  }>>;
2621
2621
  uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2622
2622
  name: import("zod").ZodString;
@@ -2631,69 +2631,69 @@ export declare const backwardCompatibleSqliteSchema: import("zod").ZodObject<imp
2631
2631
  }, "strict", import("zod").ZodTypeAny, {
2632
2632
  name: string;
2633
2633
  columns: Record<string, {
2634
- default?: any;
2635
- autoincrement?: boolean | undefined;
2636
2634
  name: string;
2637
2635
  type: string;
2638
2636
  primaryKey: boolean;
2639
2637
  notNull: boolean;
2638
+ default?: any;
2639
+ autoincrement?: boolean | undefined;
2640
2640
  }>;
2641
2641
  indexes: Record<string, {
2642
- where?: string | undefined;
2643
2642
  name: string;
2644
2643
  columns: string[];
2645
2644
  isUnique: boolean;
2645
+ where?: string | undefined;
2646
2646
  }>;
2647
2647
  foreignKeys: Record<string, {
2648
- onUpdate?: string | undefined;
2649
- onDelete?: string | undefined;
2650
2648
  name: string;
2651
2649
  tableFrom: string;
2652
2650
  columnsFrom: string[];
2653
2651
  tableTo: string;
2654
2652
  columnsTo: string[];
2653
+ onUpdate?: string | undefined;
2654
+ onDelete?: string | undefined;
2655
2655
  }>;
2656
2656
  compositePrimaryKeys: Record<string, {
2657
- name?: string | undefined;
2658
2657
  columns: string[];
2658
+ name?: string | undefined;
2659
2659
  }>;
2660
2660
  uniqueConstraints: Record<string, {
2661
2661
  name: string;
2662
2662
  columns: string[];
2663
2663
  }>;
2664
2664
  }, {
2665
- uniqueConstraints?: Record<string, {
2666
- name: string;
2667
- columns: string[];
2668
- }> | undefined;
2669
2665
  name: string;
2670
2666
  columns: Record<string, {
2671
- default?: any;
2672
- autoincrement?: boolean | undefined;
2673
2667
  name: string;
2674
2668
  type: string;
2675
2669
  primaryKey: boolean;
2676
2670
  notNull: boolean;
2671
+ default?: any;
2672
+ autoincrement?: boolean | undefined;
2677
2673
  }>;
2678
2674
  indexes: Record<string, {
2679
- where?: string | undefined;
2680
2675
  name: string;
2681
2676
  columns: string[];
2682
2677
  isUnique: boolean;
2678
+ where?: string | undefined;
2683
2679
  }>;
2684
2680
  foreignKeys: Record<string, {
2685
- onUpdate?: string | undefined;
2686
- onDelete?: string | undefined;
2687
2681
  name: string;
2688
2682
  tableFrom: string;
2689
2683
  columnsFrom: string[];
2690
2684
  tableTo: string;
2691
2685
  columnsTo: string[];
2686
+ onUpdate?: string | undefined;
2687
+ onDelete?: string | undefined;
2692
2688
  }>;
2693
2689
  compositePrimaryKeys: Record<string, {
2694
- name?: string | undefined;
2695
2690
  columns: string[];
2691
+ name?: string | undefined;
2696
2692
  }>;
2693
+ uniqueConstraints?: Record<string, {
2694
+ name: string;
2695
+ columns: string[];
2696
+ }> | undefined;
2697
2697
  }>>;
2698
2698
  enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
2699
2699
  _meta: import("zod").ZodObject<{
@@ -2713,31 +2713,31 @@ export declare const backwardCompatibleSqliteSchema: import("zod").ZodObject<imp
2713
2713
  tables: Record<string, {
2714
2714
  name: string;
2715
2715
  columns: Record<string, {
2716
- default?: any;
2717
- autoincrement?: boolean | undefined;
2718
2716
  name: string;
2719
2717
  type: string;
2720
2718
  primaryKey: boolean;
2721
2719
  notNull: boolean;
2720
+ default?: any;
2721
+ autoincrement?: boolean | undefined;
2722
2722
  }>;
2723
2723
  indexes: Record<string, {
2724
- where?: string | undefined;
2725
2724
  name: string;
2726
2725
  columns: string[];
2727
2726
  isUnique: boolean;
2727
+ where?: string | undefined;
2728
2728
  }>;
2729
2729
  foreignKeys: Record<string, {
2730
- onUpdate?: string | undefined;
2731
- onDelete?: string | undefined;
2732
2730
  name: string;
2733
2731
  tableFrom: string;
2734
2732
  columnsFrom: string[];
2735
2733
  tableTo: string;
2736
2734
  columnsTo: string[];
2735
+ onUpdate?: string | undefined;
2736
+ onDelete?: string | undefined;
2737
2737
  }>;
2738
2738
  compositePrimaryKeys: Record<string, {
2739
- name?: string | undefined;
2740
2739
  columns: string[];
2740
+ name?: string | undefined;
2741
2741
  }>;
2742
2742
  uniqueConstraints: Record<string, {
2743
2743
  name: string;
@@ -2755,38 +2755,38 @@ export declare const backwardCompatibleSqliteSchema: import("zod").ZodObject<imp
2755
2755
  enums: {};
2756
2756
  }, {
2757
2757
  tables: Record<string, {
2758
- uniqueConstraints?: Record<string, {
2759
- name: string;
2760
- columns: string[];
2761
- }> | undefined;
2762
2758
  name: string;
2763
2759
  columns: Record<string, {
2764
- default?: any;
2765
- autoincrement?: boolean | undefined;
2766
2760
  name: string;
2767
2761
  type: string;
2768
2762
  primaryKey: boolean;
2769
2763
  notNull: boolean;
2764
+ default?: any;
2765
+ autoincrement?: boolean | undefined;
2770
2766
  }>;
2771
2767
  indexes: Record<string, {
2772
- where?: string | undefined;
2773
2768
  name: string;
2774
2769
  columns: string[];
2775
2770
  isUnique: boolean;
2771
+ where?: string | undefined;
2776
2772
  }>;
2777
2773
  foreignKeys: Record<string, {
2778
- onUpdate?: string | undefined;
2779
- onDelete?: string | undefined;
2780
2774
  name: string;
2781
2775
  tableFrom: string;
2782
2776
  columnsFrom: string[];
2783
2777
  tableTo: string;
2784
2778
  columnsTo: string[];
2779
+ onUpdate?: string | undefined;
2780
+ onDelete?: string | undefined;
2785
2781
  }>;
2786
2782
  compositePrimaryKeys: Record<string, {
2787
- name?: string | undefined;
2788
2783
  columns: string[];
2784
+ name?: string | undefined;
2789
2785
  }>;
2786
+ uniqueConstraints?: Record<string, {
2787
+ name: string;
2788
+ columns: string[];
2789
+ }> | undefined;
2790
2790
  }>;
2791
2791
  id: string;
2792
2792
  prevId: string;