drizzle-kit 0.20.17-56cc78f → 0.20.17-57f44bf

Sign up to get free protection for your applications and to get access to all the features.
Files changed (55) hide show
  1. package/bin.cjs +24454 -16512
  2. package/index.d.mts +28 -14
  3. package/index.d.ts +28 -14
  4. package/package.json +5 -16
  5. package/payload.d.mts +987 -18
  6. package/payload.d.ts +987 -18
  7. package/payload.js +19804 -16879
  8. package/payload.mjs +19843 -16892
  9. package/utils-studio.js +949 -822
  10. package/utils-studio.mjs +922 -795
  11. package/utils.js +859 -218
  12. package/utils.mjs +834 -193
  13. package/@types/utils.d.ts +0 -12
  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 -58
  22. package/cli/connections.d.ts +0 -13
  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/views.d.ts +0 -63
  32. package/global.d.ts +0 -6
  33. package/introspect-sqlite.d.ts +0 -10
  34. package/jsonDiffer.d.ts +0 -61
  35. package/jsonStatements.d.ts +0 -376
  36. package/migrationPreparator.d.ts +0 -35
  37. package/schemaValidator.d.ts +0 -1316
  38. package/serializer/index.d.ts +0 -9
  39. package/serializer/mysqlImports.d.ts +0 -7
  40. package/serializer/mysqlSchema.d.ts +0 -4650
  41. package/serializer/mysqlSerializer.d.ts +0 -7
  42. package/serializer/pgImports.d.ts +0 -11
  43. package/serializer/pgSchema.d.ts +0 -4792
  44. package/serializer/pgSerializer.d.ts +0 -7
  45. package/serializer/schemaToDrizzle.d.ts +0 -7
  46. package/serializer/sqliteImports.d.ts +0 -7
  47. package/serializer/sqliteSchema.d.ts +0 -2801
  48. package/serializer/sqliteSerializer.d.ts +0 -6
  49. package/serializer/studio.d.ts +0 -51
  50. package/snapshotsDiffer.d.ts +0 -3936
  51. package/sqlgenerator.d.ts +0 -33
  52. package/utils/words.d.ts +0 -7
  53. package/utils-studio.d.mts +0 -4
  54. package/utils-studio.d.ts +0 -4
  55. 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
- isUnique?: any;
22
- default?: any;
23
- typeSchema?: string | undefined;
24
- uniqueName?: string | undefined;
25
- nullsNotDistinct?: boolean | undefined;
26
- name: string;
27
- type: string;
28
- primaryKey: boolean;
29
- notNull: boolean;
30
- }, {
31
- isUnique?: any;
32
- default?: any;
33
- typeSchema?: string | undefined;
34
- uniqueName?: string | undefined;
35
- nullsNotDistinct?: boolean | undefined;
36
- name: string;
37
- type: string;
38
- primaryKey: boolean;
39
- notNull: boolean;
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
- isUnique?: any;
49
- default?: any;
50
- typeSchema?: string | undefined;
51
- uniqueName?: string | undefined;
52
- nullsNotDistinct?: boolean | undefined;
53
- name: string;
54
- type: string;
55
- primaryKey: boolean;
56
- notNull: boolean;
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
- isUnique?: any;
67
- default?: any;
68
- typeSchema?: string | undefined;
69
- uniqueName?: string | undefined;
70
- nullsNotDistinct?: boolean | undefined;
71
- name: string;
72
- type: string;
73
- primaryKey: boolean;
74
- notNull: boolean;
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
- isUnique?: any;
101
- default?: any;
102
- typeSchema?: string | undefined;
103
- uniqueName?: string | undefined;
104
- nullsNotDistinct?: boolean | undefined;
105
- name: string;
106
- type: string;
107
- primaryKey: boolean;
108
- notNull: boolean;
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
- isUnique?: any;
129
- default?: any;
130
- typeSchema?: string | undefined;
131
- uniqueName?: string | undefined;
132
- nullsNotDistinct?: boolean | undefined;
133
- name: string;
134
- type: string;
135
- primaryKey: boolean;
136
- notNull: boolean;
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
- default?: any;
167
- onUpdate?: any;
168
- autoincrement?: boolean | undefined;
169
- name: string;
170
- type: string;
171
- primaryKey: boolean;
172
- notNull: boolean;
173
- }, {
174
- default?: any;
175
- onUpdate?: any;
176
- autoincrement?: boolean | undefined;
177
- name: string;
178
- type: string;
179
- primaryKey: boolean;
180
- notNull: boolean;
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
- default?: any;
190
- onUpdate?: any;
191
- autoincrement?: boolean | undefined;
192
- name: string;
193
- type: string;
194
- primaryKey: boolean;
195
- notNull: boolean;
196
- }>;
197
- indexes: Record<string, string>;
198
- foreignKeys: Record<string, string>;
199
- compositePrimaryKeys: Record<string, string>;
200
- uniqueConstraints: Record<string, string>;
201
- }, {
202
- uniqueConstraints?: Record<string, string> | undefined;
203
- name: string;
204
- columns: Record<string, {
205
- default?: any;
206
- onUpdate?: any;
207
- autoincrement?: boolean | undefined;
208
- name: string;
209
- type: string;
210
- primaryKey: boolean;
211
- notNull: boolean;
212
- }>;
213
- indexes: Record<string, string>;
214
- foreignKeys: Record<string, string>;
215
- compositePrimaryKeys: Record<string, string>;
216
- }>>;
217
- }, "strict", import("zod").ZodTypeAny, {
218
- tables: Record<string, {
219
- name: string;
220
- columns: Record<string, {
221
- default?: any;
222
- onUpdate?: any;
223
- autoincrement?: boolean | undefined;
224
- name: string;
225
- type: string;
226
- primaryKey: boolean;
227
- notNull: boolean;
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
- uniqueConstraints?: Record<string, string> | undefined;
239
- name: string;
240
- columns: Record<string, {
241
- default?: any;
242
- onUpdate?: any;
243
- autoincrement?: boolean | undefined;
244
- name: string;
245
- type: string;
246
- primaryKey: boolean;
247
- notNull: boolean;
248
- }>;
249
- indexes: Record<string, string>;
250
- foreignKeys: Record<string, string>;
251
- compositePrimaryKeys: Record<string, string>;
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
- default?: any;
269
- autoincrement?: boolean | undefined;
270
- name: string;
271
- type: string;
272
- primaryKey: boolean;
273
- notNull: boolean;
274
- }, {
275
- default?: any;
276
- autoincrement?: boolean | undefined;
277
- name: string;
278
- type: string;
279
- primaryKey: boolean;
280
- notNull: boolean;
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
- default?: any;
290
- autoincrement?: boolean | undefined;
291
- name: string;
292
- type: string;
293
- primaryKey: boolean;
294
- notNull: boolean;
295
- }>;
296
- indexes: Record<string, string>;
297
- foreignKeys: Record<string, string>;
298
- compositePrimaryKeys: Record<string, string>;
299
- uniqueConstraints: Record<string, string>;
300
- }, {
301
- uniqueConstraints?: Record<string, string> | undefined;
302
- name: string;
303
- columns: Record<string, {
304
- default?: any;
305
- autoincrement?: boolean | undefined;
306
- name: string;
307
- type: string;
308
- primaryKey: boolean;
309
- notNull: boolean;
310
- }>;
311
- indexes: Record<string, string>;
312
- foreignKeys: Record<string, string>;
313
- compositePrimaryKeys: Record<string, string>;
314
- }>>;
315
- enums: import("zod").ZodAny;
316
- }, "strict", import("zod").ZodTypeAny, {
317
- enums?: any;
318
- tables: Record<string, {
319
- name: string;
320
- columns: Record<string, {
321
- default?: any;
322
- autoincrement?: boolean | undefined;
323
- name: string;
324
- type: string;
325
- primaryKey: boolean;
326
- notNull: boolean;
327
- }>;
328
- indexes: Record<string, string>;
329
- foreignKeys: Record<string, string>;
330
- compositePrimaryKeys: Record<string, string>;
331
- uniqueConstraints: Record<string, string>;
332
- }>;
333
- version: "5";
334
- dialect: "sqlite";
335
- }, {
336
- enums?: any;
337
- tables: Record<string, {
338
- uniqueConstraints?: Record<string, string> | undefined;
339
- name: string;
340
- columns: Record<string, {
341
- default?: any;
342
- autoincrement?: boolean | undefined;
343
- name: string;
344
- type: string;
345
- primaryKey: boolean;
346
- notNull: boolean;
347
- }>;
348
- indexes: Record<string, string>;
349
- foreignKeys: Record<string, string>;
350
- compositePrimaryKeys: Record<string, string>;
351
- }>;
352
- version: "5";
353
- dialect: "sqlite";
354
- }>]>;
355
- declare const commonSchema: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").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
- isUnique?: any;
373
- default?: any;
374
- typeSchema?: string | undefined;
375
- uniqueName?: string | undefined;
376
- nullsNotDistinct?: boolean | undefined;
377
- name: string;
378
- type: string;
379
- primaryKey: boolean;
380
- notNull: boolean;
381
- }, {
382
- isUnique?: any;
383
- default?: any;
384
- typeSchema?: string | undefined;
385
- uniqueName?: string | undefined;
386
- nullsNotDistinct?: boolean | undefined;
387
- name: string;
388
- type: string;
389
- primaryKey: boolean;
390
- notNull: boolean;
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
- onUpdate?: string | undefined;
416
- onDelete?: string | undefined;
417
- schemaTo?: string | undefined;
418
- name: string;
419
- tableFrom: string;
420
- columnsFrom: string[];
421
- tableTo: string;
422
- columnsTo: string[];
423
- }, {
424
- onUpdate?: string | undefined;
425
- onDelete?: string | undefined;
426
- schemaTo?: string | undefined;
427
- name: string;
428
- tableFrom: string;
429
- columnsFrom: string[];
430
- tableTo: string;
431
- columnsTo: string[];
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
- isUnique?: any;
460
- default?: any;
461
- typeSchema?: string | undefined;
462
- uniqueName?: string | undefined;
463
- nullsNotDistinct?: boolean | undefined;
464
- name: string;
465
- type: string;
466
- primaryKey: boolean;
467
- notNull: boolean;
468
- }>;
469
- indexes: Record<string, {
470
- name: string;
471
- columns: string[];
472
- isUnique: boolean;
473
- }>;
474
- foreignKeys: Record<string, {
475
- onUpdate?: string | undefined;
476
- onDelete?: string | undefined;
477
- schemaTo?: string | undefined;
478
- name: string;
479
- tableFrom: string;
480
- columnsFrom: string[];
481
- tableTo: string;
482
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
496
- name: string;
497
- columns: string[];
498
- nullsNotDistinct: boolean;
499
- }> | undefined;
500
- name: string;
501
- columns: Record<string, {
502
- isUnique?: any;
503
- default?: any;
504
- typeSchema?: string | undefined;
505
- uniqueName?: string | undefined;
506
- nullsNotDistinct?: boolean | undefined;
507
- name: string;
508
- type: string;
509
- primaryKey: boolean;
510
- notNull: boolean;
511
- }>;
512
- indexes: Record<string, {
513
- name: string;
514
- columns: string[];
515
- isUnique: boolean;
516
- }>;
517
- foreignKeys: Record<string, {
518
- onUpdate?: string | undefined;
519
- onDelete?: string | undefined;
520
- schemaTo?: string | undefined;
521
- name: string;
522
- tableFrom: string;
523
- columnsFrom: string[];
524
- tableTo: string;
525
- columnsTo: string[];
526
- }>;
527
- schema: string;
528
- compositePrimaryKeys: Record<string, {
529
- name: string;
530
- columns: string[];
531
- }>;
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
- internal?: {
610
- tables: Record<string, {
611
- columns: Record<string, {
612
- isArray?: boolean | undefined;
613
- dimensions?: number | undefined;
614
- rawType?: string | undefined;
615
- } | undefined>;
616
- } | undefined>;
617
- } | undefined;
618
- tables: Record<string, {
619
- name: string;
620
- columns: Record<string, {
621
- isUnique?: any;
622
- default?: any;
623
- typeSchema?: string | undefined;
624
- uniqueName?: string | undefined;
625
- nullsNotDistinct?: boolean | undefined;
626
- name: string;
627
- type: string;
628
- primaryKey: boolean;
629
- notNull: boolean;
630
- }>;
631
- indexes: Record<string, {
632
- name: string;
633
- columns: string[];
634
- isUnique: boolean;
635
- }>;
636
- foreignKeys: Record<string, {
637
- onUpdate?: string | undefined;
638
- onDelete?: string | undefined;
639
- schemaTo?: string | undefined;
640
- name: string;
641
- tableFrom: string;
642
- columnsFrom: string[];
643
- tableTo: string;
644
- columnsTo: string[];
645
- }>;
646
- schema: string;
647
- compositePrimaryKeys: Record<string, {
648
- name: string;
649
- columns: string[];
650
- }>;
651
- uniqueConstraints: Record<string, {
652
- name: string;
653
- columns: string[];
654
- nullsNotDistinct: boolean;
655
- }>;
656
- }>;
657
- id: string;
658
- prevId: string;
659
- version: "6";
660
- dialect: "postgresql";
661
- schemas: Record<string, string>;
662
- _meta: {
663
- columns: Record<string, string>;
664
- tables: Record<string, string>;
665
- schemas: Record<string, string>;
666
- };
667
- enums: Record<string, {
668
- name: string;
669
- values: string[];
670
- schema: string;
671
- }>;
672
- }, {
673
- internal?: {
674
- tables: Record<string, {
675
- columns: Record<string, {
676
- isArray?: boolean | undefined;
677
- dimensions?: number | undefined;
678
- rawType?: string | undefined;
679
- } | undefined>;
680
- } | undefined>;
681
- } | undefined;
682
- tables: Record<string, {
683
- uniqueConstraints?: Record<string, {
684
- name: string;
685
- columns: string[];
686
- nullsNotDistinct: boolean;
687
- }> | undefined;
688
- name: string;
689
- columns: Record<string, {
690
- isUnique?: any;
691
- default?: any;
692
- typeSchema?: string | undefined;
693
- uniqueName?: string | undefined;
694
- nullsNotDistinct?: boolean | undefined;
695
- name: string;
696
- type: string;
697
- primaryKey: boolean;
698
- notNull: boolean;
699
- }>;
700
- indexes: Record<string, {
701
- name: string;
702
- columns: string[];
703
- isUnique: boolean;
704
- }>;
705
- foreignKeys: Record<string, {
706
- onUpdate?: string | undefined;
707
- onDelete?: string | undefined;
708
- schemaTo?: string | undefined;
709
- name: string;
710
- tableFrom: string;
711
- columnsFrom: string[];
712
- tableTo: string;
713
- columnsTo: string[];
714
- }>;
715
- schema: string;
716
- compositePrimaryKeys: Record<string, {
717
- name: string;
718
- columns: string[];
719
- }>;
720
- }>;
721
- id: string;
722
- prevId: string;
723
- version: "6";
724
- dialect: "postgresql";
725
- schemas: Record<string, string>;
726
- _meta: {
727
- columns: Record<string, string>;
728
- tables: Record<string, string>;
729
- schemas: Record<string, string>;
730
- };
731
- enums: Record<string, {
732
- name: string;
733
- values: string[];
734
- schema: string;
735
- }>;
736
- }>, import("zod").ZodObject<import("zod").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
- default?: any;
751
- onUpdate?: any;
752
- autoincrement?: boolean | undefined;
753
- name: string;
754
- type: string;
755
- primaryKey: boolean;
756
- notNull: boolean;
757
- }, {
758
- default?: any;
759
- onUpdate?: any;
760
- autoincrement?: boolean | undefined;
761
- name: string;
762
- type: string;
763
- primaryKey: boolean;
764
- notNull: boolean;
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
- using?: "btree" | "hash" | undefined;
775
- algorithm?: "default" | "inplace" | "copy" | undefined;
776
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
777
- name: string;
778
- columns: string[];
779
- isUnique: boolean;
780
- }, {
781
- using?: "btree" | "hash" | undefined;
782
- algorithm?: "default" | "inplace" | "copy" | undefined;
783
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
784
- name: string;
785
- columns: string[];
786
- isUnique: boolean;
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
- onUpdate?: string | undefined;
798
- onDelete?: string | undefined;
799
- name: string;
800
- tableFrom: string;
801
- columnsFrom: string[];
802
- tableTo: string;
803
- columnsTo: string[];
804
- }, {
805
- onUpdate?: string | undefined;
806
- onDelete?: string | undefined;
807
- name: string;
808
- tableFrom: string;
809
- columnsFrom: string[];
810
- tableTo: string;
811
- columnsTo: string[];
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
- default?: any;
837
- onUpdate?: any;
838
- autoincrement?: boolean | undefined;
839
- name: string;
840
- type: string;
841
- primaryKey: boolean;
842
- notNull: boolean;
843
- }>;
844
- indexes: Record<string, {
845
- using?: "btree" | "hash" | undefined;
846
- algorithm?: "default" | "inplace" | "copy" | undefined;
847
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
848
- name: string;
849
- columns: string[];
850
- isUnique: boolean;
851
- }>;
852
- foreignKeys: Record<string, {
853
- onUpdate?: string | undefined;
854
- onDelete?: string | undefined;
855
- name: string;
856
- tableFrom: string;
857
- columnsFrom: string[];
858
- tableTo: string;
859
- columnsTo: string[];
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
- uniqueConstraints?: Record<string, {
871
- name: string;
872
- columns: string[];
873
- }> | undefined;
874
- name: string;
875
- columns: Record<string, {
876
- default?: any;
877
- onUpdate?: any;
878
- autoincrement?: boolean | undefined;
879
- name: string;
880
- type: string;
881
- primaryKey: boolean;
882
- notNull: boolean;
883
- }>;
884
- indexes: Record<string, {
885
- using?: "btree" | "hash" | undefined;
886
- algorithm?: "default" | "inplace" | "copy" | undefined;
887
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
888
- name: string;
889
- columns: string[];
890
- isUnique: boolean;
891
- }>;
892
- foreignKeys: Record<string, {
893
- onUpdate?: string | undefined;
894
- onDelete?: string | undefined;
895
- name: string;
896
- tableFrom: string;
897
- columnsFrom: string[];
898
- tableTo: string;
899
- columnsTo: string[];
900
- }>;
901
- compositePrimaryKeys: Record<string, {
902
- name: string;
903
- columns: string[];
904
- }>;
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
- internal?: {
952
- tables: Record<string, {
953
- columns: Record<string, {
954
- isDefaultAnExpression?: boolean | undefined;
955
- } | undefined>;
956
- } | undefined>;
957
- } | undefined;
958
- tables: Record<string, {
959
- name: string;
960
- columns: Record<string, {
961
- default?: any;
962
- onUpdate?: any;
963
- autoincrement?: boolean | undefined;
964
- name: string;
965
- type: string;
966
- primaryKey: boolean;
967
- notNull: boolean;
968
- }>;
969
- indexes: Record<string, {
970
- using?: "btree" | "hash" | undefined;
971
- algorithm?: "default" | "inplace" | "copy" | undefined;
972
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
973
- name: string;
974
- columns: string[];
975
- isUnique: boolean;
976
- }>;
977
- foreignKeys: Record<string, {
978
- onUpdate?: string | undefined;
979
- onDelete?: string | undefined;
980
- name: string;
981
- tableFrom: string;
982
- columnsFrom: string[];
983
- tableTo: string;
984
- columnsTo: string[];
985
- }>;
986
- compositePrimaryKeys: Record<string, {
987
- name: string;
988
- columns: string[];
989
- }>;
990
- uniqueConstraints: Record<string, {
991
- name: string;
992
- columns: string[];
993
- }>;
994
- }>;
995
- id: string;
996
- prevId: string;
997
- version: "5";
998
- dialect: "mysql";
999
- _meta: {
1000
- columns: Record<string, string>;
1001
- tables: Record<string, string>;
1002
- };
1003
- }, {
1004
- internal?: {
1005
- tables: Record<string, {
1006
- columns: Record<string, {
1007
- isDefaultAnExpression?: boolean | undefined;
1008
- } | undefined>;
1009
- } | undefined>;
1010
- } | undefined;
1011
- tables: Record<string, {
1012
- uniqueConstraints?: Record<string, {
1013
- name: string;
1014
- columns: string[];
1015
- }> | undefined;
1016
- name: string;
1017
- columns: Record<string, {
1018
- default?: any;
1019
- onUpdate?: any;
1020
- autoincrement?: boolean | undefined;
1021
- name: string;
1022
- type: string;
1023
- primaryKey: boolean;
1024
- notNull: boolean;
1025
- }>;
1026
- indexes: Record<string, {
1027
- using?: "btree" | "hash" | undefined;
1028
- algorithm?: "default" | "inplace" | "copy" | undefined;
1029
- lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1030
- name: string;
1031
- columns: string[];
1032
- isUnique: boolean;
1033
- }>;
1034
- foreignKeys: Record<string, {
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
- compositePrimaryKeys: Record<string, {
1044
- name: string;
1045
- columns: string[];
1046
- }>;
1047
- }>;
1048
- id: string;
1049
- prevId: string;
1050
- version: "5";
1051
- dialect: "mysql";
1052
- _meta: {
1053
- columns: Record<string, string>;
1054
- tables: Record<string, string>;
1055
- };
1056
- }>, import("zod").ZodObject<import("zod").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
- default?: any;
1070
- autoincrement?: boolean | undefined;
1071
- name: string;
1072
- type: string;
1073
- primaryKey: boolean;
1074
- notNull: boolean;
1075
- }, {
1076
- default?: any;
1077
- autoincrement?: boolean | undefined;
1078
- name: string;
1079
- type: string;
1080
- primaryKey: boolean;
1081
- notNull: boolean;
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
- where?: string | undefined;
1090
- name: string;
1091
- columns: string[];
1092
- isUnique: boolean;
1093
- }, {
1094
- where?: string | undefined;
1095
- name: string;
1096
- columns: string[];
1097
- isUnique: boolean;
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
- onUpdate?: string | undefined;
1109
- onDelete?: string | undefined;
1110
- name: string;
1111
- tableFrom: string;
1112
- columnsFrom: string[];
1113
- tableTo: string;
1114
- columnsTo: string[];
1115
- }, {
1116
- onUpdate?: string | undefined;
1117
- onDelete?: string | undefined;
1118
- name: string;
1119
- tableFrom: string;
1120
- columnsFrom: string[];
1121
- tableTo: string;
1122
- columnsTo: string[];
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
- name?: string | undefined;
1129
- columns: string[];
1130
- }, {
1131
- name?: string | undefined;
1132
- columns: string[];
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
- default?: any;
1148
- autoincrement?: boolean | undefined;
1149
- name: string;
1150
- type: string;
1151
- primaryKey: boolean;
1152
- notNull: boolean;
1153
- }>;
1154
- indexes: Record<string, {
1155
- where?: string | undefined;
1156
- name: string;
1157
- columns: string[];
1158
- isUnique: boolean;
1159
- }>;
1160
- foreignKeys: Record<string, {
1161
- onUpdate?: string | undefined;
1162
- onDelete?: string | undefined;
1163
- name: string;
1164
- tableFrom: string;
1165
- columnsFrom: string[];
1166
- tableTo: string;
1167
- columnsTo: string[];
1168
- }>;
1169
- compositePrimaryKeys: Record<string, {
1170
- name?: string | undefined;
1171
- columns: string[];
1172
- }>;
1173
- uniqueConstraints: Record<string, {
1174
- name: string;
1175
- columns: string[];
1176
- }>;
1177
- }, {
1178
- uniqueConstraints?: Record<string, {
1179
- name: string;
1180
- columns: string[];
1181
- }> | undefined;
1182
- name: string;
1183
- columns: Record<string, {
1184
- default?: any;
1185
- autoincrement?: boolean | undefined;
1186
- name: string;
1187
- type: string;
1188
- primaryKey: boolean;
1189
- notNull: boolean;
1190
- }>;
1191
- indexes: Record<string, {
1192
- where?: string | undefined;
1193
- name: string;
1194
- columns: string[];
1195
- isUnique: boolean;
1196
- }>;
1197
- foreignKeys: Record<string, {
1198
- onUpdate?: string | undefined;
1199
- onDelete?: string | undefined;
1200
- name: string;
1201
- tableFrom: string;
1202
- columnsFrom: string[];
1203
- tableTo: string;
1204
- columnsTo: string[];
1205
- }>;
1206
- compositePrimaryKeys: Record<string, {
1207
- name?: string | undefined;
1208
- columns: string[];
1209
- }>;
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
- default?: any;
1230
- autoincrement?: boolean | undefined;
1231
- name: string;
1232
- type: string;
1233
- primaryKey: boolean;
1234
- notNull: boolean;
1235
- }>;
1236
- indexes: Record<string, {
1237
- where?: string | undefined;
1238
- name: string;
1239
- columns: string[];
1240
- isUnique: boolean;
1241
- }>;
1242
- foreignKeys: Record<string, {
1243
- onUpdate?: string | undefined;
1244
- onDelete?: string | undefined;
1245
- name: string;
1246
- tableFrom: string;
1247
- columnsFrom: string[];
1248
- tableTo: string;
1249
- columnsTo: string[];
1250
- }>;
1251
- compositePrimaryKeys: Record<string, {
1252
- name?: string | undefined;
1253
- columns: string[];
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
- uniqueConstraints?: Record<string, {
1272
- name: string;
1273
- columns: string[];
1274
- }> | undefined;
1275
- name: string;
1276
- columns: Record<string, {
1277
- default?: any;
1278
- autoincrement?: boolean | undefined;
1279
- name: string;
1280
- type: string;
1281
- primaryKey: boolean;
1282
- notNull: boolean;
1283
- }>;
1284
- indexes: Record<string, {
1285
- where?: string | undefined;
1286
- name: string;
1287
- columns: string[];
1288
- isUnique: boolean;
1289
- }>;
1290
- foreignKeys: Record<string, {
1291
- onUpdate?: string | undefined;
1292
- onDelete?: string | undefined;
1293
- name: string;
1294
- tableFrom: string;
1295
- columnsFrom: string[];
1296
- tableTo: string;
1297
- columnsTo: string[];
1298
- }>;
1299
- compositePrimaryKeys: Record<string, {
1300
- name?: string | undefined;
1301
- columns: string[];
1302
- }>;
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 {};