drizzle-kit 0.20.16 → 0.20.17-7f33638

Sign up to get free protection for your applications and to get access to all the features.
Files changed (56) hide show
  1. package/bin.cjs +28192 -26852
  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 +4381 -6917
  48. package/utils.mjs +4594 -7130
  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 {};