drizzle-kit 0.20.16 → 0.20.17-4e262b7

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