drizzle-kit 0.20.17-4e262b7 → 0.20.17-7776aba

Sign up to get free protection for your applications and to get access to all the features.
Files changed (56) hide show
  1. package/bin.cjs +22248 -23435
  2. package/cli/commands/migrate.d.ts +135 -152
  3. package/cli/commands/mysqlIntrospect.d.ts +79 -15
  4. package/cli/commands/mysqlPushUtils.d.ts +8 -4
  5. package/cli/commands/mysqlUp.d.ts +4 -0
  6. package/cli/commands/pgConnect.d.ts +5 -0
  7. package/cli/commands/pgIntrospect.d.ts +76 -12
  8. package/cli/commands/pgPushUtils.d.ts +6 -3
  9. package/cli/commands/pgUp.d.ts +4 -0
  10. package/cli/commands/sqliteIntrospect.d.ts +29 -26
  11. package/cli/commands/sqlitePushUtils.d.ts +10 -4
  12. package/cli/commands/sqliteUtils.d.ts +162 -0
  13. package/cli/commands/upFolders.d.ts +27 -0
  14. package/cli/commands/utils.d.ts +255 -39
  15. package/cli/validations/common.d.ts +7 -208
  16. package/cli/validations/mysql.d.ts +337 -7
  17. package/cli/validations/outputs.d.ts +0 -1
  18. package/cli/validations/pg.d.ts +405 -4
  19. package/cli/views.d.ts +5 -7
  20. package/drivers/index.d.ts +39 -0
  21. package/global.d.ts +1 -3
  22. package/index.d.mts +6 -8
  23. package/index.d.ts +6 -8
  24. package/index.js +0 -1
  25. package/introspect-mysql.d.ts +9 -0
  26. package/introspect-pg.d.ts +12 -0
  27. package/introspect-sqlite.d.ts +2 -2
  28. package/jsonDiffer.d.ts +29 -14
  29. package/jsonStatements.d.ts +11 -38
  30. package/package.json +52 -24
  31. package/payload.d.mts +5 -5
  32. package/payload.d.ts +5 -5
  33. package/payload.js +24222 -26044
  34. package/payload.mjs +19956 -21767
  35. package/schemaValidator.d.ts +286 -289
  36. package/serializer/mysqlImports.d.ts +7 -3
  37. package/serializer/mysqlSchema.d.ts +1323 -2454
  38. package/serializer/mysqlSerializer.d.ts +6 -6
  39. package/serializer/pgImports.d.ts +2 -2
  40. package/serializer/pgSchema.d.ts +1283 -1742
  41. package/serializer/pgSerializer.d.ts +2 -2
  42. package/serializer/sqliteImports.d.ts +4 -2
  43. package/serializer/sqliteSchema.d.ts +979 -553
  44. package/serializer/sqliteSerializer.d.ts +4 -4
  45. package/snapshotsDiffer.d.ts +1209 -2486
  46. package/utils/words.d.ts +1 -1
  47. package/utils-studio.d.mts +1 -0
  48. package/utils-studio.d.ts +1 -0
  49. package/utils-studio.js +849 -7058
  50. package/utils-studio.mjs +829 -7035
  51. package/utils.d.ts +141 -14
  52. package/utils.js +7161 -4625
  53. package/utils.mjs +7121 -4585
  54. package/cli/utils.d.ts +0 -12
  55. package/cli/validations/cli.d.ts +0 -169
  56. package/cli/validations/sqlite.d.ts +0 -34
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,133 +287,133 @@ 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, {}, {}>;
358
358
  }, "strict", import("zod").ZodTypeAny, {
359
+ version: "3";
360
+ dialect: "sqlite";
359
361
  tables: Record<string, {
360
362
  name: string;
361
363
  columns: Record<string, {
364
+ default?: any;
365
+ autoincrement?: boolean | undefined;
362
366
  name: string;
363
367
  type: string;
364
368
  primaryKey: boolean;
365
369
  notNull: boolean;
366
- default?: any;
367
- autoincrement?: boolean | undefined;
368
370
  }>;
369
371
  indexes: Record<string, {
372
+ where?: string | undefined;
370
373
  name: string;
371
374
  columns: string[];
372
375
  isUnique: boolean;
373
- where?: string | undefined;
374
376
  }>;
375
377
  foreignKeys: Record<string, {
378
+ onUpdate?: string | undefined;
379
+ onDelete?: string | undefined;
376
380
  name: string;
377
381
  tableFrom: string;
378
382
  columnsFrom: string[];
379
383
  tableTo: string;
380
384
  columnsTo: string[];
381
- onUpdate?: string | undefined;
382
- onDelete?: string | undefined;
383
385
  }>;
384
386
  }>;
385
- version: "3";
386
- dialect: "sqlite";
387
387
  enums: {};
388
388
  }, {
389
+ version: "3";
390
+ dialect: "sqlite";
389
391
  tables: Record<string, {
390
392
  name: string;
391
393
  columns: Record<string, {
394
+ default?: any;
395
+ autoincrement?: boolean | undefined;
392
396
  name: string;
393
397
  type: string;
394
398
  primaryKey: boolean;
395
399
  notNull: boolean;
396
- default?: any;
397
- autoincrement?: boolean | undefined;
398
400
  }>;
399
401
  indexes: Record<string, {
402
+ where?: string | undefined;
400
403
  name: string;
401
404
  columns: string[];
402
405
  isUnique: boolean;
403
- where?: string | undefined;
404
406
  }>;
405
407
  foreignKeys: Record<string, {
408
+ onUpdate?: string | undefined;
409
+ onDelete?: string | undefined;
406
410
  name: string;
407
411
  tableFrom: string;
408
412
  columnsFrom: string[];
409
413
  tableTo: string;
410
414
  columnsTo: string[];
411
- onUpdate?: string | undefined;
412
- onDelete?: string | undefined;
413
415
  }>;
414
416
  }>;
415
- version: "3";
416
- dialect: "sqlite";
417
417
  enums: {};
418
418
  }>;
419
419
  export declare const schemaInternalV4: import("zod").ZodObject<{
@@ -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,146 +507,146 @@ 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
+ version: "4";
577
+ dialect: "sqlite";
576
578
  tables: Record<string, {
577
579
  name: string;
578
580
  columns: Record<string, {
581
+ default?: any;
582
+ autoincrement?: boolean | undefined;
579
583
  name: string;
580
584
  type: string;
581
585
  primaryKey: boolean;
582
586
  notNull: boolean;
583
- default?: any;
584
- autoincrement?: boolean | undefined;
585
587
  }>;
586
588
  indexes: Record<string, {
589
+ where?: string | undefined;
587
590
  name: string;
588
591
  columns: string[];
589
592
  isUnique: boolean;
590
- where?: string | undefined;
591
593
  }>;
592
594
  foreignKeys: Record<string, {
595
+ onUpdate?: string | undefined;
596
+ onDelete?: string | undefined;
593
597
  name: string;
594
598
  tableFrom: string;
595
599
  columnsFrom: string[];
596
600
  tableTo: string;
597
601
  columnsTo: string[];
598
- onUpdate?: string | undefined;
599
- onDelete?: string | undefined;
600
602
  }>;
601
603
  compositePrimaryKeys: Record<string, {
602
- columns: string[];
603
604
  name?: string | undefined;
605
+ columns: string[];
604
606
  }>;
605
607
  uniqueConstraints: Record<string, {
606
608
  name: string;
607
609
  columns: string[];
608
610
  }>;
609
611
  }>;
610
- version: "4";
611
- dialect: "sqlite";
612
612
  enums: {};
613
613
  }, {
614
+ version: "4";
615
+ dialect: "sqlite";
614
616
  tables: Record<string, {
617
+ uniqueConstraints?: Record<string, {
618
+ name: string;
619
+ columns: string[];
620
+ }> | undefined;
615
621
  name: string;
616
622
  columns: Record<string, {
623
+ default?: any;
624
+ autoincrement?: boolean | undefined;
617
625
  name: string;
618
626
  type: string;
619
627
  primaryKey: boolean;
620
628
  notNull: boolean;
621
- default?: any;
622
- autoincrement?: boolean | undefined;
623
629
  }>;
624
630
  indexes: Record<string, {
631
+ where?: string | undefined;
625
632
  name: string;
626
633
  columns: string[];
627
634
  isUnique: boolean;
628
- where?: string | undefined;
629
635
  }>;
630
636
  foreignKeys: Record<string, {
637
+ onUpdate?: string | undefined;
638
+ onDelete?: string | undefined;
631
639
  name: string;
632
640
  tableFrom: string;
633
641
  columnsFrom: string[];
634
642
  tableTo: string;
635
643
  columnsTo: string[];
636
- onUpdate?: string | undefined;
637
- onDelete?: string | undefined;
638
644
  }>;
639
645
  compositePrimaryKeys: Record<string, {
640
- columns: string[];
641
646
  name?: string | undefined;
642
- }>;
643
- uniqueConstraints?: Record<string, {
644
- name: string;
645
647
  columns: string[];
646
- }> | undefined;
648
+ }>;
647
649
  }>;
648
- version: "4";
649
- dialect: "sqlite";
650
650
  enums: {};
651
651
  }>;
652
652
  export declare const schemaInternal: import("zod").ZodObject<{
@@ -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<{
@@ -816,91 +816,91 @@ export declare const schemaInternal: import("zod").ZodObject<{
816
816
  tables: Record<string, string>;
817
817
  }>;
818
818
  }, "strict", import("zod").ZodTypeAny, {
819
+ version: "5";
820
+ dialect: "sqlite";
819
821
  tables: Record<string, {
820
822
  name: string;
821
823
  columns: Record<string, {
824
+ default?: any;
825
+ autoincrement?: boolean | undefined;
822
826
  name: string;
823
827
  type: string;
824
828
  primaryKey: boolean;
825
829
  notNull: boolean;
826
- default?: any;
827
- autoincrement?: boolean | undefined;
828
830
  }>;
829
831
  indexes: Record<string, {
832
+ where?: string | undefined;
830
833
  name: string;
831
834
  columns: string[];
832
835
  isUnique: boolean;
833
- where?: string | undefined;
834
836
  }>;
835
837
  foreignKeys: Record<string, {
838
+ onUpdate?: string | undefined;
839
+ onDelete?: string | undefined;
836
840
  name: string;
837
841
  tableFrom: string;
838
842
  columnsFrom: string[];
839
843
  tableTo: string;
840
844
  columnsTo: string[];
841
- onUpdate?: string | undefined;
842
- onDelete?: string | undefined;
843
845
  }>;
844
846
  compositePrimaryKeys: Record<string, {
845
- columns: string[];
846
847
  name?: string | undefined;
848
+ columns: string[];
847
849
  }>;
848
850
  uniqueConstraints: Record<string, {
849
851
  name: string;
850
852
  columns: string[];
851
853
  }>;
852
854
  }>;
853
- version: "5";
854
- dialect: "sqlite";
855
855
  _meta: {
856
856
  columns: Record<string, string>;
857
857
  tables: Record<string, string>;
858
858
  };
859
859
  enums: {};
860
860
  }, {
861
+ version: "5";
862
+ dialect: "sqlite";
861
863
  tables: Record<string, {
864
+ uniqueConstraints?: Record<string, {
865
+ name: string;
866
+ columns: string[];
867
+ }> | undefined;
862
868
  name: string;
863
869
  columns: Record<string, {
870
+ default?: any;
871
+ autoincrement?: boolean | undefined;
864
872
  name: string;
865
873
  type: string;
866
874
  primaryKey: boolean;
867
875
  notNull: boolean;
868
- default?: any;
869
- autoincrement?: boolean | undefined;
870
876
  }>;
871
877
  indexes: Record<string, {
878
+ where?: string | undefined;
872
879
  name: string;
873
880
  columns: string[];
874
881
  isUnique: boolean;
875
- where?: string | undefined;
876
882
  }>;
877
883
  foreignKeys: Record<string, {
884
+ onUpdate?: string | undefined;
885
+ onDelete?: string | undefined;
878
886
  name: string;
879
887
  tableFrom: string;
880
888
  columnsFrom: string[];
881
889
  tableTo: string;
882
890
  columnsTo: string[];
883
- onUpdate?: string | undefined;
884
- onDelete?: string | undefined;
885
891
  }>;
886
892
  compositePrimaryKeys: Record<string, {
887
- columns: string[];
888
893
  name?: string | undefined;
889
- }>;
890
- uniqueConstraints?: Record<string, {
891
- name: string;
892
894
  columns: string[];
893
- }> | undefined;
895
+ }>;
894
896
  }>;
895
- version: "5";
896
- dialect: "sqlite";
897
897
  _meta: {
898
898
  columns: Record<string, string>;
899
899
  tables: Record<string, string>;
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, {}, {}>;
@@ -1024,71 +1024,71 @@ export declare const schemaV3: import("zod").ZodObject<import("zod").objectUtil.
1024
1024
  id: import("zod").ZodString;
1025
1025
  prevId: import("zod").ZodString;
1026
1026
  }>, "strict", import("zod").ZodTypeAny, {
1027
+ id: string;
1028
+ prevId: string;
1029
+ version: "3";
1030
+ dialect: "sqlite";
1027
1031
  tables: Record<string, {
1028
1032
  name: string;
1029
1033
  columns: Record<string, {
1034
+ default?: any;
1035
+ autoincrement?: boolean | undefined;
1030
1036
  name: string;
1031
1037
  type: string;
1032
1038
  primaryKey: boolean;
1033
1039
  notNull: boolean;
1034
- default?: any;
1035
- autoincrement?: boolean | undefined;
1036
1040
  }>;
1037
1041
  indexes: Record<string, {
1042
+ where?: string | undefined;
1038
1043
  name: string;
1039
1044
  columns: string[];
1040
1045
  isUnique: boolean;
1041
- where?: string | undefined;
1042
1046
  }>;
1043
1047
  foreignKeys: Record<string, {
1048
+ onUpdate?: string | undefined;
1049
+ onDelete?: string | undefined;
1044
1050
  name: string;
1045
1051
  tableFrom: string;
1046
1052
  columnsFrom: string[];
1047
1053
  tableTo: string;
1048
1054
  columnsTo: string[];
1049
- onUpdate?: string | undefined;
1050
- onDelete?: string | undefined;
1051
1055
  }>;
1052
1056
  }>;
1057
+ enums: {};
1058
+ }, {
1053
1059
  id: string;
1054
1060
  prevId: string;
1055
1061
  version: "3";
1056
1062
  dialect: "sqlite";
1057
- enums: {};
1058
- }, {
1059
1063
  tables: Record<string, {
1060
1064
  name: string;
1061
1065
  columns: Record<string, {
1066
+ default?: any;
1067
+ autoincrement?: boolean | undefined;
1062
1068
  name: string;
1063
1069
  type: string;
1064
1070
  primaryKey: boolean;
1065
1071
  notNull: boolean;
1066
- default?: any;
1067
- autoincrement?: boolean | undefined;
1068
1072
  }>;
1069
1073
  indexes: Record<string, {
1074
+ where?: string | undefined;
1070
1075
  name: string;
1071
1076
  columns: string[];
1072
1077
  isUnique: boolean;
1073
- where?: string | undefined;
1074
1078
  }>;
1075
1079
  foreignKeys: Record<string, {
1080
+ onUpdate?: string | undefined;
1081
+ onDelete?: string | undefined;
1076
1082
  name: string;
1077
1083
  tableFrom: string;
1078
1084
  columnsFrom: string[];
1079
1085
  tableTo: string;
1080
1086
  columnsTo: string[];
1081
- onUpdate?: string | undefined;
1082
- onDelete?: string | undefined;
1083
1087
  }>;
1084
1088
  }>;
1085
- id: string;
1086
- prevId: string;
1087
- version: "3";
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,156 +1179,156 @@ 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
  }, {
1248
1248
  id: import("zod").ZodString;
1249
1249
  prevId: import("zod").ZodString;
1250
1250
  }>, "strict", import("zod").ZodTypeAny, {
1251
+ id: string;
1252
+ prevId: string;
1253
+ version: "4";
1254
+ dialect: "sqlite";
1251
1255
  tables: Record<string, {
1252
1256
  name: string;
1253
1257
  columns: Record<string, {
1258
+ default?: any;
1259
+ autoincrement?: boolean | undefined;
1254
1260
  name: string;
1255
1261
  type: string;
1256
1262
  primaryKey: boolean;
1257
1263
  notNull: boolean;
1258
- default?: any;
1259
- autoincrement?: boolean | undefined;
1260
1264
  }>;
1261
1265
  indexes: Record<string, {
1266
+ where?: string | undefined;
1262
1267
  name: string;
1263
1268
  columns: string[];
1264
1269
  isUnique: boolean;
1265
- where?: string | undefined;
1266
1270
  }>;
1267
1271
  foreignKeys: Record<string, {
1272
+ onUpdate?: string | undefined;
1273
+ onDelete?: string | undefined;
1268
1274
  name: string;
1269
1275
  tableFrom: string;
1270
1276
  columnsFrom: string[];
1271
1277
  tableTo: string;
1272
1278
  columnsTo: string[];
1273
- onUpdate?: string | undefined;
1274
- onDelete?: string | undefined;
1275
1279
  }>;
1276
1280
  compositePrimaryKeys: Record<string, {
1277
- columns: string[];
1278
1281
  name?: string | undefined;
1282
+ columns: string[];
1279
1283
  }>;
1280
1284
  uniqueConstraints: Record<string, {
1281
1285
  name: string;
1282
1286
  columns: string[];
1283
1287
  }>;
1284
1288
  }>;
1289
+ enums: {};
1290
+ }, {
1285
1291
  id: string;
1286
1292
  prevId: string;
1287
1293
  version: "4";
1288
1294
  dialect: "sqlite";
1289
- enums: {};
1290
- }, {
1291
1295
  tables: Record<string, {
1296
+ uniqueConstraints?: Record<string, {
1297
+ name: string;
1298
+ columns: string[];
1299
+ }> | undefined;
1292
1300
  name: string;
1293
1301
  columns: Record<string, {
1302
+ default?: any;
1303
+ autoincrement?: boolean | undefined;
1294
1304
  name: string;
1295
1305
  type: string;
1296
1306
  primaryKey: boolean;
1297
1307
  notNull: boolean;
1298
- default?: any;
1299
- autoincrement?: boolean | undefined;
1300
1308
  }>;
1301
1309
  indexes: Record<string, {
1310
+ where?: string | undefined;
1302
1311
  name: string;
1303
1312
  columns: string[];
1304
1313
  isUnique: boolean;
1305
- where?: string | undefined;
1306
1314
  }>;
1307
1315
  foreignKeys: Record<string, {
1316
+ onUpdate?: string | undefined;
1317
+ onDelete?: string | undefined;
1308
1318
  name: string;
1309
1319
  tableFrom: string;
1310
1320
  columnsFrom: string[];
1311
1321
  tableTo: string;
1312
1322
  columnsTo: string[];
1313
- onUpdate?: string | undefined;
1314
- onDelete?: string | undefined;
1315
1323
  }>;
1316
1324
  compositePrimaryKeys: Record<string, {
1317
- columns: string[];
1318
1325
  name?: string | undefined;
1319
- }>;
1320
- uniqueConstraints?: Record<string, {
1321
- name: string;
1322
1326
  columns: string[];
1323
- }> | undefined;
1327
+ }>;
1324
1328
  }>;
1325
- id: string;
1326
- prevId: string;
1327
- version: "4";
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<{
@@ -1498,88 +1498,88 @@ export declare const schema: import("zod").ZodObject<import("zod").objectUtil.ex
1498
1498
  id: import("zod").ZodString;
1499
1499
  prevId: import("zod").ZodString;
1500
1500
  }>, "strict", import("zod").ZodTypeAny, {
1501
+ id: string;
1502
+ prevId: string;
1503
+ version: "5";
1504
+ dialect: "sqlite";
1501
1505
  tables: Record<string, {
1502
1506
  name: string;
1503
1507
  columns: Record<string, {
1508
+ default?: any;
1509
+ autoincrement?: boolean | undefined;
1504
1510
  name: string;
1505
1511
  type: string;
1506
1512
  primaryKey: boolean;
1507
1513
  notNull: boolean;
1508
- default?: any;
1509
- autoincrement?: boolean | undefined;
1510
1514
  }>;
1511
1515
  indexes: Record<string, {
1516
+ where?: string | undefined;
1512
1517
  name: string;
1513
1518
  columns: string[];
1514
1519
  isUnique: boolean;
1515
- where?: string | undefined;
1516
1520
  }>;
1517
1521
  foreignKeys: Record<string, {
1522
+ onUpdate?: string | undefined;
1523
+ onDelete?: string | undefined;
1518
1524
  name: string;
1519
1525
  tableFrom: string;
1520
1526
  columnsFrom: string[];
1521
1527
  tableTo: string;
1522
1528
  columnsTo: string[];
1523
- onUpdate?: string | undefined;
1524
- onDelete?: string | undefined;
1525
1529
  }>;
1526
1530
  compositePrimaryKeys: Record<string, {
1527
- columns: string[];
1528
1531
  name?: string | undefined;
1532
+ columns: string[];
1529
1533
  }>;
1530
1534
  uniqueConstraints: Record<string, {
1531
1535
  name: string;
1532
1536
  columns: string[];
1533
1537
  }>;
1534
1538
  }>;
1535
- id: string;
1536
- prevId: string;
1537
- version: "5";
1538
- dialect: "sqlite";
1539
1539
  _meta: {
1540
1540
  columns: Record<string, string>;
1541
1541
  tables: Record<string, string>;
1542
1542
  };
1543
1543
  enums: {};
1544
1544
  }, {
1545
+ id: string;
1546
+ prevId: string;
1547
+ version: "5";
1548
+ dialect: "sqlite";
1545
1549
  tables: Record<string, {
1550
+ uniqueConstraints?: Record<string, {
1551
+ name: string;
1552
+ columns: string[];
1553
+ }> | undefined;
1546
1554
  name: string;
1547
1555
  columns: Record<string, {
1556
+ default?: any;
1557
+ autoincrement?: boolean | undefined;
1548
1558
  name: string;
1549
1559
  type: string;
1550
1560
  primaryKey: boolean;
1551
1561
  notNull: boolean;
1552
- default?: any;
1553
- autoincrement?: boolean | undefined;
1554
1562
  }>;
1555
1563
  indexes: Record<string, {
1564
+ where?: string | undefined;
1556
1565
  name: string;
1557
1566
  columns: string[];
1558
1567
  isUnique: boolean;
1559
- where?: string | undefined;
1560
1568
  }>;
1561
1569
  foreignKeys: Record<string, {
1570
+ onUpdate?: string | undefined;
1571
+ onDelete?: string | undefined;
1562
1572
  name: string;
1563
1573
  tableFrom: string;
1564
1574
  columnsFrom: string[];
1565
1575
  tableTo: string;
1566
1576
  columnsTo: string[];
1567
- onUpdate?: string | undefined;
1568
- onDelete?: string | undefined;
1569
1577
  }>;
1570
1578
  compositePrimaryKeys: Record<string, {
1571
- columns: string[];
1572
1579
  name?: string | undefined;
1573
- }>;
1574
- uniqueConstraints?: Record<string, {
1575
- name: string;
1576
1580
  columns: string[];
1577
- }> | undefined;
1581
+ }>;
1578
1582
  }>;
1579
- id: string;
1580
- prevId: string;
1581
- version: "5";
1582
- dialect: "sqlite";
1583
1583
  _meta: {
1584
1584
  columns: Record<string, string>;
1585
1585
  tables: Record<string, 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,71 +1620,71 @@ 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;
1652
+ version: "5";
1653
+ dialect: "sqlite";
1651
1654
  tables: Record<string, {
1652
1655
  name: string;
1653
1656
  columns: Record<string, {
1657
+ default?: any;
1658
+ autoincrement?: boolean | undefined;
1654
1659
  name: string;
1655
1660
  type: string;
1656
1661
  primaryKey: boolean;
1657
1662
  notNull: boolean;
1658
- default?: any;
1659
- autoincrement?: boolean | undefined;
1660
1663
  }>;
1661
1664
  indexes: Record<string, string>;
1662
1665
  foreignKeys: Record<string, string>;
1663
1666
  compositePrimaryKeys: Record<string, string>;
1664
1667
  uniqueConstraints: Record<string, string>;
1665
1668
  }>;
1669
+ }, {
1670
+ enums?: any;
1666
1671
  version: "5";
1667
1672
  dialect: "sqlite";
1668
- enums?: any;
1669
- }, {
1670
1673
  tables: Record<string, {
1674
+ uniqueConstraints?: Record<string, string> | undefined;
1671
1675
  name: string;
1672
1676
  columns: Record<string, {
1677
+ default?: any;
1678
+ autoincrement?: boolean | undefined;
1673
1679
  name: string;
1674
1680
  type: string;
1675
1681
  primaryKey: boolean;
1676
1682
  notNull: boolean;
1677
- default?: any;
1678
- autoincrement?: boolean | undefined;
1679
1683
  }>;
1680
1684
  indexes: Record<string, string>;
1681
1685
  foreignKeys: Record<string, string>;
1682
1686
  compositePrimaryKeys: Record<string, string>;
1683
- uniqueConstraints?: Record<string, string> | undefined;
1684
1687
  }>;
1685
- version: "5";
1686
- dialect: "sqlite";
1687
- enums?: any;
1688
1688
  }>;
1689
1689
  export type Dialect = TypeOf<typeof dialect>;
1690
1690
  export type Column = TypeOf<typeof column>;
@@ -1710,51 +1710,51 @@ export declare const SQLiteSquasher: {
1710
1710
  };
1711
1711
  export declare const squashSqliteScheme: (json: SQLiteSchema | SQLiteSchemaV4) => SQLiteSchemaSquashed;
1712
1712
  export declare const drySQLite: {
1713
+ id: string;
1714
+ prevId: string;
1715
+ version: "5";
1716
+ dialect: "sqlite";
1713
1717
  tables: Record<string, {
1714
1718
  name: string;
1715
1719
  columns: Record<string, {
1720
+ default?: any;
1721
+ autoincrement?: boolean | undefined;
1716
1722
  name: string;
1717
1723
  type: string;
1718
1724
  primaryKey: boolean;
1719
1725
  notNull: boolean;
1720
- default?: any;
1721
- autoincrement?: boolean | undefined;
1722
1726
  }>;
1723
1727
  indexes: Record<string, {
1728
+ where?: string | undefined;
1724
1729
  name: string;
1725
1730
  columns: string[];
1726
1731
  isUnique: boolean;
1727
- where?: string | undefined;
1728
1732
  }>;
1729
1733
  foreignKeys: Record<string, {
1734
+ onUpdate?: string | undefined;
1735
+ onDelete?: string | undefined;
1730
1736
  name: string;
1731
1737
  tableFrom: string;
1732
1738
  columnsFrom: string[];
1733
1739
  tableTo: string;
1734
1740
  columnsTo: string[];
1735
- onUpdate?: string | undefined;
1736
- onDelete?: string | undefined;
1737
1741
  }>;
1738
1742
  compositePrimaryKeys: Record<string, {
1739
- columns: string[];
1740
1743
  name?: string | undefined;
1744
+ columns: string[];
1741
1745
  }>;
1742
1746
  uniqueConstraints: Record<string, {
1743
1747
  name: string;
1744
1748
  columns: string[];
1745
1749
  }>;
1746
1750
  }>;
1747
- id: string;
1748
- prevId: string;
1749
- version: "5";
1750
- dialect: "sqlite";
1751
1751
  _meta: {
1752
1752
  columns: Record<string, string>;
1753
1753
  tables: Record<string, string>;
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, {}, {}>;
@@ -1878,71 +1878,71 @@ export declare const sqliteSchemaV3: import("zod").ZodObject<import("zod").objec
1878
1878
  id: import("zod").ZodString;
1879
1879
  prevId: import("zod").ZodString;
1880
1880
  }>, "strict", import("zod").ZodTypeAny, {
1881
+ id: string;
1882
+ prevId: string;
1883
+ version: "3";
1884
+ dialect: "sqlite";
1881
1885
  tables: Record<string, {
1882
1886
  name: string;
1883
1887
  columns: Record<string, {
1888
+ default?: any;
1889
+ autoincrement?: boolean | undefined;
1884
1890
  name: string;
1885
1891
  type: string;
1886
1892
  primaryKey: boolean;
1887
1893
  notNull: boolean;
1888
- default?: any;
1889
- autoincrement?: boolean | undefined;
1890
1894
  }>;
1891
1895
  indexes: Record<string, {
1896
+ where?: string | undefined;
1892
1897
  name: string;
1893
1898
  columns: string[];
1894
1899
  isUnique: boolean;
1895
- where?: string | undefined;
1896
1900
  }>;
1897
1901
  foreignKeys: Record<string, {
1902
+ onUpdate?: string | undefined;
1903
+ onDelete?: string | undefined;
1898
1904
  name: string;
1899
1905
  tableFrom: string;
1900
1906
  columnsFrom: string[];
1901
1907
  tableTo: string;
1902
1908
  columnsTo: string[];
1903
- onUpdate?: string | undefined;
1904
- onDelete?: string | undefined;
1905
1909
  }>;
1906
1910
  }>;
1911
+ enums: {};
1912
+ }, {
1907
1913
  id: string;
1908
1914
  prevId: string;
1909
1915
  version: "3";
1910
1916
  dialect: "sqlite";
1911
- enums: {};
1912
- }, {
1913
1917
  tables: Record<string, {
1914
1918
  name: string;
1915
1919
  columns: Record<string, {
1920
+ default?: any;
1921
+ autoincrement?: boolean | undefined;
1916
1922
  name: string;
1917
1923
  type: string;
1918
1924
  primaryKey: boolean;
1919
1925
  notNull: boolean;
1920
- default?: any;
1921
- autoincrement?: boolean | undefined;
1922
1926
  }>;
1923
1927
  indexes: Record<string, {
1928
+ where?: string | undefined;
1924
1929
  name: string;
1925
1930
  columns: string[];
1926
1931
  isUnique: boolean;
1927
- where?: string | undefined;
1928
1932
  }>;
1929
1933
  foreignKeys: Record<string, {
1934
+ onUpdate?: string | undefined;
1935
+ onDelete?: string | undefined;
1930
1936
  name: string;
1931
1937
  tableFrom: string;
1932
1938
  columnsFrom: string[];
1933
1939
  tableTo: string;
1934
1940
  columnsTo: string[];
1935
- onUpdate?: string | undefined;
1936
- onDelete?: string | undefined;
1937
1941
  }>;
1938
1942
  }>;
1939
- id: string;
1940
- prevId: string;
1941
- version: "3";
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,156 +2033,156 @@ 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
  }, {
2102
2102
  id: import("zod").ZodString;
2103
2103
  prevId: import("zod").ZodString;
2104
2104
  }>, "strict", import("zod").ZodTypeAny, {
2105
+ id: string;
2106
+ prevId: string;
2107
+ version: "4";
2108
+ dialect: "sqlite";
2105
2109
  tables: Record<string, {
2106
2110
  name: string;
2107
2111
  columns: Record<string, {
2112
+ default?: any;
2113
+ autoincrement?: boolean | undefined;
2108
2114
  name: string;
2109
2115
  type: string;
2110
2116
  primaryKey: boolean;
2111
2117
  notNull: boolean;
2112
- default?: any;
2113
- autoincrement?: boolean | undefined;
2114
2118
  }>;
2115
2119
  indexes: Record<string, {
2120
+ where?: string | undefined;
2116
2121
  name: string;
2117
2122
  columns: string[];
2118
2123
  isUnique: boolean;
2119
- where?: string | undefined;
2120
2124
  }>;
2121
2125
  foreignKeys: Record<string, {
2126
+ onUpdate?: string | undefined;
2127
+ onDelete?: string | undefined;
2122
2128
  name: string;
2123
2129
  tableFrom: string;
2124
2130
  columnsFrom: string[];
2125
2131
  tableTo: string;
2126
2132
  columnsTo: string[];
2127
- onUpdate?: string | undefined;
2128
- onDelete?: string | undefined;
2129
2133
  }>;
2130
2134
  compositePrimaryKeys: Record<string, {
2131
- columns: string[];
2132
2135
  name?: string | undefined;
2136
+ columns: string[];
2133
2137
  }>;
2134
2138
  uniqueConstraints: Record<string, {
2135
2139
  name: string;
2136
2140
  columns: string[];
2137
2141
  }>;
2138
2142
  }>;
2143
+ enums: {};
2144
+ }, {
2139
2145
  id: string;
2140
2146
  prevId: string;
2141
2147
  version: "4";
2142
2148
  dialect: "sqlite";
2143
- enums: {};
2144
- }, {
2145
2149
  tables: Record<string, {
2150
+ uniqueConstraints?: Record<string, {
2151
+ name: string;
2152
+ columns: string[];
2153
+ }> | undefined;
2146
2154
  name: string;
2147
2155
  columns: Record<string, {
2156
+ default?: any;
2157
+ autoincrement?: boolean | undefined;
2148
2158
  name: string;
2149
2159
  type: string;
2150
2160
  primaryKey: boolean;
2151
2161
  notNull: boolean;
2152
- default?: any;
2153
- autoincrement?: boolean | undefined;
2154
2162
  }>;
2155
2163
  indexes: Record<string, {
2164
+ where?: string | undefined;
2156
2165
  name: string;
2157
2166
  columns: string[];
2158
2167
  isUnique: boolean;
2159
- where?: string | undefined;
2160
2168
  }>;
2161
2169
  foreignKeys: Record<string, {
2170
+ onUpdate?: string | undefined;
2171
+ onDelete?: string | undefined;
2162
2172
  name: string;
2163
2173
  tableFrom: string;
2164
2174
  columnsFrom: string[];
2165
2175
  tableTo: string;
2166
2176
  columnsTo: string[];
2167
- onUpdate?: string | undefined;
2168
- onDelete?: string | undefined;
2169
2177
  }>;
2170
2178
  compositePrimaryKeys: Record<string, {
2171
- columns: string[];
2172
2179
  name?: string | undefined;
2173
- }>;
2174
- uniqueConstraints?: Record<string, {
2175
- name: string;
2176
2180
  columns: string[];
2177
- }> | undefined;
2181
+ }>;
2178
2182
  }>;
2179
- id: string;
2180
- prevId: string;
2181
- version: "4";
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<{
@@ -2352,88 +2352,88 @@ export declare const sqliteSchema: import("zod").ZodObject<import("zod").objectU
2352
2352
  id: import("zod").ZodString;
2353
2353
  prevId: import("zod").ZodString;
2354
2354
  }>, "strict", import("zod").ZodTypeAny, {
2355
+ id: string;
2356
+ prevId: string;
2357
+ version: "5";
2358
+ dialect: "sqlite";
2355
2359
  tables: Record<string, {
2356
2360
  name: string;
2357
2361
  columns: Record<string, {
2362
+ default?: any;
2363
+ autoincrement?: boolean | undefined;
2358
2364
  name: string;
2359
2365
  type: string;
2360
2366
  primaryKey: boolean;
2361
2367
  notNull: boolean;
2362
- default?: any;
2363
- autoincrement?: boolean | undefined;
2364
2368
  }>;
2365
2369
  indexes: Record<string, {
2370
+ where?: string | undefined;
2366
2371
  name: string;
2367
2372
  columns: string[];
2368
2373
  isUnique: boolean;
2369
- where?: string | undefined;
2370
2374
  }>;
2371
2375
  foreignKeys: Record<string, {
2376
+ onUpdate?: string | undefined;
2377
+ onDelete?: string | undefined;
2372
2378
  name: string;
2373
2379
  tableFrom: string;
2374
2380
  columnsFrom: string[];
2375
2381
  tableTo: string;
2376
2382
  columnsTo: string[];
2377
- onUpdate?: string | undefined;
2378
- onDelete?: string | undefined;
2379
2383
  }>;
2380
2384
  compositePrimaryKeys: Record<string, {
2381
- columns: string[];
2382
2385
  name?: string | undefined;
2386
+ columns: string[];
2383
2387
  }>;
2384
2388
  uniqueConstraints: Record<string, {
2385
2389
  name: string;
2386
2390
  columns: string[];
2387
2391
  }>;
2388
2392
  }>;
2389
- id: string;
2390
- prevId: string;
2391
- version: "5";
2392
- dialect: "sqlite";
2393
2393
  _meta: {
2394
2394
  columns: Record<string, string>;
2395
2395
  tables: Record<string, string>;
2396
2396
  };
2397
2397
  enums: {};
2398
2398
  }, {
2399
+ id: string;
2400
+ prevId: string;
2401
+ version: "5";
2402
+ dialect: "sqlite";
2399
2403
  tables: Record<string, {
2404
+ uniqueConstraints?: Record<string, {
2405
+ name: string;
2406
+ columns: string[];
2407
+ }> | undefined;
2400
2408
  name: string;
2401
2409
  columns: Record<string, {
2410
+ default?: any;
2411
+ autoincrement?: boolean | undefined;
2402
2412
  name: string;
2403
2413
  type: string;
2404
2414
  primaryKey: boolean;
2405
2415
  notNull: boolean;
2406
- default?: any;
2407
- autoincrement?: boolean | undefined;
2408
2416
  }>;
2409
2417
  indexes: Record<string, {
2418
+ where?: string | undefined;
2410
2419
  name: string;
2411
2420
  columns: string[];
2412
2421
  isUnique: boolean;
2413
- where?: string | undefined;
2414
2422
  }>;
2415
2423
  foreignKeys: Record<string, {
2424
+ onUpdate?: string | undefined;
2425
+ onDelete?: string | undefined;
2416
2426
  name: string;
2417
2427
  tableFrom: string;
2418
2428
  columnsFrom: string[];
2419
2429
  tableTo: string;
2420
2430
  columnsTo: string[];
2421
- onUpdate?: string | undefined;
2422
- onDelete?: string | undefined;
2423
2431
  }>;
2424
2432
  compositePrimaryKeys: Record<string, {
2425
- columns: string[];
2426
2433
  name?: string | undefined;
2427
- }>;
2428
- uniqueConstraints?: Record<string, {
2429
- name: string;
2430
2434
  columns: string[];
2431
- }> | undefined;
2435
+ }>;
2432
2436
  }>;
2433
- id: string;
2434
- prevId: string;
2435
- version: "5";
2436
- dialect: "sqlite";
2437
2437
  _meta: {
2438
2438
  columns: Record<string, string>;
2439
2439
  tables: Record<string, 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,74 +2474,74 @@ 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;
2506
+ version: "5";
2507
+ dialect: "sqlite";
2505
2508
  tables: Record<string, {
2506
2509
  name: string;
2507
2510
  columns: Record<string, {
2511
+ default?: any;
2512
+ autoincrement?: boolean | undefined;
2508
2513
  name: string;
2509
2514
  type: string;
2510
2515
  primaryKey: boolean;
2511
2516
  notNull: boolean;
2512
- default?: any;
2513
- autoincrement?: boolean | undefined;
2514
2517
  }>;
2515
2518
  indexes: Record<string, string>;
2516
2519
  foreignKeys: Record<string, string>;
2517
2520
  compositePrimaryKeys: Record<string, string>;
2518
2521
  uniqueConstraints: Record<string, string>;
2519
2522
  }>;
2523
+ }, {
2524
+ enums?: any;
2520
2525
  version: "5";
2521
2526
  dialect: "sqlite";
2522
- enums?: any;
2523
- }, {
2524
2527
  tables: Record<string, {
2528
+ uniqueConstraints?: Record<string, string> | undefined;
2525
2529
  name: string;
2526
2530
  columns: Record<string, {
2531
+ default?: any;
2532
+ autoincrement?: boolean | undefined;
2527
2533
  name: string;
2528
2534
  type: string;
2529
2535
  primaryKey: boolean;
2530
2536
  notNull: boolean;
2531
- default?: any;
2532
- autoincrement?: boolean | undefined;
2533
2537
  }>;
2534
2538
  indexes: Record<string, string>;
2535
2539
  foreignKeys: Record<string, string>;
2536
2540
  compositePrimaryKeys: Record<string, string>;
2537
- uniqueConstraints?: Record<string, string> | undefined;
2538
2541
  }>;
2539
- version: "5";
2540
- dialect: "sqlite";
2541
- enums?: any;
2542
2542
  }>;
2543
- export declare const backwardCompatibleSqliteSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
2544
- version: import("zod").ZodLiteral<"5">;
2543
+ export declare const backwardCompatibleSqliteSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
2544
+ version: import("zod").ZodLiteral<"3">;
2545
2545
  dialect: import("zod").ZodEnum<["sqlite"]>;
2546
2546
  tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2547
2547
  name: import("zod").ZodString;
@@ -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,210 +2592,636 @@ 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
- }>>;
2611
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2612
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2613
- name: import("zod").ZodOptional<import("zod").ZodString>;
2614
- }, "strict", import("zod").ZodTypeAny, {
2615
- columns: string[];
2616
- name?: string | undefined;
2617
- }, {
2618
- columns: string[];
2619
- name?: string | undefined;
2620
2610
  }>>;
2621
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2622
- name: import("zod").ZodString;
2623
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2624
- }, "strict", import("zod").ZodTypeAny, {
2625
- name: string;
2626
- columns: string[];
2627
- }, {
2628
- name: string;
2629
- columns: string[];
2630
- }>>>;
2631
2611
  }, "strict", import("zod").ZodTypeAny, {
2632
2612
  name: string;
2633
2613
  columns: Record<string, {
2614
+ default?: any;
2615
+ autoincrement?: boolean | undefined;
2634
2616
  name: string;
2635
2617
  type: string;
2636
2618
  primaryKey: boolean;
2637
2619
  notNull: boolean;
2638
- default?: any;
2639
- autoincrement?: boolean | undefined;
2640
2620
  }>;
2641
2621
  indexes: Record<string, {
2622
+ where?: string | undefined;
2642
2623
  name: string;
2643
2624
  columns: string[];
2644
2625
  isUnique: boolean;
2645
- where?: string | undefined;
2646
2626
  }>;
2647
2627
  foreignKeys: Record<string, {
2628
+ onUpdate?: string | undefined;
2629
+ onDelete?: string | undefined;
2648
2630
  name: string;
2649
2631
  tableFrom: string;
2650
2632
  columnsFrom: string[];
2651
2633
  tableTo: string;
2652
2634
  columnsTo: string[];
2653
- onUpdate?: string | undefined;
2654
- onDelete?: string | undefined;
2655
- }>;
2656
- compositePrimaryKeys: Record<string, {
2657
- columns: string[];
2658
- name?: string | undefined;
2659
- }>;
2660
- uniqueConstraints: Record<string, {
2661
- name: string;
2662
- columns: string[];
2663
2635
  }>;
2664
2636
  }, {
2665
2637
  name: string;
2666
2638
  columns: Record<string, {
2639
+ default?: any;
2640
+ autoincrement?: boolean | undefined;
2667
2641
  name: string;
2668
2642
  type: string;
2669
2643
  primaryKey: boolean;
2670
2644
  notNull: boolean;
2671
- default?: any;
2672
- autoincrement?: boolean | undefined;
2673
2645
  }>;
2674
2646
  indexes: Record<string, {
2647
+ where?: string | undefined;
2675
2648
  name: string;
2676
2649
  columns: string[];
2677
2650
  isUnique: boolean;
2678
- where?: string | undefined;
2679
2651
  }>;
2680
2652
  foreignKeys: Record<string, {
2653
+ onUpdate?: string | undefined;
2654
+ onDelete?: string | undefined;
2681
2655
  name: string;
2682
2656
  tableFrom: string;
2683
2657
  columnsFrom: string[];
2684
2658
  tableTo: string;
2685
2659
  columnsTo: string[];
2686
- onUpdate?: string | undefined;
2687
- onDelete?: string | undefined;
2688
- }>;
2689
- compositePrimaryKeys: Record<string, {
2690
- columns: string[];
2691
- name?: string | undefined;
2692
2660
  }>;
2693
- uniqueConstraints?: Record<string, {
2694
- name: string;
2695
- columns: string[];
2696
- }> | undefined;
2697
2661
  }>>;
2698
2662
  enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
2699
- _meta: import("zod").ZodObject<{
2700
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2701
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2702
- }, "strip", import("zod").ZodTypeAny, {
2703
- columns: Record<string, string>;
2704
- tables: Record<string, string>;
2705
- }, {
2706
- columns: Record<string, string>;
2707
- tables: Record<string, string>;
2708
- }>;
2709
2663
  }, {
2710
2664
  id: import("zod").ZodString;
2711
2665
  prevId: import("zod").ZodString;
2712
2666
  }>, "strict", import("zod").ZodTypeAny, {
2667
+ id: string;
2668
+ prevId: string;
2669
+ version: "3";
2670
+ dialect: "sqlite";
2713
2671
  tables: Record<string, {
2714
2672
  name: string;
2715
2673
  columns: Record<string, {
2674
+ default?: any;
2675
+ autoincrement?: boolean | undefined;
2716
2676
  name: string;
2717
2677
  type: string;
2718
2678
  primaryKey: boolean;
2719
2679
  notNull: boolean;
2680
+ }>;
2681
+ indexes: Record<string, {
2682
+ where?: string | undefined;
2683
+ name: string;
2684
+ columns: string[];
2685
+ isUnique: boolean;
2686
+ }>;
2687
+ foreignKeys: Record<string, {
2688
+ onUpdate?: string | undefined;
2689
+ onDelete?: string | undefined;
2690
+ name: string;
2691
+ tableFrom: string;
2692
+ columnsFrom: string[];
2693
+ tableTo: string;
2694
+ columnsTo: string[];
2695
+ }>;
2696
+ }>;
2697
+ enums: {};
2698
+ }, {
2699
+ id: string;
2700
+ prevId: string;
2701
+ version: "3";
2702
+ dialect: "sqlite";
2703
+ tables: Record<string, {
2704
+ name: string;
2705
+ columns: Record<string, {
2720
2706
  default?: any;
2721
2707
  autoincrement?: boolean | undefined;
2708
+ name: string;
2709
+ type: string;
2710
+ primaryKey: boolean;
2711
+ notNull: boolean;
2722
2712
  }>;
2723
2713
  indexes: Record<string, {
2714
+ where?: string | undefined;
2724
2715
  name: string;
2725
2716
  columns: string[];
2726
2717
  isUnique: boolean;
2718
+ }>;
2719
+ foreignKeys: Record<string, {
2720
+ onUpdate?: string | undefined;
2721
+ onDelete?: string | undefined;
2722
+ name: string;
2723
+ tableFrom: string;
2724
+ columnsFrom: string[];
2725
+ tableTo: string;
2726
+ columnsTo: string[];
2727
+ }>;
2728
+ }>;
2729
+ enums: {};
2730
+ }>, import("zod").ZodObject<import("zod").extendShape<{
2731
+ version: import("zod").ZodLiteral<"4">;
2732
+ dialect: import("zod").ZodEnum<["sqlite"]>;
2733
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2734
+ name: import("zod").ZodString;
2735
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2736
+ name: import("zod").ZodString;
2737
+ type: import("zod").ZodString;
2738
+ primaryKey: import("zod").ZodBoolean;
2739
+ notNull: import("zod").ZodBoolean;
2740
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2741
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2742
+ }, "strict", import("zod").ZodTypeAny, {
2743
+ default?: any;
2744
+ autoincrement?: boolean | undefined;
2745
+ name: string;
2746
+ type: string;
2747
+ primaryKey: boolean;
2748
+ notNull: boolean;
2749
+ }, {
2750
+ default?: any;
2751
+ autoincrement?: boolean | undefined;
2752
+ name: string;
2753
+ type: string;
2754
+ primaryKey: boolean;
2755
+ notNull: boolean;
2756
+ }>>;
2757
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2758
+ name: import("zod").ZodString;
2759
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2760
+ where: import("zod").ZodOptional<import("zod").ZodString>;
2761
+ isUnique: import("zod").ZodBoolean;
2762
+ }, "strict", import("zod").ZodTypeAny, {
2763
+ where?: string | undefined;
2764
+ name: string;
2765
+ columns: string[];
2766
+ isUnique: boolean;
2767
+ }, {
2768
+ where?: string | undefined;
2769
+ name: string;
2770
+ columns: string[];
2771
+ isUnique: boolean;
2772
+ }>>;
2773
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2774
+ name: import("zod").ZodString;
2775
+ tableFrom: import("zod").ZodString;
2776
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2777
+ tableTo: import("zod").ZodString;
2778
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2779
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2780
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2781
+ }, "strict", import("zod").ZodTypeAny, {
2782
+ onUpdate?: string | undefined;
2783
+ onDelete?: string | undefined;
2784
+ name: string;
2785
+ tableFrom: string;
2786
+ columnsFrom: string[];
2787
+ tableTo: string;
2788
+ columnsTo: string[];
2789
+ }, {
2790
+ onUpdate?: string | undefined;
2791
+ onDelete?: string | undefined;
2792
+ name: string;
2793
+ tableFrom: string;
2794
+ columnsFrom: string[];
2795
+ tableTo: string;
2796
+ columnsTo: string[];
2797
+ }>>;
2798
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2799
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2800
+ name: import("zod").ZodOptional<import("zod").ZodString>;
2801
+ }, "strict", import("zod").ZodTypeAny, {
2802
+ name?: string | undefined;
2803
+ columns: string[];
2804
+ }, {
2805
+ name?: string | undefined;
2806
+ columns: string[];
2807
+ }>>;
2808
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2809
+ name: import("zod").ZodString;
2810
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2811
+ }, "strict", import("zod").ZodTypeAny, {
2812
+ name: string;
2813
+ columns: string[];
2814
+ }, {
2815
+ name: string;
2816
+ columns: string[];
2817
+ }>>>;
2818
+ }, "strict", import("zod").ZodTypeAny, {
2819
+ name: string;
2820
+ columns: Record<string, {
2821
+ default?: any;
2822
+ autoincrement?: boolean | undefined;
2823
+ name: string;
2824
+ type: string;
2825
+ primaryKey: boolean;
2826
+ notNull: boolean;
2827
+ }>;
2828
+ indexes: Record<string, {
2727
2829
  where?: string | undefined;
2830
+ name: string;
2831
+ columns: string[];
2832
+ isUnique: boolean;
2728
2833
  }>;
2729
2834
  foreignKeys: Record<string, {
2835
+ onUpdate?: string | undefined;
2836
+ onDelete?: string | undefined;
2730
2837
  name: string;
2731
2838
  tableFrom: string;
2732
2839
  columnsFrom: string[];
2733
2840
  tableTo: string;
2734
2841
  columnsTo: string[];
2842
+ }>;
2843
+ compositePrimaryKeys: Record<string, {
2844
+ name?: string | undefined;
2845
+ columns: string[];
2846
+ }>;
2847
+ uniqueConstraints: Record<string, {
2848
+ name: string;
2849
+ columns: string[];
2850
+ }>;
2851
+ }, {
2852
+ uniqueConstraints?: Record<string, {
2853
+ name: string;
2854
+ columns: string[];
2855
+ }> | undefined;
2856
+ name: string;
2857
+ columns: Record<string, {
2858
+ default?: any;
2859
+ autoincrement?: boolean | undefined;
2860
+ name: string;
2861
+ type: string;
2862
+ primaryKey: boolean;
2863
+ notNull: boolean;
2864
+ }>;
2865
+ indexes: Record<string, {
2866
+ where?: string | undefined;
2867
+ name: string;
2868
+ columns: string[];
2869
+ isUnique: boolean;
2870
+ }>;
2871
+ foreignKeys: Record<string, {
2735
2872
  onUpdate?: string | undefined;
2736
2873
  onDelete?: string | undefined;
2874
+ name: string;
2875
+ tableFrom: string;
2876
+ columnsFrom: string[];
2877
+ tableTo: string;
2878
+ columnsTo: string[];
2737
2879
  }>;
2738
2880
  compositePrimaryKeys: Record<string, {
2881
+ name?: string | undefined;
2739
2882
  columns: string[];
2883
+ }>;
2884
+ }>>;
2885
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
2886
+ }, {
2887
+ id: import("zod").ZodString;
2888
+ prevId: import("zod").ZodString;
2889
+ }>, "strict", import("zod").ZodTypeAny, {
2890
+ id: string;
2891
+ prevId: string;
2892
+ version: "4";
2893
+ dialect: "sqlite";
2894
+ tables: Record<string, {
2895
+ name: string;
2896
+ columns: Record<string, {
2897
+ default?: any;
2898
+ autoincrement?: boolean | undefined;
2899
+ name: string;
2900
+ type: string;
2901
+ primaryKey: boolean;
2902
+ notNull: boolean;
2903
+ }>;
2904
+ indexes: Record<string, {
2905
+ where?: string | undefined;
2906
+ name: string;
2907
+ columns: string[];
2908
+ isUnique: boolean;
2909
+ }>;
2910
+ foreignKeys: Record<string, {
2911
+ onUpdate?: string | undefined;
2912
+ onDelete?: string | undefined;
2913
+ name: string;
2914
+ tableFrom: string;
2915
+ columnsFrom: string[];
2916
+ tableTo: string;
2917
+ columnsTo: string[];
2918
+ }>;
2919
+ compositePrimaryKeys: Record<string, {
2740
2920
  name?: string | undefined;
2921
+ columns: string[];
2741
2922
  }>;
2742
2923
  uniqueConstraints: Record<string, {
2743
2924
  name: string;
2744
2925
  columns: string[];
2745
2926
  }>;
2746
2927
  }>;
2928
+ enums: {};
2929
+ }, {
2747
2930
  id: string;
2748
2931
  prevId: string;
2749
- version: "5";
2932
+ version: "4";
2750
2933
  dialect: "sqlite";
2751
- _meta: {
2752
- columns: Record<string, string>;
2753
- tables: Record<string, string>;
2754
- };
2755
- enums: {};
2756
- }, {
2757
2934
  tables: Record<string, {
2935
+ uniqueConstraints?: Record<string, {
2936
+ name: string;
2937
+ columns: string[];
2938
+ }> | undefined;
2758
2939
  name: string;
2759
2940
  columns: Record<string, {
2941
+ default?: any;
2942
+ autoincrement?: boolean | undefined;
2760
2943
  name: string;
2761
2944
  type: string;
2762
2945
  primaryKey: boolean;
2763
2946
  notNull: boolean;
2947
+ }>;
2948
+ indexes: Record<string, {
2949
+ where?: string | undefined;
2950
+ name: string;
2951
+ columns: string[];
2952
+ isUnique: boolean;
2953
+ }>;
2954
+ foreignKeys: Record<string, {
2955
+ onUpdate?: string | undefined;
2956
+ onDelete?: string | undefined;
2957
+ name: string;
2958
+ tableFrom: string;
2959
+ columnsFrom: string[];
2960
+ tableTo: string;
2961
+ columnsTo: string[];
2962
+ }>;
2963
+ compositePrimaryKeys: Record<string, {
2964
+ name?: string | undefined;
2965
+ columns: string[];
2966
+ }>;
2967
+ }>;
2968
+ enums: {};
2969
+ }>, import("zod").ZodObject<import("zod").extendShape<{
2970
+ version: import("zod").ZodLiteral<"5">;
2971
+ dialect: import("zod").ZodEnum<["sqlite"]>;
2972
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2973
+ name: import("zod").ZodString;
2974
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2975
+ name: import("zod").ZodString;
2976
+ type: import("zod").ZodString;
2977
+ primaryKey: import("zod").ZodBoolean;
2978
+ notNull: import("zod").ZodBoolean;
2979
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2980
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2981
+ }, "strict", import("zod").ZodTypeAny, {
2982
+ default?: any;
2983
+ autoincrement?: boolean | undefined;
2984
+ name: string;
2985
+ type: string;
2986
+ primaryKey: boolean;
2987
+ notNull: boolean;
2988
+ }, {
2764
2989
  default?: any;
2765
2990
  autoincrement?: boolean | undefined;
2991
+ name: string;
2992
+ type: string;
2993
+ primaryKey: boolean;
2994
+ notNull: boolean;
2995
+ }>>;
2996
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2997
+ name: import("zod").ZodString;
2998
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2999
+ where: import("zod").ZodOptional<import("zod").ZodString>;
3000
+ isUnique: import("zod").ZodBoolean;
3001
+ }, "strict", import("zod").ZodTypeAny, {
3002
+ where?: string | undefined;
3003
+ name: string;
3004
+ columns: string[];
3005
+ isUnique: boolean;
3006
+ }, {
3007
+ where?: string | undefined;
3008
+ name: string;
3009
+ columns: string[];
3010
+ isUnique: boolean;
3011
+ }>>;
3012
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3013
+ name: import("zod").ZodString;
3014
+ tableFrom: import("zod").ZodString;
3015
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
3016
+ tableTo: import("zod").ZodString;
3017
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
3018
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
3019
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
3020
+ }, "strict", import("zod").ZodTypeAny, {
3021
+ onUpdate?: string | undefined;
3022
+ onDelete?: string | undefined;
3023
+ name: string;
3024
+ tableFrom: string;
3025
+ columnsFrom: string[];
3026
+ tableTo: string;
3027
+ columnsTo: string[];
3028
+ }, {
3029
+ onUpdate?: string | undefined;
3030
+ onDelete?: string | undefined;
3031
+ name: string;
3032
+ tableFrom: string;
3033
+ columnsFrom: string[];
3034
+ tableTo: string;
3035
+ columnsTo: string[];
3036
+ }>>;
3037
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3038
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3039
+ name: import("zod").ZodOptional<import("zod").ZodString>;
3040
+ }, "strict", import("zod").ZodTypeAny, {
3041
+ name?: string | undefined;
3042
+ columns: string[];
3043
+ }, {
3044
+ name?: string | undefined;
3045
+ columns: string[];
3046
+ }>>;
3047
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
3048
+ name: import("zod").ZodString;
3049
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
3050
+ }, "strict", import("zod").ZodTypeAny, {
3051
+ name: string;
3052
+ columns: string[];
3053
+ }, {
3054
+ name: string;
3055
+ columns: string[];
3056
+ }>>>;
3057
+ }, "strict", import("zod").ZodTypeAny, {
3058
+ name: string;
3059
+ columns: Record<string, {
3060
+ default?: any;
3061
+ autoincrement?: boolean | undefined;
3062
+ name: string;
3063
+ type: string;
3064
+ primaryKey: boolean;
3065
+ notNull: boolean;
2766
3066
  }>;
2767
3067
  indexes: Record<string, {
3068
+ where?: string | undefined;
2768
3069
  name: string;
2769
3070
  columns: string[];
2770
3071
  isUnique: boolean;
2771
- where?: string | undefined;
2772
3072
  }>;
2773
3073
  foreignKeys: Record<string, {
3074
+ onUpdate?: string | undefined;
3075
+ onDelete?: string | undefined;
2774
3076
  name: string;
2775
3077
  tableFrom: string;
2776
3078
  columnsFrom: string[];
2777
3079
  tableTo: string;
2778
3080
  columnsTo: string[];
3081
+ }>;
3082
+ compositePrimaryKeys: Record<string, {
3083
+ name?: string | undefined;
3084
+ columns: string[];
3085
+ }>;
3086
+ uniqueConstraints: Record<string, {
3087
+ name: string;
3088
+ columns: string[];
3089
+ }>;
3090
+ }, {
3091
+ uniqueConstraints?: Record<string, {
3092
+ name: string;
3093
+ columns: string[];
3094
+ }> | undefined;
3095
+ name: string;
3096
+ columns: Record<string, {
3097
+ default?: any;
3098
+ autoincrement?: boolean | undefined;
3099
+ name: string;
3100
+ type: string;
3101
+ primaryKey: boolean;
3102
+ notNull: boolean;
3103
+ }>;
3104
+ indexes: Record<string, {
3105
+ where?: string | undefined;
3106
+ name: string;
3107
+ columns: string[];
3108
+ isUnique: boolean;
3109
+ }>;
3110
+ foreignKeys: Record<string, {
2779
3111
  onUpdate?: string | undefined;
2780
3112
  onDelete?: string | undefined;
3113
+ name: string;
3114
+ tableFrom: string;
3115
+ columnsFrom: string[];
3116
+ tableTo: string;
3117
+ columnsTo: string[];
2781
3118
  }>;
2782
3119
  compositePrimaryKeys: Record<string, {
3120
+ name?: string | undefined;
3121
+ columns: string[];
3122
+ }>;
3123
+ }>>;
3124
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
3125
+ _meta: import("zod").ZodObject<{
3126
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3127
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3128
+ }, "strip", import("zod").ZodTypeAny, {
3129
+ columns: Record<string, string>;
3130
+ tables: Record<string, string>;
3131
+ }, {
3132
+ columns: Record<string, string>;
3133
+ tables: Record<string, string>;
3134
+ }>;
3135
+ }, {
3136
+ id: import("zod").ZodString;
3137
+ prevId: import("zod").ZodString;
3138
+ }>, "strict", import("zod").ZodTypeAny, {
3139
+ id: string;
3140
+ prevId: string;
3141
+ version: "5";
3142
+ dialect: "sqlite";
3143
+ tables: Record<string, {
3144
+ name: string;
3145
+ columns: Record<string, {
3146
+ default?: any;
3147
+ autoincrement?: boolean | undefined;
3148
+ name: string;
3149
+ type: string;
3150
+ primaryKey: boolean;
3151
+ notNull: boolean;
3152
+ }>;
3153
+ indexes: Record<string, {
3154
+ where?: string | undefined;
3155
+ name: string;
2783
3156
  columns: string[];
3157
+ isUnique: boolean;
3158
+ }>;
3159
+ foreignKeys: Record<string, {
3160
+ onUpdate?: string | undefined;
3161
+ onDelete?: string | undefined;
3162
+ name: string;
3163
+ tableFrom: string;
3164
+ columnsFrom: string[];
3165
+ tableTo: string;
3166
+ columnsTo: string[];
3167
+ }>;
3168
+ compositePrimaryKeys: Record<string, {
2784
3169
  name?: string | undefined;
3170
+ columns: string[];
2785
3171
  }>;
2786
- uniqueConstraints?: Record<string, {
3172
+ uniqueConstraints: Record<string, {
2787
3173
  name: string;
2788
3174
  columns: string[];
2789
- }> | undefined;
3175
+ }>;
2790
3176
  }>;
3177
+ _meta: {
3178
+ columns: Record<string, string>;
3179
+ tables: Record<string, string>;
3180
+ };
3181
+ enums: {};
3182
+ }, {
2791
3183
  id: string;
2792
3184
  prevId: string;
2793
3185
  version: "5";
2794
3186
  dialect: "sqlite";
3187
+ tables: Record<string, {
3188
+ uniqueConstraints?: Record<string, {
3189
+ name: string;
3190
+ columns: string[];
3191
+ }> | undefined;
3192
+ name: string;
3193
+ columns: Record<string, {
3194
+ default?: any;
3195
+ autoincrement?: boolean | undefined;
3196
+ name: string;
3197
+ type: string;
3198
+ primaryKey: boolean;
3199
+ notNull: boolean;
3200
+ }>;
3201
+ indexes: Record<string, {
3202
+ where?: string | undefined;
3203
+ name: string;
3204
+ columns: string[];
3205
+ isUnique: boolean;
3206
+ }>;
3207
+ foreignKeys: Record<string, {
3208
+ onUpdate?: string | undefined;
3209
+ onDelete?: string | undefined;
3210
+ name: string;
3211
+ tableFrom: string;
3212
+ columnsFrom: string[];
3213
+ tableTo: string;
3214
+ columnsTo: string[];
3215
+ }>;
3216
+ compositePrimaryKeys: Record<string, {
3217
+ name?: string | undefined;
3218
+ columns: string[];
3219
+ }>;
3220
+ }>;
2795
3221
  _meta: {
2796
3222
  columns: Record<string, string>;
2797
3223
  tables: Record<string, string>;
2798
3224
  };
2799
3225
  enums: {};
2800
- }>;
3226
+ }>]>;
2801
3227
  export {};