drizzle-kit 0.20.17-4e262b7 → 0.20.17-571b8f9

Sign up to get free protection for your applications and to get access to all the features.
Files changed (31) hide show
  1. package/bin.cjs +51003 -12190
  2. package/cli/commands/migrate.d.ts +43 -43
  3. package/cli/commands/mysqlIntrospect.d.ts +9 -14
  4. package/cli/commands/pgIntrospect.d.ts +8 -8
  5. package/cli/commands/sqliteIntrospect.d.ts +12 -13
  6. package/cli/commands/sqlitePushUtils.d.ts +2 -2
  7. package/cli/commands/utils.d.ts +2 -2
  8. package/cli/connections.d.ts +13 -0
  9. package/cli/utils.d.ts +1 -0
  10. package/cli/validations/cli.d.ts +49 -49
  11. package/cli/validations/common.d.ts +35 -35
  12. package/cli/validations/mysql.d.ts +7 -13
  13. package/cli/validations/outputs.d.ts +2 -2
  14. package/cli/validations/pg.d.ts +22 -13
  15. package/cli/validations/sqlite.d.ts +0 -12
  16. package/index.d.mts +17 -57
  17. package/index.d.ts +17 -57
  18. package/package.json +12 -6
  19. package/payload.js +1634 -20675
  20. package/payload.mjs +1455 -20496
  21. package/schemaValidator.d.ts +228 -228
  22. package/serializer/mysqlSchema.d.ts +910 -1224
  23. package/serializer/pgSchema.d.ts +745 -745
  24. package/serializer/sqliteSchema.d.ts +457 -457
  25. package/serializer/studio.d.ts +51 -0
  26. package/snapshotsDiffer.d.ts +315 -316
  27. package/utils-studio.js +887 -3448
  28. package/utils-studio.mjs +852 -3413
  29. package/utils.d.ts +6 -0
  30. package/utils.js +222 -857
  31. package/utils.mjs +197 -832
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;
8
9
  name: string;
9
10
  columns: string[];
10
11
  isUnique: boolean;
11
- where?: string | undefined;
12
12
  }, {
13
+ where?: string | undefined;
13
14
  name: string;
14
15
  columns: string[];
15
16
  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;
27
29
  name: string;
28
30
  tableFrom: string;
29
31
  columnsFrom: string[];
30
32
  tableTo: string;
31
33
  columnsTo: string[];
34
+ }, {
32
35
  onUpdate?: string | undefined;
33
36
  onDelete?: string | undefined;
34
- }, {
35
37
  name: string;
36
38
  tableFrom: string;
37
39
  columnsFrom: string[];
38
40
  tableTo: string;
39
41
  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
- columns: string[];
48
47
  name?: string | undefined;
49
- }, {
50
48
  columns: string[];
49
+ }, {
51
50
  name?: string | undefined;
51
+ columns: string[];
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;
61
63
  name: string;
62
64
  type: string;
63
65
  primaryKey: boolean;
64
66
  notNull: boolean;
67
+ }, {
65
68
  default?: any;
66
69
  autoincrement?: boolean | undefined;
67
- }, {
68
70
  name: string;
69
71
  type: string;
70
72
  primaryKey: boolean;
71
73
  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;
95
97
  name: string;
96
98
  type: string;
97
99
  primaryKey: boolean;
98
100
  notNull: boolean;
101
+ }, {
99
102
  default?: any;
100
103
  autoincrement?: boolean | undefined;
101
- }, {
102
104
  name: string;
103
105
  type: string;
104
106
  primaryKey: boolean;
105
107
  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;
115
116
  name: string;
116
117
  columns: string[];
117
118
  isUnique: boolean;
118
- where?: string | undefined;
119
119
  }, {
120
+ where?: string | undefined;
120
121
  name: string;
121
122
  columns: string[];
122
123
  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;
134
136
  name: string;
135
137
  tableFrom: string;
136
138
  columnsFrom: string[];
137
139
  tableTo: string;
138
140
  columnsTo: string[];
141
+ }, {
139
142
  onUpdate?: string | undefined;
140
143
  onDelete?: string | undefined;
141
- }, {
142
144
  name: string;
143
145
  tableFrom: string;
144
146
  columnsFrom: string[];
145
147
  tableTo: string;
146
148
  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
- columns: string[];
155
154
  name?: string | undefined;
156
- }, {
157
155
  columns: string[];
156
+ }, {
158
157
  name?: string | undefined;
158
+ columns: string[];
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;
173
175
  name: string;
174
176
  type: string;
175
177
  primaryKey: boolean;
176
178
  notNull: boolean;
177
- default?: any;
178
- autoincrement?: boolean | undefined;
179
179
  }>;
180
180
  indexes: Record<string, {
181
+ where?: string | undefined;
181
182
  name: string;
182
183
  columns: string[];
183
184
  isUnique: boolean;
184
- where?: string | undefined;
185
185
  }>;
186
186
  foreignKeys: Record<string, {
187
+ onUpdate?: string | undefined;
188
+ onDelete?: string | undefined;
187
189
  name: string;
188
190
  tableFrom: string;
189
191
  columnsFrom: string[];
190
192
  tableTo: string;
191
193
  columnsTo: string[];
192
- onUpdate?: string | undefined;
193
- onDelete?: string | undefined;
194
194
  }>;
195
195
  compositePrimaryKeys: Record<string, {
196
- columns: string[];
197
196
  name?: string | undefined;
197
+ columns: string[];
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;
204
208
  name: string;
205
209
  columns: Record<string, {
210
+ default?: any;
211
+ autoincrement?: boolean | undefined;
206
212
  name: string;
207
213
  type: string;
208
214
  primaryKey: boolean;
209
215
  notNull: boolean;
210
- default?: any;
211
- autoincrement?: boolean | undefined;
212
216
  }>;
213
217
  indexes: Record<string, {
218
+ where?: string | undefined;
214
219
  name: string;
215
220
  columns: string[];
216
221
  isUnique: boolean;
217
- where?: string | undefined;
218
222
  }>;
219
223
  foreignKeys: Record<string, {
224
+ onUpdate?: string | undefined;
225
+ onDelete?: string | undefined;
220
226
  name: string;
221
227
  tableFrom: string;
222
228
  columnsFrom: string[];
223
229
  tableTo: string;
224
230
  columnsTo: string[];
225
- onUpdate?: string | undefined;
226
- onDelete?: string | undefined;
227
231
  }>;
228
232
  compositePrimaryKeys: Record<string, {
229
- columns: string[];
230
233
  name?: string | undefined;
231
- }>;
232
- uniqueConstraints?: Record<string, {
233
- name: string;
234
234
  columns: string[];
235
- }> | undefined;
235
+ }>;
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;
251
253
  name: string;
252
254
  type: string;
253
255
  primaryKey: boolean;
254
256
  notNull: boolean;
257
+ }, {
255
258
  default?: any;
256
259
  autoincrement?: boolean | undefined;
257
- }, {
258
260
  name: string;
259
261
  type: string;
260
262
  primaryKey: boolean;
261
263
  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;
271
272
  name: string;
272
273
  columns: string[];
273
274
  isUnique: boolean;
274
- where?: string | undefined;
275
275
  }, {
276
+ where?: string | undefined;
276
277
  name: string;
277
278
  columns: string[];
278
279
  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;
290
292
  name: string;
291
293
  tableFrom: string;
292
294
  columnsFrom: string[];
293
295
  tableTo: string;
294
296
  columnsTo: string[];
297
+ }, {
295
298
  onUpdate?: string | undefined;
296
299
  onDelete?: string | undefined;
297
- }, {
298
300
  name: string;
299
301
  tableFrom: string;
300
302
  columnsFrom: string[];
301
303
  tableTo: string;
302
304
  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;
309
311
  name: string;
310
312
  type: string;
311
313
  primaryKey: boolean;
312
314
  notNull: boolean;
313
- default?: any;
314
- autoincrement?: boolean | undefined;
315
315
  }>;
316
316
  indexes: Record<string, {
317
+ where?: string | undefined;
317
318
  name: string;
318
319
  columns: string[];
319
320
  isUnique: boolean;
320
- where?: string | undefined;
321
321
  }>;
322
322
  foreignKeys: Record<string, {
323
+ onUpdate?: string | undefined;
324
+ onDelete?: string | undefined;
323
325
  name: string;
324
326
  tableFrom: string;
325
327
  columnsFrom: string[];
326
328
  tableTo: string;
327
329
  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;
334
336
  name: string;
335
337
  type: string;
336
338
  primaryKey: boolean;
337
339
  notNull: boolean;
338
- default?: any;
339
- autoincrement?: boolean | undefined;
340
340
  }>;
341
341
  indexes: Record<string, {
342
+ where?: string | undefined;
342
343
  name: string;
343
344
  columns: string[];
344
345
  isUnique: boolean;
345
- where?: string | undefined;
346
346
  }>;
347
347
  foreignKeys: Record<string, {
348
+ onUpdate?: string | undefined;
349
+ onDelete?: string | undefined;
348
350
  name: string;
349
351
  tableFrom: string;
350
352
  columnsFrom: string[];
351
353
  tableTo: string;
352
354
  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;
362
364
  name: string;
363
365
  type: string;
364
366
  primaryKey: boolean;
365
367
  notNull: boolean;
366
- default?: any;
367
- autoincrement?: boolean | undefined;
368
368
  }>;
369
369
  indexes: Record<string, {
370
+ where?: string | undefined;
370
371
  name: string;
371
372
  columns: string[];
372
373
  isUnique: boolean;
373
- where?: string | undefined;
374
374
  }>;
375
375
  foreignKeys: Record<string, {
376
+ onUpdate?: string | undefined;
377
+ onDelete?: string | undefined;
376
378
  name: string;
377
379
  tableFrom: string;
378
380
  columnsFrom: string[];
379
381
  tableTo: string;
380
382
  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;
392
394
  name: string;
393
395
  type: string;
394
396
  primaryKey: boolean;
395
397
  notNull: boolean;
396
- default?: any;
397
- autoincrement?: boolean | undefined;
398
398
  }>;
399
399
  indexes: Record<string, {
400
+ where?: string | undefined;
400
401
  name: string;
401
402
  columns: string[];
402
403
  isUnique: boolean;
403
- where?: string | undefined;
404
404
  }>;
405
405
  foreignKeys: Record<string, {
406
+ onUpdate?: string | undefined;
407
+ onDelete?: string | undefined;
406
408
  name: string;
407
409
  tableFrom: string;
408
410
  columnsFrom: string[];
409
411
  tableTo: string;
410
412
  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;
432
434
  name: string;
433
435
  type: string;
434
436
  primaryKey: boolean;
435
437
  notNull: boolean;
438
+ }, {
436
439
  default?: any;
437
440
  autoincrement?: boolean | undefined;
438
- }, {
439
441
  name: string;
440
442
  type: string;
441
443
  primaryKey: boolean;
442
444
  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;
452
453
  name: string;
453
454
  columns: string[];
454
455
  isUnique: boolean;
455
- where?: string | undefined;
456
456
  }, {
457
+ where?: string | undefined;
457
458
  name: string;
458
459
  columns: string[];
459
460
  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;
471
473
  name: string;
472
474
  tableFrom: string;
473
475
  columnsFrom: string[];
474
476
  tableTo: string;
475
477
  columnsTo: string[];
478
+ }, {
476
479
  onUpdate?: string | undefined;
477
480
  onDelete?: string | undefined;
478
- }, {
479
481
  name: string;
480
482
  tableFrom: string;
481
483
  columnsFrom: string[];
482
484
  tableTo: string;
483
485
  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
- columns: string[];
492
491
  name?: string | undefined;
493
- }, {
494
492
  columns: string[];
493
+ }, {
495
494
  name?: string | undefined;
495
+ columns: string[];
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;
510
512
  name: string;
511
513
  type: string;
512
514
  primaryKey: boolean;
513
515
  notNull: boolean;
514
- default?: any;
515
- autoincrement?: boolean | undefined;
516
516
  }>;
517
517
  indexes: Record<string, {
518
+ where?: string | undefined;
518
519
  name: string;
519
520
  columns: string[];
520
521
  isUnique: boolean;
521
- where?: string | undefined;
522
522
  }>;
523
523
  foreignKeys: Record<string, {
524
+ onUpdate?: string | undefined;
525
+ onDelete?: string | undefined;
524
526
  name: string;
525
527
  tableFrom: string;
526
528
  columnsFrom: string[];
527
529
  tableTo: string;
528
530
  columnsTo: string[];
529
- onUpdate?: string | undefined;
530
- onDelete?: string | undefined;
531
531
  }>;
532
532
  compositePrimaryKeys: Record<string, {
533
- columns: string[];
534
533
  name?: string | undefined;
534
+ columns: string[];
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;
541
545
  name: string;
542
546
  columns: Record<string, {
547
+ default?: any;
548
+ autoincrement?: boolean | undefined;
543
549
  name: string;
544
550
  type: string;
545
551
  primaryKey: boolean;
546
552
  notNull: boolean;
547
- default?: any;
548
- autoincrement?: boolean | undefined;
549
553
  }>;
550
554
  indexes: Record<string, {
555
+ where?: string | undefined;
551
556
  name: string;
552
557
  columns: string[];
553
558
  isUnique: boolean;
554
- where?: string | undefined;
555
559
  }>;
556
560
  foreignKeys: Record<string, {
561
+ onUpdate?: string | undefined;
562
+ onDelete?: string | undefined;
557
563
  name: string;
558
564
  tableFrom: string;
559
565
  columnsFrom: string[];
560
566
  tableTo: string;
561
567
  columnsTo: string[];
562
- onUpdate?: string | undefined;
563
- onDelete?: string | undefined;
564
568
  }>;
565
569
  compositePrimaryKeys: Record<string, {
566
- columns: string[];
567
570
  name?: string | undefined;
568
- }>;
569
- uniqueConstraints?: Record<string, {
570
- name: string;
571
571
  columns: string[];
572
- }> | undefined;
572
+ }>;
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;
579
581
  name: string;
580
582
  type: string;
581
583
  primaryKey: boolean;
582
584
  notNull: boolean;
583
- default?: any;
584
- autoincrement?: boolean | undefined;
585
585
  }>;
586
586
  indexes: Record<string, {
587
+ where?: string | undefined;
587
588
  name: string;
588
589
  columns: string[];
589
590
  isUnique: boolean;
590
- where?: string | undefined;
591
591
  }>;
592
592
  foreignKeys: Record<string, {
593
+ onUpdate?: string | undefined;
594
+ onDelete?: string | undefined;
593
595
  name: string;
594
596
  tableFrom: string;
595
597
  columnsFrom: string[];
596
598
  tableTo: string;
597
599
  columnsTo: string[];
598
- onUpdate?: string | undefined;
599
- onDelete?: string | undefined;
600
600
  }>;
601
601
  compositePrimaryKeys: Record<string, {
602
- columns: string[];
603
602
  name?: string | undefined;
603
+ columns: string[];
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;
615
619
  name: string;
616
620
  columns: Record<string, {
621
+ default?: any;
622
+ autoincrement?: boolean | undefined;
617
623
  name: string;
618
624
  type: string;
619
625
  primaryKey: boolean;
620
626
  notNull: boolean;
621
- default?: any;
622
- autoincrement?: boolean | undefined;
623
627
  }>;
624
628
  indexes: Record<string, {
629
+ where?: string | undefined;
625
630
  name: string;
626
631
  columns: string[];
627
632
  isUnique: boolean;
628
- where?: string | undefined;
629
633
  }>;
630
634
  foreignKeys: Record<string, {
635
+ onUpdate?: string | undefined;
636
+ onDelete?: string | undefined;
631
637
  name: string;
632
638
  tableFrom: string;
633
639
  columnsFrom: string[];
634
640
  tableTo: string;
635
641
  columnsTo: string[];
636
- onUpdate?: string | undefined;
637
- onDelete?: string | undefined;
638
642
  }>;
639
643
  compositePrimaryKeys: Record<string, {
640
- columns: string[];
641
644
  name?: string | undefined;
642
- }>;
643
- uniqueConstraints?: Record<string, {
644
- name: string;
645
645
  columns: string[];
646
- }> | undefined;
646
+ }>;
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;
665
667
  name: string;
666
668
  type: string;
667
669
  primaryKey: boolean;
668
670
  notNull: boolean;
671
+ }, {
669
672
  default?: any;
670
673
  autoincrement?: boolean | undefined;
671
- }, {
672
674
  name: string;
673
675
  type: string;
674
676
  primaryKey: boolean;
675
677
  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;
685
686
  name: string;
686
687
  columns: string[];
687
688
  isUnique: boolean;
688
- where?: string | undefined;
689
689
  }, {
690
+ where?: string | undefined;
690
691
  name: string;
691
692
  columns: string[];
692
693
  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;
704
706
  name: string;
705
707
  tableFrom: string;
706
708
  columnsFrom: string[];
707
709
  tableTo: string;
708
710
  columnsTo: string[];
711
+ }, {
709
712
  onUpdate?: string | undefined;
710
713
  onDelete?: string | undefined;
711
- }, {
712
714
  name: string;
713
715
  tableFrom: string;
714
716
  columnsFrom: string[];
715
717
  tableTo: string;
716
718
  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
- columns: string[];
725
724
  name?: string | undefined;
726
- }, {
727
725
  columns: string[];
726
+ }, {
728
727
  name?: string | undefined;
728
+ columns: string[];
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;
743
745
  name: string;
744
746
  type: string;
745
747
  primaryKey: boolean;
746
748
  notNull: boolean;
747
- default?: any;
748
- autoincrement?: boolean | undefined;
749
749
  }>;
750
750
  indexes: Record<string, {
751
+ where?: string | undefined;
751
752
  name: string;
752
753
  columns: string[];
753
754
  isUnique: boolean;
754
- where?: string | undefined;
755
755
  }>;
756
756
  foreignKeys: Record<string, {
757
+ onUpdate?: string | undefined;
758
+ onDelete?: string | undefined;
757
759
  name: string;
758
760
  tableFrom: string;
759
761
  columnsFrom: string[];
760
762
  tableTo: string;
761
763
  columnsTo: string[];
762
- onUpdate?: string | undefined;
763
- onDelete?: string | undefined;
764
764
  }>;
765
765
  compositePrimaryKeys: Record<string, {
766
- columns: string[];
767
766
  name?: string | undefined;
767
+ columns: string[];
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;
774
778
  name: string;
775
779
  columns: Record<string, {
780
+ default?: any;
781
+ autoincrement?: boolean | undefined;
776
782
  name: string;
777
783
  type: string;
778
784
  primaryKey: boolean;
779
785
  notNull: boolean;
780
- default?: any;
781
- autoincrement?: boolean | undefined;
782
786
  }>;
783
787
  indexes: Record<string, {
788
+ where?: string | undefined;
784
789
  name: string;
785
790
  columns: string[];
786
791
  isUnique: boolean;
787
- where?: string | undefined;
788
792
  }>;
789
793
  foreignKeys: Record<string, {
794
+ onUpdate?: string | undefined;
795
+ onDelete?: string | undefined;
790
796
  name: string;
791
797
  tableFrom: string;
792
798
  columnsFrom: string[];
793
799
  tableTo: string;
794
800
  columnsTo: string[];
795
- onUpdate?: string | undefined;
796
- onDelete?: string | undefined;
797
801
  }>;
798
802
  compositePrimaryKeys: Record<string, {
799
- columns: string[];
800
803
  name?: string | undefined;
801
- }>;
802
- uniqueConstraints?: Record<string, {
803
- name: string;
804
804
  columns: string[];
805
- }> | undefined;
805
+ }>;
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;
822
824
  name: string;
823
825
  type: string;
824
826
  primaryKey: boolean;
825
827
  notNull: boolean;
826
- default?: any;
827
- autoincrement?: boolean | undefined;
828
828
  }>;
829
829
  indexes: Record<string, {
830
+ where?: string | undefined;
830
831
  name: string;
831
832
  columns: string[];
832
833
  isUnique: boolean;
833
- where?: string | undefined;
834
834
  }>;
835
835
  foreignKeys: Record<string, {
836
+ onUpdate?: string | undefined;
837
+ onDelete?: string | undefined;
836
838
  name: string;
837
839
  tableFrom: string;
838
840
  columnsFrom: string[];
839
841
  tableTo: string;
840
842
  columnsTo: string[];
841
- onUpdate?: string | undefined;
842
- onDelete?: string | undefined;
843
843
  }>;
844
844
  compositePrimaryKeys: Record<string, {
845
- columns: string[];
846
845
  name?: string | undefined;
846
+ columns: string[];
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;
862
866
  name: string;
863
867
  columns: Record<string, {
868
+ default?: any;
869
+ autoincrement?: boolean | undefined;
864
870
  name: string;
865
871
  type: string;
866
872
  primaryKey: boolean;
867
873
  notNull: boolean;
868
- default?: any;
869
- autoincrement?: boolean | undefined;
870
874
  }>;
871
875
  indexes: Record<string, {
876
+ where?: string | undefined;
872
877
  name: string;
873
878
  columns: string[];
874
879
  isUnique: boolean;
875
- where?: string | undefined;
876
880
  }>;
877
881
  foreignKeys: Record<string, {
882
+ onUpdate?: string | undefined;
883
+ onDelete?: string | undefined;
878
884
  name: string;
879
885
  tableFrom: string;
880
886
  columnsFrom: string[];
881
887
  tableTo: string;
882
888
  columnsTo: string[];
883
- onUpdate?: string | undefined;
884
- onDelete?: string | undefined;
885
889
  }>;
886
890
  compositePrimaryKeys: Record<string, {
887
- columns: string[];
888
891
  name?: string | undefined;
889
- }>;
890
- uniqueConstraints?: Record<string, {
891
- name: string;
892
892
  columns: string[];
893
- }> | undefined;
893
+ }>;
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").objectUtil.extendShape<{
903
+ export declare const schemaV3: import("zod").ZodObject<import("zod").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").objectUtil.
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;
916
918
  name: string;
917
919
  type: string;
918
920
  primaryKey: boolean;
919
921
  notNull: boolean;
922
+ }, {
920
923
  default?: any;
921
924
  autoincrement?: boolean | undefined;
922
- }, {
923
925
  name: string;
924
926
  type: string;
925
927
  primaryKey: boolean;
926
928
  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").objectUtil.
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;
936
937
  name: string;
937
938
  columns: string[];
938
939
  isUnique: boolean;
939
- where?: string | undefined;
940
940
  }, {
941
+ where?: string | undefined;
941
942
  name: string;
942
943
  columns: string[];
943
944
  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").objectUtil.
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;
955
957
  name: string;
956
958
  tableFrom: string;
957
959
  columnsFrom: string[];
958
960
  tableTo: string;
959
961
  columnsTo: string[];
962
+ }, {
960
963
  onUpdate?: string | undefined;
961
964
  onDelete?: string | undefined;
962
- }, {
963
965
  name: string;
964
966
  tableFrom: string;
965
967
  columnsFrom: string[];
966
968
  tableTo: string;
967
969
  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;
974
976
  name: string;
975
977
  type: string;
976
978
  primaryKey: boolean;
977
979
  notNull: boolean;
978
- default?: any;
979
- autoincrement?: boolean | undefined;
980
980
  }>;
981
981
  indexes: Record<string, {
982
+ where?: string | undefined;
982
983
  name: string;
983
984
  columns: string[];
984
985
  isUnique: boolean;
985
- where?: string | undefined;
986
986
  }>;
987
987
  foreignKeys: Record<string, {
988
+ onUpdate?: string | undefined;
989
+ onDelete?: string | undefined;
988
990
  name: string;
989
991
  tableFrom: string;
990
992
  columnsFrom: string[];
991
993
  tableTo: string;
992
994
  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;
999
1001
  name: string;
1000
1002
  type: string;
1001
1003
  primaryKey: boolean;
1002
1004
  notNull: boolean;
1003
- default?: any;
1004
- autoincrement?: boolean | undefined;
1005
1005
  }>;
1006
1006
  indexes: Record<string, {
1007
+ where?: string | undefined;
1007
1008
  name: string;
1008
1009
  columns: string[];
1009
1010
  isUnique: boolean;
1010
- where?: string | undefined;
1011
1011
  }>;
1012
1012
  foreignKeys: Record<string, {
1013
+ onUpdate?: string | undefined;
1014
+ onDelete?: string | undefined;
1013
1015
  name: string;
1014
1016
  tableFrom: string;
1015
1017
  columnsFrom: string[];
1016
1018
  tableTo: string;
1017
1019
  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").objectUtil.
1027
1027
  tables: Record<string, {
1028
1028
  name: string;
1029
1029
  columns: Record<string, {
1030
+ default?: any;
1031
+ autoincrement?: boolean | undefined;
1030
1032
  name: string;
1031
1033
  type: string;
1032
1034
  primaryKey: boolean;
1033
1035
  notNull: boolean;
1034
- default?: any;
1035
- autoincrement?: boolean | undefined;
1036
1036
  }>;
1037
1037
  indexes: Record<string, {
1038
+ where?: string | undefined;
1038
1039
  name: string;
1039
1040
  columns: string[];
1040
1041
  isUnique: boolean;
1041
- where?: string | undefined;
1042
1042
  }>;
1043
1043
  foreignKeys: Record<string, {
1044
+ onUpdate?: string | undefined;
1045
+ onDelete?: string | undefined;
1044
1046
  name: string;
1045
1047
  tableFrom: string;
1046
1048
  columnsFrom: string[];
1047
1049
  tableTo: string;
1048
1050
  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").objectUtil.
1059
1059
  tables: Record<string, {
1060
1060
  name: string;
1061
1061
  columns: Record<string, {
1062
+ default?: any;
1063
+ autoincrement?: boolean | undefined;
1062
1064
  name: string;
1063
1065
  type: string;
1064
1066
  primaryKey: boolean;
1065
1067
  notNull: boolean;
1066
- default?: any;
1067
- autoincrement?: boolean | undefined;
1068
1068
  }>;
1069
1069
  indexes: Record<string, {
1070
+ where?: string | undefined;
1070
1071
  name: string;
1071
1072
  columns: string[];
1072
1073
  isUnique: boolean;
1073
- where?: string | undefined;
1074
1074
  }>;
1075
1075
  foreignKeys: Record<string, {
1076
+ onUpdate?: string | undefined;
1077
+ onDelete?: string | undefined;
1076
1078
  name: string;
1077
1079
  tableFrom: string;
1078
1080
  columnsFrom: string[];
1079
1081
  tableTo: string;
1080
1082
  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").objectUtil.
1088
1088
  dialect: "sqlite";
1089
1089
  enums: {};
1090
1090
  }>;
1091
- export declare const schemaV4: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
1091
+ export declare const schemaV4: import("zod").ZodObject<import("zod").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").objectUtil.
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;
1104
1106
  name: string;
1105
1107
  type: string;
1106
1108
  primaryKey: boolean;
1107
1109
  notNull: boolean;
1110
+ }, {
1108
1111
  default?: any;
1109
1112
  autoincrement?: boolean | undefined;
1110
- }, {
1111
1113
  name: string;
1112
1114
  type: string;
1113
1115
  primaryKey: boolean;
1114
1116
  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").objectUtil.
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;
1124
1125
  name: string;
1125
1126
  columns: string[];
1126
1127
  isUnique: boolean;
1127
- where?: string | undefined;
1128
1128
  }, {
1129
+ where?: string | undefined;
1129
1130
  name: string;
1130
1131
  columns: string[];
1131
1132
  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").objectUtil.
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;
1143
1145
  name: string;
1144
1146
  tableFrom: string;
1145
1147
  columnsFrom: string[];
1146
1148
  tableTo: string;
1147
1149
  columnsTo: string[];
1150
+ }, {
1148
1151
  onUpdate?: string | undefined;
1149
1152
  onDelete?: string | undefined;
1150
- }, {
1151
1153
  name: string;
1152
1154
  tableFrom: string;
1153
1155
  columnsFrom: string[];
1154
1156
  tableTo: string;
1155
1157
  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
- columns: string[];
1164
1163
  name?: string | undefined;
1165
- }, {
1166
1164
  columns: string[];
1165
+ }, {
1167
1166
  name?: string | undefined;
1167
+ columns: string[];
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").objectUtil.
1179
1179
  }, "strict", import("zod").ZodTypeAny, {
1180
1180
  name: string;
1181
1181
  columns: Record<string, {
1182
+ default?: any;
1183
+ autoincrement?: boolean | undefined;
1182
1184
  name: string;
1183
1185
  type: string;
1184
1186
  primaryKey: boolean;
1185
1187
  notNull: boolean;
1186
- default?: any;
1187
- autoincrement?: boolean | undefined;
1188
1188
  }>;
1189
1189
  indexes: Record<string, {
1190
+ where?: string | undefined;
1190
1191
  name: string;
1191
1192
  columns: string[];
1192
1193
  isUnique: boolean;
1193
- where?: string | undefined;
1194
1194
  }>;
1195
1195
  foreignKeys: Record<string, {
1196
+ onUpdate?: string | undefined;
1197
+ onDelete?: string | undefined;
1196
1198
  name: string;
1197
1199
  tableFrom: string;
1198
1200
  columnsFrom: string[];
1199
1201
  tableTo: string;
1200
1202
  columnsTo: string[];
1201
- onUpdate?: string | undefined;
1202
- onDelete?: string | undefined;
1203
1203
  }>;
1204
1204
  compositePrimaryKeys: Record<string, {
1205
- columns: string[];
1206
1205
  name?: string | undefined;
1206
+ columns: string[];
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;
1213
1217
  name: string;
1214
1218
  columns: Record<string, {
1219
+ default?: any;
1220
+ autoincrement?: boolean | undefined;
1215
1221
  name: string;
1216
1222
  type: string;
1217
1223
  primaryKey: boolean;
1218
1224
  notNull: boolean;
1219
- default?: any;
1220
- autoincrement?: boolean | undefined;
1221
1225
  }>;
1222
1226
  indexes: Record<string, {
1227
+ where?: string | undefined;
1223
1228
  name: string;
1224
1229
  columns: string[];
1225
1230
  isUnique: boolean;
1226
- where?: string | undefined;
1227
1231
  }>;
1228
1232
  foreignKeys: Record<string, {
1233
+ onUpdate?: string | undefined;
1234
+ onDelete?: string | undefined;
1229
1235
  name: string;
1230
1236
  tableFrom: string;
1231
1237
  columnsFrom: string[];
1232
1238
  tableTo: string;
1233
1239
  columnsTo: string[];
1234
- onUpdate?: string | undefined;
1235
- onDelete?: string | undefined;
1236
1240
  }>;
1237
1241
  compositePrimaryKeys: Record<string, {
1238
- columns: string[];
1239
1242
  name?: string | undefined;
1240
- }>;
1241
- uniqueConstraints?: Record<string, {
1242
- name: string;
1243
1243
  columns: string[];
1244
- }> | undefined;
1244
+ }>;
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").objectUtil.
1251
1251
  tables: Record<string, {
1252
1252
  name: string;
1253
1253
  columns: Record<string, {
1254
+ default?: any;
1255
+ autoincrement?: boolean | undefined;
1254
1256
  name: string;
1255
1257
  type: string;
1256
1258
  primaryKey: boolean;
1257
1259
  notNull: boolean;
1258
- default?: any;
1259
- autoincrement?: boolean | undefined;
1260
1260
  }>;
1261
1261
  indexes: Record<string, {
1262
+ where?: string | undefined;
1262
1263
  name: string;
1263
1264
  columns: string[];
1264
1265
  isUnique: boolean;
1265
- where?: string | undefined;
1266
1266
  }>;
1267
1267
  foreignKeys: Record<string, {
1268
+ onUpdate?: string | undefined;
1269
+ onDelete?: string | undefined;
1268
1270
  name: string;
1269
1271
  tableFrom: string;
1270
1272
  columnsFrom: string[];
1271
1273
  tableTo: string;
1272
1274
  columnsTo: string[];
1273
- onUpdate?: string | undefined;
1274
- onDelete?: string | undefined;
1275
1275
  }>;
1276
1276
  compositePrimaryKeys: Record<string, {
1277
- columns: string[];
1278
1277
  name?: string | undefined;
1278
+ columns: string[];
1279
1279
  }>;
1280
1280
  uniqueConstraints: Record<string, {
1281
1281
  name: string;
@@ -1289,38 +1289,38 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").objectUtil.
1289
1289
  enums: {};
1290
1290
  }, {
1291
1291
  tables: Record<string, {
1292
+ uniqueConstraints?: Record<string, {
1293
+ name: string;
1294
+ columns: string[];
1295
+ }> | undefined;
1292
1296
  name: string;
1293
1297
  columns: Record<string, {
1298
+ default?: any;
1299
+ autoincrement?: boolean | undefined;
1294
1300
  name: string;
1295
1301
  type: string;
1296
1302
  primaryKey: boolean;
1297
1303
  notNull: boolean;
1298
- default?: any;
1299
- autoincrement?: boolean | undefined;
1300
1304
  }>;
1301
1305
  indexes: Record<string, {
1306
+ where?: string | undefined;
1302
1307
  name: string;
1303
1308
  columns: string[];
1304
1309
  isUnique: boolean;
1305
- where?: string | undefined;
1306
1310
  }>;
1307
1311
  foreignKeys: Record<string, {
1312
+ onUpdate?: string | undefined;
1313
+ onDelete?: string | undefined;
1308
1314
  name: string;
1309
1315
  tableFrom: string;
1310
1316
  columnsFrom: string[];
1311
1317
  tableTo: string;
1312
1318
  columnsTo: string[];
1313
- onUpdate?: string | undefined;
1314
- onDelete?: string | undefined;
1315
1319
  }>;
1316
1320
  compositePrimaryKeys: Record<string, {
1317
- columns: string[];
1318
1321
  name?: string | undefined;
1319
- }>;
1320
- uniqueConstraints?: Record<string, {
1321
- name: string;
1322
1322
  columns: string[];
1323
- }> | undefined;
1323
+ }>;
1324
1324
  }>;
1325
1325
  id: string;
1326
1326
  prevId: string;
@@ -1328,7 +1328,7 @@ export declare const schemaV4: import("zod").ZodObject<import("zod").objectUtil.
1328
1328
  dialect: "sqlite";
1329
1329
  enums: {};
1330
1330
  }>;
1331
- export declare const schema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
1331
+ export declare const schema: import("zod").ZodObject<import("zod").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").objectUtil.ex
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;
1344
1346
  name: string;
1345
1347
  type: string;
1346
1348
  primaryKey: boolean;
1347
1349
  notNull: boolean;
1350
+ }, {
1348
1351
  default?: any;
1349
1352
  autoincrement?: boolean | undefined;
1350
- }, {
1351
1353
  name: string;
1352
1354
  type: string;
1353
1355
  primaryKey: boolean;
1354
1356
  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").objectUtil.ex
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;
1364
1365
  name: string;
1365
1366
  columns: string[];
1366
1367
  isUnique: boolean;
1367
- where?: string | undefined;
1368
1368
  }, {
1369
+ where?: string | undefined;
1369
1370
  name: string;
1370
1371
  columns: string[];
1371
1372
  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").objectUtil.ex
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;
1383
1385
  name: string;
1384
1386
  tableFrom: string;
1385
1387
  columnsFrom: string[];
1386
1388
  tableTo: string;
1387
1389
  columnsTo: string[];
1390
+ }, {
1388
1391
  onUpdate?: string | undefined;
1389
1392
  onDelete?: string | undefined;
1390
- }, {
1391
1393
  name: string;
1392
1394
  tableFrom: string;
1393
1395
  columnsFrom: string[];
1394
1396
  tableTo: string;
1395
1397
  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
- columns: string[];
1404
1403
  name?: string | undefined;
1405
- }, {
1406
1404
  columns: string[];
1405
+ }, {
1407
1406
  name?: string | undefined;
1407
+ columns: string[];
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").objectUtil.ex
1419
1419
  }, "strict", import("zod").ZodTypeAny, {
1420
1420
  name: string;
1421
1421
  columns: Record<string, {
1422
+ default?: any;
1423
+ autoincrement?: boolean | undefined;
1422
1424
  name: string;
1423
1425
  type: string;
1424
1426
  primaryKey: boolean;
1425
1427
  notNull: boolean;
1426
- default?: any;
1427
- autoincrement?: boolean | undefined;
1428
1428
  }>;
1429
1429
  indexes: Record<string, {
1430
+ where?: string | undefined;
1430
1431
  name: string;
1431
1432
  columns: string[];
1432
1433
  isUnique: boolean;
1433
- where?: string | undefined;
1434
1434
  }>;
1435
1435
  foreignKeys: Record<string, {
1436
+ onUpdate?: string | undefined;
1437
+ onDelete?: string | undefined;
1436
1438
  name: string;
1437
1439
  tableFrom: string;
1438
1440
  columnsFrom: string[];
1439
1441
  tableTo: string;
1440
1442
  columnsTo: string[];
1441
- onUpdate?: string | undefined;
1442
- onDelete?: string | undefined;
1443
1443
  }>;
1444
1444
  compositePrimaryKeys: Record<string, {
1445
- columns: string[];
1446
1445
  name?: string | undefined;
1446
+ columns: string[];
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;
1453
1457
  name: string;
1454
1458
  columns: Record<string, {
1459
+ default?: any;
1460
+ autoincrement?: boolean | undefined;
1455
1461
  name: string;
1456
1462
  type: string;
1457
1463
  primaryKey: boolean;
1458
1464
  notNull: boolean;
1459
- default?: any;
1460
- autoincrement?: boolean | undefined;
1461
1465
  }>;
1462
1466
  indexes: Record<string, {
1467
+ where?: string | undefined;
1463
1468
  name: string;
1464
1469
  columns: string[];
1465
1470
  isUnique: boolean;
1466
- where?: string | undefined;
1467
1471
  }>;
1468
1472
  foreignKeys: Record<string, {
1473
+ onUpdate?: string | undefined;
1474
+ onDelete?: string | undefined;
1469
1475
  name: string;
1470
1476
  tableFrom: string;
1471
1477
  columnsFrom: string[];
1472
1478
  tableTo: string;
1473
1479
  columnsTo: string[];
1474
- onUpdate?: string | undefined;
1475
- onDelete?: string | undefined;
1476
1480
  }>;
1477
1481
  compositePrimaryKeys: Record<string, {
1478
- columns: string[];
1479
1482
  name?: string | undefined;
1480
- }>;
1481
- uniqueConstraints?: Record<string, {
1482
- name: string;
1483
1483
  columns: string[];
1484
- }> | undefined;
1484
+ }>;
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").objectUtil.ex
1501
1501
  tables: Record<string, {
1502
1502
  name: string;
1503
1503
  columns: Record<string, {
1504
+ default?: any;
1505
+ autoincrement?: boolean | undefined;
1504
1506
  name: string;
1505
1507
  type: string;
1506
1508
  primaryKey: boolean;
1507
1509
  notNull: boolean;
1508
- default?: any;
1509
- autoincrement?: boolean | undefined;
1510
1510
  }>;
1511
1511
  indexes: Record<string, {
1512
+ where?: string | undefined;
1512
1513
  name: string;
1513
1514
  columns: string[];
1514
1515
  isUnique: boolean;
1515
- where?: string | undefined;
1516
1516
  }>;
1517
1517
  foreignKeys: Record<string, {
1518
+ onUpdate?: string | undefined;
1519
+ onDelete?: string | undefined;
1518
1520
  name: string;
1519
1521
  tableFrom: string;
1520
1522
  columnsFrom: string[];
1521
1523
  tableTo: string;
1522
1524
  columnsTo: string[];
1523
- onUpdate?: string | undefined;
1524
- onDelete?: string | undefined;
1525
1525
  }>;
1526
1526
  compositePrimaryKeys: Record<string, {
1527
- columns: string[];
1528
1527
  name?: string | undefined;
1528
+ columns: string[];
1529
1529
  }>;
1530
1530
  uniqueConstraints: Record<string, {
1531
1531
  name: string;
@@ -1543,38 +1543,38 @@ export declare const schema: import("zod").ZodObject<import("zod").objectUtil.ex
1543
1543
  enums: {};
1544
1544
  }, {
1545
1545
  tables: Record<string, {
1546
+ uniqueConstraints?: Record<string, {
1547
+ name: string;
1548
+ columns: string[];
1549
+ }> | undefined;
1546
1550
  name: string;
1547
1551
  columns: Record<string, {
1552
+ default?: any;
1553
+ autoincrement?: boolean | undefined;
1548
1554
  name: string;
1549
1555
  type: string;
1550
1556
  primaryKey: boolean;
1551
1557
  notNull: boolean;
1552
- default?: any;
1553
- autoincrement?: boolean | undefined;
1554
1558
  }>;
1555
1559
  indexes: Record<string, {
1560
+ where?: string | undefined;
1556
1561
  name: string;
1557
1562
  columns: string[];
1558
1563
  isUnique: boolean;
1559
- where?: string | undefined;
1560
1564
  }>;
1561
1565
  foreignKeys: Record<string, {
1566
+ onUpdate?: string | undefined;
1567
+ onDelete?: string | undefined;
1562
1568
  name: string;
1563
1569
  tableFrom: string;
1564
1570
  columnsFrom: string[];
1565
1571
  tableTo: string;
1566
1572
  columnsTo: string[];
1567
- onUpdate?: string | undefined;
1568
- onDelete?: string | undefined;
1569
1573
  }>;
1570
1574
  compositePrimaryKeys: Record<string, {
1571
- columns: string[];
1572
1575
  name?: string | undefined;
1573
- }>;
1574
- uniqueConstraints?: Record<string, {
1575
- name: string;
1576
1576
  columns: string[];
1577
- }> | undefined;
1577
+ }>;
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;
1602
1604
  name: string;
1603
1605
  type: string;
1604
1606
  primaryKey: boolean;
1605
1607
  notNull: boolean;
1608
+ }, {
1606
1609
  default?: any;
1607
1610
  autoincrement?: boolean | undefined;
1608
- }, {
1609
1611
  name: string;
1610
1612
  type: string;
1611
1613
  primaryKey: boolean;
1612
1614
  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,43 +1620,44 @@ 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;
1623
1625
  name: string;
1624
1626
  type: string;
1625
1627
  primaryKey: boolean;
1626
1628
  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;
1635
1636
  name: string;
1636
1637
  columns: Record<string, {
1638
+ default?: any;
1639
+ autoincrement?: boolean | undefined;
1637
1640
  name: string;
1638
1641
  type: string;
1639
1642
  primaryKey: boolean;
1640
1643
  notNull: boolean;
1641
- default?: any;
1642
- autoincrement?: boolean | undefined;
1643
1644
  }>;
1644
1645
  indexes: Record<string, string>;
1645
1646
  foreignKeys: Record<string, string>;
1646
1647
  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;
1651
1652
  tables: Record<string, {
1652
1653
  name: string;
1653
1654
  columns: Record<string, {
1655
+ default?: any;
1656
+ autoincrement?: boolean | undefined;
1654
1657
  name: string;
1655
1658
  type: string;
1656
1659
  primaryKey: boolean;
1657
1660
  notNull: boolean;
1658
- default?: any;
1659
- autoincrement?: boolean | undefined;
1660
1661
  }>;
1661
1662
  indexes: Record<string, string>;
1662
1663
  foreignKeys: Record<string, string>;
@@ -1665,26 +1666,25 @@ export declare const schemaSquashed: import("zod").ZodObject<{
1665
1666
  }>;
1666
1667
  version: "5";
1667
1668
  dialect: "sqlite";
1668
- enums?: any;
1669
1669
  }, {
1670
+ enums?: any;
1670
1671
  tables: Record<string, {
1672
+ uniqueConstraints?: Record<string, string> | undefined;
1671
1673
  name: string;
1672
1674
  columns: Record<string, {
1675
+ default?: any;
1676
+ autoincrement?: boolean | undefined;
1673
1677
  name: string;
1674
1678
  type: string;
1675
1679
  primaryKey: boolean;
1676
1680
  notNull: boolean;
1677
- default?: any;
1678
- autoincrement?: boolean | undefined;
1679
1681
  }>;
1680
1682
  indexes: Record<string, string>;
1681
1683
  foreignKeys: Record<string, string>;
1682
1684
  compositePrimaryKeys: Record<string, string>;
1683
- uniqueConstraints?: Record<string, string> | undefined;
1684
1685
  }>;
1685
1686
  version: "5";
1686
1687
  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;
1716
1718
  name: string;
1717
1719
  type: string;
1718
1720
  primaryKey: boolean;
1719
1721
  notNull: boolean;
1720
- default?: any;
1721
- autoincrement?: boolean | undefined;
1722
1722
  }>;
1723
1723
  indexes: Record<string, {
1724
+ where?: string | undefined;
1724
1725
  name: string;
1725
1726
  columns: string[];
1726
1727
  isUnique: boolean;
1727
- where?: string | undefined;
1728
1728
  }>;
1729
1729
  foreignKeys: Record<string, {
1730
+ onUpdate?: string | undefined;
1731
+ onDelete?: string | undefined;
1730
1732
  name: string;
1731
1733
  tableFrom: string;
1732
1734
  columnsFrom: string[];
1733
1735
  tableTo: string;
1734
1736
  columnsTo: string[];
1735
- onUpdate?: string | undefined;
1736
- onDelete?: string | undefined;
1737
1737
  }>;
1738
1738
  compositePrimaryKeys: Record<string, {
1739
- columns: string[];
1740
1739
  name?: string | undefined;
1740
+ columns: string[];
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").objectUtil.extendShape<{
1757
+ export declare const sqliteSchemaV3: import("zod").ZodObject<import("zod").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").objec
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;
1770
1772
  name: string;
1771
1773
  type: string;
1772
1774
  primaryKey: boolean;
1773
1775
  notNull: boolean;
1776
+ }, {
1774
1777
  default?: any;
1775
1778
  autoincrement?: boolean | undefined;
1776
- }, {
1777
1779
  name: string;
1778
1780
  type: string;
1779
1781
  primaryKey: boolean;
1780
1782
  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").objec
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;
1790
1791
  name: string;
1791
1792
  columns: string[];
1792
1793
  isUnique: boolean;
1793
- where?: string | undefined;
1794
1794
  }, {
1795
+ where?: string | undefined;
1795
1796
  name: string;
1796
1797
  columns: string[];
1797
1798
  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").objec
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;
1809
1811
  name: string;
1810
1812
  tableFrom: string;
1811
1813
  columnsFrom: string[];
1812
1814
  tableTo: string;
1813
1815
  columnsTo: string[];
1816
+ }, {
1814
1817
  onUpdate?: string | undefined;
1815
1818
  onDelete?: string | undefined;
1816
- }, {
1817
1819
  name: string;
1818
1820
  tableFrom: string;
1819
1821
  columnsFrom: string[];
1820
1822
  tableTo: string;
1821
1823
  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;
1828
1830
  name: string;
1829
1831
  type: string;
1830
1832
  primaryKey: boolean;
1831
1833
  notNull: boolean;
1832
- default?: any;
1833
- autoincrement?: boolean | undefined;
1834
1834
  }>;
1835
1835
  indexes: Record<string, {
1836
+ where?: string | undefined;
1836
1837
  name: string;
1837
1838
  columns: string[];
1838
1839
  isUnique: boolean;
1839
- where?: string | undefined;
1840
1840
  }>;
1841
1841
  foreignKeys: Record<string, {
1842
+ onUpdate?: string | undefined;
1843
+ onDelete?: string | undefined;
1842
1844
  name: string;
1843
1845
  tableFrom: string;
1844
1846
  columnsFrom: string[];
1845
1847
  tableTo: string;
1846
1848
  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;
1853
1855
  name: string;
1854
1856
  type: string;
1855
1857
  primaryKey: boolean;
1856
1858
  notNull: boolean;
1857
- default?: any;
1858
- autoincrement?: boolean | undefined;
1859
1859
  }>;
1860
1860
  indexes: Record<string, {
1861
+ where?: string | undefined;
1861
1862
  name: string;
1862
1863
  columns: string[];
1863
1864
  isUnique: boolean;
1864
- where?: string | undefined;
1865
1865
  }>;
1866
1866
  foreignKeys: Record<string, {
1867
+ onUpdate?: string | undefined;
1868
+ onDelete?: string | undefined;
1867
1869
  name: string;
1868
1870
  tableFrom: string;
1869
1871
  columnsFrom: string[];
1870
1872
  tableTo: string;
1871
1873
  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").objec
1881
1881
  tables: Record<string, {
1882
1882
  name: string;
1883
1883
  columns: Record<string, {
1884
+ default?: any;
1885
+ autoincrement?: boolean | undefined;
1884
1886
  name: string;
1885
1887
  type: string;
1886
1888
  primaryKey: boolean;
1887
1889
  notNull: boolean;
1888
- default?: any;
1889
- autoincrement?: boolean | undefined;
1890
1890
  }>;
1891
1891
  indexes: Record<string, {
1892
+ where?: string | undefined;
1892
1893
  name: string;
1893
1894
  columns: string[];
1894
1895
  isUnique: boolean;
1895
- where?: string | undefined;
1896
1896
  }>;
1897
1897
  foreignKeys: Record<string, {
1898
+ onUpdate?: string | undefined;
1899
+ onDelete?: string | undefined;
1898
1900
  name: string;
1899
1901
  tableFrom: string;
1900
1902
  columnsFrom: string[];
1901
1903
  tableTo: string;
1902
1904
  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").objec
1913
1913
  tables: Record<string, {
1914
1914
  name: string;
1915
1915
  columns: Record<string, {
1916
+ default?: any;
1917
+ autoincrement?: boolean | undefined;
1916
1918
  name: string;
1917
1919
  type: string;
1918
1920
  primaryKey: boolean;
1919
1921
  notNull: boolean;
1920
- default?: any;
1921
- autoincrement?: boolean | undefined;
1922
1922
  }>;
1923
1923
  indexes: Record<string, {
1924
+ where?: string | undefined;
1924
1925
  name: string;
1925
1926
  columns: string[];
1926
1927
  isUnique: boolean;
1927
- where?: string | undefined;
1928
1928
  }>;
1929
1929
  foreignKeys: Record<string, {
1930
+ onUpdate?: string | undefined;
1931
+ onDelete?: string | undefined;
1930
1932
  name: string;
1931
1933
  tableFrom: string;
1932
1934
  columnsFrom: string[];
1933
1935
  tableTo: string;
1934
1936
  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").objec
1942
1942
  dialect: "sqlite";
1943
1943
  enums: {};
1944
1944
  }>;
1945
- export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
1945
+ export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").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").objec
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;
1958
1960
  name: string;
1959
1961
  type: string;
1960
1962
  primaryKey: boolean;
1961
1963
  notNull: boolean;
1964
+ }, {
1962
1965
  default?: any;
1963
1966
  autoincrement?: boolean | undefined;
1964
- }, {
1965
1967
  name: string;
1966
1968
  type: string;
1967
1969
  primaryKey: boolean;
1968
1970
  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").objec
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;
1978
1979
  name: string;
1979
1980
  columns: string[];
1980
1981
  isUnique: boolean;
1981
- where?: string | undefined;
1982
1982
  }, {
1983
+ where?: string | undefined;
1983
1984
  name: string;
1984
1985
  columns: string[];
1985
1986
  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").objec
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;
1997
1999
  name: string;
1998
2000
  tableFrom: string;
1999
2001
  columnsFrom: string[];
2000
2002
  tableTo: string;
2001
2003
  columnsTo: string[];
2004
+ }, {
2002
2005
  onUpdate?: string | undefined;
2003
2006
  onDelete?: string | undefined;
2004
- }, {
2005
2007
  name: string;
2006
2008
  tableFrom: string;
2007
2009
  columnsFrom: string[];
2008
2010
  tableTo: string;
2009
2011
  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
- columns: string[];
2018
2017
  name?: string | undefined;
2019
- }, {
2020
2018
  columns: string[];
2019
+ }, {
2021
2020
  name?: string | undefined;
2021
+ columns: string[];
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").objec
2033
2033
  }, "strict", import("zod").ZodTypeAny, {
2034
2034
  name: string;
2035
2035
  columns: Record<string, {
2036
+ default?: any;
2037
+ autoincrement?: boolean | undefined;
2036
2038
  name: string;
2037
2039
  type: string;
2038
2040
  primaryKey: boolean;
2039
2041
  notNull: boolean;
2040
- default?: any;
2041
- autoincrement?: boolean | undefined;
2042
2042
  }>;
2043
2043
  indexes: Record<string, {
2044
+ where?: string | undefined;
2044
2045
  name: string;
2045
2046
  columns: string[];
2046
2047
  isUnique: boolean;
2047
- where?: string | undefined;
2048
2048
  }>;
2049
2049
  foreignKeys: Record<string, {
2050
+ onUpdate?: string | undefined;
2051
+ onDelete?: string | undefined;
2050
2052
  name: string;
2051
2053
  tableFrom: string;
2052
2054
  columnsFrom: string[];
2053
2055
  tableTo: string;
2054
2056
  columnsTo: string[];
2055
- onUpdate?: string | undefined;
2056
- onDelete?: string | undefined;
2057
2057
  }>;
2058
2058
  compositePrimaryKeys: Record<string, {
2059
- columns: string[];
2060
2059
  name?: string | undefined;
2060
+ columns: string[];
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;
2067
2071
  name: string;
2068
2072
  columns: Record<string, {
2073
+ default?: any;
2074
+ autoincrement?: boolean | undefined;
2069
2075
  name: string;
2070
2076
  type: string;
2071
2077
  primaryKey: boolean;
2072
2078
  notNull: boolean;
2073
- default?: any;
2074
- autoincrement?: boolean | undefined;
2075
2079
  }>;
2076
2080
  indexes: Record<string, {
2081
+ where?: string | undefined;
2077
2082
  name: string;
2078
2083
  columns: string[];
2079
2084
  isUnique: boolean;
2080
- where?: string | undefined;
2081
2085
  }>;
2082
2086
  foreignKeys: Record<string, {
2087
+ onUpdate?: string | undefined;
2088
+ onDelete?: string | undefined;
2083
2089
  name: string;
2084
2090
  tableFrom: string;
2085
2091
  columnsFrom: string[];
2086
2092
  tableTo: string;
2087
2093
  columnsTo: string[];
2088
- onUpdate?: string | undefined;
2089
- onDelete?: string | undefined;
2090
2094
  }>;
2091
2095
  compositePrimaryKeys: Record<string, {
2092
- columns: string[];
2093
2096
  name?: string | undefined;
2094
- }>;
2095
- uniqueConstraints?: Record<string, {
2096
- name: string;
2097
2097
  columns: string[];
2098
- }> | undefined;
2098
+ }>;
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").objec
2105
2105
  tables: Record<string, {
2106
2106
  name: string;
2107
2107
  columns: Record<string, {
2108
+ default?: any;
2109
+ autoincrement?: boolean | undefined;
2108
2110
  name: string;
2109
2111
  type: string;
2110
2112
  primaryKey: boolean;
2111
2113
  notNull: boolean;
2112
- default?: any;
2113
- autoincrement?: boolean | undefined;
2114
2114
  }>;
2115
2115
  indexes: Record<string, {
2116
+ where?: string | undefined;
2116
2117
  name: string;
2117
2118
  columns: string[];
2118
2119
  isUnique: boolean;
2119
- where?: string | undefined;
2120
2120
  }>;
2121
2121
  foreignKeys: Record<string, {
2122
+ onUpdate?: string | undefined;
2123
+ onDelete?: string | undefined;
2122
2124
  name: string;
2123
2125
  tableFrom: string;
2124
2126
  columnsFrom: string[];
2125
2127
  tableTo: string;
2126
2128
  columnsTo: string[];
2127
- onUpdate?: string | undefined;
2128
- onDelete?: string | undefined;
2129
2129
  }>;
2130
2130
  compositePrimaryKeys: Record<string, {
2131
- columns: string[];
2132
2131
  name?: string | undefined;
2132
+ columns: string[];
2133
2133
  }>;
2134
2134
  uniqueConstraints: Record<string, {
2135
2135
  name: string;
@@ -2143,38 +2143,38 @@ export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").objec
2143
2143
  enums: {};
2144
2144
  }, {
2145
2145
  tables: Record<string, {
2146
+ uniqueConstraints?: Record<string, {
2147
+ name: string;
2148
+ columns: string[];
2149
+ }> | undefined;
2146
2150
  name: string;
2147
2151
  columns: Record<string, {
2152
+ default?: any;
2153
+ autoincrement?: boolean | undefined;
2148
2154
  name: string;
2149
2155
  type: string;
2150
2156
  primaryKey: boolean;
2151
2157
  notNull: boolean;
2152
- default?: any;
2153
- autoincrement?: boolean | undefined;
2154
2158
  }>;
2155
2159
  indexes: Record<string, {
2160
+ where?: string | undefined;
2156
2161
  name: string;
2157
2162
  columns: string[];
2158
2163
  isUnique: boolean;
2159
- where?: string | undefined;
2160
2164
  }>;
2161
2165
  foreignKeys: Record<string, {
2166
+ onUpdate?: string | undefined;
2167
+ onDelete?: string | undefined;
2162
2168
  name: string;
2163
2169
  tableFrom: string;
2164
2170
  columnsFrom: string[];
2165
2171
  tableTo: string;
2166
2172
  columnsTo: string[];
2167
- onUpdate?: string | undefined;
2168
- onDelete?: string | undefined;
2169
2173
  }>;
2170
2174
  compositePrimaryKeys: Record<string, {
2171
- columns: string[];
2172
2175
  name?: string | undefined;
2173
- }>;
2174
- uniqueConstraints?: Record<string, {
2175
- name: string;
2176
2176
  columns: string[];
2177
- }> | undefined;
2177
+ }>;
2178
2178
  }>;
2179
2179
  id: string;
2180
2180
  prevId: string;
@@ -2182,7 +2182,7 @@ export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").objec
2182
2182
  dialect: "sqlite";
2183
2183
  enums: {};
2184
2184
  }>;
2185
- export declare const sqliteSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
2185
+ export declare const sqliteSchema: import("zod").ZodObject<import("zod").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").objectU
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;
2198
2200
  name: string;
2199
2201
  type: string;
2200
2202
  primaryKey: boolean;
2201
2203
  notNull: boolean;
2204
+ }, {
2202
2205
  default?: any;
2203
2206
  autoincrement?: boolean | undefined;
2204
- }, {
2205
2207
  name: string;
2206
2208
  type: string;
2207
2209
  primaryKey: boolean;
2208
2210
  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").objectU
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;
2218
2219
  name: string;
2219
2220
  columns: string[];
2220
2221
  isUnique: boolean;
2221
- where?: string | undefined;
2222
2222
  }, {
2223
+ where?: string | undefined;
2223
2224
  name: string;
2224
2225
  columns: string[];
2225
2226
  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").objectU
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;
2237
2239
  name: string;
2238
2240
  tableFrom: string;
2239
2241
  columnsFrom: string[];
2240
2242
  tableTo: string;
2241
2243
  columnsTo: string[];
2244
+ }, {
2242
2245
  onUpdate?: string | undefined;
2243
2246
  onDelete?: string | undefined;
2244
- }, {
2245
2247
  name: string;
2246
2248
  tableFrom: string;
2247
2249
  columnsFrom: string[];
2248
2250
  tableTo: string;
2249
2251
  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
- columns: string[];
2258
2257
  name?: string | undefined;
2259
- }, {
2260
2258
  columns: string[];
2259
+ }, {
2261
2260
  name?: string | undefined;
2261
+ columns: string[];
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").objectU
2273
2273
  }, "strict", import("zod").ZodTypeAny, {
2274
2274
  name: string;
2275
2275
  columns: Record<string, {
2276
+ default?: any;
2277
+ autoincrement?: boolean | undefined;
2276
2278
  name: string;
2277
2279
  type: string;
2278
2280
  primaryKey: boolean;
2279
2281
  notNull: boolean;
2280
- default?: any;
2281
- autoincrement?: boolean | undefined;
2282
2282
  }>;
2283
2283
  indexes: Record<string, {
2284
+ where?: string | undefined;
2284
2285
  name: string;
2285
2286
  columns: string[];
2286
2287
  isUnique: boolean;
2287
- where?: string | undefined;
2288
2288
  }>;
2289
2289
  foreignKeys: Record<string, {
2290
+ onUpdate?: string | undefined;
2291
+ onDelete?: string | undefined;
2290
2292
  name: string;
2291
2293
  tableFrom: string;
2292
2294
  columnsFrom: string[];
2293
2295
  tableTo: string;
2294
2296
  columnsTo: string[];
2295
- onUpdate?: string | undefined;
2296
- onDelete?: string | undefined;
2297
2297
  }>;
2298
2298
  compositePrimaryKeys: Record<string, {
2299
- columns: string[];
2300
2299
  name?: string | undefined;
2300
+ columns: string[];
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;
2307
2311
  name: string;
2308
2312
  columns: Record<string, {
2313
+ default?: any;
2314
+ autoincrement?: boolean | undefined;
2309
2315
  name: string;
2310
2316
  type: string;
2311
2317
  primaryKey: boolean;
2312
2318
  notNull: boolean;
2313
- default?: any;
2314
- autoincrement?: boolean | undefined;
2315
2319
  }>;
2316
2320
  indexes: Record<string, {
2321
+ where?: string | undefined;
2317
2322
  name: string;
2318
2323
  columns: string[];
2319
2324
  isUnique: boolean;
2320
- where?: string | undefined;
2321
2325
  }>;
2322
2326
  foreignKeys: Record<string, {
2327
+ onUpdate?: string | undefined;
2328
+ onDelete?: string | undefined;
2323
2329
  name: string;
2324
2330
  tableFrom: string;
2325
2331
  columnsFrom: string[];
2326
2332
  tableTo: string;
2327
2333
  columnsTo: string[];
2328
- onUpdate?: string | undefined;
2329
- onDelete?: string | undefined;
2330
2334
  }>;
2331
2335
  compositePrimaryKeys: Record<string, {
2332
- columns: string[];
2333
2336
  name?: string | undefined;
2334
- }>;
2335
- uniqueConstraints?: Record<string, {
2336
- name: string;
2337
2337
  columns: string[];
2338
- }> | undefined;
2338
+ }>;
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").objectU
2355
2355
  tables: Record<string, {
2356
2356
  name: string;
2357
2357
  columns: Record<string, {
2358
+ default?: any;
2359
+ autoincrement?: boolean | undefined;
2358
2360
  name: string;
2359
2361
  type: string;
2360
2362
  primaryKey: boolean;
2361
2363
  notNull: boolean;
2362
- default?: any;
2363
- autoincrement?: boolean | undefined;
2364
2364
  }>;
2365
2365
  indexes: Record<string, {
2366
+ where?: string | undefined;
2366
2367
  name: string;
2367
2368
  columns: string[];
2368
2369
  isUnique: boolean;
2369
- where?: string | undefined;
2370
2370
  }>;
2371
2371
  foreignKeys: Record<string, {
2372
+ onUpdate?: string | undefined;
2373
+ onDelete?: string | undefined;
2372
2374
  name: string;
2373
2375
  tableFrom: string;
2374
2376
  columnsFrom: string[];
2375
2377
  tableTo: string;
2376
2378
  columnsTo: string[];
2377
- onUpdate?: string | undefined;
2378
- onDelete?: string | undefined;
2379
2379
  }>;
2380
2380
  compositePrimaryKeys: Record<string, {
2381
- columns: string[];
2382
2381
  name?: string | undefined;
2382
+ columns: string[];
2383
2383
  }>;
2384
2384
  uniqueConstraints: Record<string, {
2385
2385
  name: string;
@@ -2397,38 +2397,38 @@ export declare const sqliteSchema: import("zod").ZodObject<import("zod").objectU
2397
2397
  enums: {};
2398
2398
  }, {
2399
2399
  tables: Record<string, {
2400
+ uniqueConstraints?: Record<string, {
2401
+ name: string;
2402
+ columns: string[];
2403
+ }> | undefined;
2400
2404
  name: string;
2401
2405
  columns: Record<string, {
2406
+ default?: any;
2407
+ autoincrement?: boolean | undefined;
2402
2408
  name: string;
2403
2409
  type: string;
2404
2410
  primaryKey: boolean;
2405
2411
  notNull: boolean;
2406
- default?: any;
2407
- autoincrement?: boolean | undefined;
2408
2412
  }>;
2409
2413
  indexes: Record<string, {
2414
+ where?: string | undefined;
2410
2415
  name: string;
2411
2416
  columns: string[];
2412
2417
  isUnique: boolean;
2413
- where?: string | undefined;
2414
2418
  }>;
2415
2419
  foreignKeys: Record<string, {
2420
+ onUpdate?: string | undefined;
2421
+ onDelete?: string | undefined;
2416
2422
  name: string;
2417
2423
  tableFrom: string;
2418
2424
  columnsFrom: string[];
2419
2425
  tableTo: string;
2420
2426
  columnsTo: string[];
2421
- onUpdate?: string | undefined;
2422
- onDelete?: string | undefined;
2423
2427
  }>;
2424
2428
  compositePrimaryKeys: Record<string, {
2425
- columns: string[];
2426
2429
  name?: string | undefined;
2427
- }>;
2428
- uniqueConstraints?: Record<string, {
2429
- name: string;
2430
2430
  columns: string[];
2431
- }> | undefined;
2431
+ }>;
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;
2456
2458
  name: string;
2457
2459
  type: string;
2458
2460
  primaryKey: boolean;
2459
2461
  notNull: boolean;
2462
+ }, {
2460
2463
  default?: any;
2461
2464
  autoincrement?: boolean | undefined;
2462
- }, {
2463
2465
  name: string;
2464
2466
  type: string;
2465
2467
  primaryKey: boolean;
2466
2468
  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,43 +2474,44 @@ 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;
2477
2479
  name: string;
2478
2480
  type: string;
2479
2481
  primaryKey: boolean;
2480
2482
  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;
2489
2490
  name: string;
2490
2491
  columns: Record<string, {
2492
+ default?: any;
2493
+ autoincrement?: boolean | undefined;
2491
2494
  name: string;
2492
2495
  type: string;
2493
2496
  primaryKey: boolean;
2494
2497
  notNull: boolean;
2495
- default?: any;
2496
- autoincrement?: boolean | undefined;
2497
2498
  }>;
2498
2499
  indexes: Record<string, string>;
2499
2500
  foreignKeys: Record<string, string>;
2500
2501
  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;
2505
2506
  tables: Record<string, {
2506
2507
  name: string;
2507
2508
  columns: Record<string, {
2509
+ default?: any;
2510
+ autoincrement?: boolean | undefined;
2508
2511
  name: string;
2509
2512
  type: string;
2510
2513
  primaryKey: boolean;
2511
2514
  notNull: boolean;
2512
- default?: any;
2513
- autoincrement?: boolean | undefined;
2514
2515
  }>;
2515
2516
  indexes: Record<string, string>;
2516
2517
  foreignKeys: Record<string, string>;
@@ -2519,28 +2520,27 @@ export declare const SQLiteSchemaSquashed: import("zod").ZodObject<{
2519
2520
  }>;
2520
2521
  version: "5";
2521
2522
  dialect: "sqlite";
2522
- enums?: any;
2523
2523
  }, {
2524
+ enums?: any;
2524
2525
  tables: Record<string, {
2526
+ uniqueConstraints?: Record<string, string> | undefined;
2525
2527
  name: string;
2526
2528
  columns: Record<string, {
2529
+ default?: any;
2530
+ autoincrement?: boolean | undefined;
2527
2531
  name: string;
2528
2532
  type: string;
2529
2533
  primaryKey: boolean;
2530
2534
  notNull: boolean;
2531
- default?: any;
2532
- autoincrement?: boolean | undefined;
2533
2535
  }>;
2534
2536
  indexes: Record<string, string>;
2535
2537
  foreignKeys: Record<string, string>;
2536
2538
  compositePrimaryKeys: Record<string, string>;
2537
- uniqueConstraints?: Record<string, string> | undefined;
2538
2539
  }>;
2539
2540
  version: "5";
2540
2541
  dialect: "sqlite";
2541
- enums?: any;
2542
2542
  }>;
2543
- export declare const backwardCompatibleSqliteSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
2543
+ export declare const backwardCompatibleSqliteSchema: import("zod").ZodObject<import("zod").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;
2556
2558
  name: string;
2557
2559
  type: string;
2558
2560
  primaryKey: boolean;
2559
2561
  notNull: boolean;
2562
+ }, {
2560
2563
  default?: any;
2561
2564
  autoincrement?: boolean | undefined;
2562
- }, {
2563
2565
  name: string;
2564
2566
  type: string;
2565
2567
  primaryKey: boolean;
2566
2568
  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;
2576
2577
  name: string;
2577
2578
  columns: string[];
2578
2579
  isUnique: boolean;
2579
- where?: string | undefined;
2580
2580
  }, {
2581
+ where?: string | undefined;
2581
2582
  name: string;
2582
2583
  columns: string[];
2583
2584
  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;
2595
2597
  name: string;
2596
2598
  tableFrom: string;
2597
2599
  columnsFrom: string[];
2598
2600
  tableTo: string;
2599
2601
  columnsTo: string[];
2602
+ }, {
2600
2603
  onUpdate?: string | undefined;
2601
2604
  onDelete?: string | undefined;
2602
- }, {
2603
2605
  name: string;
2604
2606
  tableFrom: string;
2605
2607
  columnsFrom: string[];
2606
2608
  tableTo: string;
2607
2609
  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
- columns: string[];
2616
2615
  name?: string | undefined;
2617
- }, {
2618
2616
  columns: string[];
2617
+ }, {
2619
2618
  name?: string | undefined;
2619
+ columns: string[];
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;
2634
2636
  name: string;
2635
2637
  type: string;
2636
2638
  primaryKey: boolean;
2637
2639
  notNull: boolean;
2638
- default?: any;
2639
- autoincrement?: boolean | undefined;
2640
2640
  }>;
2641
2641
  indexes: Record<string, {
2642
+ where?: string | undefined;
2642
2643
  name: string;
2643
2644
  columns: string[];
2644
2645
  isUnique: boolean;
2645
- where?: string | undefined;
2646
2646
  }>;
2647
2647
  foreignKeys: Record<string, {
2648
+ onUpdate?: string | undefined;
2649
+ onDelete?: string | undefined;
2648
2650
  name: string;
2649
2651
  tableFrom: string;
2650
2652
  columnsFrom: string[];
2651
2653
  tableTo: string;
2652
2654
  columnsTo: string[];
2653
- onUpdate?: string | undefined;
2654
- onDelete?: string | undefined;
2655
2655
  }>;
2656
2656
  compositePrimaryKeys: Record<string, {
2657
- columns: string[];
2658
2657
  name?: string | undefined;
2658
+ columns: string[];
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;
2665
2669
  name: string;
2666
2670
  columns: Record<string, {
2671
+ default?: any;
2672
+ autoincrement?: boolean | undefined;
2667
2673
  name: string;
2668
2674
  type: string;
2669
2675
  primaryKey: boolean;
2670
2676
  notNull: boolean;
2671
- default?: any;
2672
- autoincrement?: boolean | undefined;
2673
2677
  }>;
2674
2678
  indexes: Record<string, {
2679
+ where?: string | undefined;
2675
2680
  name: string;
2676
2681
  columns: string[];
2677
2682
  isUnique: boolean;
2678
- where?: string | undefined;
2679
2683
  }>;
2680
2684
  foreignKeys: Record<string, {
2685
+ onUpdate?: string | undefined;
2686
+ onDelete?: string | undefined;
2681
2687
  name: string;
2682
2688
  tableFrom: string;
2683
2689
  columnsFrom: string[];
2684
2690
  tableTo: string;
2685
2691
  columnsTo: string[];
2686
- onUpdate?: string | undefined;
2687
- onDelete?: string | undefined;
2688
2692
  }>;
2689
2693
  compositePrimaryKeys: Record<string, {
2690
- columns: string[];
2691
2694
  name?: string | undefined;
2692
- }>;
2693
- uniqueConstraints?: Record<string, {
2694
- name: string;
2695
2695
  columns: string[];
2696
- }> | undefined;
2696
+ }>;
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;
2716
2718
  name: string;
2717
2719
  type: string;
2718
2720
  primaryKey: boolean;
2719
2721
  notNull: boolean;
2720
- default?: any;
2721
- autoincrement?: boolean | undefined;
2722
2722
  }>;
2723
2723
  indexes: Record<string, {
2724
+ where?: string | undefined;
2724
2725
  name: string;
2725
2726
  columns: string[];
2726
2727
  isUnique: boolean;
2727
- where?: string | undefined;
2728
2728
  }>;
2729
2729
  foreignKeys: Record<string, {
2730
+ onUpdate?: string | undefined;
2731
+ onDelete?: string | undefined;
2730
2732
  name: string;
2731
2733
  tableFrom: string;
2732
2734
  columnsFrom: string[];
2733
2735
  tableTo: string;
2734
2736
  columnsTo: string[];
2735
- onUpdate?: string | undefined;
2736
- onDelete?: string | undefined;
2737
2737
  }>;
2738
2738
  compositePrimaryKeys: Record<string, {
2739
- columns: string[];
2740
2739
  name?: string | undefined;
2740
+ columns: string[];
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;
2758
2762
  name: string;
2759
2763
  columns: Record<string, {
2764
+ default?: any;
2765
+ autoincrement?: boolean | undefined;
2760
2766
  name: string;
2761
2767
  type: string;
2762
2768
  primaryKey: boolean;
2763
2769
  notNull: boolean;
2764
- default?: any;
2765
- autoincrement?: boolean | undefined;
2766
2770
  }>;
2767
2771
  indexes: Record<string, {
2772
+ where?: string | undefined;
2768
2773
  name: string;
2769
2774
  columns: string[];
2770
2775
  isUnique: boolean;
2771
- where?: string | undefined;
2772
2776
  }>;
2773
2777
  foreignKeys: Record<string, {
2778
+ onUpdate?: string | undefined;
2779
+ onDelete?: string | undefined;
2774
2780
  name: string;
2775
2781
  tableFrom: string;
2776
2782
  columnsFrom: string[];
2777
2783
  tableTo: string;
2778
2784
  columnsTo: string[];
2779
- onUpdate?: string | undefined;
2780
- onDelete?: string | undefined;
2781
2785
  }>;
2782
2786
  compositePrimaryKeys: Record<string, {
2783
- columns: string[];
2784
2787
  name?: string | undefined;
2785
- }>;
2786
- uniqueConstraints?: Record<string, {
2787
- name: string;
2788
2788
  columns: string[];
2789
- }> | undefined;
2789
+ }>;
2790
2790
  }>;
2791
2791
  id: string;
2792
2792
  prevId: string;