drizzle-kit 0.19.13-e7108b7 → 0.19.13-e99bac1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (45) hide show
  1. package/@types/utils.d.ts +12 -0
  2. package/cli/commands/migrate.d.ts +141 -0
  3. package/cli/commands/mysqlUp.d.ts +4 -0
  4. package/cli/commands/pgIntrospect.d.ts +118 -0
  5. package/cli/commands/pgPushUtils.d.ts +14 -0
  6. package/cli/commands/pgUp.d.ts +4 -0
  7. package/cli/commands/sqliteIntrospect.d.ts +102 -0
  8. package/cli/commands/sqliteUtils.d.ts +162 -0
  9. package/cli/commands/upFolders.d.ts +27 -0
  10. package/cli/commands/utils.d.ts +265 -0
  11. package/cli/selector-ui.d.ts +13 -0
  12. package/cli/validations/common.d.ts +13 -0
  13. package/cli/validations/mysql.d.ts +414 -0
  14. package/cli/validations/outputs.d.ts +39 -0
  15. package/cli/validations/pg.d.ts +438 -0
  16. package/cli/validations/sqlite.d.ts +220 -0
  17. package/cli/validations/studio.d.ts +469 -0
  18. package/cli/views.d.ts +61 -0
  19. package/drivers/index.d.ts +26 -0
  20. package/global.d.ts +2 -0
  21. package/index.cjs +127 -8668
  22. package/introspect.d.ts +4 -0
  23. package/jsonDiffer.d.ts +76 -0
  24. package/jsonStatements.d.ts +349 -0
  25. package/migrationPreparator.d.ts +35 -0
  26. package/package.json +1 -1
  27. package/schemaValidator.d.ts +1236 -0
  28. package/serializer/index.d.ts +9 -0
  29. package/serializer/mysqlImports.d.ts +6 -0
  30. package/serializer/mysqlSchema.d.ts +3833 -0
  31. package/serializer/mysqlSerializer.d.ts +7 -0
  32. package/serializer/pgImports.d.ts +11 -0
  33. package/serializer/pgSchema.d.ts +4000 -0
  34. package/serializer/pgSerializer.d.ts +7 -0
  35. package/serializer/sqliteImports.d.ts +5 -0
  36. package/serializer/sqliteSchema.d.ts +3162 -0
  37. package/serializer/sqliteSerializer.d.ts +8 -0
  38. package/serializer/studioUtils.d.ts +31 -0
  39. package/snapshotsDiffer.d.ts +2660 -0
  40. package/sqlgenerator.d.ts +33 -0
  41. package/sqlite-introspect.d.ts +5 -0
  42. package/utils/words.d.ts +7 -0
  43. package/utils.d.ts +10 -6
  44. package/utils.js +117 -8658
  45. package/utilsR.d.ts +209 -0
package/serializer/sqliteSchema.d.ts ADDED
@@ -0,0 +1,3162 @@
1
+ import { TypeOf } from "zod";
2
+ declare const index: import("zod").ZodObject<{
3
+ name: import("zod").ZodString;
4
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
5
+ where: import("zod").ZodOptional<import("zod").ZodString>;
6
+ isUnique: import("zod").ZodBoolean;
7
+ }, "strict", import("zod").ZodTypeAny, {
8
+ where?: string | undefined;
9
+ name: string;
10
+ columns: string[];
11
+ isUnique: boolean;
12
+ }, {
13
+ where?: string | undefined;
14
+ name: string;
15
+ columns: string[];
16
+ isUnique: boolean;
17
+ }>;
18
+ declare const fk: import("zod").ZodObject<{
19
+ name: import("zod").ZodString;
20
+ tableFrom: import("zod").ZodString;
21
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
22
+ tableTo: import("zod").ZodString;
23
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
24
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
25
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
26
+ }, "strict", import("zod").ZodTypeAny, {
27
+ onUpdate?: string | undefined;
28
+ onDelete?: string | undefined;
29
+ name: string;
30
+ tableFrom: string;
31
+ columnsFrom: string[];
32
+ tableTo: string;
33
+ columnsTo: string[];
34
+ }, {
35
+ onUpdate?: string | undefined;
36
+ onDelete?: string | undefined;
37
+ name: string;
38
+ tableFrom: string;
39
+ columnsFrom: string[];
40
+ tableTo: string;
41
+ columnsTo: string[];
42
+ }>;
43
+ declare const compositePK: import("zod").ZodObject<{
44
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
45
+ }, "strict", import("zod").ZodTypeAny, {
46
+ columns: string[];
47
+ }, {
48
+ columns: string[];
49
+ }>;
50
+ declare const column: import("zod").ZodObject<{
51
+ name: import("zod").ZodString;
52
+ type: import("zod").ZodString;
53
+ primaryKey: import("zod").ZodBoolean;
54
+ notNull: import("zod").ZodBoolean;
55
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
56
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
57
+ }, "strict", import("zod").ZodTypeAny, {
58
+ default?: any;
59
+ autoincrement?: boolean | undefined;
60
+ name: string;
61
+ type: string;
62
+ primaryKey: boolean;
63
+ notNull: boolean;
64
+ }, {
65
+ default?: any;
66
+ autoincrement?: boolean | undefined;
67
+ name: string;
68
+ type: string;
69
+ primaryKey: boolean;
70
+ notNull: boolean;
71
+ }>;
72
+ declare const uniqueConstraint: import("zod").ZodObject<{
73
+ name: import("zod").ZodString;
74
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
75
+ }, "strict", import("zod").ZodTypeAny, {
76
+ name: string;
77
+ columns: string[];
78
+ }, {
79
+ name: string;
80
+ columns: string[];
81
+ }>;
82
+ declare const table: import("zod").ZodObject<{
83
+ name: import("zod").ZodString;
84
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
85
+ name: import("zod").ZodString;
86
+ type: import("zod").ZodString;
87
+ primaryKey: import("zod").ZodBoolean;
88
+ notNull: import("zod").ZodBoolean;
89
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
90
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
91
+ }, "strict", import("zod").ZodTypeAny, {
92
+ default?: any;
93
+ autoincrement?: boolean | undefined;
94
+ name: string;
95
+ type: string;
96
+ primaryKey: boolean;
97
+ notNull: boolean;
98
+ }, {
99
+ default?: any;
100
+ autoincrement?: boolean | undefined;
101
+ name: string;
102
+ type: string;
103
+ primaryKey: boolean;
104
+ notNull: boolean;
105
+ }>>;
106
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
107
+ name: import("zod").ZodString;
108
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
109
+ where: import("zod").ZodOptional<import("zod").ZodString>;
110
+ isUnique: import("zod").ZodBoolean;
111
+ }, "strict", import("zod").ZodTypeAny, {
112
+ where?: string | undefined;
113
+ name: string;
114
+ columns: string[];
115
+ isUnique: boolean;
116
+ }, {
117
+ where?: string | undefined;
118
+ name: string;
119
+ columns: string[];
120
+ isUnique: boolean;
121
+ }>>;
122
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
123
+ name: import("zod").ZodString;
124
+ tableFrom: import("zod").ZodString;
125
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
126
+ tableTo: import("zod").ZodString;
127
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
128
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
129
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
130
+ }, "strict", import("zod").ZodTypeAny, {
131
+ onUpdate?: string | undefined;
132
+ onDelete?: string | undefined;
133
+ name: string;
134
+ tableFrom: string;
135
+ columnsFrom: string[];
136
+ tableTo: string;
137
+ columnsTo: string[];
138
+ }, {
139
+ onUpdate?: string | undefined;
140
+ onDelete?: string | undefined;
141
+ name: string;
142
+ tableFrom: string;
143
+ columnsFrom: string[];
144
+ tableTo: string;
145
+ columnsTo: string[];
146
+ }>>;
147
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
148
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
149
+ }, "strict", import("zod").ZodTypeAny, {
150
+ columns: string[];
151
+ }, {
152
+ columns: string[];
153
+ }>>;
154
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
155
+ name: import("zod").ZodString;
156
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
157
+ }, "strict", import("zod").ZodTypeAny, {
158
+ name: string;
159
+ columns: string[];
160
+ }, {
161
+ name: string;
162
+ columns: string[];
163
+ }>>>;
164
+ }, "strict", import("zod").ZodTypeAny, {
165
+ name: string;
166
+ columns: Record<string, {
167
+ default?: any;
168
+ autoincrement?: boolean | undefined;
169
+ name: string;
170
+ type: string;
171
+ primaryKey: boolean;
172
+ notNull: boolean;
173
+ }>;
174
+ indexes: Record<string, {
175
+ where?: string | undefined;
176
+ name: string;
177
+ columns: string[];
178
+ isUnique: boolean;
179
+ }>;
180
+ foreignKeys: Record<string, {
181
+ onUpdate?: string | undefined;
182
+ onDelete?: string | undefined;
183
+ name: string;
184
+ tableFrom: string;
185
+ columnsFrom: string[];
186
+ tableTo: string;
187
+ columnsTo: string[];
188
+ }>;
189
+ compositePrimaryKeys: Record<string, {
190
+ columns: string[];
191
+ }>;
192
+ uniqueConstraints: Record<string, {
193
+ name: string;
194
+ columns: string[];
195
+ }>;
196
+ }, {
197
+ uniqueConstraints?: Record<string, {
198
+ name: string;
199
+ columns: string[];
200
+ }> | undefined;
201
+ name: string;
202
+ columns: Record<string, {
203
+ default?: any;
204
+ autoincrement?: boolean | undefined;
205
+ name: string;
206
+ type: string;
207
+ primaryKey: boolean;
208
+ notNull: boolean;
209
+ }>;
210
+ indexes: Record<string, {
211
+ where?: string | undefined;
212
+ name: string;
213
+ columns: string[];
214
+ isUnique: boolean;
215
+ }>;
216
+ foreignKeys: Record<string, {
217
+ onUpdate?: string | undefined;
218
+ onDelete?: string | undefined;
219
+ name: string;
220
+ tableFrom: string;
221
+ columnsFrom: string[];
222
+ tableTo: string;
223
+ columnsTo: string[];
224
+ }>;
225
+ compositePrimaryKeys: Record<string, {
226
+ columns: string[];
227
+ }>;
228
+ }>;
229
+ declare const dialect: import("zod").ZodEnum<["sqlite"]>;
230
+ export declare const schemaInternalV3: import("zod").ZodObject<{
231
+ version: import("zod").ZodLiteral<"3">;
232
+ dialect: import("zod").ZodEnum<["sqlite"]>;
233
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
234
+ name: import("zod").ZodString;
235
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
236
+ name: import("zod").ZodString;
237
+ type: import("zod").ZodString;
238
+ primaryKey: import("zod").ZodBoolean;
239
+ notNull: import("zod").ZodBoolean;
240
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
241
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
242
+ }, "strict", import("zod").ZodTypeAny, {
243
+ default?: any;
244
+ autoincrement?: boolean | undefined;
245
+ name: string;
246
+ type: string;
247
+ primaryKey: boolean;
248
+ notNull: boolean;
249
+ }, {
250
+ default?: any;
251
+ autoincrement?: boolean | undefined;
252
+ name: string;
253
+ type: string;
254
+ primaryKey: boolean;
255
+ notNull: boolean;
256
+ }>>;
257
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
258
+ name: import("zod").ZodString;
259
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
260
+ where: import("zod").ZodOptional<import("zod").ZodString>;
261
+ isUnique: import("zod").ZodBoolean;
262
+ }, "strict", import("zod").ZodTypeAny, {
263
+ where?: string | undefined;
264
+ name: string;
265
+ columns: string[];
266
+ isUnique: boolean;
267
+ }, {
268
+ where?: string | undefined;
269
+ name: string;
270
+ columns: string[];
271
+ isUnique: boolean;
272
+ }>>;
273
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
274
+ name: import("zod").ZodString;
275
+ tableFrom: import("zod").ZodString;
276
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
277
+ tableTo: import("zod").ZodString;
278
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
279
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
280
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
281
+ }, "strict", import("zod").ZodTypeAny, {
282
+ onUpdate?: string | undefined;
283
+ onDelete?: string | undefined;
284
+ name: string;
285
+ tableFrom: string;
286
+ columnsFrom: string[];
287
+ tableTo: string;
288
+ columnsTo: string[];
289
+ }, {
290
+ onUpdate?: string | undefined;
291
+ onDelete?: string | undefined;
292
+ name: string;
293
+ tableFrom: string;
294
+ columnsFrom: string[];
295
+ tableTo: string;
296
+ columnsTo: string[];
297
+ }>>;
298
+ }, "strict", import("zod").ZodTypeAny, {
299
+ name: string;
300
+ columns: Record<string, {
301
+ default?: any;
302
+ autoincrement?: boolean | undefined;
303
+ name: string;
304
+ type: string;
305
+ primaryKey: boolean;
306
+ notNull: boolean;
307
+ }>;
308
+ indexes: Record<string, {
309
+ where?: string | undefined;
310
+ name: string;
311
+ columns: string[];
312
+ isUnique: boolean;
313
+ }>;
314
+ foreignKeys: Record<string, {
315
+ onUpdate?: string | undefined;
316
+ onDelete?: string | undefined;
317
+ name: string;
318
+ tableFrom: string;
319
+ columnsFrom: string[];
320
+ tableTo: string;
321
+ columnsTo: string[];
322
+ }>;
323
+ }, {
324
+ name: string;
325
+ columns: Record<string, {
326
+ default?: any;
327
+ autoincrement?: boolean | undefined;
328
+ name: string;
329
+ type: string;
330
+ primaryKey: boolean;
331
+ notNull: boolean;
332
+ }>;
333
+ indexes: Record<string, {
334
+ where?: string | undefined;
335
+ name: string;
336
+ columns: string[];
337
+ isUnique: boolean;
338
+ }>;
339
+ foreignKeys: Record<string, {
340
+ onUpdate?: string | undefined;
341
+ onDelete?: string | undefined;
342
+ name: string;
343
+ tableFrom: string;
344
+ columnsFrom: string[];
345
+ tableTo: string;
346
+ columnsTo: string[];
347
+ }>;
348
+ }>>;
349
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
350
+ }, "strict", import("zod").ZodTypeAny, {
351
+ version: "3";
352
+ dialect: "sqlite";
353
+ tables: Record<string, {
354
+ name: string;
355
+ columns: Record<string, {
356
+ default?: any;
357
+ autoincrement?: boolean | undefined;
358
+ name: string;
359
+ type: string;
360
+ primaryKey: boolean;
361
+ notNull: boolean;
362
+ }>;
363
+ indexes: Record<string, {
364
+ where?: string | undefined;
365
+ name: string;
366
+ columns: string[];
367
+ isUnique: boolean;
368
+ }>;
369
+ foreignKeys: Record<string, {
370
+ onUpdate?: string | undefined;
371
+ onDelete?: string | undefined;
372
+ name: string;
373
+ tableFrom: string;
374
+ columnsFrom: string[];
375
+ tableTo: string;
376
+ columnsTo: string[];
377
+ }>;
378
+ }>;
379
+ enums: {};
380
+ }, {
381
+ version: "3";
382
+ dialect: "sqlite";
383
+ tables: Record<string, {
384
+ name: string;
385
+ columns: Record<string, {
386
+ default?: any;
387
+ autoincrement?: boolean | undefined;
388
+ name: string;
389
+ type: string;
390
+ primaryKey: boolean;
391
+ notNull: boolean;
392
+ }>;
393
+ indexes: Record<string, {
394
+ where?: string | undefined;
395
+ name: string;
396
+ columns: string[];
397
+ isUnique: boolean;
398
+ }>;
399
+ foreignKeys: Record<string, {
400
+ onUpdate?: string | undefined;
401
+ onDelete?: string | undefined;
402
+ name: string;
403
+ tableFrom: string;
404
+ columnsFrom: string[];
405
+ tableTo: string;
406
+ columnsTo: string[];
407
+ }>;
408
+ }>;
409
+ enums: {};
410
+ }>;
411
+ export declare const schemaInternalV4: import("zod").ZodObject<{
412
+ version: import("zod").ZodLiteral<"4">;
413
+ dialect: import("zod").ZodEnum<["sqlite"]>;
414
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
415
+ name: import("zod").ZodString;
416
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
417
+ name: import("zod").ZodString;
418
+ type: import("zod").ZodString;
419
+ primaryKey: import("zod").ZodBoolean;
420
+ notNull: import("zod").ZodBoolean;
421
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
422
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
423
+ }, "strict", import("zod").ZodTypeAny, {
424
+ default?: any;
425
+ autoincrement?: boolean | undefined;
426
+ name: string;
427
+ type: string;
428
+ primaryKey: boolean;
429
+ notNull: boolean;
430
+ }, {
431
+ default?: any;
432
+ autoincrement?: boolean | undefined;
433
+ name: string;
434
+ type: string;
435
+ primaryKey: boolean;
436
+ notNull: boolean;
437
+ }>>;
438
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
439
+ name: import("zod").ZodString;
440
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
441
+ where: import("zod").ZodOptional<import("zod").ZodString>;
442
+ isUnique: import("zod").ZodBoolean;
443
+ }, "strict", import("zod").ZodTypeAny, {
444
+ where?: string | undefined;
445
+ name: string;
446
+ columns: string[];
447
+ isUnique: boolean;
448
+ }, {
449
+ where?: string | undefined;
450
+ name: string;
451
+ columns: string[];
452
+ isUnique: boolean;
453
+ }>>;
454
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
455
+ name: import("zod").ZodString;
456
+ tableFrom: import("zod").ZodString;
457
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
458
+ tableTo: import("zod").ZodString;
459
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
460
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
461
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
462
+ }, "strict", import("zod").ZodTypeAny, {
463
+ onUpdate?: string | undefined;
464
+ onDelete?: string | undefined;
465
+ name: string;
466
+ tableFrom: string;
467
+ columnsFrom: string[];
468
+ tableTo: string;
469
+ columnsTo: string[];
470
+ }, {
471
+ onUpdate?: string | undefined;
472
+ onDelete?: string | undefined;
473
+ name: string;
474
+ tableFrom: string;
475
+ columnsFrom: string[];
476
+ tableTo: string;
477
+ columnsTo: string[];
478
+ }>>;
479
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
480
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
481
+ }, "strict", import("zod").ZodTypeAny, {
482
+ columns: string[];
483
+ }, {
484
+ columns: string[];
485
+ }>>;
486
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
487
+ name: import("zod").ZodString;
488
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
489
+ }, "strict", import("zod").ZodTypeAny, {
490
+ name: string;
491
+ columns: string[];
492
+ }, {
493
+ name: string;
494
+ columns: string[];
495
+ }>>>;
496
+ }, "strict", import("zod").ZodTypeAny, {
497
+ name: string;
498
+ columns: Record<string, {
499
+ default?: any;
500
+ autoincrement?: boolean | undefined;
501
+ name: string;
502
+ type: string;
503
+ primaryKey: boolean;
504
+ notNull: boolean;
505
+ }>;
506
+ indexes: Record<string, {
507
+ where?: string | undefined;
508
+ name: string;
509
+ columns: string[];
510
+ isUnique: boolean;
511
+ }>;
512
+ foreignKeys: Record<string, {
513
+ onUpdate?: string | undefined;
514
+ onDelete?: string | undefined;
515
+ name: string;
516
+ tableFrom: string;
517
+ columnsFrom: string[];
518
+ tableTo: string;
519
+ columnsTo: string[];
520
+ }>;
521
+ compositePrimaryKeys: Record<string, {
522
+ columns: string[];
523
+ }>;
524
+ uniqueConstraints: Record<string, {
525
+ name: string;
526
+ columns: string[];
527
+ }>;
528
+ }, {
529
+ uniqueConstraints?: Record<string, {
530
+ name: string;
531
+ columns: string[];
532
+ }> | undefined;
533
+ name: string;
534
+ columns: Record<string, {
535
+ default?: any;
536
+ autoincrement?: boolean | undefined;
537
+ name: string;
538
+ type: string;
539
+ primaryKey: boolean;
540
+ notNull: boolean;
541
+ }>;
542
+ indexes: Record<string, {
543
+ where?: string | undefined;
544
+ name: string;
545
+ columns: string[];
546
+ isUnique: boolean;
547
+ }>;
548
+ foreignKeys: Record<string, {
549
+ onUpdate?: string | undefined;
550
+ onDelete?: string | undefined;
551
+ name: string;
552
+ tableFrom: string;
553
+ columnsFrom: string[];
554
+ tableTo: string;
555
+ columnsTo: string[];
556
+ }>;
557
+ compositePrimaryKeys: Record<string, {
558
+ columns: string[];
559
+ }>;
560
+ }>>;
561
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
562
+ }, "strict", import("zod").ZodTypeAny, {
563
+ version: "4";
564
+ dialect: "sqlite";
565
+ tables: Record<string, {
566
+ name: string;
567
+ columns: Record<string, {
568
+ default?: any;
569
+ autoincrement?: boolean | undefined;
570
+ name: string;
571
+ type: string;
572
+ primaryKey: boolean;
573
+ notNull: boolean;
574
+ }>;
575
+ indexes: Record<string, {
576
+ where?: string | undefined;
577
+ name: string;
578
+ columns: string[];
579
+ isUnique: boolean;
580
+ }>;
581
+ foreignKeys: Record<string, {
582
+ onUpdate?: string | undefined;
583
+ onDelete?: string | undefined;
584
+ name: string;
585
+ tableFrom: string;
586
+ columnsFrom: string[];
587
+ tableTo: string;
588
+ columnsTo: string[];
589
+ }>;
590
+ compositePrimaryKeys: Record<string, {
591
+ columns: string[];
592
+ }>;
593
+ uniqueConstraints: Record<string, {
594
+ name: string;
595
+ columns: string[];
596
+ }>;
597
+ }>;
598
+ enums: {};
599
+ }, {
600
+ version: "4";
601
+ dialect: "sqlite";
602
+ tables: Record<string, {
603
+ uniqueConstraints?: Record<string, {
604
+ name: string;
605
+ columns: string[];
606
+ }> | undefined;
607
+ name: string;
608
+ columns: Record<string, {
609
+ default?: any;
610
+ autoincrement?: boolean | undefined;
611
+ name: string;
612
+ type: string;
613
+ primaryKey: boolean;
614
+ notNull: boolean;
615
+ }>;
616
+ indexes: Record<string, {
617
+ where?: string | undefined;
618
+ name: string;
619
+ columns: string[];
620
+ isUnique: boolean;
621
+ }>;
622
+ foreignKeys: Record<string, {
623
+ onUpdate?: string | undefined;
624
+ onDelete?: string | undefined;
625
+ name: string;
626
+ tableFrom: string;
627
+ columnsFrom: string[];
628
+ tableTo: string;
629
+ columnsTo: string[];
630
+ }>;
631
+ compositePrimaryKeys: Record<string, {
632
+ columns: string[];
633
+ }>;
634
+ }>;
635
+ enums: {};
636
+ }>;
637
+ export declare const schemaInternal: import("zod").ZodObject<{
638
+ version: import("zod").ZodLiteral<"5">;
639
+ dialect: import("zod").ZodEnum<["sqlite"]>;
640
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
641
+ name: import("zod").ZodString;
642
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
643
+ name: import("zod").ZodString;
644
+ type: import("zod").ZodString;
645
+ primaryKey: import("zod").ZodBoolean;
646
+ notNull: import("zod").ZodBoolean;
647
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
648
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
649
+ }, "strict", import("zod").ZodTypeAny, {
650
+ default?: any;
651
+ autoincrement?: boolean | undefined;
652
+ name: string;
653
+ type: string;
654
+ primaryKey: boolean;
655
+ notNull: boolean;
656
+ }, {
657
+ default?: any;
658
+ autoincrement?: boolean | undefined;
659
+ name: string;
660
+ type: string;
661
+ primaryKey: boolean;
662
+ notNull: boolean;
663
+ }>>;
664
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
665
+ name: import("zod").ZodString;
666
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
667
+ where: import("zod").ZodOptional<import("zod").ZodString>;
668
+ isUnique: import("zod").ZodBoolean;
669
+ }, "strict", import("zod").ZodTypeAny, {
670
+ where?: string | undefined;
671
+ name: string;
672
+ columns: string[];
673
+ isUnique: boolean;
674
+ }, {
675
+ where?: string | undefined;
676
+ name: string;
677
+ columns: string[];
678
+ isUnique: boolean;
679
+ }>>;
680
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
681
+ name: import("zod").ZodString;
682
+ tableFrom: import("zod").ZodString;
683
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
684
+ tableTo: import("zod").ZodString;
685
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
686
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
687
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
688
+ }, "strict", import("zod").ZodTypeAny, {
689
+ onUpdate?: string | undefined;
690
+ onDelete?: string | undefined;
691
+ name: string;
692
+ tableFrom: string;
693
+ columnsFrom: string[];
694
+ tableTo: string;
695
+ columnsTo: string[];
696
+ }, {
697
+ onUpdate?: string | undefined;
698
+ onDelete?: string | undefined;
699
+ name: string;
700
+ tableFrom: string;
701
+ columnsFrom: string[];
702
+ tableTo: string;
703
+ columnsTo: string[];
704
+ }>>;
705
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
706
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
707
+ }, "strict", import("zod").ZodTypeAny, {
708
+ columns: string[];
709
+ }, {
710
+ columns: string[];
711
+ }>>;
712
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
713
+ name: import("zod").ZodString;
714
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
715
+ }, "strict", import("zod").ZodTypeAny, {
716
+ name: string;
717
+ columns: string[];
718
+ }, {
719
+ name: string;
720
+ columns: string[];
721
+ }>>>;
722
+ }, "strict", import("zod").ZodTypeAny, {
723
+ name: string;
724
+ columns: Record<string, {
725
+ default?: any;
726
+ autoincrement?: boolean | undefined;
727
+ name: string;
728
+ type: string;
729
+ primaryKey: boolean;
730
+ notNull: boolean;
731
+ }>;
732
+ indexes: Record<string, {
733
+ where?: string | undefined;
734
+ name: string;
735
+ columns: string[];
736
+ isUnique: boolean;
737
+ }>;
738
+ foreignKeys: Record<string, {
739
+ onUpdate?: string | undefined;
740
+ onDelete?: string | undefined;
741
+ name: string;
742
+ tableFrom: string;
743
+ columnsFrom: string[];
744
+ tableTo: string;
745
+ columnsTo: string[];
746
+ }>;
747
+ compositePrimaryKeys: Record<string, {
748
+ columns: string[];
749
+ }>;
750
+ uniqueConstraints: Record<string, {
751
+ name: string;
752
+ columns: string[];
753
+ }>;
754
+ }, {
755
+ uniqueConstraints?: Record<string, {
756
+ name: string;
757
+ columns: string[];
758
+ }> | undefined;
759
+ name: string;
760
+ columns: Record<string, {
761
+ default?: any;
762
+ autoincrement?: boolean | undefined;
763
+ name: string;
764
+ type: string;
765
+ primaryKey: boolean;
766
+ notNull: boolean;
767
+ }>;
768
+ indexes: Record<string, {
769
+ where?: string | undefined;
770
+ name: string;
771
+ columns: string[];
772
+ isUnique: boolean;
773
+ }>;
774
+ foreignKeys: Record<string, {
775
+ onUpdate?: string | undefined;
776
+ onDelete?: string | undefined;
777
+ name: string;
778
+ tableFrom: string;
779
+ columnsFrom: string[];
780
+ tableTo: string;
781
+ columnsTo: string[];
782
+ }>;
783
+ compositePrimaryKeys: Record<string, {
784
+ columns: string[];
785
+ }>;
786
+ }>>;
787
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
788
+ _meta: import("zod").ZodObject<{
789
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
790
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
791
+ }, "strip", import("zod").ZodTypeAny, {
792
+ columns: Record<string, string>;
793
+ tables: Record<string, string>;
794
+ }, {
795
+ columns: Record<string, string>;
796
+ tables: Record<string, string>;
797
+ }>;
798
+ }, "strict", import("zod").ZodTypeAny, {
799
+ version: "5";
800
+ dialect: "sqlite";
801
+ tables: Record<string, {
802
+ name: string;
803
+ columns: Record<string, {
804
+ default?: any;
805
+ autoincrement?: boolean | undefined;
806
+ name: string;
807
+ type: string;
808
+ primaryKey: boolean;
809
+ notNull: boolean;
810
+ }>;
811
+ indexes: Record<string, {
812
+ where?: string | undefined;
813
+ name: string;
814
+ columns: string[];
815
+ isUnique: boolean;
816
+ }>;
817
+ foreignKeys: Record<string, {
818
+ onUpdate?: string | undefined;
819
+ onDelete?: string | undefined;
820
+ name: string;
821
+ tableFrom: string;
822
+ columnsFrom: string[];
823
+ tableTo: string;
824
+ columnsTo: string[];
825
+ }>;
826
+ compositePrimaryKeys: Record<string, {
827
+ columns: string[];
828
+ }>;
829
+ uniqueConstraints: Record<string, {
830
+ name: string;
831
+ columns: string[];
832
+ }>;
833
+ }>;
834
+ _meta: {
835
+ columns: Record<string, string>;
836
+ tables: Record<string, string>;
837
+ };
838
+ enums: {};
839
+ }, {
840
+ version: "5";
841
+ dialect: "sqlite";
842
+ tables: Record<string, {
843
+ uniqueConstraints?: Record<string, {
844
+ name: string;
845
+ columns: string[];
846
+ }> | undefined;
847
+ name: string;
848
+ columns: Record<string, {
849
+ default?: any;
850
+ autoincrement?: boolean | undefined;
851
+ name: string;
852
+ type: string;
853
+ primaryKey: boolean;
854
+ notNull: boolean;
855
+ }>;
856
+ indexes: Record<string, {
857
+ where?: string | undefined;
858
+ name: string;
859
+ columns: string[];
860
+ isUnique: boolean;
861
+ }>;
862
+ foreignKeys: Record<string, {
863
+ onUpdate?: string | undefined;
864
+ onDelete?: string | undefined;
865
+ name: string;
866
+ tableFrom: string;
867
+ columnsFrom: string[];
868
+ tableTo: string;
869
+ columnsTo: string[];
870
+ }>;
871
+ compositePrimaryKeys: Record<string, {
872
+ columns: string[];
873
+ }>;
874
+ }>;
875
+ _meta: {
876
+ columns: Record<string, string>;
877
+ tables: Record<string, string>;
878
+ };
879
+ enums: {};
880
+ }>;
881
+ export declare const schemaV3: import("zod").ZodObject<import("zod").extendShape<{
882
+ version: import("zod").ZodLiteral<"3">;
883
+ dialect: import("zod").ZodEnum<["sqlite"]>;
884
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
885
+ name: import("zod").ZodString;
886
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
887
+ name: import("zod").ZodString;
888
+ type: import("zod").ZodString;
889
+ primaryKey: import("zod").ZodBoolean;
890
+ notNull: import("zod").ZodBoolean;
891
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
892
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
893
+ }, "strict", import("zod").ZodTypeAny, {
894
+ default?: any;
895
+ autoincrement?: boolean | undefined;
896
+ name: string;
897
+ type: string;
898
+ primaryKey: boolean;
899
+ notNull: boolean;
900
+ }, {
901
+ default?: any;
902
+ autoincrement?: boolean | undefined;
903
+ name: string;
904
+ type: string;
905
+ primaryKey: boolean;
906
+ notNull: boolean;
907
+ }>>;
908
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
909
+ name: import("zod").ZodString;
910
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
911
+ where: import("zod").ZodOptional<import("zod").ZodString>;
912
+ isUnique: import("zod").ZodBoolean;
913
+ }, "strict", import("zod").ZodTypeAny, {
914
+ where?: string | undefined;
915
+ name: string;
916
+ columns: string[];
917
+ isUnique: boolean;
918
+ }, {
919
+ where?: string | undefined;
920
+ name: string;
921
+ columns: string[];
922
+ isUnique: boolean;
923
+ }>>;
924
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
925
+ name: import("zod").ZodString;
926
+ tableFrom: import("zod").ZodString;
927
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
928
+ tableTo: import("zod").ZodString;
929
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
930
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
931
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
932
+ }, "strict", import("zod").ZodTypeAny, {
933
+ onUpdate?: string | undefined;
934
+ onDelete?: string | undefined;
935
+ name: string;
936
+ tableFrom: string;
937
+ columnsFrom: string[];
938
+ tableTo: string;
939
+ columnsTo: string[];
940
+ }, {
941
+ onUpdate?: string | undefined;
942
+ onDelete?: string | undefined;
943
+ name: string;
944
+ tableFrom: string;
945
+ columnsFrom: string[];
946
+ tableTo: string;
947
+ columnsTo: string[];
948
+ }>>;
949
+ }, "strict", import("zod").ZodTypeAny, {
950
+ name: string;
951
+ columns: Record<string, {
952
+ default?: any;
953
+ autoincrement?: boolean | undefined;
954
+ name: string;
955
+ type: string;
956
+ primaryKey: boolean;
957
+ notNull: boolean;
958
+ }>;
959
+ indexes: Record<string, {
960
+ where?: string | undefined;
961
+ name: string;
962
+ columns: string[];
963
+ isUnique: boolean;
964
+ }>;
965
+ foreignKeys: Record<string, {
966
+ onUpdate?: string | undefined;
967
+ onDelete?: string | undefined;
968
+ name: string;
969
+ tableFrom: string;
970
+ columnsFrom: string[];
971
+ tableTo: string;
972
+ columnsTo: string[];
973
+ }>;
974
+ }, {
975
+ name: string;
976
+ columns: Record<string, {
977
+ default?: any;
978
+ autoincrement?: boolean | undefined;
979
+ name: string;
980
+ type: string;
981
+ primaryKey: boolean;
982
+ notNull: boolean;
983
+ }>;
984
+ indexes: Record<string, {
985
+ where?: string | undefined;
986
+ name: string;
987
+ columns: string[];
988
+ isUnique: boolean;
989
+ }>;
990
+ foreignKeys: Record<string, {
991
+ onUpdate?: string | undefined;
992
+ onDelete?: string | undefined;
993
+ name: string;
994
+ tableFrom: string;
995
+ columnsFrom: string[];
996
+ tableTo: string;
997
+ columnsTo: string[];
998
+ }>;
999
+ }>>;
1000
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
1001
+ }, {
1002
+ id: import("zod").ZodString;
1003
+ prevId: import("zod").ZodString;
1004
+ }>, "strict", import("zod").ZodTypeAny, {
1005
+ id: string;
1006
+ prevId: string;
1007
+ version: "3";
1008
+ dialect: "sqlite";
1009
+ tables: Record<string, {
1010
+ name: string;
1011
+ columns: Record<string, {
1012
+ default?: any;
1013
+ autoincrement?: boolean | undefined;
1014
+ name: string;
1015
+ type: string;
1016
+ primaryKey: boolean;
1017
+ notNull: boolean;
1018
+ }>;
1019
+ indexes: Record<string, {
1020
+ where?: string | undefined;
1021
+ name: string;
1022
+ columns: string[];
1023
+ isUnique: boolean;
1024
+ }>;
1025
+ foreignKeys: Record<string, {
1026
+ onUpdate?: string | undefined;
1027
+ onDelete?: string | undefined;
1028
+ name: string;
1029
+ tableFrom: string;
1030
+ columnsFrom: string[];
1031
+ tableTo: string;
1032
+ columnsTo: string[];
1033
+ }>;
1034
+ }>;
1035
+ enums: {};
1036
+ }, {
1037
+ id: string;
1038
+ prevId: string;
1039
+ version: "3";
1040
+ dialect: "sqlite";
1041
+ tables: Record<string, {
1042
+ name: string;
1043
+ columns: Record<string, {
1044
+ default?: any;
1045
+ autoincrement?: boolean | undefined;
1046
+ name: string;
1047
+ type: string;
1048
+ primaryKey: boolean;
1049
+ notNull: boolean;
1050
+ }>;
1051
+ indexes: Record<string, {
1052
+ where?: string | undefined;
1053
+ name: string;
1054
+ columns: string[];
1055
+ isUnique: boolean;
1056
+ }>;
1057
+ foreignKeys: Record<string, {
1058
+ onUpdate?: string | undefined;
1059
+ onDelete?: string | undefined;
1060
+ name: string;
1061
+ tableFrom: string;
1062
+ columnsFrom: string[];
1063
+ tableTo: string;
1064
+ columnsTo: string[];
1065
+ }>;
1066
+ }>;
1067
+ enums: {};
1068
+ }>;
1069
+ export declare const schemaV4: import("zod").ZodObject<import("zod").extendShape<{
1070
+ version: import("zod").ZodLiteral<"4">;
1071
+ dialect: import("zod").ZodEnum<["sqlite"]>;
1072
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1073
+ name: import("zod").ZodString;
1074
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1075
+ name: import("zod").ZodString;
1076
+ type: import("zod").ZodString;
1077
+ primaryKey: import("zod").ZodBoolean;
1078
+ notNull: import("zod").ZodBoolean;
1079
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1080
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
1081
+ }, "strict", import("zod").ZodTypeAny, {
1082
+ default?: any;
1083
+ autoincrement?: boolean | undefined;
1084
+ name: string;
1085
+ type: string;
1086
+ primaryKey: boolean;
1087
+ notNull: boolean;
1088
+ }, {
1089
+ default?: any;
1090
+ autoincrement?: boolean | undefined;
1091
+ name: string;
1092
+ type: string;
1093
+ primaryKey: boolean;
1094
+ notNull: boolean;
1095
+ }>>;
1096
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1097
+ name: import("zod").ZodString;
1098
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1099
+ where: import("zod").ZodOptional<import("zod").ZodString>;
1100
+ isUnique: import("zod").ZodBoolean;
1101
+ }, "strict", import("zod").ZodTypeAny, {
1102
+ where?: string | undefined;
1103
+ name: string;
1104
+ columns: string[];
1105
+ isUnique: boolean;
1106
+ }, {
1107
+ where?: string | undefined;
1108
+ name: string;
1109
+ columns: string[];
1110
+ isUnique: boolean;
1111
+ }>>;
1112
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1113
+ name: import("zod").ZodString;
1114
+ tableFrom: import("zod").ZodString;
1115
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1116
+ tableTo: import("zod").ZodString;
1117
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1118
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1119
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1120
+ }, "strict", import("zod").ZodTypeAny, {
1121
+ onUpdate?: string | undefined;
1122
+ onDelete?: string | undefined;
1123
+ name: string;
1124
+ tableFrom: string;
1125
+ columnsFrom: string[];
1126
+ tableTo: string;
1127
+ columnsTo: string[];
1128
+ }, {
1129
+ onUpdate?: string | undefined;
1130
+ onDelete?: string | undefined;
1131
+ name: string;
1132
+ tableFrom: string;
1133
+ columnsFrom: string[];
1134
+ tableTo: string;
1135
+ columnsTo: string[];
1136
+ }>>;
1137
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1138
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1139
+ }, "strict", import("zod").ZodTypeAny, {
1140
+ columns: string[];
1141
+ }, {
1142
+ columns: string[];
1143
+ }>>;
1144
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1145
+ name: import("zod").ZodString;
1146
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1147
+ }, "strict", import("zod").ZodTypeAny, {
1148
+ name: string;
1149
+ columns: string[];
1150
+ }, {
1151
+ name: string;
1152
+ columns: string[];
1153
+ }>>>;
1154
+ }, "strict", import("zod").ZodTypeAny, {
1155
+ name: string;
1156
+ columns: Record<string, {
1157
+ default?: any;
1158
+ autoincrement?: boolean | undefined;
1159
+ name: string;
1160
+ type: string;
1161
+ primaryKey: boolean;
1162
+ notNull: boolean;
1163
+ }>;
1164
+ indexes: Record<string, {
1165
+ where?: string | undefined;
1166
+ name: string;
1167
+ columns: string[];
1168
+ isUnique: boolean;
1169
+ }>;
1170
+ foreignKeys: Record<string, {
1171
+ onUpdate?: string | undefined;
1172
+ onDelete?: string | undefined;
1173
+ name: string;
1174
+ tableFrom: string;
1175
+ columnsFrom: string[];
1176
+ tableTo: string;
1177
+ columnsTo: string[];
1178
+ }>;
1179
+ compositePrimaryKeys: Record<string, {
1180
+ columns: string[];
1181
+ }>;
1182
+ uniqueConstraints: Record<string, {
1183
+ name: string;
1184
+ columns: string[];
1185
+ }>;
1186
+ }, {
1187
+ uniqueConstraints?: Record<string, {
1188
+ name: string;
1189
+ columns: string[];
1190
+ }> | undefined;
1191
+ name: string;
1192
+ columns: Record<string, {
1193
+ default?: any;
1194
+ autoincrement?: boolean | undefined;
1195
+ name: string;
1196
+ type: string;
1197
+ primaryKey: boolean;
1198
+ notNull: boolean;
1199
+ }>;
1200
+ indexes: Record<string, {
1201
+ where?: string | undefined;
1202
+ name: string;
1203
+ columns: string[];
1204
+ isUnique: boolean;
1205
+ }>;
1206
+ foreignKeys: Record<string, {
1207
+ onUpdate?: string | undefined;
1208
+ onDelete?: string | undefined;
1209
+ name: string;
1210
+ tableFrom: string;
1211
+ columnsFrom: string[];
1212
+ tableTo: string;
1213
+ columnsTo: string[];
1214
+ }>;
1215
+ compositePrimaryKeys: Record<string, {
1216
+ columns: string[];
1217
+ }>;
1218
+ }>>;
1219
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
1220
+ }, {
1221
+ id: import("zod").ZodString;
1222
+ prevId: import("zod").ZodString;
1223
+ }>, "strict", import("zod").ZodTypeAny, {
1224
+ id: string;
1225
+ prevId: string;
1226
+ version: "4";
1227
+ dialect: "sqlite";
1228
+ tables: Record<string, {
1229
+ name: string;
1230
+ columns: Record<string, {
1231
+ default?: any;
1232
+ autoincrement?: boolean | undefined;
1233
+ name: string;
1234
+ type: string;
1235
+ primaryKey: boolean;
1236
+ notNull: boolean;
1237
+ }>;
1238
+ indexes: Record<string, {
1239
+ where?: string | undefined;
1240
+ name: string;
1241
+ columns: string[];
1242
+ isUnique: boolean;
1243
+ }>;
1244
+ foreignKeys: Record<string, {
1245
+ onUpdate?: string | undefined;
1246
+ onDelete?: string | undefined;
1247
+ name: string;
1248
+ tableFrom: string;
1249
+ columnsFrom: string[];
1250
+ tableTo: string;
1251
+ columnsTo: string[];
1252
+ }>;
1253
+ compositePrimaryKeys: Record<string, {
1254
+ columns: string[];
1255
+ }>;
1256
+ uniqueConstraints: Record<string, {
1257
+ name: string;
1258
+ columns: string[];
1259
+ }>;
1260
+ }>;
1261
+ enums: {};
1262
+ }, {
1263
+ id: string;
1264
+ prevId: string;
1265
+ version: "4";
1266
+ dialect: "sqlite";
1267
+ tables: Record<string, {
1268
+ uniqueConstraints?: Record<string, {
1269
+ name: string;
1270
+ columns: string[];
1271
+ }> | undefined;
1272
+ name: string;
1273
+ columns: Record<string, {
1274
+ default?: any;
1275
+ autoincrement?: boolean | undefined;
1276
+ name: string;
1277
+ type: string;
1278
+ primaryKey: boolean;
1279
+ notNull: boolean;
1280
+ }>;
1281
+ indexes: Record<string, {
1282
+ where?: string | undefined;
1283
+ name: string;
1284
+ columns: string[];
1285
+ isUnique: boolean;
1286
+ }>;
1287
+ foreignKeys: Record<string, {
1288
+ onUpdate?: string | undefined;
1289
+ onDelete?: string | undefined;
1290
+ name: string;
1291
+ tableFrom: string;
1292
+ columnsFrom: string[];
1293
+ tableTo: string;
1294
+ columnsTo: string[];
1295
+ }>;
1296
+ compositePrimaryKeys: Record<string, {
1297
+ columns: string[];
1298
+ }>;
1299
+ }>;
1300
+ enums: {};
1301
+ }>;
1302
+ export declare const schema: import("zod").ZodObject<import("zod").extendShape<{
1303
+ version: import("zod").ZodLiteral<"5">;
1304
+ dialect: import("zod").ZodEnum<["sqlite"]>;
1305
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1306
+ name: import("zod").ZodString;
1307
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1308
+ name: import("zod").ZodString;
1309
+ type: import("zod").ZodString;
1310
+ primaryKey: import("zod").ZodBoolean;
1311
+ notNull: import("zod").ZodBoolean;
1312
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1313
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
1314
+ }, "strict", import("zod").ZodTypeAny, {
1315
+ default?: any;
1316
+ autoincrement?: boolean | undefined;
1317
+ name: string;
1318
+ type: string;
1319
+ primaryKey: boolean;
1320
+ notNull: boolean;
1321
+ }, {
1322
+ default?: any;
1323
+ autoincrement?: boolean | undefined;
1324
+ name: string;
1325
+ type: string;
1326
+ primaryKey: boolean;
1327
+ notNull: boolean;
1328
+ }>>;
1329
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1330
+ name: import("zod").ZodString;
1331
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1332
+ where: import("zod").ZodOptional<import("zod").ZodString>;
1333
+ isUnique: import("zod").ZodBoolean;
1334
+ }, "strict", import("zod").ZodTypeAny, {
1335
+ where?: string | undefined;
1336
+ name: string;
1337
+ columns: string[];
1338
+ isUnique: boolean;
1339
+ }, {
1340
+ where?: string | undefined;
1341
+ name: string;
1342
+ columns: string[];
1343
+ isUnique: boolean;
1344
+ }>>;
1345
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1346
+ name: import("zod").ZodString;
1347
+ tableFrom: import("zod").ZodString;
1348
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1349
+ tableTo: import("zod").ZodString;
1350
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1351
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1352
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1353
+ }, "strict", import("zod").ZodTypeAny, {
1354
+ onUpdate?: string | undefined;
1355
+ onDelete?: string | undefined;
1356
+ name: string;
1357
+ tableFrom: string;
1358
+ columnsFrom: string[];
1359
+ tableTo: string;
1360
+ columnsTo: string[];
1361
+ }, {
1362
+ onUpdate?: string | undefined;
1363
+ onDelete?: string | undefined;
1364
+ name: string;
1365
+ tableFrom: string;
1366
+ columnsFrom: string[];
1367
+ tableTo: string;
1368
+ columnsTo: string[];
1369
+ }>>;
1370
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1371
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1372
+ }, "strict", import("zod").ZodTypeAny, {
1373
+ columns: string[];
1374
+ }, {
1375
+ columns: string[];
1376
+ }>>;
1377
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1378
+ name: import("zod").ZodString;
1379
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1380
+ }, "strict", import("zod").ZodTypeAny, {
1381
+ name: string;
1382
+ columns: string[];
1383
+ }, {
1384
+ name: string;
1385
+ columns: string[];
1386
+ }>>>;
1387
+ }, "strict", import("zod").ZodTypeAny, {
1388
+ name: string;
1389
+ columns: Record<string, {
1390
+ default?: any;
1391
+ autoincrement?: boolean | undefined;
1392
+ name: string;
1393
+ type: string;
1394
+ primaryKey: boolean;
1395
+ notNull: boolean;
1396
+ }>;
1397
+ indexes: Record<string, {
1398
+ where?: string | undefined;
1399
+ name: string;
1400
+ columns: string[];
1401
+ isUnique: boolean;
1402
+ }>;
1403
+ foreignKeys: Record<string, {
1404
+ onUpdate?: string | undefined;
1405
+ onDelete?: string | undefined;
1406
+ name: string;
1407
+ tableFrom: string;
1408
+ columnsFrom: string[];
1409
+ tableTo: string;
1410
+ columnsTo: string[];
1411
+ }>;
1412
+ compositePrimaryKeys: Record<string, {
1413
+ columns: string[];
1414
+ }>;
1415
+ uniqueConstraints: Record<string, {
1416
+ name: string;
1417
+ columns: string[];
1418
+ }>;
1419
+ }, {
1420
+ uniqueConstraints?: Record<string, {
1421
+ name: string;
1422
+ columns: string[];
1423
+ }> | undefined;
1424
+ name: string;
1425
+ columns: Record<string, {
1426
+ default?: any;
1427
+ autoincrement?: boolean | undefined;
1428
+ name: string;
1429
+ type: string;
1430
+ primaryKey: boolean;
1431
+ notNull: boolean;
1432
+ }>;
1433
+ indexes: Record<string, {
1434
+ where?: string | undefined;
1435
+ name: string;
1436
+ columns: string[];
1437
+ isUnique: boolean;
1438
+ }>;
1439
+ foreignKeys: Record<string, {
1440
+ onUpdate?: string | undefined;
1441
+ onDelete?: string | undefined;
1442
+ name: string;
1443
+ tableFrom: string;
1444
+ columnsFrom: string[];
1445
+ tableTo: string;
1446
+ columnsTo: string[];
1447
+ }>;
1448
+ compositePrimaryKeys: Record<string, {
1449
+ columns: string[];
1450
+ }>;
1451
+ }>>;
1452
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
1453
+ _meta: import("zod").ZodObject<{
1454
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1455
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1456
+ }, "strip", import("zod").ZodTypeAny, {
1457
+ columns: Record<string, string>;
1458
+ tables: Record<string, string>;
1459
+ }, {
1460
+ columns: Record<string, string>;
1461
+ tables: Record<string, string>;
1462
+ }>;
1463
+ }, {
1464
+ id: import("zod").ZodString;
1465
+ prevId: import("zod").ZodString;
1466
+ }>, "strict", import("zod").ZodTypeAny, {
1467
+ id: string;
1468
+ prevId: string;
1469
+ version: "5";
1470
+ dialect: "sqlite";
1471
+ tables: Record<string, {
1472
+ name: string;
1473
+ columns: Record<string, {
1474
+ default?: any;
1475
+ autoincrement?: boolean | undefined;
1476
+ name: string;
1477
+ type: string;
1478
+ primaryKey: boolean;
1479
+ notNull: boolean;
1480
+ }>;
1481
+ indexes: Record<string, {
1482
+ where?: string | undefined;
1483
+ name: string;
1484
+ columns: string[];
1485
+ isUnique: boolean;
1486
+ }>;
1487
+ foreignKeys: Record<string, {
1488
+ onUpdate?: string | undefined;
1489
+ onDelete?: string | undefined;
1490
+ name: string;
1491
+ tableFrom: string;
1492
+ columnsFrom: string[];
1493
+ tableTo: string;
1494
+ columnsTo: string[];
1495
+ }>;
1496
+ compositePrimaryKeys: Record<string, {
1497
+ columns: string[];
1498
+ }>;
1499
+ uniqueConstraints: Record<string, {
1500
+ name: string;
1501
+ columns: string[];
1502
+ }>;
1503
+ }>;
1504
+ _meta: {
1505
+ columns: Record<string, string>;
1506
+ tables: Record<string, string>;
1507
+ };
1508
+ enums: {};
1509
+ }, {
1510
+ id: string;
1511
+ prevId: string;
1512
+ version: "5";
1513
+ dialect: "sqlite";
1514
+ tables: Record<string, {
1515
+ uniqueConstraints?: Record<string, {
1516
+ name: string;
1517
+ columns: string[];
1518
+ }> | undefined;
1519
+ name: string;
1520
+ columns: Record<string, {
1521
+ default?: any;
1522
+ autoincrement?: boolean | undefined;
1523
+ name: string;
1524
+ type: string;
1525
+ primaryKey: boolean;
1526
+ notNull: boolean;
1527
+ }>;
1528
+ indexes: Record<string, {
1529
+ where?: string | undefined;
1530
+ name: string;
1531
+ columns: string[];
1532
+ isUnique: boolean;
1533
+ }>;
1534
+ foreignKeys: Record<string, {
1535
+ onUpdate?: string | undefined;
1536
+ onDelete?: string | undefined;
1537
+ name: string;
1538
+ tableFrom: string;
1539
+ columnsFrom: string[];
1540
+ tableTo: string;
1541
+ columnsTo: string[];
1542
+ }>;
1543
+ compositePrimaryKeys: Record<string, {
1544
+ columns: string[];
1545
+ }>;
1546
+ }>;
1547
+ _meta: {
1548
+ columns: Record<string, string>;
1549
+ tables: Record<string, string>;
1550
+ };
1551
+ enums: {};
1552
+ }>;
1553
+ export declare const schemaSquashed: import("zod").ZodObject<{
1554
+ version: import("zod").ZodLiteral<"5">;
1555
+ dialect: import("zod").ZodEnum<["sqlite"]>;
1556
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1557
+ name: import("zod").ZodString;
1558
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1559
+ name: import("zod").ZodString;
1560
+ type: import("zod").ZodString;
1561
+ primaryKey: import("zod").ZodBoolean;
1562
+ notNull: import("zod").ZodBoolean;
1563
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1564
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
1565
+ }, "strict", import("zod").ZodTypeAny, {
1566
+ default?: any;
1567
+ autoincrement?: boolean | undefined;
1568
+ name: string;
1569
+ type: string;
1570
+ primaryKey: boolean;
1571
+ notNull: boolean;
1572
+ }, {
1573
+ default?: any;
1574
+ autoincrement?: boolean | undefined;
1575
+ name: string;
1576
+ type: string;
1577
+ primaryKey: boolean;
1578
+ notNull: boolean;
1579
+ }>>;
1580
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1581
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1582
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1583
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
1584
+ }, "strict", import("zod").ZodTypeAny, {
1585
+ name: string;
1586
+ columns: Record<string, {
1587
+ default?: any;
1588
+ autoincrement?: boolean | undefined;
1589
+ name: string;
1590
+ type: string;
1591
+ primaryKey: boolean;
1592
+ notNull: boolean;
1593
+ }>;
1594
+ indexes: Record<string, string>;
1595
+ foreignKeys: Record<string, string>;
1596
+ compositePrimaryKeys: Record<string, string>;
1597
+ uniqueConstraints: Record<string, string>;
1598
+ }, {
1599
+ uniqueConstraints?: Record<string, string> | undefined;
1600
+ name: string;
1601
+ columns: Record<string, {
1602
+ default?: any;
1603
+ autoincrement?: boolean | undefined;
1604
+ name: string;
1605
+ type: string;
1606
+ primaryKey: boolean;
1607
+ notNull: boolean;
1608
+ }>;
1609
+ indexes: Record<string, string>;
1610
+ foreignKeys: Record<string, string>;
1611
+ compositePrimaryKeys: Record<string, string>;
1612
+ }>>;
1613
+ enums: import("zod").ZodAny;
1614
+ }, "strict", import("zod").ZodTypeAny, {
1615
+ enums?: any;
1616
+ version: "5";
1617
+ dialect: "sqlite";
1618
+ tables: Record<string, {
1619
+ name: string;
1620
+ columns: Record<string, {
1621
+ default?: any;
1622
+ autoincrement?: boolean | undefined;
1623
+ name: string;
1624
+ type: string;
1625
+ primaryKey: boolean;
1626
+ notNull: boolean;
1627
+ }>;
1628
+ indexes: Record<string, string>;
1629
+ foreignKeys: Record<string, string>;
1630
+ compositePrimaryKeys: Record<string, string>;
1631
+ uniqueConstraints: Record<string, string>;
1632
+ }>;
1633
+ }, {
1634
+ enums?: any;
1635
+ version: "5";
1636
+ dialect: "sqlite";
1637
+ tables: Record<string, {
1638
+ uniqueConstraints?: Record<string, string> | undefined;
1639
+ name: string;
1640
+ columns: Record<string, {
1641
+ default?: any;
1642
+ autoincrement?: boolean | undefined;
1643
+ name: string;
1644
+ type: string;
1645
+ primaryKey: boolean;
1646
+ notNull: boolean;
1647
+ }>;
1648
+ indexes: Record<string, string>;
1649
+ foreignKeys: Record<string, string>;
1650
+ compositePrimaryKeys: Record<string, string>;
1651
+ }>;
1652
+ }>;
1653
+ export type Dialect = TypeOf<typeof dialect>;
1654
+ export type Column = TypeOf<typeof column>;
1655
+ export type Table = TypeOf<typeof table>;
1656
+ export type SQLiteSchema = TypeOf<typeof schema>;
1657
+ export type SQLiteSchemaV3 = TypeOf<typeof schemaV3>;
1658
+ export type SQLiteSchemaV4 = TypeOf<typeof schemaV4>;
1659
+ export type SQLiteSchemaInternal = TypeOf<typeof schemaInternal>;
1660
+ export type SQLiteSchemaSquashed = TypeOf<typeof schemaSquashed>;
1661
+ export type Index = TypeOf<typeof index>;
1662
+ export type ForeignKey = TypeOf<typeof fk>;
1663
+ export type PrimaryKey = TypeOf<typeof compositePK>;
1664
+ export type UniqueConstraint = TypeOf<typeof uniqueConstraint>;
1665
+ export declare const SQLiteSquasher: {
1666
+ squashIdx: (idx: Index) => string;
1667
+ unsquashIdx: (input: string) => Index;
1668
+ squashUnique: (unq: UniqueConstraint) => string;
1669
+ unsquashUnique: (unq: string) => UniqueConstraint;
1670
+ squashFK: (fk: ForeignKey) => string;
1671
+ unsquashFK: (input: string) => ForeignKey;
1672
+ squashPK: (pk: PrimaryKey) => string;
1673
+ unsquashPK: (pk: string) => string[];
1674
+ };
1675
+ export declare const squashSqliteScheme: (json: SQLiteSchema | SQLiteSchemaV4) => SQLiteSchemaSquashed;
1676
+ export declare const drySQLite: {
1677
+ id: string;
1678
+ prevId: string;
1679
+ version: "5";
1680
+ dialect: "sqlite";
1681
+ tables: Record<string, {
1682
+ name: string;
1683
+ columns: Record<string, {
1684
+ default?: any;
1685
+ autoincrement?: boolean | undefined;
1686
+ name: string;
1687
+ type: string;
1688
+ primaryKey: boolean;
1689
+ notNull: boolean;
1690
+ }>;
1691
+ indexes: Record<string, {
1692
+ where?: string | undefined;
1693
+ name: string;
1694
+ columns: string[];
1695
+ isUnique: boolean;
1696
+ }>;
1697
+ foreignKeys: Record<string, {
1698
+ onUpdate?: string | undefined;
1699
+ onDelete?: string | undefined;
1700
+ name: string;
1701
+ tableFrom: string;
1702
+ columnsFrom: string[];
1703
+ tableTo: string;
1704
+ columnsTo: string[];
1705
+ }>;
1706
+ compositePrimaryKeys: Record<string, {
1707
+ columns: string[];
1708
+ }>;
1709
+ uniqueConstraints: Record<string, {
1710
+ name: string;
1711
+ columns: string[];
1712
+ }>;
1713
+ }>;
1714
+ _meta: {
1715
+ columns: Record<string, string>;
1716
+ tables: Record<string, string>;
1717
+ };
1718
+ enums: {};
1719
+ };
1720
+ export declare const sqliteSchemaV3: import("zod").ZodObject<import("zod").extendShape<{
1721
+ version: import("zod").ZodLiteral<"3">;
1722
+ dialect: import("zod").ZodEnum<["sqlite"]>;
1723
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1724
+ name: import("zod").ZodString;
1725
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1726
+ name: import("zod").ZodString;
1727
+ type: import("zod").ZodString;
1728
+ primaryKey: import("zod").ZodBoolean;
1729
+ notNull: import("zod").ZodBoolean;
1730
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1731
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
1732
+ }, "strict", import("zod").ZodTypeAny, {
1733
+ default?: any;
1734
+ autoincrement?: boolean | undefined;
1735
+ name: string;
1736
+ type: string;
1737
+ primaryKey: boolean;
1738
+ notNull: boolean;
1739
+ }, {
1740
+ default?: any;
1741
+ autoincrement?: boolean | undefined;
1742
+ name: string;
1743
+ type: string;
1744
+ primaryKey: boolean;
1745
+ notNull: boolean;
1746
+ }>>;
1747
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1748
+ name: import("zod").ZodString;
1749
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1750
+ where: import("zod").ZodOptional<import("zod").ZodString>;
1751
+ isUnique: import("zod").ZodBoolean;
1752
+ }, "strict", import("zod").ZodTypeAny, {
1753
+ where?: string | undefined;
1754
+ name: string;
1755
+ columns: string[];
1756
+ isUnique: boolean;
1757
+ }, {
1758
+ where?: string | undefined;
1759
+ name: string;
1760
+ columns: string[];
1761
+ isUnique: boolean;
1762
+ }>>;
1763
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1764
+ name: import("zod").ZodString;
1765
+ tableFrom: import("zod").ZodString;
1766
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1767
+ tableTo: import("zod").ZodString;
1768
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1769
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1770
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1771
+ }, "strict", import("zod").ZodTypeAny, {
1772
+ onUpdate?: string | undefined;
1773
+ onDelete?: string | undefined;
1774
+ name: string;
1775
+ tableFrom: string;
1776
+ columnsFrom: string[];
1777
+ tableTo: string;
1778
+ columnsTo: string[];
1779
+ }, {
1780
+ onUpdate?: string | undefined;
1781
+ onDelete?: string | undefined;
1782
+ name: string;
1783
+ tableFrom: string;
1784
+ columnsFrom: string[];
1785
+ tableTo: string;
1786
+ columnsTo: string[];
1787
+ }>>;
1788
+ }, "strict", import("zod").ZodTypeAny, {
1789
+ name: string;
1790
+ columns: Record<string, {
1791
+ default?: any;
1792
+ autoincrement?: boolean | undefined;
1793
+ name: string;
1794
+ type: string;
1795
+ primaryKey: boolean;
1796
+ notNull: boolean;
1797
+ }>;
1798
+ indexes: Record<string, {
1799
+ where?: string | undefined;
1800
+ name: string;
1801
+ columns: string[];
1802
+ isUnique: boolean;
1803
+ }>;
1804
+ foreignKeys: Record<string, {
1805
+ onUpdate?: string | undefined;
1806
+ onDelete?: string | undefined;
1807
+ name: string;
1808
+ tableFrom: string;
1809
+ columnsFrom: string[];
1810
+ tableTo: string;
1811
+ columnsTo: string[];
1812
+ }>;
1813
+ }, {
1814
+ name: string;
1815
+ columns: Record<string, {
1816
+ default?: any;
1817
+ autoincrement?: boolean | undefined;
1818
+ name: string;
1819
+ type: string;
1820
+ primaryKey: boolean;
1821
+ notNull: boolean;
1822
+ }>;
1823
+ indexes: Record<string, {
1824
+ where?: string | undefined;
1825
+ name: string;
1826
+ columns: string[];
1827
+ isUnique: boolean;
1828
+ }>;
1829
+ foreignKeys: Record<string, {
1830
+ onUpdate?: string | undefined;
1831
+ onDelete?: string | undefined;
1832
+ name: string;
1833
+ tableFrom: string;
1834
+ columnsFrom: string[];
1835
+ tableTo: string;
1836
+ columnsTo: string[];
1837
+ }>;
1838
+ }>>;
1839
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
1840
+ }, {
1841
+ id: import("zod").ZodString;
1842
+ prevId: import("zod").ZodString;
1843
+ }>, "strict", import("zod").ZodTypeAny, {
1844
+ id: string;
1845
+ prevId: string;
1846
+ version: "3";
1847
+ dialect: "sqlite";
1848
+ tables: Record<string, {
1849
+ name: string;
1850
+ columns: Record<string, {
1851
+ default?: any;
1852
+ autoincrement?: boolean | undefined;
1853
+ name: string;
1854
+ type: string;
1855
+ primaryKey: boolean;
1856
+ notNull: boolean;
1857
+ }>;
1858
+ indexes: Record<string, {
1859
+ where?: string | undefined;
1860
+ name: string;
1861
+ columns: string[];
1862
+ isUnique: boolean;
1863
+ }>;
1864
+ foreignKeys: Record<string, {
1865
+ onUpdate?: string | undefined;
1866
+ onDelete?: string | undefined;
1867
+ name: string;
1868
+ tableFrom: string;
1869
+ columnsFrom: string[];
1870
+ tableTo: string;
1871
+ columnsTo: string[];
1872
+ }>;
1873
+ }>;
1874
+ enums: {};
1875
+ }, {
1876
+ id: string;
1877
+ prevId: string;
1878
+ version: "3";
1879
+ dialect: "sqlite";
1880
+ tables: Record<string, {
1881
+ name: string;
1882
+ columns: Record<string, {
1883
+ default?: any;
1884
+ autoincrement?: boolean | undefined;
1885
+ name: string;
1886
+ type: string;
1887
+ primaryKey: boolean;
1888
+ notNull: boolean;
1889
+ }>;
1890
+ indexes: Record<string, {
1891
+ where?: string | undefined;
1892
+ name: string;
1893
+ columns: string[];
1894
+ isUnique: boolean;
1895
+ }>;
1896
+ foreignKeys: Record<string, {
1897
+ onUpdate?: string | undefined;
1898
+ onDelete?: string | undefined;
1899
+ name: string;
1900
+ tableFrom: string;
1901
+ columnsFrom: string[];
1902
+ tableTo: string;
1903
+ columnsTo: string[];
1904
+ }>;
1905
+ }>;
1906
+ enums: {};
1907
+ }>;
1908
+ export declare const sqliteSchemaV4: import("zod").ZodObject<import("zod").extendShape<{
1909
+ version: import("zod").ZodLiteral<"4">;
1910
+ dialect: import("zod").ZodEnum<["sqlite"]>;
1911
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1912
+ name: import("zod").ZodString;
1913
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1914
+ name: import("zod").ZodString;
1915
+ type: import("zod").ZodString;
1916
+ primaryKey: import("zod").ZodBoolean;
1917
+ notNull: import("zod").ZodBoolean;
1918
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1919
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
1920
+ }, "strict", import("zod").ZodTypeAny, {
1921
+ default?: any;
1922
+ autoincrement?: boolean | undefined;
1923
+ name: string;
1924
+ type: string;
1925
+ primaryKey: boolean;
1926
+ notNull: boolean;
1927
+ }, {
1928
+ default?: any;
1929
+ autoincrement?: boolean | undefined;
1930
+ name: string;
1931
+ type: string;
1932
+ primaryKey: boolean;
1933
+ notNull: boolean;
1934
+ }>>;
1935
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1936
+ name: import("zod").ZodString;
1937
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1938
+ where: import("zod").ZodOptional<import("zod").ZodString>;
1939
+ isUnique: import("zod").ZodBoolean;
1940
+ }, "strict", import("zod").ZodTypeAny, {
1941
+ where?: string | undefined;
1942
+ name: string;
1943
+ columns: string[];
1944
+ isUnique: boolean;
1945
+ }, {
1946
+ where?: string | undefined;
1947
+ name: string;
1948
+ columns: string[];
1949
+ isUnique: boolean;
1950
+ }>>;
1951
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1952
+ name: import("zod").ZodString;
1953
+ tableFrom: import("zod").ZodString;
1954
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1955
+ tableTo: import("zod").ZodString;
1956
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1957
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1958
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1959
+ }, "strict", import("zod").ZodTypeAny, {
1960
+ onUpdate?: string | undefined;
1961
+ onDelete?: string | undefined;
1962
+ name: string;
1963
+ tableFrom: string;
1964
+ columnsFrom: string[];
1965
+ tableTo: string;
1966
+ columnsTo: string[];
1967
+ }, {
1968
+ onUpdate?: string | undefined;
1969
+ onDelete?: string | undefined;
1970
+ name: string;
1971
+ tableFrom: string;
1972
+ columnsFrom: string[];
1973
+ tableTo: string;
1974
+ columnsTo: string[];
1975
+ }>>;
1976
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1977
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1978
+ }, "strict", import("zod").ZodTypeAny, {
1979
+ columns: string[];
1980
+ }, {
1981
+ columns: string[];
1982
+ }>>;
1983
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1984
+ name: import("zod").ZodString;
1985
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1986
+ }, "strict", import("zod").ZodTypeAny, {
1987
+ name: string;
1988
+ columns: string[];
1989
+ }, {
1990
+ name: string;
1991
+ columns: string[];
1992
+ }>>>;
1993
+ }, "strict", import("zod").ZodTypeAny, {
1994
+ name: string;
1995
+ columns: Record<string, {
1996
+ default?: any;
1997
+ autoincrement?: boolean | undefined;
1998
+ name: string;
1999
+ type: string;
2000
+ primaryKey: boolean;
2001
+ notNull: boolean;
2002
+ }>;
2003
+ indexes: Record<string, {
2004
+ where?: string | undefined;
2005
+ name: string;
2006
+ columns: string[];
2007
+ isUnique: boolean;
2008
+ }>;
2009
+ foreignKeys: Record<string, {
2010
+ onUpdate?: string | undefined;
2011
+ onDelete?: string | undefined;
2012
+ name: string;
2013
+ tableFrom: string;
2014
+ columnsFrom: string[];
2015
+ tableTo: string;
2016
+ columnsTo: string[];
2017
+ }>;
2018
+ compositePrimaryKeys: Record<string, {
2019
+ columns: string[];
2020
+ }>;
2021
+ uniqueConstraints: Record<string, {
2022
+ name: string;
2023
+ columns: string[];
2024
+ }>;
2025
+ }, {
2026
+ uniqueConstraints?: Record<string, {
2027
+ name: string;
2028
+ columns: string[];
2029
+ }> | undefined;
2030
+ name: string;
2031
+ columns: Record<string, {
2032
+ default?: any;
2033
+ autoincrement?: boolean | undefined;
2034
+ name: string;
2035
+ type: string;
2036
+ primaryKey: boolean;
2037
+ notNull: boolean;
2038
+ }>;
2039
+ indexes: Record<string, {
2040
+ where?: string | undefined;
2041
+ name: string;
2042
+ columns: string[];
2043
+ isUnique: boolean;
2044
+ }>;
2045
+ foreignKeys: Record<string, {
2046
+ onUpdate?: string | undefined;
2047
+ onDelete?: string | undefined;
2048
+ name: string;
2049
+ tableFrom: string;
2050
+ columnsFrom: string[];
2051
+ tableTo: string;
2052
+ columnsTo: string[];
2053
+ }>;
2054
+ compositePrimaryKeys: Record<string, {
2055
+ columns: string[];
2056
+ }>;
2057
+ }>>;
2058
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
2059
+ }, {
2060
+ id: import("zod").ZodString;
2061
+ prevId: import("zod").ZodString;
2062
+ }>, "strict", import("zod").ZodTypeAny, {
2063
+ id: string;
2064
+ prevId: string;
2065
+ version: "4";
2066
+ dialect: "sqlite";
2067
+ tables: Record<string, {
2068
+ name: string;
2069
+ columns: Record<string, {
2070
+ default?: any;
2071
+ autoincrement?: boolean | undefined;
2072
+ name: string;
2073
+ type: string;
2074
+ primaryKey: boolean;
2075
+ notNull: boolean;
2076
+ }>;
2077
+ indexes: Record<string, {
2078
+ where?: string | undefined;
2079
+ name: string;
2080
+ columns: string[];
2081
+ isUnique: boolean;
2082
+ }>;
2083
+ foreignKeys: Record<string, {
2084
+ onUpdate?: string | undefined;
2085
+ onDelete?: string | undefined;
2086
+ name: string;
2087
+ tableFrom: string;
2088
+ columnsFrom: string[];
2089
+ tableTo: string;
2090
+ columnsTo: string[];
2091
+ }>;
2092
+ compositePrimaryKeys: Record<string, {
2093
+ columns: string[];
2094
+ }>;
2095
+ uniqueConstraints: Record<string, {
2096
+ name: string;
2097
+ columns: string[];
2098
+ }>;
2099
+ }>;
2100
+ enums: {};
2101
+ }, {
2102
+ id: string;
2103
+ prevId: string;
2104
+ version: "4";
2105
+ dialect: "sqlite";
2106
+ tables: Record<string, {
2107
+ uniqueConstraints?: Record<string, {
2108
+ name: string;
2109
+ columns: string[];
2110
+ }> | undefined;
2111
+ name: string;
2112
+ columns: Record<string, {
2113
+ default?: any;
2114
+ autoincrement?: boolean | undefined;
2115
+ name: string;
2116
+ type: string;
2117
+ primaryKey: boolean;
2118
+ notNull: boolean;
2119
+ }>;
2120
+ indexes: Record<string, {
2121
+ where?: string | undefined;
2122
+ name: string;
2123
+ columns: string[];
2124
+ isUnique: boolean;
2125
+ }>;
2126
+ foreignKeys: Record<string, {
2127
+ onUpdate?: string | undefined;
2128
+ onDelete?: string | undefined;
2129
+ name: string;
2130
+ tableFrom: string;
2131
+ columnsFrom: string[];
2132
+ tableTo: string;
2133
+ columnsTo: string[];
2134
+ }>;
2135
+ compositePrimaryKeys: Record<string, {
2136
+ columns: string[];
2137
+ }>;
2138
+ }>;
2139
+ enums: {};
2140
+ }>;
2141
+ export declare const sqliteSchema: import("zod").ZodObject<import("zod").extendShape<{
2142
+ version: import("zod").ZodLiteral<"5">;
2143
+ dialect: import("zod").ZodEnum<["sqlite"]>;
2144
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2145
+ name: import("zod").ZodString;
2146
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2147
+ name: import("zod").ZodString;
2148
+ type: import("zod").ZodString;
2149
+ primaryKey: import("zod").ZodBoolean;
2150
+ notNull: import("zod").ZodBoolean;
2151
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2152
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2153
+ }, "strict", import("zod").ZodTypeAny, {
2154
+ default?: any;
2155
+ autoincrement?: boolean | undefined;
2156
+ name: string;
2157
+ type: string;
2158
+ primaryKey: boolean;
2159
+ notNull: boolean;
2160
+ }, {
2161
+ default?: any;
2162
+ autoincrement?: boolean | undefined;
2163
+ name: string;
2164
+ type: string;
2165
+ primaryKey: boolean;
2166
+ notNull: boolean;
2167
+ }>>;
2168
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2169
+ name: import("zod").ZodString;
2170
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2171
+ where: import("zod").ZodOptional<import("zod").ZodString>;
2172
+ isUnique: import("zod").ZodBoolean;
2173
+ }, "strict", import("zod").ZodTypeAny, {
2174
+ where?: string | undefined;
2175
+ name: string;
2176
+ columns: string[];
2177
+ isUnique: boolean;
2178
+ }, {
2179
+ where?: string | undefined;
2180
+ name: string;
2181
+ columns: string[];
2182
+ isUnique: boolean;
2183
+ }>>;
2184
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2185
+ name: import("zod").ZodString;
2186
+ tableFrom: import("zod").ZodString;
2187
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2188
+ tableTo: import("zod").ZodString;
2189
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2190
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2191
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2192
+ }, "strict", import("zod").ZodTypeAny, {
2193
+ onUpdate?: string | undefined;
2194
+ onDelete?: string | undefined;
2195
+ name: string;
2196
+ tableFrom: string;
2197
+ columnsFrom: string[];
2198
+ tableTo: string;
2199
+ columnsTo: string[];
2200
+ }, {
2201
+ onUpdate?: string | undefined;
2202
+ onDelete?: string | undefined;
2203
+ name: string;
2204
+ tableFrom: string;
2205
+ columnsFrom: string[];
2206
+ tableTo: string;
2207
+ columnsTo: string[];
2208
+ }>>;
2209
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2210
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2211
+ }, "strict", import("zod").ZodTypeAny, {
2212
+ columns: string[];
2213
+ }, {
2214
+ columns: string[];
2215
+ }>>;
2216
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2217
+ name: import("zod").ZodString;
2218
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2219
+ }, "strict", import("zod").ZodTypeAny, {
2220
+ name: string;
2221
+ columns: string[];
2222
+ }, {
2223
+ name: string;
2224
+ columns: string[];
2225
+ }>>>;
2226
+ }, "strict", import("zod").ZodTypeAny, {
2227
+ name: string;
2228
+ columns: Record<string, {
2229
+ default?: any;
2230
+ autoincrement?: boolean | undefined;
2231
+ name: string;
2232
+ type: string;
2233
+ primaryKey: boolean;
2234
+ notNull: boolean;
2235
+ }>;
2236
+ indexes: Record<string, {
2237
+ where?: string | undefined;
2238
+ name: string;
2239
+ columns: string[];
2240
+ isUnique: boolean;
2241
+ }>;
2242
+ foreignKeys: Record<string, {
2243
+ onUpdate?: string | undefined;
2244
+ onDelete?: string | undefined;
2245
+ name: string;
2246
+ tableFrom: string;
2247
+ columnsFrom: string[];
2248
+ tableTo: string;
2249
+ columnsTo: string[];
2250
+ }>;
2251
+ compositePrimaryKeys: Record<string, {
2252
+ columns: string[];
2253
+ }>;
2254
+ uniqueConstraints: Record<string, {
2255
+ name: string;
2256
+ columns: string[];
2257
+ }>;
2258
+ }, {
2259
+ uniqueConstraints?: Record<string, {
2260
+ name: string;
2261
+ columns: string[];
2262
+ }> | undefined;
2263
+ name: string;
2264
+ columns: Record<string, {
2265
+ default?: any;
2266
+ autoincrement?: boolean | undefined;
2267
+ name: string;
2268
+ type: string;
2269
+ primaryKey: boolean;
2270
+ notNull: boolean;
2271
+ }>;
2272
+ indexes: Record<string, {
2273
+ where?: string | undefined;
2274
+ name: string;
2275
+ columns: string[];
2276
+ isUnique: boolean;
2277
+ }>;
2278
+ foreignKeys: Record<string, {
2279
+ onUpdate?: string | undefined;
2280
+ onDelete?: string | undefined;
2281
+ name: string;
2282
+ tableFrom: string;
2283
+ columnsFrom: string[];
2284
+ tableTo: string;
2285
+ columnsTo: string[];
2286
+ }>;
2287
+ compositePrimaryKeys: Record<string, {
2288
+ columns: string[];
2289
+ }>;
2290
+ }>>;
2291
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
2292
+ _meta: import("zod").ZodObject<{
2293
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2294
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2295
+ }, "strip", import("zod").ZodTypeAny, {
2296
+ columns: Record<string, string>;
2297
+ tables: Record<string, string>;
2298
+ }, {
2299
+ columns: Record<string, string>;
2300
+ tables: Record<string, string>;
2301
+ }>;
2302
+ }, {
2303
+ id: import("zod").ZodString;
2304
+ prevId: import("zod").ZodString;
2305
+ }>, "strict", import("zod").ZodTypeAny, {
2306
+ id: string;
2307
+ prevId: string;
2308
+ version: "5";
2309
+ dialect: "sqlite";
2310
+ tables: Record<string, {
2311
+ name: string;
2312
+ columns: Record<string, {
2313
+ default?: any;
2314
+ autoincrement?: boolean | undefined;
2315
+ name: string;
2316
+ type: string;
2317
+ primaryKey: boolean;
2318
+ notNull: boolean;
2319
+ }>;
2320
+ indexes: Record<string, {
2321
+ where?: string | undefined;
2322
+ name: string;
2323
+ columns: string[];
2324
+ isUnique: boolean;
2325
+ }>;
2326
+ foreignKeys: Record<string, {
2327
+ onUpdate?: string | undefined;
2328
+ onDelete?: string | undefined;
2329
+ name: string;
2330
+ tableFrom: string;
2331
+ columnsFrom: string[];
2332
+ tableTo: string;
2333
+ columnsTo: string[];
2334
+ }>;
2335
+ compositePrimaryKeys: Record<string, {
2336
+ columns: string[];
2337
+ }>;
2338
+ uniqueConstraints: Record<string, {
2339
+ name: string;
2340
+ columns: string[];
2341
+ }>;
2342
+ }>;
2343
+ _meta: {
2344
+ columns: Record<string, string>;
2345
+ tables: Record<string, string>;
2346
+ };
2347
+ enums: {};
2348
+ }, {
2349
+ id: string;
2350
+ prevId: string;
2351
+ version: "5";
2352
+ dialect: "sqlite";
2353
+ tables: Record<string, {
2354
+ uniqueConstraints?: Record<string, {
2355
+ name: string;
2356
+ columns: string[];
2357
+ }> | undefined;
2358
+ name: string;
2359
+ columns: Record<string, {
2360
+ default?: any;
2361
+ autoincrement?: boolean | undefined;
2362
+ name: string;
2363
+ type: string;
2364
+ primaryKey: boolean;
2365
+ notNull: boolean;
2366
+ }>;
2367
+ indexes: Record<string, {
2368
+ where?: string | undefined;
2369
+ name: string;
2370
+ columns: string[];
2371
+ isUnique: boolean;
2372
+ }>;
2373
+ foreignKeys: Record<string, {
2374
+ onUpdate?: string | undefined;
2375
+ onDelete?: string | undefined;
2376
+ name: string;
2377
+ tableFrom: string;
2378
+ columnsFrom: string[];
2379
+ tableTo: string;
2380
+ columnsTo: string[];
2381
+ }>;
2382
+ compositePrimaryKeys: Record<string, {
2383
+ columns: string[];
2384
+ }>;
2385
+ }>;
2386
+ _meta: {
2387
+ columns: Record<string, string>;
2388
+ tables: Record<string, string>;
2389
+ };
2390
+ enums: {};
2391
+ }>;
2392
+ export declare const SQLiteSchemaSquashed: import("zod").ZodObject<{
2393
+ version: import("zod").ZodLiteral<"5">;
2394
+ dialect: import("zod").ZodEnum<["sqlite"]>;
2395
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2396
+ name: import("zod").ZodString;
2397
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2398
+ name: import("zod").ZodString;
2399
+ type: import("zod").ZodString;
2400
+ primaryKey: import("zod").ZodBoolean;
2401
+ notNull: import("zod").ZodBoolean;
2402
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2403
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2404
+ }, "strict", import("zod").ZodTypeAny, {
2405
+ default?: any;
2406
+ autoincrement?: boolean | undefined;
2407
+ name: string;
2408
+ type: string;
2409
+ primaryKey: boolean;
2410
+ notNull: boolean;
2411
+ }, {
2412
+ default?: any;
2413
+ autoincrement?: boolean | undefined;
2414
+ name: string;
2415
+ type: string;
2416
+ primaryKey: boolean;
2417
+ notNull: boolean;
2418
+ }>>;
2419
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2420
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2421
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
2422
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
2423
+ }, "strict", import("zod").ZodTypeAny, {
2424
+ name: string;
2425
+ columns: Record<string, {
2426
+ default?: any;
2427
+ autoincrement?: boolean | undefined;
2428
+ name: string;
2429
+ type: string;
2430
+ primaryKey: boolean;
2431
+ notNull: boolean;
2432
+ }>;
2433
+ indexes: Record<string, string>;
2434
+ foreignKeys: Record<string, string>;
2435
+ compositePrimaryKeys: Record<string, string>;
2436
+ uniqueConstraints: Record<string, string>;
2437
+ }, {
2438
+ uniqueConstraints?: Record<string, string> | undefined;
2439
+ name: string;
2440
+ columns: Record<string, {
2441
+ default?: any;
2442
+ autoincrement?: boolean | undefined;
2443
+ name: string;
2444
+ type: string;
2445
+ primaryKey: boolean;
2446
+ notNull: boolean;
2447
+ }>;
2448
+ indexes: Record<string, string>;
2449
+ foreignKeys: Record<string, string>;
2450
+ compositePrimaryKeys: Record<string, string>;
2451
+ }>>;
2452
+ enums: import("zod").ZodAny;
2453
+ }, "strict", import("zod").ZodTypeAny, {
2454
+ enums?: any;
2455
+ version: "5";
2456
+ dialect: "sqlite";
2457
+ tables: Record<string, {
2458
+ name: string;
2459
+ columns: Record<string, {
2460
+ default?: any;
2461
+ autoincrement?: boolean | undefined;
2462
+ name: string;
2463
+ type: string;
2464
+ primaryKey: boolean;
2465
+ notNull: boolean;
2466
+ }>;
2467
+ indexes: Record<string, string>;
2468
+ foreignKeys: Record<string, string>;
2469
+ compositePrimaryKeys: Record<string, string>;
2470
+ uniqueConstraints: Record<string, string>;
2471
+ }>;
2472
+ }, {
2473
+ enums?: any;
2474
+ version: "5";
2475
+ dialect: "sqlite";
2476
+ tables: Record<string, {
2477
+ uniqueConstraints?: Record<string, string> | undefined;
2478
+ name: string;
2479
+ columns: Record<string, {
2480
+ default?: any;
2481
+ autoincrement?: boolean | undefined;
2482
+ name: string;
2483
+ type: string;
2484
+ primaryKey: boolean;
2485
+ notNull: boolean;
2486
+ }>;
2487
+ indexes: Record<string, string>;
2488
+ foreignKeys: Record<string, string>;
2489
+ compositePrimaryKeys: Record<string, string>;
2490
+ }>;
2491
+ }>;
2492
+ export declare const backwardCompatibleSqliteSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
2493
+ version: import("zod").ZodLiteral<"3">;
2494
+ dialect: import("zod").ZodEnum<["sqlite"]>;
2495
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2496
+ name: import("zod").ZodString;
2497
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2498
+ name: import("zod").ZodString;
2499
+ type: import("zod").ZodString;
2500
+ primaryKey: import("zod").ZodBoolean;
2501
+ notNull: import("zod").ZodBoolean;
2502
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2503
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2504
+ }, "strict", import("zod").ZodTypeAny, {
2505
+ default?: any;
2506
+ autoincrement?: boolean | undefined;
2507
+ name: string;
2508
+ type: string;
2509
+ primaryKey: boolean;
2510
+ notNull: boolean;
2511
+ }, {
2512
+ default?: any;
2513
+ autoincrement?: boolean | undefined;
2514
+ name: string;
2515
+ type: string;
2516
+ primaryKey: boolean;
2517
+ notNull: boolean;
2518
+ }>>;
2519
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2520
+ name: import("zod").ZodString;
2521
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2522
+ where: import("zod").ZodOptional<import("zod").ZodString>;
2523
+ isUnique: import("zod").ZodBoolean;
2524
+ }, "strict", import("zod").ZodTypeAny, {
2525
+ where?: string | undefined;
2526
+ name: string;
2527
+ columns: string[];
2528
+ isUnique: boolean;
2529
+ }, {
2530
+ where?: string | undefined;
2531
+ name: string;
2532
+ columns: string[];
2533
+ isUnique: boolean;
2534
+ }>>;
2535
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2536
+ name: import("zod").ZodString;
2537
+ tableFrom: import("zod").ZodString;
2538
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2539
+ tableTo: import("zod").ZodString;
2540
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2541
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2542
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2543
+ }, "strict", import("zod").ZodTypeAny, {
2544
+ onUpdate?: string | undefined;
2545
+ onDelete?: string | undefined;
2546
+ name: string;
2547
+ tableFrom: string;
2548
+ columnsFrom: string[];
2549
+ tableTo: string;
2550
+ columnsTo: string[];
2551
+ }, {
2552
+ onUpdate?: string | undefined;
2553
+ onDelete?: string | undefined;
2554
+ name: string;
2555
+ tableFrom: string;
2556
+ columnsFrom: string[];
2557
+ tableTo: string;
2558
+ columnsTo: string[];
2559
+ }>>;
2560
+ }, "strict", import("zod").ZodTypeAny, {
2561
+ name: string;
2562
+ columns: Record<string, {
2563
+ default?: any;
2564
+ autoincrement?: boolean | undefined;
2565
+ name: string;
2566
+ type: string;
2567
+ primaryKey: boolean;
2568
+ notNull: boolean;
2569
+ }>;
2570
+ indexes: Record<string, {
2571
+ where?: string | undefined;
2572
+ name: string;
2573
+ columns: string[];
2574
+ isUnique: boolean;
2575
+ }>;
2576
+ foreignKeys: Record<string, {
2577
+ onUpdate?: string | undefined;
2578
+ onDelete?: string | undefined;
2579
+ name: string;
2580
+ tableFrom: string;
2581
+ columnsFrom: string[];
2582
+ tableTo: string;
2583
+ columnsTo: string[];
2584
+ }>;
2585
+ }, {
2586
+ name: string;
2587
+ columns: Record<string, {
2588
+ default?: any;
2589
+ autoincrement?: boolean | undefined;
2590
+ name: string;
2591
+ type: string;
2592
+ primaryKey: boolean;
2593
+ notNull: boolean;
2594
+ }>;
2595
+ indexes: Record<string, {
2596
+ where?: string | undefined;
2597
+ name: string;
2598
+ columns: string[];
2599
+ isUnique: boolean;
2600
+ }>;
2601
+ foreignKeys: Record<string, {
2602
+ onUpdate?: string | undefined;
2603
+ onDelete?: string | undefined;
2604
+ name: string;
2605
+ tableFrom: string;
2606
+ columnsFrom: string[];
2607
+ tableTo: string;
2608
+ columnsTo: string[];
2609
+ }>;
2610
+ }>>;
2611
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
2612
+ }, {
2613
+ id: import("zod").ZodString;
2614
+ prevId: import("zod").ZodString;
2615
+ }>, "strict", import("zod").ZodTypeAny, {
2616
+ id: string;
2617
+ prevId: string;
2618
+ version: "3";
2619
+ dialect: "sqlite";
2620
+ tables: Record<string, {
2621
+ name: string;
2622
+ columns: Record<string, {
2623
+ default?: any;
2624
+ autoincrement?: boolean | undefined;
2625
+ name: string;
2626
+ type: string;
2627
+ primaryKey: boolean;
2628
+ notNull: boolean;
2629
+ }>;
2630
+ indexes: Record<string, {
2631
+ where?: string | undefined;
2632
+ name: string;
2633
+ columns: string[];
2634
+ isUnique: boolean;
2635
+ }>;
2636
+ foreignKeys: Record<string, {
2637
+ onUpdate?: string | undefined;
2638
+ onDelete?: string | undefined;
2639
+ name: string;
2640
+ tableFrom: string;
2641
+ columnsFrom: string[];
2642
+ tableTo: string;
2643
+ columnsTo: string[];
2644
+ }>;
2645
+ }>;
2646
+ enums: {};
2647
+ }, {
2648
+ id: string;
2649
+ prevId: string;
2650
+ version: "3";
2651
+ dialect: "sqlite";
2652
+ tables: Record<string, {
2653
+ name: string;
2654
+ columns: Record<string, {
2655
+ default?: any;
2656
+ autoincrement?: boolean | undefined;
2657
+ name: string;
2658
+ type: string;
2659
+ primaryKey: boolean;
2660
+ notNull: boolean;
2661
+ }>;
2662
+ indexes: Record<string, {
2663
+ where?: string | undefined;
2664
+ name: string;
2665
+ columns: string[];
2666
+ isUnique: boolean;
2667
+ }>;
2668
+ foreignKeys: Record<string, {
2669
+ onUpdate?: string | undefined;
2670
+ onDelete?: string | undefined;
2671
+ name: string;
2672
+ tableFrom: string;
2673
+ columnsFrom: string[];
2674
+ tableTo: string;
2675
+ columnsTo: string[];
2676
+ }>;
2677
+ }>;
2678
+ enums: {};
2679
+ }>, import("zod").ZodObject<import("zod").extendShape<{
2680
+ version: import("zod").ZodLiteral<"4">;
2681
+ dialect: import("zod").ZodEnum<["sqlite"]>;
2682
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2683
+ name: import("zod").ZodString;
2684
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2685
+ name: import("zod").ZodString;
2686
+ type: import("zod").ZodString;
2687
+ primaryKey: import("zod").ZodBoolean;
2688
+ notNull: import("zod").ZodBoolean;
2689
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2690
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2691
+ }, "strict", import("zod").ZodTypeAny, {
2692
+ default?: any;
2693
+ autoincrement?: boolean | undefined;
2694
+ name: string;
2695
+ type: string;
2696
+ primaryKey: boolean;
2697
+ notNull: boolean;
2698
+ }, {
2699
+ default?: any;
2700
+ autoincrement?: boolean | undefined;
2701
+ name: string;
2702
+ type: string;
2703
+ primaryKey: boolean;
2704
+ notNull: boolean;
2705
+ }>>;
2706
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2707
+ name: import("zod").ZodString;
2708
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2709
+ where: import("zod").ZodOptional<import("zod").ZodString>;
2710
+ isUnique: import("zod").ZodBoolean;
2711
+ }, "strict", import("zod").ZodTypeAny, {
2712
+ where?: string | undefined;
2713
+ name: string;
2714
+ columns: string[];
2715
+ isUnique: boolean;
2716
+ }, {
2717
+ where?: string | undefined;
2718
+ name: string;
2719
+ columns: string[];
2720
+ isUnique: boolean;
2721
+ }>>;
2722
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2723
+ name: import("zod").ZodString;
2724
+ tableFrom: import("zod").ZodString;
2725
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2726
+ tableTo: import("zod").ZodString;
2727
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2728
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2729
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2730
+ }, "strict", import("zod").ZodTypeAny, {
2731
+ onUpdate?: string | undefined;
2732
+ onDelete?: string | undefined;
2733
+ name: string;
2734
+ tableFrom: string;
2735
+ columnsFrom: string[];
2736
+ tableTo: string;
2737
+ columnsTo: string[];
2738
+ }, {
2739
+ onUpdate?: string | undefined;
2740
+ onDelete?: string | undefined;
2741
+ name: string;
2742
+ tableFrom: string;
2743
+ columnsFrom: string[];
2744
+ tableTo: string;
2745
+ columnsTo: string[];
2746
+ }>>;
2747
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2748
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2749
+ }, "strict", import("zod").ZodTypeAny, {
2750
+ columns: string[];
2751
+ }, {
2752
+ columns: string[];
2753
+ }>>;
2754
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2755
+ name: import("zod").ZodString;
2756
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2757
+ }, "strict", import("zod").ZodTypeAny, {
2758
+ name: string;
2759
+ columns: string[];
2760
+ }, {
2761
+ name: string;
2762
+ columns: string[];
2763
+ }>>>;
2764
+ }, "strict", import("zod").ZodTypeAny, {
2765
+ name: string;
2766
+ columns: Record<string, {
2767
+ default?: any;
2768
+ autoincrement?: boolean | undefined;
2769
+ name: string;
2770
+ type: string;
2771
+ primaryKey: boolean;
2772
+ notNull: boolean;
2773
+ }>;
2774
+ indexes: Record<string, {
2775
+ where?: string | undefined;
2776
+ name: string;
2777
+ columns: string[];
2778
+ isUnique: boolean;
2779
+ }>;
2780
+ foreignKeys: Record<string, {
2781
+ onUpdate?: string | undefined;
2782
+ onDelete?: string | undefined;
2783
+ name: string;
2784
+ tableFrom: string;
2785
+ columnsFrom: string[];
2786
+ tableTo: string;
2787
+ columnsTo: string[];
2788
+ }>;
2789
+ compositePrimaryKeys: Record<string, {
2790
+ columns: string[];
2791
+ }>;
2792
+ uniqueConstraints: Record<string, {
2793
+ name: string;
2794
+ columns: string[];
2795
+ }>;
2796
+ }, {
2797
+ uniqueConstraints?: Record<string, {
2798
+ name: string;
2799
+ columns: string[];
2800
+ }> | undefined;
2801
+ name: string;
2802
+ columns: Record<string, {
2803
+ default?: any;
2804
+ autoincrement?: boolean | undefined;
2805
+ name: string;
2806
+ type: string;
2807
+ primaryKey: boolean;
2808
+ notNull: boolean;
2809
+ }>;
2810
+ indexes: Record<string, {
2811
+ where?: string | undefined;
2812
+ name: string;
2813
+ columns: string[];
2814
+ isUnique: boolean;
2815
+ }>;
2816
+ foreignKeys: Record<string, {
2817
+ onUpdate?: string | undefined;
2818
+ onDelete?: string | undefined;
2819
+ name: string;
2820
+ tableFrom: string;
2821
+ columnsFrom: string[];
2822
+ tableTo: string;
2823
+ columnsTo: string[];
2824
+ }>;
2825
+ compositePrimaryKeys: Record<string, {
2826
+ columns: string[];
2827
+ }>;
2828
+ }>>;
2829
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
2830
+ }, {
2831
+ id: import("zod").ZodString;
2832
+ prevId: import("zod").ZodString;
2833
+ }>, "strict", import("zod").ZodTypeAny, {
2834
+ id: string;
2835
+ prevId: string;
2836
+ version: "4";
2837
+ dialect: "sqlite";
2838
+ tables: Record<string, {
2839
+ name: string;
2840
+ columns: Record<string, {
2841
+ default?: any;
2842
+ autoincrement?: boolean | undefined;
2843
+ name: string;
2844
+ type: string;
2845
+ primaryKey: boolean;
2846
+ notNull: boolean;
2847
+ }>;
2848
+ indexes: Record<string, {
2849
+ where?: string | undefined;
2850
+ name: string;
2851
+ columns: string[];
2852
+ isUnique: boolean;
2853
+ }>;
2854
+ foreignKeys: Record<string, {
2855
+ onUpdate?: string | undefined;
2856
+ onDelete?: string | undefined;
2857
+ name: string;
2858
+ tableFrom: string;
2859
+ columnsFrom: string[];
2860
+ tableTo: string;
2861
+ columnsTo: string[];
2862
+ }>;
2863
+ compositePrimaryKeys: Record<string, {
2864
+ columns: string[];
2865
+ }>;
2866
+ uniqueConstraints: Record<string, {
2867
+ name: string;
2868
+ columns: string[];
2869
+ }>;
2870
+ }>;
2871
+ enums: {};
2872
+ }, {
2873
+ id: string;
2874
+ prevId: string;
2875
+ version: "4";
2876
+ dialect: "sqlite";
2877
+ tables: Record<string, {
2878
+ uniqueConstraints?: Record<string, {
2879
+ name: string;
2880
+ columns: string[];
2881
+ }> | undefined;
2882
+ name: string;
2883
+ columns: Record<string, {
2884
+ default?: any;
2885
+ autoincrement?: boolean | undefined;
2886
+ name: string;
2887
+ type: string;
2888
+ primaryKey: boolean;
2889
+ notNull: boolean;
2890
+ }>;
2891
+ indexes: Record<string, {
2892
+ where?: string | undefined;
2893
+ name: string;
2894
+ columns: string[];
2895
+ isUnique: boolean;
2896
+ }>;
2897
+ foreignKeys: Record<string, {
2898
+ onUpdate?: string | undefined;
2899
+ onDelete?: string | undefined;
2900
+ name: string;
2901
+ tableFrom: string;
2902
+ columnsFrom: string[];
2903
+ tableTo: string;
2904
+ columnsTo: string[];
2905
+ }>;
2906
+ compositePrimaryKeys: Record<string, {
2907
+ columns: string[];
2908
+ }>;
2909
+ }>;
2910
+ enums: {};
2911
+ }>, import("zod").ZodObject<import("zod").extendShape<{
2912
+ version: import("zod").ZodLiteral<"5">;
2913
+ dialect: import("zod").ZodEnum<["sqlite"]>;
2914
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2915
+ name: import("zod").ZodString;
2916
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2917
+ name: import("zod").ZodString;
2918
+ type: import("zod").ZodString;
2919
+ primaryKey: import("zod").ZodBoolean;
2920
+ notNull: import("zod").ZodBoolean;
2921
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
2922
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
2923
+ }, "strict", import("zod").ZodTypeAny, {
2924
+ default?: any;
2925
+ autoincrement?: boolean | undefined;
2926
+ name: string;
2927
+ type: string;
2928
+ primaryKey: boolean;
2929
+ notNull: boolean;
2930
+ }, {
2931
+ default?: any;
2932
+ autoincrement?: boolean | undefined;
2933
+ name: string;
2934
+ type: string;
2935
+ primaryKey: boolean;
2936
+ notNull: boolean;
2937
+ }>>;
2938
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2939
+ name: import("zod").ZodString;
2940
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2941
+ where: import("zod").ZodOptional<import("zod").ZodString>;
2942
+ isUnique: import("zod").ZodBoolean;
2943
+ }, "strict", import("zod").ZodTypeAny, {
2944
+ where?: string | undefined;
2945
+ name: string;
2946
+ columns: string[];
2947
+ isUnique: boolean;
2948
+ }, {
2949
+ where?: string | undefined;
2950
+ name: string;
2951
+ columns: string[];
2952
+ isUnique: boolean;
2953
+ }>>;
2954
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2955
+ name: import("zod").ZodString;
2956
+ tableFrom: import("zod").ZodString;
2957
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
2958
+ tableTo: import("zod").ZodString;
2959
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
2960
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
2961
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
2962
+ }, "strict", import("zod").ZodTypeAny, {
2963
+ onUpdate?: string | undefined;
2964
+ onDelete?: string | undefined;
2965
+ name: string;
2966
+ tableFrom: string;
2967
+ columnsFrom: string[];
2968
+ tableTo: string;
2969
+ columnsTo: string[];
2970
+ }, {
2971
+ onUpdate?: string | undefined;
2972
+ onDelete?: string | undefined;
2973
+ name: string;
2974
+ tableFrom: string;
2975
+ columnsFrom: string[];
2976
+ tableTo: string;
2977
+ columnsTo: string[];
2978
+ }>>;
2979
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2980
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2981
+ }, "strict", import("zod").ZodTypeAny, {
2982
+ columns: string[];
2983
+ }, {
2984
+ columns: string[];
2985
+ }>>;
2986
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
2987
+ name: import("zod").ZodString;
2988
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
2989
+ }, "strict", import("zod").ZodTypeAny, {
2990
+ name: string;
2991
+ columns: string[];
2992
+ }, {
2993
+ name: string;
2994
+ columns: string[];
2995
+ }>>>;
2996
+ }, "strict", import("zod").ZodTypeAny, {
2997
+ name: string;
2998
+ columns: Record<string, {
2999
+ default?: any;
3000
+ autoincrement?: boolean | undefined;
3001
+ name: string;
3002
+ type: string;
3003
+ primaryKey: boolean;
3004
+ notNull: boolean;
3005
+ }>;
3006
+ indexes: Record<string, {
3007
+ where?: string | undefined;
3008
+ name: string;
3009
+ columns: string[];
3010
+ isUnique: boolean;
3011
+ }>;
3012
+ foreignKeys: Record<string, {
3013
+ onUpdate?: string | undefined;
3014
+ onDelete?: string | undefined;
3015
+ name: string;
3016
+ tableFrom: string;
3017
+ columnsFrom: string[];
3018
+ tableTo: string;
3019
+ columnsTo: string[];
3020
+ }>;
3021
+ compositePrimaryKeys: Record<string, {
3022
+ columns: string[];
3023
+ }>;
3024
+ uniqueConstraints: Record<string, {
3025
+ name: string;
3026
+ columns: string[];
3027
+ }>;
3028
+ }, {
3029
+ uniqueConstraints?: Record<string, {
3030
+ name: string;
3031
+ columns: string[];
3032
+ }> | undefined;
3033
+ name: string;
3034
+ columns: Record<string, {
3035
+ default?: any;
3036
+ autoincrement?: boolean | undefined;
3037
+ name: string;
3038
+ type: string;
3039
+ primaryKey: boolean;
3040
+ notNull: boolean;
3041
+ }>;
3042
+ indexes: Record<string, {
3043
+ where?: string | undefined;
3044
+ name: string;
3045
+ columns: string[];
3046
+ isUnique: boolean;
3047
+ }>;
3048
+ foreignKeys: Record<string, {
3049
+ onUpdate?: string | undefined;
3050
+ onDelete?: string | undefined;
3051
+ name: string;
3052
+ tableFrom: string;
3053
+ columnsFrom: string[];
3054
+ tableTo: string;
3055
+ columnsTo: string[];
3056
+ }>;
3057
+ compositePrimaryKeys: Record<string, {
3058
+ columns: string[];
3059
+ }>;
3060
+ }>>;
3061
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
3062
+ _meta: import("zod").ZodObject<{
3063
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3064
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
3065
+ }, "strip", import("zod").ZodTypeAny, {
3066
+ columns: Record<string, string>;
3067
+ tables: Record<string, string>;
3068
+ }, {
3069
+ columns: Record<string, string>;
3070
+ tables: Record<string, string>;
3071
+ }>;
3072
+ }, {
3073
+ id: import("zod").ZodString;
3074
+ prevId: import("zod").ZodString;
3075
+ }>, "strict", import("zod").ZodTypeAny, {
3076
+ id: string;
3077
+ prevId: string;
3078
+ version: "5";
3079
+ dialect: "sqlite";
3080
+ tables: Record<string, {
3081
+ name: string;
3082
+ columns: Record<string, {
3083
+ default?: any;
3084
+ autoincrement?: boolean | undefined;
3085
+ name: string;
3086
+ type: string;
3087
+ primaryKey: boolean;
3088
+ notNull: boolean;
3089
+ }>;
3090
+ indexes: Record<string, {
3091
+ where?: string | undefined;
3092
+ name: string;
3093
+ columns: string[];
3094
+ isUnique: boolean;
3095
+ }>;
3096
+ foreignKeys: Record<string, {
3097
+ onUpdate?: string | undefined;
3098
+ onDelete?: string | undefined;
3099
+ name: string;
3100
+ tableFrom: string;
3101
+ columnsFrom: string[];
3102
+ tableTo: string;
3103
+ columnsTo: string[];
3104
+ }>;
3105
+ compositePrimaryKeys: Record<string, {
3106
+ columns: string[];
3107
+ }>;
3108
+ uniqueConstraints: Record<string, {
3109
+ name: string;
3110
+ columns: string[];
3111
+ }>;
3112
+ }>;
3113
+ _meta: {
3114
+ columns: Record<string, string>;
3115
+ tables: Record<string, string>;
3116
+ };
3117
+ enums: {};
3118
+ }, {
3119
+ id: string;
3120
+ prevId: string;
3121
+ version: "5";
3122
+ dialect: "sqlite";
3123
+ tables: Record<string, {
3124
+ uniqueConstraints?: Record<string, {
3125
+ name: string;
3126
+ columns: string[];
3127
+ }> | undefined;
3128
+ name: string;
3129
+ columns: Record<string, {
3130
+ default?: any;
3131
+ autoincrement?: boolean | undefined;
3132
+ name: string;
3133
+ type: string;
3134
+ primaryKey: boolean;
3135
+ notNull: boolean;
3136
+ }>;
3137
+ indexes: Record<string, {
3138
+ where?: string | undefined;
3139
+ name: string;
3140
+ columns: string[];
3141
+ isUnique: boolean;
3142
+ }>;
3143
+ foreignKeys: Record<string, {
3144
+ onUpdate?: string | undefined;
3145
+ onDelete?: string | undefined;
3146
+ name: string;
3147
+ tableFrom: string;
3148
+ columnsFrom: string[];
3149
+ tableTo: string;
3150
+ columnsTo: string[];
3151
+ }>;
3152
+ compositePrimaryKeys: Record<string, {
3153
+ columns: string[];
3154
+ }>;
3155
+ }>;
3156
+ _meta: {
3157
+ columns: Record<string, string>;
3158
+ tables: Record<string, string>;
3159
+ };
3160
+ enums: {};
3161
+ }>]>;
3162
+ export {};