drizzle-kit 0.20.17-c347d7b → 0.20.17-c50cacb

Sign up to get free protection for your applications and to get access to all the features.
Files changed (56) hide show
  1. package/bin.cjs +8046 -1215
  2. package/index.d.mts +25 -13
  3. package/index.d.ts +25 -13
  4. package/package.json +5 -16
  5. package/payload.d.mts +987 -18
  6. package/payload.d.ts +987 -18
  7. package/payload.js +19076 -16849
  8. package/payload.mjs +19093 -16841
  9. package/utils-studio.js +9 -6
  10. package/utils-studio.mjs +9 -6
  11. package/utils.js +8 -5
  12. package/utils.mjs +8 -5
  13. package/@types/utils.d.ts +0 -13
  14. package/cli/commands/migrate.d.ts +0 -287
  15. package/cli/commands/mysqlIntrospect.d.ts +0 -50
  16. package/cli/commands/mysqlPushUtils.d.ts +0 -14
  17. package/cli/commands/pgIntrospect.d.ts +0 -59
  18. package/cli/commands/pgPushUtils.d.ts +0 -11
  19. package/cli/commands/sqliteIntrospect.d.ts +0 -103
  20. package/cli/commands/sqlitePushUtils.d.ts +0 -15
  21. package/cli/commands/utils.d.ts +0 -180
  22. package/cli/connections.d.ts +0 -18
  23. package/cli/selector-ui.d.ts +0 -13
  24. package/cli/utils.d.ts +0 -13
  25. package/cli/validations/cli.d.ts +0 -169
  26. package/cli/validations/common.d.ts +0 -214
  27. package/cli/validations/mysql.d.ts +0 -29
  28. package/cli/validations/outputs.d.ts +0 -41
  29. package/cli/validations/pg.d.ts +0 -46
  30. package/cli/validations/sqlite.d.ts +0 -22
  31. package/cli/validations/studio.d.ts +0 -92
  32. package/cli/views.d.ts +0 -70
  33. package/global.d.ts +0 -6
  34. package/introspect-sqlite.d.ts +0 -10
  35. package/jsonDiffer.d.ts +0 -61
  36. package/jsonStatements.d.ts +0 -376
  37. package/migrationPreparator.d.ts +0 -35
  38. package/schemaValidator.d.ts +0 -1316
  39. package/serializer/index.d.ts +0 -9
  40. package/serializer/mysqlImports.d.ts +0 -7
  41. package/serializer/mysqlSchema.d.ts +0 -4650
  42. package/serializer/mysqlSerializer.d.ts +0 -7
  43. package/serializer/pgImports.d.ts +0 -11
  44. package/serializer/pgSchema.d.ts +0 -4792
  45. package/serializer/pgSerializer.d.ts +0 -7
  46. package/serializer/schemaToDrizzle.d.ts +0 -7
  47. package/serializer/sqliteImports.d.ts +0 -7
  48. package/serializer/sqliteSchema.d.ts +0 -2801
  49. package/serializer/sqliteSerializer.d.ts +0 -6
  50. package/serializer/studio.d.ts +0 -53
  51. package/snapshotsDiffer.d.ts +0 -3936
  52. package/sqlgenerator.d.ts +0 -33
  53. package/utils/words.d.ts +0 -7
  54. package/utils-studio.d.mts +0 -4
  55. package/utils-studio.d.ts +0 -4
  56. package/utils.d.ts +0 -78
package/schemaValidator.d.ts DELETED
@@ -1,1316 +0,0 @@
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 {};