drizzle-kit 0.20.17-cab52ad → 0.20.17-d71f2ee

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