drizzle-kit 0.19.13-a511135 → 0.19.13-c212aa4

Sign up to get free protection for your applications and to get access to all the features.
Files changed (46) hide show
  1. package/index.cjs +30671 -30644
  2. package/index.d.ts +14 -15
  3. package/package.json +3 -4
  4. package/utils.js +11724 -44481
  5. package/@types/utils.d.ts +0 -12
  6. package/cli/commands/migrate.d.ts +0 -141
  7. package/cli/commands/mysqlUp.d.ts +0 -4
  8. package/cli/commands/pgIntrospect.d.ts +0 -118
  9. package/cli/commands/pgPushUtils.d.ts +0 -14
  10. package/cli/commands/pgUp.d.ts +0 -4
  11. package/cli/commands/sqliteIntrospect.d.ts +0 -102
  12. package/cli/commands/sqliteUtils.d.ts +0 -162
  13. package/cli/commands/upFolders.d.ts +0 -27
  14. package/cli/commands/utils.d.ts +0 -265
  15. package/cli/selector-ui.d.ts +0 -13
  16. package/cli/validations/common.d.ts +0 -13
  17. package/cli/validations/mysql.d.ts +0 -414
  18. package/cli/validations/outputs.d.ts +0 -39
  19. package/cli/validations/pg.d.ts +0 -438
  20. package/cli/validations/sqlite.d.ts +0 -220
  21. package/cli/validations/studio.d.ts +0 -469
  22. package/cli/views.d.ts +0 -61
  23. package/drivers/index.d.ts +0 -26
  24. package/global.d.ts +0 -2
  25. package/introspect.d.ts +0 -4
  26. package/jsonDiffer.d.ts +0 -76
  27. package/jsonStatements.d.ts +0 -349
  28. package/migrationPreparator.d.ts +0 -35
  29. package/schemaValidator.d.ts +0 -1236
  30. package/serializer/index.d.ts +0 -9
  31. package/serializer/mysqlImports.d.ts +0 -6
  32. package/serializer/mysqlSchema.d.ts +0 -3833
  33. package/serializer/mysqlSerializer.d.ts +0 -7
  34. package/serializer/pgImports.d.ts +0 -11
  35. package/serializer/pgSchema.d.ts +0 -4000
  36. package/serializer/pgSerializer.d.ts +0 -7
  37. package/serializer/sqliteImports.d.ts +0 -5
  38. package/serializer/sqliteSchema.d.ts +0 -3162
  39. package/serializer/sqliteSerializer.d.ts +0 -8
  40. package/serializer/studioUtils.d.ts +0 -31
  41. package/snapshotsDiffer.d.ts +0 -2660
  42. package/sqlgenerator.d.ts +0 -33
  43. package/sqlite-introspect.d.ts +0 -5
  44. package/utils/words.d.ts +0 -7
  45. package/utils.d.ts +0 -32
  46. package/utilsR.d.ts +0 -209
package/serializer/sqliteSchema.d.ts DELETED
@@ -1,3162 +0,0 @@
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 {};