drizzle-kit 0.20.18 → 0.21.0-57cc2fe

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