drizzle-kit 0.19.13-3b2cf28 → 0.19.13-53915b2

Sign up to get free protection for your applications and to get access to all the features.
Files changed (46) hide show
  1. package/index.cjs +30671 -30644
  2. package/index.d.ts +14 -15
  3. package/package.json +3 -4
  4. package/utils.js +11724 -44481
  5. package/@types/utils.d.ts +0 -12
  6. package/cli/commands/migrate.d.ts +0 -141
  7. package/cli/commands/mysqlUp.d.ts +0 -4
  8. package/cli/commands/pgIntrospect.d.ts +0 -118
  9. package/cli/commands/pgPushUtils.d.ts +0 -14
  10. package/cli/commands/pgUp.d.ts +0 -4
  11. package/cli/commands/sqliteIntrospect.d.ts +0 -102
  12. package/cli/commands/sqliteUtils.d.ts +0 -162
  13. package/cli/commands/upFolders.d.ts +0 -27
  14. package/cli/commands/utils.d.ts +0 -265
  15. package/cli/selector-ui.d.ts +0 -13
  16. package/cli/validations/common.d.ts +0 -13
  17. package/cli/validations/mysql.d.ts +0 -414
  18. package/cli/validations/outputs.d.ts +0 -39
  19. package/cli/validations/pg.d.ts +0 -438
  20. package/cli/validations/sqlite.d.ts +0 -220
  21. package/cli/validations/studio.d.ts +0 -469
  22. package/cli/views.d.ts +0 -61
  23. package/drivers/index.d.ts +0 -26
  24. package/global.d.ts +0 -2
  25. package/introspect.d.ts +0 -4
  26. package/jsonDiffer.d.ts +0 -76
  27. package/jsonStatements.d.ts +0 -349
  28. package/migrationPreparator.d.ts +0 -35
  29. package/schemaValidator.d.ts +0 -1236
  30. package/serializer/index.d.ts +0 -9
  31. package/serializer/mysqlImports.d.ts +0 -6
  32. package/serializer/mysqlSchema.d.ts +0 -3833
  33. package/serializer/mysqlSerializer.d.ts +0 -7
  34. package/serializer/pgImports.d.ts +0 -11
  35. package/serializer/pgSchema.d.ts +0 -4000
  36. package/serializer/pgSerializer.d.ts +0 -7
  37. package/serializer/sqliteImports.d.ts +0 -5
  38. package/serializer/sqliteSchema.d.ts +0 -3162
  39. package/serializer/sqliteSerializer.d.ts +0 -8
  40. package/serializer/studioUtils.d.ts +0 -31
  41. package/snapshotsDiffer.d.ts +0 -2660
  42. package/sqlgenerator.d.ts +0 -33
  43. package/sqlite-introspect.d.ts +0 -5
  44. package/utils/words.d.ts +0 -7
  45. package/utils.d.ts +0 -29
  46. package/utilsR.d.ts +0 -209
package/schemaValidator.d.ts DELETED
@@ -1,1236 +0,0 @@
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
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
404
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
405
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
406
- }, "strict", import("zod").ZodTypeAny, {
407
- onUpdate?: string | undefined;
408
- onDelete?: string | undefined;
409
- name: string;
410
- tableFrom: string;
411
- columnsFrom: string[];
412
- tableTo: string;
413
- columnsTo: string[];
414
- }, {
415
- onUpdate?: string | undefined;
416
- onDelete?: string | undefined;
417
- name: string;
418
- tableFrom: string;
419
- columnsFrom: string[];
420
- tableTo: string;
421
- columnsTo: string[];
422
- }>>;
423
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
424
- name: import("zod").ZodString;
425
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
426
- }, "strict", import("zod").ZodTypeAny, {
427
- name: string;
428
- columns: string[];
429
- }, {
430
- name: string;
431
- columns: string[];
432
- }>>;
433
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
434
- name: import("zod").ZodString;
435
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
436
- nullsNotDistinct: import("zod").ZodBoolean;
437
- }, "strict", import("zod").ZodTypeAny, {
438
- name: string;
439
- columns: string[];
440
- nullsNotDistinct: boolean;
441
- }, {
442
- name: string;
443
- columns: string[];
444
- nullsNotDistinct: boolean;
445
- }>>>;
446
- }, "strict", import("zod").ZodTypeAny, {
447
- name: string;
448
- columns: Record<string, {
449
- isUnique?: any;
450
- default?: any;
451
- uniqueName?: string | undefined;
452
- nullsNotDistinct?: boolean | undefined;
453
- name: string;
454
- type: string;
455
- primaryKey: boolean;
456
- notNull: boolean;
457
- }>;
458
- indexes: Record<string, {
459
- name: string;
460
- columns: string[];
461
- isUnique: boolean;
462
- }>;
463
- foreignKeys: Record<string, {
464
- onUpdate?: string | undefined;
465
- onDelete?: string | undefined;
466
- name: string;
467
- tableFrom: string;
468
- columnsFrom: string[];
469
- tableTo: string;
470
- columnsTo: string[];
471
- }>;
472
- schema: string;
473
- compositePrimaryKeys: Record<string, {
474
- name: string;
475
- columns: string[];
476
- }>;
477
- uniqueConstraints: Record<string, {
478
- name: string;
479
- columns: string[];
480
- nullsNotDistinct: boolean;
481
- }>;
482
- }, {
483
- uniqueConstraints?: Record<string, {
484
- name: string;
485
- columns: string[];
486
- nullsNotDistinct: boolean;
487
- }> | undefined;
488
- name: string;
489
- columns: Record<string, {
490
- isUnique?: any;
491
- default?: any;
492
- uniqueName?: string | undefined;
493
- nullsNotDistinct?: boolean | undefined;
494
- name: string;
495
- type: string;
496
- primaryKey: boolean;
497
- notNull: boolean;
498
- }>;
499
- indexes: Record<string, {
500
- name: string;
501
- columns: string[];
502
- isUnique: boolean;
503
- }>;
504
- foreignKeys: Record<string, {
505
- onUpdate?: string | undefined;
506
- onDelete?: string | undefined;
507
- name: string;
508
- tableFrom: string;
509
- columnsFrom: string[];
510
- tableTo: string;
511
- columnsTo: string[];
512
- }>;
513
- schema: string;
514
- compositePrimaryKeys: Record<string, {
515
- name: string;
516
- columns: string[];
517
- }>;
518
- }>>;
519
- enums: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
520
- name: import("zod").ZodString;
521
- values: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
522
- }, "strict", import("zod").ZodTypeAny, {
523
- name: string;
524
- values: Record<string, string>;
525
- }, {
526
- name: string;
527
- values: Record<string, string>;
528
- }>>;
529
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
530
- _meta: import("zod").ZodObject<{
531
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
532
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
533
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
534
- }, "strip", import("zod").ZodTypeAny, {
535
- columns: Record<string, string>;
536
- tables: Record<string, string>;
537
- schemas: Record<string, string>;
538
- }, {
539
- columns: Record<string, string>;
540
- tables: Record<string, string>;
541
- schemas: Record<string, string>;
542
- }>;
543
- }, {
544
- id: import("zod").ZodString;
545
- prevId: import("zod").ZodString;
546
- }>, "strip", import("zod").ZodTypeAny, {
547
- id: string;
548
- prevId: string;
549
- version: "5";
550
- dialect: "pg";
551
- tables: Record<string, {
552
- name: string;
553
- columns: Record<string, {
554
- isUnique?: any;
555
- default?: any;
556
- uniqueName?: string | undefined;
557
- nullsNotDistinct?: boolean | undefined;
558
- name: string;
559
- type: string;
560
- primaryKey: boolean;
561
- notNull: boolean;
562
- }>;
563
- indexes: Record<string, {
564
- name: string;
565
- columns: string[];
566
- isUnique: boolean;
567
- }>;
568
- foreignKeys: Record<string, {
569
- onUpdate?: string | undefined;
570
- onDelete?: string | undefined;
571
- name: string;
572
- tableFrom: string;
573
- columnsFrom: string[];
574
- tableTo: string;
575
- columnsTo: string[];
576
- }>;
577
- schema: string;
578
- compositePrimaryKeys: Record<string, {
579
- name: string;
580
- columns: string[];
581
- }>;
582
- uniqueConstraints: Record<string, {
583
- name: string;
584
- columns: string[];
585
- nullsNotDistinct: boolean;
586
- }>;
587
- }>;
588
- schemas: Record<string, string>;
589
- _meta: {
590
- columns: Record<string, string>;
591
- tables: Record<string, string>;
592
- schemas: Record<string, string>;
593
- };
594
- enums: Record<string, {
595
- name: string;
596
- values: Record<string, string>;
597
- }>;
598
- }, {
599
- id: string;
600
- prevId: string;
601
- version: "5";
602
- dialect: "pg";
603
- tables: Record<string, {
604
- uniqueConstraints?: Record<string, {
605
- name: string;
606
- columns: string[];
607
- nullsNotDistinct: boolean;
608
- }> | undefined;
609
- name: string;
610
- columns: Record<string, {
611
- isUnique?: any;
612
- default?: any;
613
- uniqueName?: string | undefined;
614
- nullsNotDistinct?: boolean | undefined;
615
- name: string;
616
- type: string;
617
- primaryKey: boolean;
618
- notNull: boolean;
619
- }>;
620
- indexes: Record<string, {
621
- name: string;
622
- columns: string[];
623
- isUnique: boolean;
624
- }>;
625
- foreignKeys: Record<string, {
626
- onUpdate?: string | undefined;
627
- onDelete?: string | undefined;
628
- name: string;
629
- tableFrom: string;
630
- columnsFrom: string[];
631
- tableTo: string;
632
- columnsTo: string[];
633
- }>;
634
- schema: string;
635
- compositePrimaryKeys: Record<string, {
636
- name: string;
637
- columns: string[];
638
- }>;
639
- }>;
640
- schemas: Record<string, string>;
641
- _meta: {
642
- columns: Record<string, string>;
643
- tables: Record<string, string>;
644
- schemas: Record<string, string>;
645
- };
646
- enums: Record<string, {
647
- name: string;
648
- values: Record<string, string>;
649
- }>;
650
- }>, import("zod").ZodObject<import("zod").extendShape<{
651
- version: import("zod").ZodLiteral<"5">;
652
- dialect: import("zod").ZodLiteral<"mysql">;
653
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
654
- name: import("zod").ZodString;
655
- schema: import("zod").ZodOptional<import("zod").ZodString>;
656
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
657
- name: import("zod").ZodString;
658
- type: import("zod").ZodString;
659
- primaryKey: import("zod").ZodBoolean;
660
- notNull: import("zod").ZodBoolean;
661
- autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
662
- default: import("zod").ZodOptional<import("zod").ZodAny>;
663
- onUpdate: import("zod").ZodOptional<import("zod").ZodAny>;
664
- }, "strict", import("zod").ZodTypeAny, {
665
- default?: any;
666
- onUpdate?: any;
667
- autoincrement?: boolean | undefined;
668
- name: string;
669
- type: string;
670
- primaryKey: boolean;
671
- notNull: boolean;
672
- }, {
673
- default?: any;
674
- onUpdate?: any;
675
- autoincrement?: boolean | undefined;
676
- name: string;
677
- type: string;
678
- primaryKey: boolean;
679
- notNull: boolean;
680
- }>>;
681
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
682
- name: import("zod").ZodString;
683
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
684
- isUnique: import("zod").ZodBoolean;
685
- using: import("zod").ZodOptional<import("zod").ZodEnum<["btree", "hash"]>>;
686
- algorithm: import("zod").ZodOptional<import("zod").ZodEnum<["default", "inplace", "copy"]>>;
687
- lock: import("zod").ZodOptional<import("zod").ZodEnum<["default", "none", "shared", "exclusive"]>>;
688
- }, "strict", import("zod").ZodTypeAny, {
689
- using?: "btree" | "hash" | undefined;
690
- algorithm?: "default" | "inplace" | "copy" | undefined;
691
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
692
- name: string;
693
- columns: string[];
694
- isUnique: boolean;
695
- }, {
696
- using?: "btree" | "hash" | undefined;
697
- algorithm?: "default" | "inplace" | "copy" | undefined;
698
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
699
- name: string;
700
- columns: string[];
701
- isUnique: boolean;
702
- }>>;
703
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
704
- name: import("zod").ZodString;
705
- tableFrom: import("zod").ZodString;
706
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
707
- tableTo: import("zod").ZodString;
708
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
709
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
710
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
711
- }, "strict", import("zod").ZodTypeAny, {
712
- onUpdate?: string | undefined;
713
- onDelete?: string | undefined;
714
- name: string;
715
- tableFrom: string;
716
- columnsFrom: string[];
717
- tableTo: string;
718
- columnsTo: string[];
719
- }, {
720
- onUpdate?: string | undefined;
721
- onDelete?: string | undefined;
722
- name: string;
723
- tableFrom: string;
724
- columnsFrom: string[];
725
- tableTo: string;
726
- columnsTo: string[];
727
- }>>;
728
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
729
- name: import("zod").ZodString;
730
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
731
- }, "strict", import("zod").ZodTypeAny, {
732
- name: string;
733
- columns: string[];
734
- }, {
735
- name: string;
736
- columns: string[];
737
- }>>;
738
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
739
- name: import("zod").ZodString;
740
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
741
- }, "strict", import("zod").ZodTypeAny, {
742
- name: string;
743
- columns: string[];
744
- }, {
745
- name: string;
746
- columns: string[];
747
- }>>>;
748
- }, "strict", import("zod").ZodTypeAny, {
749
- schema?: string | undefined;
750
- name: string;
751
- columns: Record<string, {
752
- default?: any;
753
- onUpdate?: any;
754
- autoincrement?: boolean | undefined;
755
- name: string;
756
- type: string;
757
- primaryKey: boolean;
758
- notNull: boolean;
759
- }>;
760
- indexes: Record<string, {
761
- using?: "btree" | "hash" | undefined;
762
- algorithm?: "default" | "inplace" | "copy" | undefined;
763
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
764
- name: string;
765
- columns: string[];
766
- isUnique: boolean;
767
- }>;
768
- foreignKeys: Record<string, {
769
- onUpdate?: string | undefined;
770
- onDelete?: string | undefined;
771
- name: string;
772
- tableFrom: string;
773
- columnsFrom: string[];
774
- tableTo: string;
775
- columnsTo: string[];
776
- }>;
777
- compositePrimaryKeys: Record<string, {
778
- name: string;
779
- columns: string[];
780
- }>;
781
- uniqueConstraints: Record<string, {
782
- name: string;
783
- columns: string[];
784
- }>;
785
- }, {
786
- schema?: string | undefined;
787
- uniqueConstraints?: Record<string, {
788
- name: string;
789
- columns: string[];
790
- }> | undefined;
791
- name: string;
792
- columns: Record<string, {
793
- default?: any;
794
- onUpdate?: any;
795
- autoincrement?: boolean | undefined;
796
- name: string;
797
- type: string;
798
- primaryKey: boolean;
799
- notNull: boolean;
800
- }>;
801
- indexes: Record<string, {
802
- using?: "btree" | "hash" | undefined;
803
- algorithm?: "default" | "inplace" | "copy" | undefined;
804
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
805
- name: string;
806
- columns: string[];
807
- isUnique: boolean;
808
- }>;
809
- foreignKeys: Record<string, {
810
- onUpdate?: string | undefined;
811
- onDelete?: string | undefined;
812
- name: string;
813
- tableFrom: string;
814
- columnsFrom: string[];
815
- tableTo: string;
816
- columnsTo: string[];
817
- }>;
818
- compositePrimaryKeys: Record<string, {
819
- name: string;
820
- columns: string[];
821
- }>;
822
- }>>;
823
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
824
- _meta: import("zod").ZodObject<{
825
- schemas: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
826
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
827
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
828
- }, "strip", import("zod").ZodTypeAny, {
829
- columns: Record<string, string>;
830
- tables: Record<string, string>;
831
- schemas: Record<string, string>;
832
- }, {
833
- columns: Record<string, string>;
834
- tables: Record<string, string>;
835
- schemas: Record<string, string>;
836
- }>;
837
- internal: import("zod").ZodOptional<import("zod").ZodObject<{
838
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
839
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodObject<{
840
- isDefaultAnExpression: import("zod").ZodOptional<import("zod").ZodBoolean>;
841
- }, "strip", import("zod").ZodTypeAny, {
842
- isDefaultAnExpression?: boolean | undefined;
843
- }, {
844
- isDefaultAnExpression?: boolean | undefined;
845
- }>>>;
846
- }, "strip", import("zod").ZodTypeAny, {
847
- columns: Record<string, {
848
- isDefaultAnExpression?: boolean | undefined;
849
- } | undefined>;
850
- }, {
851
- columns: Record<string, {
852
- isDefaultAnExpression?: boolean | undefined;
853
- } | undefined>;
854
- }>>>;
855
- }, "strip", import("zod").ZodTypeAny, {
856
- tables: Record<string, {
857
- columns: Record<string, {
858
- isDefaultAnExpression?: boolean | undefined;
859
- } | undefined>;
860
- } | undefined>;
861
- }, {
862
- tables: Record<string, {
863
- columns: Record<string, {
864
- isDefaultAnExpression?: boolean | undefined;
865
- } | undefined>;
866
- } | undefined>;
867
- }>>;
868
- }, {
869
- id: import("zod").ZodString;
870
- prevId: import("zod").ZodString;
871
- }>, "strip", import("zod").ZodTypeAny, {
872
- internal?: {
873
- tables: Record<string, {
874
- columns: Record<string, {
875
- isDefaultAnExpression?: boolean | undefined;
876
- } | undefined>;
877
- } | undefined>;
878
- } | undefined;
879
- id: string;
880
- prevId: string;
881
- version: "5";
882
- dialect: "mysql";
883
- tables: Record<string, {
884
- schema?: string | undefined;
885
- name: string;
886
- columns: Record<string, {
887
- default?: any;
888
- onUpdate?: any;
889
- autoincrement?: boolean | undefined;
890
- name: string;
891
- type: string;
892
- primaryKey: boolean;
893
- notNull: boolean;
894
- }>;
895
- indexes: Record<string, {
896
- using?: "btree" | "hash" | undefined;
897
- algorithm?: "default" | "inplace" | "copy" | undefined;
898
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
899
- name: string;
900
- columns: string[];
901
- isUnique: boolean;
902
- }>;
903
- foreignKeys: Record<string, {
904
- onUpdate?: string | undefined;
905
- onDelete?: string | undefined;
906
- name: string;
907
- tableFrom: string;
908
- columnsFrom: string[];
909
- tableTo: string;
910
- columnsTo: string[];
911
- }>;
912
- compositePrimaryKeys: Record<string, {
913
- name: string;
914
- columns: string[];
915
- }>;
916
- uniqueConstraints: Record<string, {
917
- name: string;
918
- columns: string[];
919
- }>;
920
- }>;
921
- schemas: Record<string, string>;
922
- _meta: {
923
- columns: Record<string, string>;
924
- tables: Record<string, string>;
925
- schemas: Record<string, string>;
926
- };
927
- }, {
928
- internal?: {
929
- tables: Record<string, {
930
- columns: Record<string, {
931
- isDefaultAnExpression?: boolean | undefined;
932
- } | undefined>;
933
- } | undefined>;
934
- } | undefined;
935
- id: string;
936
- prevId: string;
937
- version: "5";
938
- dialect: "mysql";
939
- tables: Record<string, {
940
- schema?: string | undefined;
941
- uniqueConstraints?: Record<string, {
942
- name: string;
943
- columns: string[];
944
- }> | undefined;
945
- name: string;
946
- columns: Record<string, {
947
- default?: any;
948
- onUpdate?: any;
949
- autoincrement?: boolean | undefined;
950
- name: string;
951
- type: string;
952
- primaryKey: boolean;
953
- notNull: boolean;
954
- }>;
955
- indexes: Record<string, {
956
- using?: "btree" | "hash" | undefined;
957
- algorithm?: "default" | "inplace" | "copy" | undefined;
958
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
959
- name: string;
960
- columns: string[];
961
- isUnique: boolean;
962
- }>;
963
- foreignKeys: Record<string, {
964
- onUpdate?: string | undefined;
965
- onDelete?: string | undefined;
966
- name: string;
967
- tableFrom: string;
968
- columnsFrom: string[];
969
- tableTo: string;
970
- columnsTo: string[];
971
- }>;
972
- compositePrimaryKeys: Record<string, {
973
- name: string;
974
- columns: string[];
975
- }>;
976
- }>;
977
- schemas: Record<string, string>;
978
- _meta: {
979
- columns: Record<string, string>;
980
- tables: Record<string, string>;
981
- schemas: Record<string, string>;
982
- };
983
- }>, import("zod").ZodObject<import("zod").extendShape<{
984
- version: import("zod").ZodLiteral<"5">;
985
- dialect: import("zod").ZodEnum<["sqlite"]>;
986
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
987
- name: import("zod").ZodString;
988
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
989
- name: import("zod").ZodString;
990
- type: import("zod").ZodString;
991
- primaryKey: import("zod").ZodBoolean;
992
- notNull: import("zod").ZodBoolean;
993
- autoincrement: import("zod").ZodOptional<import("zod").ZodBoolean>;
994
- default: import("zod").ZodOptional<import("zod").ZodAny>;
995
- }, "strict", import("zod").ZodTypeAny, {
996
- default?: any;
997
- autoincrement?: boolean | undefined;
998
- name: string;
999
- type: string;
1000
- primaryKey: boolean;
1001
- notNull: boolean;
1002
- }, {
1003
- default?: any;
1004
- autoincrement?: boolean | undefined;
1005
- name: string;
1006
- type: string;
1007
- primaryKey: boolean;
1008
- notNull: boolean;
1009
- }>>;
1010
- indexes: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1011
- name: import("zod").ZodString;
1012
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1013
- where: import("zod").ZodOptional<import("zod").ZodString>;
1014
- isUnique: import("zod").ZodBoolean;
1015
- }, "strict", import("zod").ZodTypeAny, {
1016
- where?: string | undefined;
1017
- name: string;
1018
- columns: string[];
1019
- isUnique: boolean;
1020
- }, {
1021
- where?: string | undefined;
1022
- name: string;
1023
- columns: string[];
1024
- isUnique: boolean;
1025
- }>>;
1026
- foreignKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1027
- name: import("zod").ZodString;
1028
- tableFrom: import("zod").ZodString;
1029
- columnsFrom: import("zod").ZodArray<import("zod").ZodString, "many">;
1030
- tableTo: import("zod").ZodString;
1031
- columnsTo: import("zod").ZodArray<import("zod").ZodString, "many">;
1032
- onUpdate: import("zod").ZodOptional<import("zod").ZodString>;
1033
- onDelete: import("zod").ZodOptional<import("zod").ZodString>;
1034
- }, "strict", import("zod").ZodTypeAny, {
1035
- onUpdate?: string | undefined;
1036
- onDelete?: string | undefined;
1037
- name: string;
1038
- tableFrom: string;
1039
- columnsFrom: string[];
1040
- tableTo: string;
1041
- columnsTo: string[];
1042
- }, {
1043
- onUpdate?: string | undefined;
1044
- onDelete?: string | undefined;
1045
- name: string;
1046
- tableFrom: string;
1047
- columnsFrom: string[];
1048
- tableTo: string;
1049
- columnsTo: string[];
1050
- }>>;
1051
- compositePrimaryKeys: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1052
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1053
- }, "strict", import("zod").ZodTypeAny, {
1054
- columns: string[];
1055
- }, {
1056
- columns: string[];
1057
- }>>;
1058
- uniqueConstraints: import("zod").ZodDefault<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
1059
- name: import("zod").ZodString;
1060
- columns: import("zod").ZodArray<import("zod").ZodString, "many">;
1061
- }, "strict", import("zod").ZodTypeAny, {
1062
- name: string;
1063
- columns: string[];
1064
- }, {
1065
- name: string;
1066
- columns: string[];
1067
- }>>>;
1068
- }, "strict", import("zod").ZodTypeAny, {
1069
- name: string;
1070
- columns: Record<string, {
1071
- default?: any;
1072
- autoincrement?: boolean | undefined;
1073
- name: string;
1074
- type: string;
1075
- primaryKey: boolean;
1076
- notNull: boolean;
1077
- }>;
1078
- indexes: Record<string, {
1079
- where?: string | undefined;
1080
- name: string;
1081
- columns: string[];
1082
- isUnique: boolean;
1083
- }>;
1084
- foreignKeys: Record<string, {
1085
- onUpdate?: string | undefined;
1086
- onDelete?: string | undefined;
1087
- name: string;
1088
- tableFrom: string;
1089
- columnsFrom: string[];
1090
- tableTo: string;
1091
- columnsTo: string[];
1092
- }>;
1093
- compositePrimaryKeys: Record<string, {
1094
- columns: string[];
1095
- }>;
1096
- uniqueConstraints: Record<string, {
1097
- name: string;
1098
- columns: string[];
1099
- }>;
1100
- }, {
1101
- uniqueConstraints?: Record<string, {
1102
- name: string;
1103
- columns: string[];
1104
- }> | undefined;
1105
- name: string;
1106
- columns: Record<string, {
1107
- default?: any;
1108
- autoincrement?: boolean | undefined;
1109
- name: string;
1110
- type: string;
1111
- primaryKey: boolean;
1112
- notNull: boolean;
1113
- }>;
1114
- indexes: Record<string, {
1115
- where?: string | undefined;
1116
- name: string;
1117
- columns: string[];
1118
- isUnique: boolean;
1119
- }>;
1120
- foreignKeys: Record<string, {
1121
- onUpdate?: string | undefined;
1122
- onDelete?: string | undefined;
1123
- name: string;
1124
- tableFrom: string;
1125
- columnsFrom: string[];
1126
- tableTo: string;
1127
- columnsTo: string[];
1128
- }>;
1129
- compositePrimaryKeys: Record<string, {
1130
- columns: string[];
1131
- }>;
1132
- }>>;
1133
- enums: import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>;
1134
- _meta: import("zod").ZodObject<{
1135
- tables: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1136
- columns: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
1137
- }, "strip", import("zod").ZodTypeAny, {
1138
- columns: Record<string, string>;
1139
- tables: Record<string, string>;
1140
- }, {
1141
- columns: Record<string, string>;
1142
- tables: Record<string, string>;
1143
- }>;
1144
- }, {
1145
- id: import("zod").ZodString;
1146
- prevId: import("zod").ZodString;
1147
- }>, "strict", import("zod").ZodTypeAny, {
1148
- id: string;
1149
- prevId: string;
1150
- version: "5";
1151
- dialect: "sqlite";
1152
- tables: Record<string, {
1153
- name: string;
1154
- columns: Record<string, {
1155
- default?: any;
1156
- autoincrement?: boolean | undefined;
1157
- name: string;
1158
- type: string;
1159
- primaryKey: boolean;
1160
- notNull: boolean;
1161
- }>;
1162
- indexes: Record<string, {
1163
- where?: string | undefined;
1164
- name: string;
1165
- columns: string[];
1166
- isUnique: boolean;
1167
- }>;
1168
- foreignKeys: Record<string, {
1169
- onUpdate?: string | undefined;
1170
- onDelete?: string | undefined;
1171
- name: string;
1172
- tableFrom: string;
1173
- columnsFrom: string[];
1174
- tableTo: string;
1175
- columnsTo: string[];
1176
- }>;
1177
- compositePrimaryKeys: Record<string, {
1178
- columns: string[];
1179
- }>;
1180
- uniqueConstraints: Record<string, {
1181
- name: string;
1182
- columns: string[];
1183
- }>;
1184
- }>;
1185
- _meta: {
1186
- columns: Record<string, string>;
1187
- tables: Record<string, string>;
1188
- };
1189
- enums: {};
1190
- }, {
1191
- id: string;
1192
- prevId: string;
1193
- version: "5";
1194
- dialect: "sqlite";
1195
- tables: Record<string, {
1196
- uniqueConstraints?: Record<string, {
1197
- name: string;
1198
- columns: string[];
1199
- }> | undefined;
1200
- name: string;
1201
- columns: Record<string, {
1202
- default?: any;
1203
- autoincrement?: boolean | undefined;
1204
- name: string;
1205
- type: string;
1206
- primaryKey: boolean;
1207
- notNull: boolean;
1208
- }>;
1209
- indexes: Record<string, {
1210
- where?: string | undefined;
1211
- name: string;
1212
- columns: string[];
1213
- isUnique: boolean;
1214
- }>;
1215
- foreignKeys: Record<string, {
1216
- onUpdate?: string | undefined;
1217
- onDelete?: string | undefined;
1218
- name: string;
1219
- tableFrom: string;
1220
- columnsFrom: string[];
1221
- tableTo: string;
1222
- columnsTo: string[];
1223
- }>;
1224
- compositePrimaryKeys: Record<string, {
1225
- columns: string[];
1226
- }>;
1227
- }>;
1228
- _meta: {
1229
- columns: Record<string, string>;
1230
- tables: Record<string, string>;
1231
- };
1232
- enums: {};
1233
- }>]>;
1234
- export type CommonSquashedSchema = TypeOf<typeof commonSquashedSchema>;
1235
- export type CommonSchema = TypeOf<typeof commonSchema>;
1236
- export {};