drizzle-kit 0.20.18-d190692 → 0.20.18

Sign up to get free protection for your applications and to get access to all the features.
Files changed (59) hide show
  1. package/@types/utils.d.ts +12 -0
  2. package/bin.cjs +55769 -103683
  3. package/cli/commands/migrate.d.ts +270 -0
  4. package/cli/commands/mysqlIntrospect.d.ts +119 -0
  5. package/cli/commands/mysqlPushUtils.d.ts +18 -0
  6. package/cli/commands/mysqlUp.d.ts +4 -0
  7. package/cli/commands/pgConnect.d.ts +5 -0
  8. package/cli/commands/pgIntrospect.d.ts +123 -0
  9. package/cli/commands/pgPushUtils.d.ts +14 -0
  10. package/cli/commands/pgUp.d.ts +4 -0
  11. package/cli/commands/sqliteIntrospect.d.ts +107 -0
  12. package/cli/commands/sqlitePushUtils.d.ts +21 -0
  13. package/cli/commands/sqliteUtils.d.ts +162 -0
  14. package/cli/commands/upFolders.d.ts +27 -0
  15. package/cli/commands/utils.d.ts +274 -0
  16. package/cli/selector-ui.d.ts +13 -0
  17. package/cli/validations/common.d.ts +13 -0
  18. package/cli/validations/mysql.d.ts +365 -0
  19. package/cli/validations/outputs.d.ts +40 -0
  20. package/cli/validations/pg.d.ts +438 -0
  21. package/cli/views.d.ts +61 -0
  22. package/drivers/index.d.ts +39 -0
  23. package/global.d.ts +4 -0
  24. package/index.d.mts +68 -46
  25. package/index.d.ts +68 -46
  26. package/index.js +0 -1
  27. package/introspect-mysql.d.ts +9 -0
  28. package/introspect-pg.d.ts +12 -0
  29. package/introspect-sqlite.d.ts +10 -0
  30. package/jsonDiffer.d.ts +76 -0
  31. package/jsonStatements.d.ts +349 -0
  32. package/migrationPreparator.d.ts +35 -0
  33. package/package.json +64 -31
  34. package/payload.d.mts +18 -1052
  35. package/payload.d.ts +18 -1052
  36. package/payload.js +33563 -19279
  37. package/payload.mjs +33457 -19180
  38. package/schemaValidator.d.ts +1313 -0
  39. package/serializer/index.d.ts +9 -0
  40. package/serializer/mysqlImports.d.ts +11 -0
  41. package/serializer/mysqlSchema.d.ts +3833 -0
  42. package/serializer/mysqlSerializer.d.ts +7 -0
  43. package/serializer/pgImports.d.ts +11 -0
  44. package/serializer/pgSchema.d.ts +4333 -0
  45. package/serializer/pgSerializer.d.ts +7 -0
  46. package/serializer/schemaToDrizzle.d.ts +7 -0
  47. package/serializer/sqliteImports.d.ts +9 -0
  48. package/serializer/sqliteSchema.d.ts +3227 -0
  49. package/serializer/sqliteSerializer.d.ts +6 -0
  50. package/snapshotsDiffer.d.ts +2660 -0
  51. package/sqlgenerator.d.ts +33 -0
  52. package/utils/words.d.ts +7 -0
  53. package/utils-studio.d.mts +5 -0
  54. package/utils-studio.d.ts +5 -0
  55. package/utils-studio.js +809 -4584
  56. package/utils-studio.mjs +793 -4565
  57. package/utils.d.ts +199 -0
  58. package/utils.js +7165 -4635
  59. package/utils.mjs +7125 -4595
package/schemaValidator.d.ts ADDED
@@ -0,0 +1,1313 @@
1
+ import { TypeOf } from "zod";
2
+ declare const dialect: import("zod").ZodEnum<["pg", "mysql", "sqlite"]>;
3
+ export type Dialect = TypeOf<typeof dialect>;
4
+ declare const commonSquashedSchema: import("zod").ZodUnion<[import("zod").ZodObject<{
5
+ version: import("zod").ZodLiteral<"5">;
6
+ dialect: import("zod").ZodEnum<["pg"]>;
7
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
8
+ name: import("zod").ZodString;
9
+ schema: import("zod").ZodString;
10
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
11
+ name: import("zod").ZodString;
12
+ type: import("zod").ZodString;
13
+ primaryKey: import("zod").ZodBoolean;
14
+ notNull: import("zod").ZodBoolean;
15
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
16
+ isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
17
+ uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
18
+ nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
19
+ }, "strict", import("zod").ZodTypeAny, {
20
+ isUnique?: any;
21
+ default?: any;
22
+ uniqueName?: string | undefined;
23
+ nullsNotDistinct?: boolean | undefined;
24
+ name: string;
25
+ type: string;
26
+ primaryKey: boolean;
27
+ notNull: boolean;
28
+ }, {
29
+ isUnique?: any;
30
+ default?: any;
31
+ uniqueName?: string | undefined;
32
+ nullsNotDistinct?: boolean | undefined;
33
+ name: string;
34
+ type: string;
35
+ primaryKey: boolean;
36
+ notNull: boolean;
37
+ }>>;
38
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
39
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
40
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
41
+ uniqueConstraints: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
42
+ }, "strict", import("zod").ZodTypeAny, {
43
+ name: string;
44
+ columns: Record<string, {
45
+ isUnique?: any;
46
+ default?: any;
47
+ uniqueName?: string | undefined;
48
+ nullsNotDistinct?: boolean | undefined;
49
+ name: string;
50
+ type: string;
51
+ primaryKey: boolean;
52
+ notNull: boolean;
53
+ }>;
54
+ indexes: Record<string, string>;
55
+ foreignKeys: Record<string, string>;
56
+ schema: string;
57
+ compositePrimaryKeys: Record<string, string>;
58
+ uniqueConstraints: Record<string, string>;
59
+ }, {
60
+ name: string;
61
+ columns: Record<string, {
62
+ isUnique?: any;
63
+ default?: any;
64
+ uniqueName?: string | undefined;
65
+ nullsNotDistinct?: boolean | undefined;
66
+ name: string;
67
+ type: string;
68
+ primaryKey: boolean;
69
+ notNull: boolean;
70
+ }>;
71
+ indexes: Record<string, string>;
72
+ foreignKeys: Record<string, string>;
73
+ schema: string;
74
+ compositePrimaryKeys: Record<string, string>;
75
+ uniqueConstraints: Record<string, string>;
76
+ }>>;
77
+ enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
78
+ name: import("zod").ZodString;
79
+ values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
80
+ }, "strict", import("zod").ZodTypeAny, {
81
+ name: string;
82
+ values: Record<string, string>;
83
+ }, {
84
+ name: string;
85
+ values: Record<string, string>;
86
+ }>>;
87
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
88
+ }, "strict", import("zod").ZodTypeAny, {
89
+ version: "5";
90
+ dialect: "pg";
91
+ tables: Record<string, {
92
+ name: string;
93
+ columns: Record<string, {
94
+ isUnique?: any;
95
+ default?: any;
96
+ uniqueName?: string | undefined;
97
+ nullsNotDistinct?: boolean | undefined;
98
+ name: string;
99
+ type: string;
100
+ primaryKey: boolean;
101
+ notNull: boolean;
102
+ }>;
103
+ indexes: Record<string, string>;
104
+ foreignKeys: Record<string, string>;
105
+ schema: string;
106
+ compositePrimaryKeys: Record<string, string>;
107
+ uniqueConstraints: Record<string, string>;
108
+ }>;
109
+ schemas: Record<string, string>;
110
+ enums: Record<string, {
111
+ name: string;
112
+ values: Record<string, string>;
113
+ }>;
114
+ }, {
115
+ version: "5";
116
+ dialect: "pg";
117
+ tables: Record<string, {
118
+ name: string;
119
+ columns: Record<string, {
120
+ isUnique?: any;
121
+ default?: any;
122
+ uniqueName?: string | undefined;
123
+ nullsNotDistinct?: boolean | undefined;
124
+ name: string;
125
+ type: string;
126
+ primaryKey: boolean;
127
+ notNull: boolean;
128
+ }>;
129
+ indexes: Record<string, string>;
130
+ foreignKeys: Record<string, string>;
131
+ schema: string;
132
+ compositePrimaryKeys: Record<string, string>;
133
+ uniqueConstraints: Record<string, string>;
134
+ }>;
135
+ schemas: Record<string, string>;
136
+ enums: Record<string, {
137
+ name: string;
138
+ values: Record<string, string>;
139
+ }>;
140
+ }>, import("zod").ZodObject<{
141
+ version: import("zod").ZodLiteral<"5">;
142
+ dialect: import("zod").ZodLiteral<"mysql">;
143
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
144
+ name: import("zod").ZodString;
145
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
146
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
147
+ name: import("zod").ZodString;
148
+ type: import("zod").ZodString;
149
+ primaryKey: import("zod").ZodBoolean;
150
+ notNull: import("zod").ZodBoolean;
151
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
152
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
153
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
154
+ }, "strict", import("zod").ZodTypeAny, {
155
+ default?: any;
156
+ onUpdate?: any;
157
+ autoincrement?: boolean | undefined;
158
+ name: string;
159
+ type: string;
160
+ primaryKey: boolean;
161
+ notNull: boolean;
162
+ }, {
163
+ default?: any;
164
+ onUpdate?: any;
165
+ autoincrement?: boolean | undefined;
166
+ name: string;
167
+ type: string;
168
+ primaryKey: boolean;
169
+ notNull: boolean;
170
+ }>>;
171
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
172
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
173
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
174
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
175
+ }, "strict", import("zod").ZodTypeAny, {
176
+ schema?: string | undefined;
177
+ name: string;
178
+ columns: Record<string, {
179
+ default?: any;
180
+ onUpdate?: any;
181
+ autoincrement?: boolean | undefined;
182
+ name: string;
183
+ type: string;
184
+ primaryKey: boolean;
185
+ notNull: boolean;
186
+ }>;
187
+ indexes: Record<string, string>;
188
+ foreignKeys: Record<string, string>;
189
+ compositePrimaryKeys: Record<string, string>;
190
+ uniqueConstraints: Record<string, string>;
191
+ }, {
192
+ schema?: string | undefined;
193
+ uniqueConstraints?: Record<string, string> | undefined;
194
+ name: string;
195
+ columns: Record<string, {
196
+ default?: any;
197
+ onUpdate?: any;
198
+ autoincrement?: boolean | undefined;
199
+ name: string;
200
+ type: string;
201
+ primaryKey: boolean;
202
+ notNull: boolean;
203
+ }>;
204
+ indexes: Record<string, string>;
205
+ foreignKeys: Record<string, string>;
206
+ compositePrimaryKeys: Record<string, string>;
207
+ }>>;
208
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
209
+ }, "strict", import("zod").ZodTypeAny, {
210
+ version: "5";
211
+ dialect: "mysql";
212
+ tables: Record<string, {
213
+ schema?: string | undefined;
214
+ name: string;
215
+ columns: Record<string, {
216
+ default?: any;
217
+ onUpdate?: any;
218
+ autoincrement?: boolean | undefined;
219
+ name: string;
220
+ type: string;
221
+ primaryKey: boolean;
222
+ notNull: boolean;
223
+ }>;
224
+ indexes: Record<string, string>;
225
+ foreignKeys: Record<string, string>;
226
+ compositePrimaryKeys: Record<string, string>;
227
+ uniqueConstraints: Record<string, string>;
228
+ }>;
229
+ schemas: Record<string, string>;
230
+ }, {
231
+ version: "5";
232
+ dialect: "mysql";
233
+ tables: Record<string, {
234
+ schema?: string | undefined;
235
+ uniqueConstraints?: Record<string, string> | undefined;
236
+ name: string;
237
+ columns: Record<string, {
238
+ default?: any;
239
+ onUpdate?: any;
240
+ autoincrement?: boolean | undefined;
241
+ name: string;
242
+ type: string;
243
+ primaryKey: boolean;
244
+ notNull: boolean;
245
+ }>;
246
+ indexes: Record<string, string>;
247
+ foreignKeys: Record<string, string>;
248
+ compositePrimaryKeys: Record<string, string>;
249
+ }>;
250
+ schemas: Record<string, string>;
251
+ }>, import("zod").ZodObject<{
252
+ version: import("zod").ZodLiteral<"5">;
253
+ dialect: import("zod").ZodEnum<["sqlite"]>;
254
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
255
+ name: import("zod").ZodString;
256
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
257
+ name: import("zod").ZodString;
258
+ type: import("zod").ZodString;
259
+ primaryKey: import("zod").ZodBoolean;
260
+ notNull: import("zod").ZodBoolean;
261
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
262
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
263
+ }, "strict", import("zod").ZodTypeAny, {
264
+ default?: any;
265
+ autoincrement?: boolean | undefined;
266
+ name: string;
267
+ type: string;
268
+ primaryKey: boolean;
269
+ notNull: boolean;
270
+ }, {
271
+ default?: any;
272
+ autoincrement?: boolean | undefined;
273
+ name: string;
274
+ type: string;
275
+ primaryKey: boolean;
276
+ notNull: boolean;
277
+ }>>;
278
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
279
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
280
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
281
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
282
+ }, "strict", import("zod").ZodTypeAny, {
283
+ name: string;
284
+ columns: Record<string, {
285
+ default?: any;
286
+ autoincrement?: boolean | undefined;
287
+ name: string;
288
+ type: string;
289
+ primaryKey: boolean;
290
+ notNull: boolean;
291
+ }>;
292
+ indexes: Record<string, string>;
293
+ foreignKeys: Record<string, string>;
294
+ compositePrimaryKeys: Record<string, string>;
295
+ uniqueConstraints: Record<string, string>;
296
+ }, {
297
+ uniqueConstraints?: Record<string, string> | undefined;
298
+ name: string;
299
+ columns: Record<string, {
300
+ default?: any;
301
+ autoincrement?: boolean | undefined;
302
+ name: string;
303
+ type: string;
304
+ primaryKey: boolean;
305
+ notNull: boolean;
306
+ }>;
307
+ indexes: Record<string, string>;
308
+ foreignKeys: Record<string, string>;
309
+ compositePrimaryKeys: Record<string, string>;
310
+ }>>;
311
+ enums: import("zod").ZodAny;
312
+ }, "strict", import("zod").ZodTypeAny, {
313
+ enums?: any;
314
+ version: "5";
315
+ dialect: "sqlite";
316
+ tables: Record<string, {
317
+ name: string;
318
+ columns: Record<string, {
319
+ default?: any;
320
+ autoincrement?: boolean | undefined;
321
+ name: string;
322
+ type: string;
323
+ primaryKey: boolean;
324
+ notNull: boolean;
325
+ }>;
326
+ indexes: Record<string, string>;
327
+ foreignKeys: Record<string, string>;
328
+ compositePrimaryKeys: Record<string, string>;
329
+ uniqueConstraints: Record<string, string>;
330
+ }>;
331
+ }, {
332
+ enums?: any;
333
+ version: "5";
334
+ dialect: "sqlite";
335
+ tables: Record<string, {
336
+ uniqueConstraints?: Record<string, string> | undefined;
337
+ name: string;
338
+ columns: Record<string, {
339
+ default?: any;
340
+ autoincrement?: boolean | undefined;
341
+ name: string;
342
+ type: string;
343
+ primaryKey: boolean;
344
+ notNull: boolean;
345
+ }>;
346
+ indexes: Record<string, string>;
347
+ foreignKeys: Record<string, string>;
348
+ compositePrimaryKeys: Record<string, string>;
349
+ }>;
350
+ }>]>;
351
+ declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").extendShape<{
352
+ version: import("zod").ZodLiteral<"5">;
353
+ dialect: import("zod").ZodLiteral<"pg">;
354
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
355
+ name: import("zod").ZodString;
356
+ schema: import("zod").ZodString;
357
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
358
+ name: import("zod").ZodString;
359
+ type: import("zod").ZodString;
360
+ primaryKey: import("zod").ZodBoolean;
361
+ notNull: import("zod").ZodBoolean;
362
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
363
+ isUnique: import("zod").ZodOptional<import("zod").ZodAny>;
364
+ uniqueName: import("zod").ZodOptional<import("zod").ZodString>;
365
+ nullsNotDistinct: import("zod").ZodOptional<import("zod").ZodBoolean>;
366
+ }, "strict", import("zod").ZodTypeAny, {
367
+ isUnique?: any;
368
+ default?: any;
369
+ uniqueName?: string | undefined;
370
+ nullsNotDistinct?: boolean | undefined;
371
+ name: string;
372
+ type: string;
373
+ primaryKey: boolean;
374
+ notNull: boolean;
375
+ }, {
376
+ isUnique?: any;
377
+ default?: any;
378
+ uniqueName?: string | undefined;
379
+ nullsNotDistinct?: boolean | undefined;
380
+ name: string;
381
+ type: string;
382
+ primaryKey: boolean;
383
+ notNull: boolean;
384
+ }>>;
385
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
386
+ name: import("zod").ZodString;
387
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
388
+ isUnique: import("zod").ZodBoolean;
389
+ }, "strict", import("zod").ZodTypeAny, {
390
+ name: string;
391
+ columns: string[];
392
+ isUnique: boolean;
393
+ }, {
394
+ name: string;
395
+ columns: string[];
396
+ isUnique: boolean;
397
+ }>>;
398
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
399
+ name: import("zod").ZodString;
400
+ tableFrom: import("zod").ZodString;
401
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
402
+ tableTo: import("zod").ZodString;
403
+ schemaTo: import("zod").ZodOptional<import("zod").ZodString>;
404
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
405
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
406
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
407
+ }, "strict", import("zod").ZodTypeAny, {
408
+ onUpdate?: string | undefined;
409
+ onDelete?: string | undefined;
410
+ schemaTo?: string | undefined;
411
+ name: string;
412
+ tableFrom: string;
413
+ columnsFrom: string[];
414
+ tableTo: string;
415
+ columnsTo: string[];
416
+ }, {
417
+ onUpdate?: string | undefined;
418
+ onDelete?: string | undefined;
419
+ schemaTo?: string | undefined;
420
+ name: string;
421
+ tableFrom: string;
422
+ columnsFrom: string[];
423
+ tableTo: string;
424
+ columnsTo: string[];
425
+ }>>;
426
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
427
+ name: import("zod").ZodString;
428
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
429
+ }, "strict", import("zod").ZodTypeAny, {
430
+ name: string;
431
+ columns: string[];
432
+ }, {
433
+ name: string;
434
+ columns: string[];
435
+ }>>;
436
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
437
+ name: import("zod").ZodString;
438
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
439
+ nullsNotDistinct: import("zod").ZodBoolean;
440
+ }, "strict", import("zod").ZodTypeAny, {
441
+ name: string;
442
+ columns: string[];
443
+ nullsNotDistinct: boolean;
444
+ }, {
445
+ name: string;
446
+ columns: string[];
447
+ nullsNotDistinct: boolean;
448
+ }>>>;
449
+ }, "strict", import("zod").ZodTypeAny, {
450
+ name: string;
451
+ columns: Record<string, {
452
+ isUnique?: any;
453
+ default?: any;
454
+ uniqueName?: string | undefined;
455
+ nullsNotDistinct?: boolean | undefined;
456
+ name: string;
457
+ type: string;
458
+ primaryKey: boolean;
459
+ notNull: boolean;
460
+ }>;
461
+ indexes: Record<string, {
462
+ name: string;
463
+ columns: string[];
464
+ isUnique: boolean;
465
+ }>;
466
+ foreignKeys: Record<string, {
467
+ onUpdate?: string | undefined;
468
+ onDelete?: string | undefined;
469
+ schemaTo?: string | undefined;
470
+ name: string;
471
+ tableFrom: string;
472
+ columnsFrom: string[];
473
+ tableTo: string;
474
+ columnsTo: string[];
475
+ }>;
476
+ schema: string;
477
+ compositePrimaryKeys: Record<string, {
478
+ name: string;
479
+ columns: string[];
480
+ }>;
481
+ uniqueConstraints: Record<string, {
482
+ name: string;
483
+ columns: string[];
484
+ nullsNotDistinct: boolean;
485
+ }>;
486
+ }, {
487
+ uniqueConstraints?: Record<string, {
488
+ name: string;
489
+ columns: string[];
490
+ nullsNotDistinct: boolean;
491
+ }> | undefined;
492
+ name: string;
493
+ columns: Record<string, {
494
+ isUnique?: any;
495
+ default?: any;
496
+ uniqueName?: string | undefined;
497
+ nullsNotDistinct?: boolean | undefined;
498
+ name: string;
499
+ type: string;
500
+ primaryKey: boolean;
501
+ notNull: boolean;
502
+ }>;
503
+ indexes: Record<string, {
504
+ name: string;
505
+ columns: string[];
506
+ isUnique: boolean;
507
+ }>;
508
+ foreignKeys: Record<string, {
509
+ onUpdate?: string | undefined;
510
+ onDelete?: string | undefined;
511
+ schemaTo?: string | undefined;
512
+ name: string;
513
+ tableFrom: string;
514
+ columnsFrom: string[];
515
+ tableTo: string;
516
+ columnsTo: string[];
517
+ }>;
518
+ schema: string;
519
+ compositePrimaryKeys: Record<string, {
520
+ name: string;
521
+ columns: string[];
522
+ }>;
523
+ }>>;
524
+ enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
525
+ name: import("zod").ZodString;
526
+ values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
527
+ }, "strict", import("zod").ZodTypeAny, {
528
+ name: string;
529
+ values: Record<string, string>;
530
+ }, {
531
+ name: string;
532
+ values: Record<string, string>;
533
+ }>>;
534
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
535
+ _meta: import("zod").ZodObject<{
536
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
537
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
538
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
539
+ }, "strip", import("zod").ZodTypeAny, {
540
+ columns: Record<string, string>;
541
+ tables: Record<string, string>;
542
+ schemas: Record<string, string>;
543
+ }, {
544
+ columns: Record<string, string>;
545
+ tables: Record<string, string>;
546
+ schemas: Record<string, string>;
547
+ }>;
548
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
549
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
550
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
551
+ isArray: import("zod").ZodOptional<import("zod").ZodBoolean>;
552
+ dimensions: import("zod").ZodOptional<import("zod").ZodNumber>;
553
+ rawType: import("zod").ZodOptional<import("zod").ZodString>;
554
+ }, "strip", import("zod").ZodTypeAny, {
555
+ isArray?: boolean | undefined;
556
+ dimensions?: number | undefined;
557
+ rawType?: string | undefined;
558
+ }, {
559
+ isArray?: boolean | undefined;
560
+ dimensions?: number | undefined;
561
+ rawType?: string | undefined;
562
+ }>>>;
563
+ }, "strip", import("zod").ZodTypeAny, {
564
+ columns: Record<string, {
565
+ isArray?: boolean | undefined;
566
+ dimensions?: number | undefined;
567
+ rawType?: string | undefined;
568
+ } | undefined>;
569
+ }, {
570
+ columns: Record<string, {
571
+ isArray?: boolean | undefined;
572
+ dimensions?: number | undefined;
573
+ rawType?: string | undefined;
574
+ } | undefined>;
575
+ }>>>;
576
+ }, "strip", import("zod").ZodTypeAny, {
577
+ tables: Record<string, {
578
+ columns: Record<string, {
579
+ isArray?: boolean | undefined;
580
+ dimensions?: number | undefined;
581
+ rawType?: string | undefined;
582
+ } | undefined>;
583
+ } | undefined>;
584
+ }, {
585
+ tables: Record<string, {
586
+ columns: Record<string, {
587
+ isArray?: boolean | undefined;
588
+ dimensions?: number | undefined;
589
+ rawType?: string | undefined;
590
+ } | undefined>;
591
+ } | undefined>;
592
+ }>>;
593
+ }, {
594
+ id: import("zod").ZodString;
595
+ prevId: import("zod").ZodString;
596
+ }>, "strip", import("zod").ZodTypeAny, {
597
+ internal?: {
598
+ tables: Record<string, {
599
+ columns: Record<string, {
600
+ isArray?: boolean | undefined;
601
+ dimensions?: number | undefined;
602
+ rawType?: string | undefined;
603
+ } | undefined>;
604
+ } | undefined>;
605
+ } | undefined;
606
+ id: string;
607
+ prevId: string;
608
+ version: "5";
609
+ dialect: "pg";
610
+ tables: Record<string, {
611
+ name: string;
612
+ columns: Record<string, {
613
+ isUnique?: any;
614
+ default?: any;
615
+ uniqueName?: string | undefined;
616
+ nullsNotDistinct?: boolean | undefined;
617
+ name: string;
618
+ type: string;
619
+ primaryKey: boolean;
620
+ notNull: boolean;
621
+ }>;
622
+ indexes: Record<string, {
623
+ name: string;
624
+ columns: string[];
625
+ isUnique: boolean;
626
+ }>;
627
+ foreignKeys: Record<string, {
628
+ onUpdate?: string | undefined;
629
+ onDelete?: string | undefined;
630
+ schemaTo?: string | undefined;
631
+ name: string;
632
+ tableFrom: string;
633
+ columnsFrom: string[];
634
+ tableTo: string;
635
+ columnsTo: string[];
636
+ }>;
637
+ schema: string;
638
+ compositePrimaryKeys: Record<string, {
639
+ name: string;
640
+ columns: string[];
641
+ }>;
642
+ uniqueConstraints: Record<string, {
643
+ name: string;
644
+ columns: string[];
645
+ nullsNotDistinct: boolean;
646
+ }>;
647
+ }>;
648
+ schemas: Record<string, string>;
649
+ _meta: {
650
+ columns: Record<string, string>;
651
+ tables: Record<string, string>;
652
+ schemas: Record<string, string>;
653
+ };
654
+ enums: Record<string, {
655
+ name: string;
656
+ values: Record<string, string>;
657
+ }>;
658
+ }, {
659
+ internal?: {
660
+ tables: Record<string, {
661
+ columns: Record<string, {
662
+ isArray?: boolean | undefined;
663
+ dimensions?: number | undefined;
664
+ rawType?: string | undefined;
665
+ } | undefined>;
666
+ } | undefined>;
667
+ } | undefined;
668
+ id: string;
669
+ prevId: string;
670
+ version: "5";
671
+ dialect: "pg";
672
+ tables: Record<string, {
673
+ uniqueConstraints?: Record<string, {
674
+ name: string;
675
+ columns: string[];
676
+ nullsNotDistinct: boolean;
677
+ }> | undefined;
678
+ name: string;
679
+ columns: Record<string, {
680
+ isUnique?: any;
681
+ default?: any;
682
+ uniqueName?: string | undefined;
683
+ nullsNotDistinct?: boolean | undefined;
684
+ name: string;
685
+ type: string;
686
+ primaryKey: boolean;
687
+ notNull: boolean;
688
+ }>;
689
+ indexes: Record<string, {
690
+ name: string;
691
+ columns: string[];
692
+ isUnique: boolean;
693
+ }>;
694
+ foreignKeys: Record<string, {
695
+ onUpdate?: string | undefined;
696
+ onDelete?: string | undefined;
697
+ schemaTo?: string | undefined;
698
+ name: string;
699
+ tableFrom: string;
700
+ columnsFrom: string[];
701
+ tableTo: string;
702
+ columnsTo: string[];
703
+ }>;
704
+ schema: string;
705
+ compositePrimaryKeys: Record<string, {
706
+ name: string;
707
+ columns: string[];
708
+ }>;
709
+ }>;
710
+ schemas: Record<string, string>;
711
+ _meta: {
712
+ columns: Record<string, string>;
713
+ tables: Record<string, string>;
714
+ schemas: Record<string, string>;
715
+ };
716
+ enums: Record<string, {
717
+ name: string;
718
+ values: Record<string, string>;
719
+ }>;
720
+ }>, import("zod").ZodObject<import("zod").extendShape<{
721
+ version: import("zod").ZodLiteral<"5">;
722
+ dialect: import("zod").ZodLiteral<"mysql">;
723
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
724
+ name: import("zod").ZodString;
725
+ schema: import("zod").ZodOptional<import("zod").ZodString>;
726
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
727
+ name: import("zod").ZodString;
728
+ type: import("zod").ZodString;
729
+ primaryKey: import("zod").ZodBoolean;
730
+ notNull: import("zod").ZodBoolean;
731
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
732
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
733
+ onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
734
+ }, "strict", import("zod").ZodTypeAny, {
735
+ default?: any;
736
+ onUpdate?: any;
737
+ autoincrement?: boolean | undefined;
738
+ name: string;
739
+ type: string;
740
+ primaryKey: boolean;
741
+ notNull: boolean;
742
+ }, {
743
+ default?: any;
744
+ onUpdate?: any;
745
+ autoincrement?: boolean | undefined;
746
+ name: string;
747
+ type: string;
748
+ primaryKey: boolean;
749
+ notNull: boolean;
750
+ }>>;
751
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
752
+ name: import("zod").ZodString;
753
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
754
+ isUnique: import("zod").ZodBoolean;
755
+ using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
756
+ algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
757
+ lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
758
+ }, "strict", import("zod").ZodTypeAny, {
759
+ using?: "btree" | "hash" | undefined;
760
+ algorithm?: "default" | "inplace" | "copy" | undefined;
761
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
762
+ name: string;
763
+ columns: string[];
764
+ isUnique: boolean;
765
+ }, {
766
+ using?: "btree" | "hash" | undefined;
767
+ algorithm?: "default" | "inplace" | "copy" | undefined;
768
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
769
+ name: string;
770
+ columns: string[];
771
+ isUnique: boolean;
772
+ }>>;
773
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
774
+ name: import("zod").ZodString;
775
+ tableFrom: import("zod").ZodString;
776
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
777
+ tableTo: import("zod").ZodString;
778
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
779
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
780
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
781
+ }, "strict", import("zod").ZodTypeAny, {
782
+ onUpdate?: string | undefined;
783
+ onDelete?: string | undefined;
784
+ name: string;
785
+ tableFrom: string;
786
+ columnsFrom: string[];
787
+ tableTo: string;
788
+ columnsTo: string[];
789
+ }, {
790
+ onUpdate?: string | undefined;
791
+ onDelete?: string | undefined;
792
+ name: string;
793
+ tableFrom: string;
794
+ columnsFrom: string[];
795
+ tableTo: string;
796
+ columnsTo: string[];
797
+ }>>;
798
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
799
+ name: import("zod").ZodString;
800
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
801
+ }, "strict", import("zod").ZodTypeAny, {
802
+ name: string;
803
+ columns: string[];
804
+ }, {
805
+ name: string;
806
+ columns: string[];
807
+ }>>;
808
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
809
+ name: import("zod").ZodString;
810
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
811
+ }, "strict", import("zod").ZodTypeAny, {
812
+ name: string;
813
+ columns: string[];
814
+ }, {
815
+ name: string;
816
+ columns: string[];
817
+ }>>>;
818
+ }, "strict", import("zod").ZodTypeAny, {
819
+ schema?: string | undefined;
820
+ name: string;
821
+ columns: Record<string, {
822
+ default?: any;
823
+ onUpdate?: any;
824
+ autoincrement?: boolean | undefined;
825
+ name: string;
826
+ type: string;
827
+ primaryKey: boolean;
828
+ notNull: boolean;
829
+ }>;
830
+ indexes: Record<string, {
831
+ using?: "btree" | "hash" | undefined;
832
+ algorithm?: "default" | "inplace" | "copy" | undefined;
833
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
834
+ name: string;
835
+ columns: string[];
836
+ isUnique: boolean;
837
+ }>;
838
+ foreignKeys: Record<string, {
839
+ onUpdate?: string | undefined;
840
+ onDelete?: string | undefined;
841
+ name: string;
842
+ tableFrom: string;
843
+ columnsFrom: string[];
844
+ tableTo: string;
845
+ columnsTo: string[];
846
+ }>;
847
+ compositePrimaryKeys: Record<string, {
848
+ name: string;
849
+ columns: string[];
850
+ }>;
851
+ uniqueConstraints: Record<string, {
852
+ name: string;
853
+ columns: string[];
854
+ }>;
855
+ }, {
856
+ schema?: string | undefined;
857
+ uniqueConstraints?: Record<string, {
858
+ name: string;
859
+ columns: string[];
860
+ }> | undefined;
861
+ name: string;
862
+ columns: Record<string, {
863
+ default?: any;
864
+ onUpdate?: any;
865
+ autoincrement?: boolean | undefined;
866
+ name: string;
867
+ type: string;
868
+ primaryKey: boolean;
869
+ notNull: boolean;
870
+ }>;
871
+ indexes: Record<string, {
872
+ using?: "btree" | "hash" | undefined;
873
+ algorithm?: "default" | "inplace" | "copy" | undefined;
874
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
875
+ name: string;
876
+ columns: string[];
877
+ isUnique: boolean;
878
+ }>;
879
+ foreignKeys: Record<string, {
880
+ onUpdate?: string | undefined;
881
+ onDelete?: string | undefined;
882
+ name: string;
883
+ tableFrom: string;
884
+ columnsFrom: string[];
885
+ tableTo: string;
886
+ columnsTo: string[];
887
+ }>;
888
+ compositePrimaryKeys: Record<string, {
889
+ name: string;
890
+ columns: string[];
891
+ }>;
892
+ }>>;
893
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
894
+ _meta: import("zod").ZodObject<{
895
+ schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
896
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
897
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
898
+ }, "strip", import("zod").ZodTypeAny, {
899
+ columns: Record<string, string>;
900
+ tables: Record<string, string>;
901
+ schemas: Record<string, string>;
902
+ }, {
903
+ columns: Record<string, string>;
904
+ tables: Record<string, string>;
905
+ schemas: Record<string, string>;
906
+ }>;
907
+ internal: import("zod").ZodOptional<import("zod").ZodObject<{
908
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
909
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
910
+ isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
911
+ }, "strip", import("zod").ZodTypeAny, {
912
+ isDefaultAnExpression?: boolean | undefined;
913
+ }, {
914
+ isDefaultAnExpression?: boolean | undefined;
915
+ }>>>;
916
+ }, "strip", import("zod").ZodTypeAny, {
917
+ columns: Record<string, {
918
+ isDefaultAnExpression?: boolean | undefined;
919
+ } | undefined>;
920
+ }, {
921
+ columns: Record<string, {
922
+ isDefaultAnExpression?: boolean | undefined;
923
+ } | undefined>;
924
+ }>>>;
925
+ }, "strip", import("zod").ZodTypeAny, {
926
+ tables: Record<string, {
927
+ columns: Record<string, {
928
+ isDefaultAnExpression?: boolean | undefined;
929
+ } | undefined>;
930
+ } | undefined>;
931
+ }, {
932
+ tables: Record<string, {
933
+ columns: Record<string, {
934
+ isDefaultAnExpression?: boolean | undefined;
935
+ } | undefined>;
936
+ } | undefined>;
937
+ }>>;
938
+ }, {
939
+ id: import("zod").ZodString;
940
+ prevId: import("zod").ZodString;
941
+ }>, "strip", import("zod").ZodTypeAny, {
942
+ internal?: {
943
+ tables: Record<string, {
944
+ columns: Record<string, {
945
+ isDefaultAnExpression?: boolean | undefined;
946
+ } | undefined>;
947
+ } | undefined>;
948
+ } | undefined;
949
+ id: string;
950
+ prevId: string;
951
+ version: "5";
952
+ dialect: "mysql";
953
+ tables: Record<string, {
954
+ schema?: string | undefined;
955
+ name: string;
956
+ columns: Record<string, {
957
+ default?: any;
958
+ onUpdate?: any;
959
+ autoincrement?: boolean | undefined;
960
+ name: string;
961
+ type: string;
962
+ primaryKey: boolean;
963
+ notNull: boolean;
964
+ }>;
965
+ indexes: Record<string, {
966
+ using?: "btree" | "hash" | undefined;
967
+ algorithm?: "default" | "inplace" | "copy" | undefined;
968
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
969
+ name: string;
970
+ columns: string[];
971
+ isUnique: boolean;
972
+ }>;
973
+ foreignKeys: Record<string, {
974
+ onUpdate?: string | undefined;
975
+ onDelete?: string | undefined;
976
+ name: string;
977
+ tableFrom: string;
978
+ columnsFrom: string[];
979
+ tableTo: string;
980
+ columnsTo: string[];
981
+ }>;
982
+ compositePrimaryKeys: Record<string, {
983
+ name: string;
984
+ columns: string[];
985
+ }>;
986
+ uniqueConstraints: Record<string, {
987
+ name: string;
988
+ columns: string[];
989
+ }>;
990
+ }>;
991
+ schemas: Record<string, string>;
992
+ _meta: {
993
+ columns: Record<string, string>;
994
+ tables: Record<string, string>;
995
+ schemas: Record<string, string>;
996
+ };
997
+ }, {
998
+ internal?: {
999
+ tables: Record<string, {
1000
+ columns: Record<string, {
1001
+ isDefaultAnExpression?: boolean | undefined;
1002
+ } | undefined>;
1003
+ } | undefined>;
1004
+ } | undefined;
1005
+ id: string;
1006
+ prevId: string;
1007
+ version: "5";
1008
+ dialect: "mysql";
1009
+ tables: Record<string, {
1010
+ schema?: string | undefined;
1011
+ uniqueConstraints?: Record<string, {
1012
+ name: string;
1013
+ columns: string[];
1014
+ }> | undefined;
1015
+ name: string;
1016
+ columns: Record<string, {
1017
+ default?: any;
1018
+ onUpdate?: any;
1019
+ autoincrement?: boolean | undefined;
1020
+ name: string;
1021
+ type: string;
1022
+ primaryKey: boolean;
1023
+ notNull: boolean;
1024
+ }>;
1025
+ indexes: Record<string, {
1026
+ using?: "btree" | "hash" | undefined;
1027
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1028
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1029
+ name: string;
1030
+ columns: string[];
1031
+ isUnique: boolean;
1032
+ }>;
1033
+ foreignKeys: Record<string, {
1034
+ onUpdate?: string | undefined;
1035
+ onDelete?: string | undefined;
1036
+ name: string;
1037
+ tableFrom: string;
1038
+ columnsFrom: string[];
1039
+ tableTo: string;
1040
+ columnsTo: string[];
1041
+ }>;
1042
+ compositePrimaryKeys: Record<string, {
1043
+ name: string;
1044
+ columns: string[];
1045
+ }>;
1046
+ }>;
1047
+ schemas: Record<string, string>;
1048
+ _meta: {
1049
+ columns: Record<string, string>;
1050
+ tables: Record<string, string>;
1051
+ schemas: Record<string, string>;
1052
+ };
1053
+ }>, import("zod").ZodObject<import("zod").extendShape<{
1054
+ version: import("zod").ZodLiteral<"5">;
1055
+ dialect: import("zod").ZodEnum<["sqlite"]>;
1056
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1057
+ name: import("zod").ZodString;
1058
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1059
+ name: import("zod").ZodString;
1060
+ type: import("zod").ZodString;
1061
+ primaryKey: import("zod").ZodBoolean;
1062
+ notNull: import("zod").ZodBoolean;
1063
+ autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
1064
+ default: import("zod").ZodOptional<import("zod").ZodAny>;
1065
+ }, "strict", import("zod").ZodTypeAny, {
1066
+ default?: any;
1067
+ autoincrement?: boolean | undefined;
1068
+ name: string;
1069
+ type: string;
1070
+ primaryKey: boolean;
1071
+ notNull: boolean;
1072
+ }, {
1073
+ default?: any;
1074
+ autoincrement?: boolean | undefined;
1075
+ name: string;
1076
+ type: string;
1077
+ primaryKey: boolean;
1078
+ notNull: boolean;
1079
+ }>>;
1080
+ indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1081
+ name: import("zod").ZodString;
1082
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1083
+ where: import("zod").ZodOptional<import("zod").ZodString>;
1084
+ isUnique: import("zod").ZodBoolean;
1085
+ }, "strict", import("zod").ZodTypeAny, {
1086
+ where?: string | undefined;
1087
+ name: string;
1088
+ columns: string[];
1089
+ isUnique: boolean;
1090
+ }, {
1091
+ where?: string | undefined;
1092
+ name: string;
1093
+ columns: string[];
1094
+ isUnique: boolean;
1095
+ }>>;
1096
+ foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1097
+ name: import("zod").ZodString;
1098
+ tableFrom: import("zod").ZodString;
1099
+ columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1100
+ tableTo: import("zod").ZodString;
1101
+ columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1102
+ onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1103
+ onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1104
+ }, "strict", import("zod").ZodTypeAny, {
1105
+ onUpdate?: string | undefined;
1106
+ onDelete?: string | undefined;
1107
+ name: string;
1108
+ tableFrom: string;
1109
+ columnsFrom: string[];
1110
+ tableTo: string;
1111
+ columnsTo: string[];
1112
+ }, {
1113
+ onUpdate?: string | undefined;
1114
+ onDelete?: string | undefined;
1115
+ name: string;
1116
+ tableFrom: string;
1117
+ columnsFrom: string[];
1118
+ tableTo: string;
1119
+ columnsTo: string[];
1120
+ }>>;
1121
+ compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1122
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1123
+ name: import("zod").ZodOptional<import("zod").ZodString>;
1124
+ }, "strict", import("zod").ZodTypeAny, {
1125
+ name?: string | undefined;
1126
+ columns: string[];
1127
+ }, {
1128
+ name?: string | undefined;
1129
+ columns: string[];
1130
+ }>>;
1131
+ uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1132
+ name: import("zod").ZodString;
1133
+ columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1134
+ }, "strict", import("zod").ZodTypeAny, {
1135
+ name: string;
1136
+ columns: string[];
1137
+ }, {
1138
+ name: string;
1139
+ columns: string[];
1140
+ }>>>;
1141
+ }, "strict", import("zod").ZodTypeAny, {
1142
+ name: string;
1143
+ columns: Record<string, {
1144
+ default?: any;
1145
+ autoincrement?: boolean | undefined;
1146
+ name: string;
1147
+ type: string;
1148
+ primaryKey: boolean;
1149
+ notNull: boolean;
1150
+ }>;
1151
+ indexes: Record<string, {
1152
+ where?: string | undefined;
1153
+ name: string;
1154
+ columns: string[];
1155
+ isUnique: boolean;
1156
+ }>;
1157
+ foreignKeys: Record<string, {
1158
+ onUpdate?: string | undefined;
1159
+ onDelete?: string | undefined;
1160
+ name: string;
1161
+ tableFrom: string;
1162
+ columnsFrom: string[];
1163
+ tableTo: string;
1164
+ columnsTo: string[];
1165
+ }>;
1166
+ compositePrimaryKeys: Record<string, {
1167
+ name?: string | undefined;
1168
+ columns: string[];
1169
+ }>;
1170
+ uniqueConstraints: Record<string, {
1171
+ name: string;
1172
+ columns: string[];
1173
+ }>;
1174
+ }, {
1175
+ uniqueConstraints?: Record<string, {
1176
+ name: string;
1177
+ columns: string[];
1178
+ }> | undefined;
1179
+ name: string;
1180
+ columns: Record<string, {
1181
+ default?: any;
1182
+ autoincrement?: boolean | undefined;
1183
+ name: string;
1184
+ type: string;
1185
+ primaryKey: boolean;
1186
+ notNull: boolean;
1187
+ }>;
1188
+ indexes: Record<string, {
1189
+ where?: string | undefined;
1190
+ name: string;
1191
+ columns: string[];
1192
+ isUnique: boolean;
1193
+ }>;
1194
+ foreignKeys: Record<string, {
1195
+ onUpdate?: string | undefined;
1196
+ onDelete?: string | undefined;
1197
+ name: string;
1198
+ tableFrom: string;
1199
+ columnsFrom: string[];
1200
+ tableTo: string;
1201
+ columnsTo: string[];
1202
+ }>;
1203
+ compositePrimaryKeys: Record<string, {
1204
+ name?: string | undefined;
1205
+ columns: string[];
1206
+ }>;
1207
+ }>>;
1208
+ enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
1209
+ _meta: import("zod").ZodObject<{
1210
+ tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1211
+ columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1212
+ }, "strip", import("zod").ZodTypeAny, {
1213
+ columns: Record<string, string>;
1214
+ tables: Record<string, string>;
1215
+ }, {
1216
+ columns: Record<string, string>;
1217
+ tables: Record<string, string>;
1218
+ }>;
1219
+ }, {
1220
+ id: import("zod").ZodString;
1221
+ prevId: import("zod").ZodString;
1222
+ }>, "strict", import("zod").ZodTypeAny, {
1223
+ id: string;
1224
+ prevId: string;
1225
+ version: "5";
1226
+ dialect: "sqlite";
1227
+ tables: Record<string, {
1228
+ name: string;
1229
+ columns: Record<string, {
1230
+ default?: any;
1231
+ autoincrement?: boolean | undefined;
1232
+ name: string;
1233
+ type: string;
1234
+ primaryKey: boolean;
1235
+ notNull: boolean;
1236
+ }>;
1237
+ indexes: Record<string, {
1238
+ where?: string | undefined;
1239
+ name: string;
1240
+ columns: string[];
1241
+ isUnique: boolean;
1242
+ }>;
1243
+ foreignKeys: Record<string, {
1244
+ onUpdate?: string | undefined;
1245
+ onDelete?: string | undefined;
1246
+ name: string;
1247
+ tableFrom: string;
1248
+ columnsFrom: string[];
1249
+ tableTo: string;
1250
+ columnsTo: string[];
1251
+ }>;
1252
+ compositePrimaryKeys: Record<string, {
1253
+ name?: string | undefined;
1254
+ columns: string[];
1255
+ }>;
1256
+ uniqueConstraints: Record<string, {
1257
+ name: string;
1258
+ columns: string[];
1259
+ }>;
1260
+ }>;
1261
+ _meta: {
1262
+ columns: Record<string, string>;
1263
+ tables: Record<string, string>;
1264
+ };
1265
+ enums: {};
1266
+ }, {
1267
+ id: string;
1268
+ prevId: string;
1269
+ version: "5";
1270
+ dialect: "sqlite";
1271
+ tables: Record<string, {
1272
+ uniqueConstraints?: Record<string, {
1273
+ name: string;
1274
+ columns: string[];
1275
+ }> | undefined;
1276
+ name: string;
1277
+ columns: Record<string, {
1278
+ default?: any;
1279
+ autoincrement?: boolean | undefined;
1280
+ name: string;
1281
+ type: string;
1282
+ primaryKey: boolean;
1283
+ notNull: boolean;
1284
+ }>;
1285
+ indexes: Record<string, {
1286
+ where?: string | undefined;
1287
+ name: string;
1288
+ columns: string[];
1289
+ isUnique: boolean;
1290
+ }>;
1291
+ foreignKeys: Record<string, {
1292
+ onUpdate?: string | undefined;
1293
+ onDelete?: string | undefined;
1294
+ name: string;
1295
+ tableFrom: string;
1296
+ columnsFrom: string[];
1297
+ tableTo: string;
1298
+ columnsTo: string[];
1299
+ }>;
1300
+ compositePrimaryKeys: Record<string, {
1301
+ name?: string | undefined;
1302
+ columns: string[];
1303
+ }>;
1304
+ }>;
1305
+ _meta: {
1306
+ columns: Record<string, string>;
1307
+ tables: Record<string, string>;
1308
+ };
1309
+ enums: {};
1310
+ }>]>;
1311
+ export type CommonSquashedSchema = TypeOf<typeof commonSquashedSchema>;
1312
+ export type CommonSchema = TypeOf<typeof commonSchema>;
1313
+ export {};