drizzle-kit 0.21.2 → 0.21.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/bin.cjs +34625 -26761
- package/index.d.mts +9 -1
- package/index.d.ts +9 -1
- package/package.json +2 -1
- package/payload.d.mts +177 -177
- package/payload.d.ts +177 -177
- package/payload.js +533 -454
- package/payload.mjs +510 -431
- package/utils-studio.js +934 -246
- package/utils-studio.mjs +908 -220
- package/utils.js +842 -215
- package/utils.mjs +817 -190
package/payload.d.mts
CHANGED
|
@@ -4,7 +4,7 @@ import { TypeOf } from 'zod';
|
|
|
4
4
|
import { MySql2Database } from 'drizzle-orm/mysql2';
|
|
5
5
|
import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
|
|
6
6
|
|
|
7
|
-
declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
7
|
+
declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
8
8
|
version: zod.ZodLiteral<"6">;
|
|
9
9
|
dialect: zod.ZodLiteral<"postgresql">;
|
|
10
10
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -21,25 +21,25 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
21
21
|
uniqueName: zod.ZodOptional<zod.ZodString>;
|
|
22
22
|
nullsNotDistinct: zod.ZodOptional<zod.ZodBoolean>;
|
|
23
23
|
}, "strict", zod.ZodTypeAny, {
|
|
24
|
+
type: string;
|
|
25
|
+
name: string;
|
|
26
|
+
primaryKey: boolean;
|
|
27
|
+
notNull: boolean;
|
|
24
28
|
isUnique?: any;
|
|
25
29
|
default?: any;
|
|
26
30
|
typeSchema?: string | undefined;
|
|
27
31
|
uniqueName?: string | undefined;
|
|
28
32
|
nullsNotDistinct?: boolean | undefined;
|
|
33
|
+
}, {
|
|
29
34
|
type: string;
|
|
30
35
|
name: string;
|
|
31
36
|
primaryKey: boolean;
|
|
32
37
|
notNull: boolean;
|
|
33
|
-
}, {
|
|
34
38
|
isUnique?: any;
|
|
35
39
|
default?: any;
|
|
36
40
|
typeSchema?: string | undefined;
|
|
37
41
|
uniqueName?: string | undefined;
|
|
38
42
|
nullsNotDistinct?: boolean | undefined;
|
|
39
|
-
type: string;
|
|
40
|
-
name: string;
|
|
41
|
-
primaryKey: boolean;
|
|
42
|
-
notNull: boolean;
|
|
43
43
|
}>>;
|
|
44
44
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
45
45
|
name: zod.ZodString;
|
|
@@ -64,23 +64,23 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
64
64
|
onUpdate: zod.ZodOptional<zod.ZodString>;
|
|
65
65
|
onDelete: zod.ZodOptional<zod.ZodString>;
|
|
66
66
|
}, "strict", zod.ZodTypeAny, {
|
|
67
|
-
onUpdate?: string | undefined;
|
|
68
|
-
onDelete?: string | undefined;
|
|
69
|
-
schemaTo?: string | undefined;
|
|
70
67
|
name: string;
|
|
71
68
|
tableFrom: string;
|
|
72
69
|
columnsFrom: string[];
|
|
73
70
|
tableTo: string;
|
|
74
71
|
columnsTo: string[];
|
|
75
|
-
}, {
|
|
76
72
|
onUpdate?: string | undefined;
|
|
77
73
|
onDelete?: string | undefined;
|
|
78
74
|
schemaTo?: string | undefined;
|
|
75
|
+
}, {
|
|
79
76
|
name: string;
|
|
80
77
|
tableFrom: string;
|
|
81
78
|
columnsFrom: string[];
|
|
82
79
|
tableTo: string;
|
|
83
80
|
columnsTo: string[];
|
|
81
|
+
onUpdate?: string | undefined;
|
|
82
|
+
onDelete?: string | undefined;
|
|
83
|
+
schemaTo?: string | undefined;
|
|
84
84
|
}>>;
|
|
85
85
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
86
86
|
name: zod.ZodString;
|
|
@@ -108,15 +108,15 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
108
108
|
}, "strict", zod.ZodTypeAny, {
|
|
109
109
|
name: string;
|
|
110
110
|
columns: Record<string, {
|
|
111
|
+
type: string;
|
|
112
|
+
name: string;
|
|
113
|
+
primaryKey: boolean;
|
|
114
|
+
notNull: boolean;
|
|
111
115
|
isUnique?: any;
|
|
112
116
|
default?: any;
|
|
113
117
|
typeSchema?: string | undefined;
|
|
114
118
|
uniqueName?: string | undefined;
|
|
115
119
|
nullsNotDistinct?: boolean | undefined;
|
|
116
|
-
type: string;
|
|
117
|
-
name: string;
|
|
118
|
-
primaryKey: boolean;
|
|
119
|
-
notNull: boolean;
|
|
120
120
|
}>;
|
|
121
121
|
indexes: Record<string, {
|
|
122
122
|
name: string;
|
|
@@ -124,14 +124,14 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
124
124
|
isUnique: boolean;
|
|
125
125
|
}>;
|
|
126
126
|
foreignKeys: Record<string, {
|
|
127
|
-
onUpdate?: string | undefined;
|
|
128
|
-
onDelete?: string | undefined;
|
|
129
|
-
schemaTo?: string | undefined;
|
|
130
127
|
name: string;
|
|
131
128
|
tableFrom: string;
|
|
132
129
|
columnsFrom: string[];
|
|
133
130
|
tableTo: string;
|
|
134
131
|
columnsTo: string[];
|
|
132
|
+
onUpdate?: string | undefined;
|
|
133
|
+
onDelete?: string | undefined;
|
|
134
|
+
schemaTo?: string | undefined;
|
|
135
135
|
}>;
|
|
136
136
|
schema: string;
|
|
137
137
|
compositePrimaryKeys: Record<string, {
|
|
@@ -144,22 +144,17 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
144
144
|
nullsNotDistinct: boolean;
|
|
145
145
|
}>;
|
|
146
146
|
}, {
|
|
147
|
-
uniqueConstraints?: Record<string, {
|
|
148
|
-
name: string;
|
|
149
|
-
columns: string[];
|
|
150
|
-
nullsNotDistinct: boolean;
|
|
151
|
-
}> | undefined;
|
|
152
147
|
name: string;
|
|
153
148
|
columns: Record<string, {
|
|
149
|
+
type: string;
|
|
150
|
+
name: string;
|
|
151
|
+
primaryKey: boolean;
|
|
152
|
+
notNull: boolean;
|
|
154
153
|
isUnique?: any;
|
|
155
154
|
default?: any;
|
|
156
155
|
typeSchema?: string | undefined;
|
|
157
156
|
uniqueName?: string | undefined;
|
|
158
157
|
nullsNotDistinct?: boolean | undefined;
|
|
159
|
-
type: string;
|
|
160
|
-
name: string;
|
|
161
|
-
primaryKey: boolean;
|
|
162
|
-
notNull: boolean;
|
|
163
158
|
}>;
|
|
164
159
|
indexes: Record<string, {
|
|
165
160
|
name: string;
|
|
@@ -167,20 +162,25 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
167
162
|
isUnique: boolean;
|
|
168
163
|
}>;
|
|
169
164
|
foreignKeys: Record<string, {
|
|
170
|
-
onUpdate?: string | undefined;
|
|
171
|
-
onDelete?: string | undefined;
|
|
172
|
-
schemaTo?: string | undefined;
|
|
173
165
|
name: string;
|
|
174
166
|
tableFrom: string;
|
|
175
167
|
columnsFrom: string[];
|
|
176
168
|
tableTo: string;
|
|
177
169
|
columnsTo: string[];
|
|
170
|
+
onUpdate?: string | undefined;
|
|
171
|
+
onDelete?: string | undefined;
|
|
172
|
+
schemaTo?: string | undefined;
|
|
178
173
|
}>;
|
|
179
174
|
schema: string;
|
|
180
175
|
compositePrimaryKeys: Record<string, {
|
|
181
176
|
name: string;
|
|
182
177
|
columns: string[];
|
|
183
178
|
}>;
|
|
179
|
+
uniqueConstraints?: Record<string, {
|
|
180
|
+
name: string;
|
|
181
|
+
columns: string[];
|
|
182
|
+
nullsNotDistinct: boolean;
|
|
183
|
+
}> | undefined;
|
|
184
184
|
}>>;
|
|
185
185
|
enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
186
186
|
name: zod.ZodString;
|
|
@@ -258,27 +258,18 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
258
258
|
id: zod.ZodString;
|
|
259
259
|
prevId: zod.ZodString;
|
|
260
260
|
}>, "strip", zod.ZodTypeAny, {
|
|
261
|
-
internal?: {
|
|
262
|
-
tables: Record<string, {
|
|
263
|
-
columns: Record<string, {
|
|
264
|
-
isArray?: boolean | undefined;
|
|
265
|
-
dimensions?: number | undefined;
|
|
266
|
-
rawType?: string | undefined;
|
|
267
|
-
} | undefined>;
|
|
268
|
-
} | undefined>;
|
|
269
|
-
} | undefined;
|
|
270
261
|
tables: Record<string, {
|
|
271
262
|
name: string;
|
|
272
263
|
columns: Record<string, {
|
|
264
|
+
type: string;
|
|
265
|
+
name: string;
|
|
266
|
+
primaryKey: boolean;
|
|
267
|
+
notNull: boolean;
|
|
273
268
|
isUnique?: any;
|
|
274
269
|
default?: any;
|
|
275
270
|
typeSchema?: string | undefined;
|
|
276
271
|
uniqueName?: string | undefined;
|
|
277
272
|
nullsNotDistinct?: boolean | undefined;
|
|
278
|
-
type: string;
|
|
279
|
-
name: string;
|
|
280
|
-
primaryKey: boolean;
|
|
281
|
-
notNull: boolean;
|
|
282
273
|
}>;
|
|
283
274
|
indexes: Record<string, {
|
|
284
275
|
name: string;
|
|
@@ -286,14 +277,14 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
286
277
|
isUnique: boolean;
|
|
287
278
|
}>;
|
|
288
279
|
foreignKeys: Record<string, {
|
|
289
|
-
onUpdate?: string | undefined;
|
|
290
|
-
onDelete?: string | undefined;
|
|
291
|
-
schemaTo?: string | undefined;
|
|
292
280
|
name: string;
|
|
293
281
|
tableFrom: string;
|
|
294
282
|
columnsFrom: string[];
|
|
295
283
|
tableTo: string;
|
|
296
284
|
columnsTo: string[];
|
|
285
|
+
onUpdate?: string | undefined;
|
|
286
|
+
onDelete?: string | undefined;
|
|
287
|
+
schemaTo?: string | undefined;
|
|
297
288
|
}>;
|
|
298
289
|
schema: string;
|
|
299
290
|
compositePrimaryKeys: Record<string, {
|
|
@@ -321,7 +312,6 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
321
312
|
name: string;
|
|
322
313
|
schema: string;
|
|
323
314
|
}>;
|
|
324
|
-
}, {
|
|
325
315
|
internal?: {
|
|
326
316
|
tables: Record<string, {
|
|
327
317
|
columns: Record<string, {
|
|
@@ -331,23 +321,19 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
331
321
|
} | undefined>;
|
|
332
322
|
} | undefined>;
|
|
333
323
|
} | undefined;
|
|
324
|
+
}, {
|
|
334
325
|
tables: Record<string, {
|
|
335
|
-
uniqueConstraints?: Record<string, {
|
|
336
|
-
name: string;
|
|
337
|
-
columns: string[];
|
|
338
|
-
nullsNotDistinct: boolean;
|
|
339
|
-
}> | undefined;
|
|
340
326
|
name: string;
|
|
341
327
|
columns: Record<string, {
|
|
328
|
+
type: string;
|
|
329
|
+
name: string;
|
|
330
|
+
primaryKey: boolean;
|
|
331
|
+
notNull: boolean;
|
|
342
332
|
isUnique?: any;
|
|
343
333
|
default?: any;
|
|
344
334
|
typeSchema?: string | undefined;
|
|
345
335
|
uniqueName?: string | undefined;
|
|
346
336
|
nullsNotDistinct?: boolean | undefined;
|
|
347
|
-
type: string;
|
|
348
|
-
name: string;
|
|
349
|
-
primaryKey: boolean;
|
|
350
|
-
notNull: boolean;
|
|
351
337
|
}>;
|
|
352
338
|
indexes: Record<string, {
|
|
353
339
|
name: string;
|
|
@@ -355,20 +341,25 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
355
341
|
isUnique: boolean;
|
|
356
342
|
}>;
|
|
357
343
|
foreignKeys: Record<string, {
|
|
358
|
-
onUpdate?: string | undefined;
|
|
359
|
-
onDelete?: string | undefined;
|
|
360
|
-
schemaTo?: string | undefined;
|
|
361
344
|
name: string;
|
|
362
345
|
tableFrom: string;
|
|
363
346
|
columnsFrom: string[];
|
|
364
347
|
tableTo: string;
|
|
365
348
|
columnsTo: string[];
|
|
349
|
+
onUpdate?: string | undefined;
|
|
350
|
+
onDelete?: string | undefined;
|
|
351
|
+
schemaTo?: string | undefined;
|
|
366
352
|
}>;
|
|
367
353
|
schema: string;
|
|
368
354
|
compositePrimaryKeys: Record<string, {
|
|
369
355
|
name: string;
|
|
370
356
|
columns: string[];
|
|
371
357
|
}>;
|
|
358
|
+
uniqueConstraints?: Record<string, {
|
|
359
|
+
name: string;
|
|
360
|
+
columns: string[];
|
|
361
|
+
nullsNotDistinct: boolean;
|
|
362
|
+
}> | undefined;
|
|
372
363
|
}>;
|
|
373
364
|
id: string;
|
|
374
365
|
prevId: string;
|
|
@@ -385,10 +376,19 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
385
376
|
name: string;
|
|
386
377
|
schema: string;
|
|
387
378
|
}>;
|
|
379
|
+
internal?: {
|
|
380
|
+
tables: Record<string, {
|
|
381
|
+
columns: Record<string, {
|
|
382
|
+
isArray?: boolean | undefined;
|
|
383
|
+
dimensions?: number | undefined;
|
|
384
|
+
rawType?: string | undefined;
|
|
385
|
+
} | undefined>;
|
|
386
|
+
} | undefined>;
|
|
387
|
+
} | undefined;
|
|
388
388
|
}>;
|
|
389
389
|
type PgSchema = TypeOf<typeof pgSchema>;
|
|
390
390
|
|
|
391
|
-
declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
391
|
+
declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
392
392
|
version: zod.ZodLiteral<"6">;
|
|
393
393
|
dialect: zod.ZodEnum<["sqlite"]>;
|
|
394
394
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -401,19 +401,19 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
401
401
|
autoincrement: zod.ZodOptional<zod.ZodBoolean>;
|
|
402
402
|
default: zod.ZodOptional<zod.ZodAny>;
|
|
403
403
|
}, "strict", zod.ZodTypeAny, {
|
|
404
|
-
default?: any;
|
|
405
|
-
autoincrement?: boolean | undefined;
|
|
406
404
|
type: string;
|
|
407
405
|
name: string;
|
|
408
406
|
primaryKey: boolean;
|
|
409
407
|
notNull: boolean;
|
|
410
|
-
}, {
|
|
411
408
|
default?: any;
|
|
412
409
|
autoincrement?: boolean | undefined;
|
|
410
|
+
}, {
|
|
413
411
|
type: string;
|
|
414
412
|
name: string;
|
|
415
413
|
primaryKey: boolean;
|
|
416
414
|
notNull: boolean;
|
|
415
|
+
default?: any;
|
|
416
|
+
autoincrement?: boolean | undefined;
|
|
417
417
|
}>>;
|
|
418
418
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
419
419
|
name: zod.ZodString;
|
|
@@ -421,15 +421,15 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
421
421
|
where: zod.ZodOptional<zod.ZodString>;
|
|
422
422
|
isUnique: zod.ZodBoolean;
|
|
423
423
|
}, "strict", zod.ZodTypeAny, {
|
|
424
|
-
where?: string | undefined;
|
|
425
424
|
name: string;
|
|
426
425
|
columns: string[];
|
|
427
426
|
isUnique: boolean;
|
|
428
|
-
}, {
|
|
429
427
|
where?: string | undefined;
|
|
428
|
+
}, {
|
|
430
429
|
name: string;
|
|
431
430
|
columns: string[];
|
|
432
431
|
isUnique: boolean;
|
|
432
|
+
where?: string | undefined;
|
|
433
433
|
}>>;
|
|
434
434
|
foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
435
435
|
name: zod.ZodString;
|
|
@@ -440,31 +440,31 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
440
440
|
onUpdate: zod.ZodOptional<zod.ZodString>;
|
|
441
441
|
onDelete: zod.ZodOptional<zod.ZodString>;
|
|
442
442
|
}, "strict", zod.ZodTypeAny, {
|
|
443
|
-
onUpdate?: string | undefined;
|
|
444
|
-
onDelete?: string | undefined;
|
|
445
443
|
name: string;
|
|
446
444
|
tableFrom: string;
|
|
447
445
|
columnsFrom: string[];
|
|
448
446
|
tableTo: string;
|
|
449
447
|
columnsTo: string[];
|
|
450
|
-
}, {
|
|
451
448
|
onUpdate?: string | undefined;
|
|
452
449
|
onDelete?: string | undefined;
|
|
450
|
+
}, {
|
|
453
451
|
name: string;
|
|
454
452
|
tableFrom: string;
|
|
455
453
|
columnsFrom: string[];
|
|
456
454
|
tableTo: string;
|
|
457
455
|
columnsTo: string[];
|
|
456
|
+
onUpdate?: string | undefined;
|
|
457
|
+
onDelete?: string | undefined;
|
|
458
458
|
}>>;
|
|
459
459
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
460
460
|
columns: zod.ZodArray<zod.ZodString, "many">;
|
|
461
461
|
name: zod.ZodOptional<zod.ZodString>;
|
|
462
462
|
}, "strict", zod.ZodTypeAny, {
|
|
463
|
-
name?: string | undefined;
|
|
464
463
|
columns: string[];
|
|
465
|
-
}, {
|
|
466
464
|
name?: string | undefined;
|
|
465
|
+
}, {
|
|
467
466
|
columns: string[];
|
|
467
|
+
name?: string | undefined;
|
|
468
468
|
}>>;
|
|
469
469
|
uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
470
470
|
name: zod.ZodString;
|
|
@@ -479,69 +479,69 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
479
479
|
}, "strict", zod.ZodTypeAny, {
|
|
480
480
|
name: string;
|
|
481
481
|
columns: Record<string, {
|
|
482
|
-
default?: any;
|
|
483
|
-
autoincrement?: boolean | undefined;
|
|
484
482
|
type: string;
|
|
485
483
|
name: string;
|
|
486
484
|
primaryKey: boolean;
|
|
487
485
|
notNull: boolean;
|
|
486
|
+
default?: any;
|
|
487
|
+
autoincrement?: boolean | undefined;
|
|
488
488
|
}>;
|
|
489
489
|
indexes: Record<string, {
|
|
490
|
-
where?: string | undefined;
|
|
491
490
|
name: string;
|
|
492
491
|
columns: string[];
|
|
493
492
|
isUnique: boolean;
|
|
493
|
+
where?: string | undefined;
|
|
494
494
|
}>;
|
|
495
495
|
foreignKeys: Record<string, {
|
|
496
|
-
onUpdate?: string | undefined;
|
|
497
|
-
onDelete?: string | undefined;
|
|
498
496
|
name: string;
|
|
499
497
|
tableFrom: string;
|
|
500
498
|
columnsFrom: string[];
|
|
501
499
|
tableTo: string;
|
|
502
500
|
columnsTo: string[];
|
|
501
|
+
onUpdate?: string | undefined;
|
|
502
|
+
onDelete?: string | undefined;
|
|
503
503
|
}>;
|
|
504
504
|
compositePrimaryKeys: Record<string, {
|
|
505
|
-
name?: string | undefined;
|
|
506
505
|
columns: string[];
|
|
506
|
+
name?: string | undefined;
|
|
507
507
|
}>;
|
|
508
508
|
uniqueConstraints: Record<string, {
|
|
509
509
|
name: string;
|
|
510
510
|
columns: string[];
|
|
511
511
|
}>;
|
|
512
512
|
}, {
|
|
513
|
-
uniqueConstraints?: Record<string, {
|
|
514
|
-
name: string;
|
|
515
|
-
columns: string[];
|
|
516
|
-
}> | undefined;
|
|
517
513
|
name: string;
|
|
518
514
|
columns: Record<string, {
|
|
519
|
-
default?: any;
|
|
520
|
-
autoincrement?: boolean | undefined;
|
|
521
515
|
type: string;
|
|
522
516
|
name: string;
|
|
523
517
|
primaryKey: boolean;
|
|
524
518
|
notNull: boolean;
|
|
519
|
+
default?: any;
|
|
520
|
+
autoincrement?: boolean | undefined;
|
|
525
521
|
}>;
|
|
526
522
|
indexes: Record<string, {
|
|
527
|
-
where?: string | undefined;
|
|
528
523
|
name: string;
|
|
529
524
|
columns: string[];
|
|
530
525
|
isUnique: boolean;
|
|
526
|
+
where?: string | undefined;
|
|
531
527
|
}>;
|
|
532
528
|
foreignKeys: Record<string, {
|
|
533
|
-
onUpdate?: string | undefined;
|
|
534
|
-
onDelete?: string | undefined;
|
|
535
529
|
name: string;
|
|
536
530
|
tableFrom: string;
|
|
537
531
|
columnsFrom: string[];
|
|
538
532
|
tableTo: string;
|
|
539
533
|
columnsTo: string[];
|
|
534
|
+
onUpdate?: string | undefined;
|
|
535
|
+
onDelete?: string | undefined;
|
|
540
536
|
}>;
|
|
541
537
|
compositePrimaryKeys: Record<string, {
|
|
542
|
-
name?: string | undefined;
|
|
543
538
|
columns: string[];
|
|
539
|
+
name?: string | undefined;
|
|
544
540
|
}>;
|
|
541
|
+
uniqueConstraints?: Record<string, {
|
|
542
|
+
name: string;
|
|
543
|
+
columns: string[];
|
|
544
|
+
}> | undefined;
|
|
545
545
|
}>>;
|
|
546
546
|
enums: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
|
|
547
547
|
_meta: zod.ZodObject<{
|
|
@@ -561,31 +561,31 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
561
561
|
tables: Record<string, {
|
|
562
562
|
name: string;
|
|
563
563
|
columns: Record<string, {
|
|
564
|
-
default?: any;
|
|
565
|
-
autoincrement?: boolean | undefined;
|
|
566
564
|
type: string;
|
|
567
565
|
name: string;
|
|
568
566
|
primaryKey: boolean;
|
|
569
567
|
notNull: boolean;
|
|
568
|
+
default?: any;
|
|
569
|
+
autoincrement?: boolean | undefined;
|
|
570
570
|
}>;
|
|
571
571
|
indexes: Record<string, {
|
|
572
|
-
where?: string | undefined;
|
|
573
572
|
name: string;
|
|
574
573
|
columns: string[];
|
|
575
574
|
isUnique: boolean;
|
|
575
|
+
where?: string | undefined;
|
|
576
576
|
}>;
|
|
577
577
|
foreignKeys: Record<string, {
|
|
578
|
-
onUpdate?: string | undefined;
|
|
579
|
-
onDelete?: string | undefined;
|
|
580
578
|
name: string;
|
|
581
579
|
tableFrom: string;
|
|
582
580
|
columnsFrom: string[];
|
|
583
581
|
tableTo: string;
|
|
584
582
|
columnsTo: string[];
|
|
583
|
+
onUpdate?: string | undefined;
|
|
584
|
+
onDelete?: string | undefined;
|
|
585
585
|
}>;
|
|
586
586
|
compositePrimaryKeys: Record<string, {
|
|
587
|
-
name?: string | undefined;
|
|
588
587
|
columns: string[];
|
|
588
|
+
name?: string | undefined;
|
|
589
589
|
}>;
|
|
590
590
|
uniqueConstraints: Record<string, {
|
|
591
591
|
name: string;
|
|
@@ -603,38 +603,38 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
603
603
|
enums: {};
|
|
604
604
|
}, {
|
|
605
605
|
tables: Record<string, {
|
|
606
|
-
uniqueConstraints?: Record<string, {
|
|
607
|
-
name: string;
|
|
608
|
-
columns: string[];
|
|
609
|
-
}> | undefined;
|
|
610
606
|
name: string;
|
|
611
607
|
columns: Record<string, {
|
|
612
|
-
default?: any;
|
|
613
|
-
autoincrement?: boolean | undefined;
|
|
614
608
|
type: string;
|
|
615
609
|
name: string;
|
|
616
610
|
primaryKey: boolean;
|
|
617
611
|
notNull: boolean;
|
|
612
|
+
default?: any;
|
|
613
|
+
autoincrement?: boolean | undefined;
|
|
618
614
|
}>;
|
|
619
615
|
indexes: Record<string, {
|
|
620
|
-
where?: string | undefined;
|
|
621
616
|
name: string;
|
|
622
617
|
columns: string[];
|
|
623
618
|
isUnique: boolean;
|
|
619
|
+
where?: string | undefined;
|
|
624
620
|
}>;
|
|
625
621
|
foreignKeys: Record<string, {
|
|
626
|
-
onUpdate?: string | undefined;
|
|
627
|
-
onDelete?: string | undefined;
|
|
628
622
|
name: string;
|
|
629
623
|
tableFrom: string;
|
|
630
624
|
columnsFrom: string[];
|
|
631
625
|
tableTo: string;
|
|
632
626
|
columnsTo: string[];
|
|
627
|
+
onUpdate?: string | undefined;
|
|
628
|
+
onDelete?: string | undefined;
|
|
633
629
|
}>;
|
|
634
630
|
compositePrimaryKeys: Record<string, {
|
|
635
|
-
name?: string | undefined;
|
|
636
631
|
columns: string[];
|
|
632
|
+
name?: string | undefined;
|
|
637
633
|
}>;
|
|
634
|
+
uniqueConstraints?: Record<string, {
|
|
635
|
+
name: string;
|
|
636
|
+
columns: string[];
|
|
637
|
+
}> | undefined;
|
|
638
638
|
}>;
|
|
639
639
|
id: string;
|
|
640
640
|
prevId: string;
|
|
@@ -648,7 +648,7 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
648
648
|
}>;
|
|
649
649
|
type SQLiteSchema = TypeOf<typeof schema$1>;
|
|
650
650
|
|
|
651
|
-
declare const schema: zod.ZodObject<zod.extendShape<{
|
|
651
|
+
declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
652
652
|
version: zod.ZodLiteral<"5">;
|
|
653
653
|
dialect: zod.ZodLiteral<"mysql">;
|
|
654
654
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -662,21 +662,21 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
662
662
|
default: zod.ZodOptional<zod.ZodAny>;
|
|
663
663
|
onUpdate: zod.ZodOptional<zod.ZodAny>;
|
|
664
664
|
}, "strict", zod.ZodTypeAny, {
|
|
665
|
-
default?: any;
|
|
666
|
-
onUpdate?: any;
|
|
667
|
-
autoincrement?: boolean | undefined;
|
|
668
665
|
type: string;
|
|
669
666
|
name: string;
|
|
670
667
|
primaryKey: boolean;
|
|
671
668
|
notNull: boolean;
|
|
672
|
-
}, {
|
|
673
669
|
default?: any;
|
|
674
670
|
onUpdate?: any;
|
|
675
671
|
autoincrement?: boolean | undefined;
|
|
672
|
+
}, {
|
|
676
673
|
type: string;
|
|
677
674
|
name: string;
|
|
678
675
|
primaryKey: boolean;
|
|
679
676
|
notNull: boolean;
|
|
677
|
+
default?: any;
|
|
678
|
+
onUpdate?: any;
|
|
679
|
+
autoincrement?: boolean | undefined;
|
|
680
680
|
}>>;
|
|
681
681
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
682
682
|
name: zod.ZodString;
|
|
@@ -686,19 +686,19 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
686
686
|
algorithm: zod.ZodOptional<zod.ZodEnum<["default", "inplace", "copy"]>>;
|
|
687
687
|
lock: zod.ZodOptional<zod.ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
688
688
|
}, "strict", zod.ZodTypeAny, {
|
|
689
|
-
using?: "btree" | "hash" | undefined;
|
|
690
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
691
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
692
689
|
name: string;
|
|
693
690
|
columns: string[];
|
|
694
691
|
isUnique: boolean;
|
|
695
|
-
}, {
|
|
696
692
|
using?: "btree" | "hash" | undefined;
|
|
697
693
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
698
694
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
695
|
+
}, {
|
|
699
696
|
name: string;
|
|
700
697
|
columns: string[];
|
|
701
698
|
isUnique: boolean;
|
|
699
|
+
using?: "btree" | "hash" | undefined;
|
|
700
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
701
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
702
702
|
}>>;
|
|
703
703
|
foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
704
704
|
name: zod.ZodString;
|
|
@@ -709,21 +709,21 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
709
709
|
onUpdate: zod.ZodOptional<zod.ZodString>;
|
|
710
710
|
onDelete: zod.ZodOptional<zod.ZodString>;
|
|
711
711
|
}, "strict", zod.ZodTypeAny, {
|
|
712
|
-
onUpdate?: string | undefined;
|
|
713
|
-
onDelete?: string | undefined;
|
|
714
712
|
name: string;
|
|
715
713
|
tableFrom: string;
|
|
716
714
|
columnsFrom: string[];
|
|
717
715
|
tableTo: string;
|
|
718
716
|
columnsTo: string[];
|
|
719
|
-
}, {
|
|
720
717
|
onUpdate?: string | undefined;
|
|
721
718
|
onDelete?: string | undefined;
|
|
719
|
+
}, {
|
|
722
720
|
name: string;
|
|
723
721
|
tableFrom: string;
|
|
724
722
|
columnsFrom: string[];
|
|
725
723
|
tableTo: string;
|
|
726
724
|
columnsTo: string[];
|
|
725
|
+
onUpdate?: string | undefined;
|
|
726
|
+
onDelete?: string | undefined;
|
|
727
727
|
}>>;
|
|
728
728
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
729
729
|
name: zod.ZodString;
|
|
@@ -748,30 +748,30 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
748
748
|
}, "strict", zod.ZodTypeAny, {
|
|
749
749
|
name: string;
|
|
750
750
|
columns: Record<string, {
|
|
751
|
-
default?: any;
|
|
752
|
-
onUpdate?: any;
|
|
753
|
-
autoincrement?: boolean | undefined;
|
|
754
751
|
type: string;
|
|
755
752
|
name: string;
|
|
756
753
|
primaryKey: boolean;
|
|
757
754
|
notNull: boolean;
|
|
755
|
+
default?: any;
|
|
756
|
+
onUpdate?: any;
|
|
757
|
+
autoincrement?: boolean | undefined;
|
|
758
758
|
}>;
|
|
759
759
|
indexes: Record<string, {
|
|
760
|
-
using?: "btree" | "hash" | undefined;
|
|
761
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
762
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
763
760
|
name: string;
|
|
764
761
|
columns: string[];
|
|
765
762
|
isUnique: boolean;
|
|
763
|
+
using?: "btree" | "hash" | undefined;
|
|
764
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
765
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
766
766
|
}>;
|
|
767
767
|
foreignKeys: Record<string, {
|
|
768
|
-
onUpdate?: string | undefined;
|
|
769
|
-
onDelete?: string | undefined;
|
|
770
768
|
name: string;
|
|
771
769
|
tableFrom: string;
|
|
772
770
|
columnsFrom: string[];
|
|
773
771
|
tableTo: string;
|
|
774
772
|
columnsTo: string[];
|
|
773
|
+
onUpdate?: string | undefined;
|
|
774
|
+
onDelete?: string | undefined;
|
|
775
775
|
}>;
|
|
776
776
|
compositePrimaryKeys: Record<string, {
|
|
777
777
|
name: string;
|
|
@@ -782,41 +782,41 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
782
782
|
columns: string[];
|
|
783
783
|
}>;
|
|
784
784
|
}, {
|
|
785
|
-
uniqueConstraints?: Record<string, {
|
|
786
|
-
name: string;
|
|
787
|
-
columns: string[];
|
|
788
|
-
}> | undefined;
|
|
789
785
|
name: string;
|
|
790
786
|
columns: Record<string, {
|
|
791
|
-
default?: any;
|
|
792
|
-
onUpdate?: any;
|
|
793
|
-
autoincrement?: boolean | undefined;
|
|
794
787
|
type: string;
|
|
795
788
|
name: string;
|
|
796
789
|
primaryKey: boolean;
|
|
797
790
|
notNull: boolean;
|
|
791
|
+
default?: any;
|
|
792
|
+
onUpdate?: any;
|
|
793
|
+
autoincrement?: boolean | undefined;
|
|
798
794
|
}>;
|
|
799
795
|
indexes: Record<string, {
|
|
800
|
-
using?: "btree" | "hash" | undefined;
|
|
801
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
802
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
803
796
|
name: string;
|
|
804
797
|
columns: string[];
|
|
805
798
|
isUnique: boolean;
|
|
799
|
+
using?: "btree" | "hash" | undefined;
|
|
800
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
801
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
806
802
|
}>;
|
|
807
803
|
foreignKeys: Record<string, {
|
|
808
|
-
onUpdate?: string | undefined;
|
|
809
|
-
onDelete?: string | undefined;
|
|
810
804
|
name: string;
|
|
811
805
|
tableFrom: string;
|
|
812
806
|
columnsFrom: string[];
|
|
813
807
|
tableTo: string;
|
|
814
808
|
columnsTo: string[];
|
|
809
|
+
onUpdate?: string | undefined;
|
|
810
|
+
onDelete?: string | undefined;
|
|
815
811
|
}>;
|
|
816
812
|
compositePrimaryKeys: Record<string, {
|
|
817
813
|
name: string;
|
|
818
814
|
columns: string[];
|
|
819
815
|
}>;
|
|
816
|
+
uniqueConstraints?: Record<string, {
|
|
817
|
+
name: string;
|
|
818
|
+
columns: string[];
|
|
819
|
+
}> | undefined;
|
|
820
820
|
}>>;
|
|
821
821
|
_meta: zod.ZodObject<{
|
|
822
822
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
@@ -863,40 +863,33 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
863
863
|
id: zod.ZodString;
|
|
864
864
|
prevId: zod.ZodString;
|
|
865
865
|
}>, "strip", zod.ZodTypeAny, {
|
|
866
|
-
internal?: {
|
|
867
|
-
tables: Record<string, {
|
|
868
|
-
columns: Record<string, {
|
|
869
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
870
|
-
} | undefined>;
|
|
871
|
-
} | undefined>;
|
|
872
|
-
} | undefined;
|
|
873
866
|
tables: Record<string, {
|
|
874
867
|
name: string;
|
|
875
868
|
columns: Record<string, {
|
|
876
|
-
default?: any;
|
|
877
|
-
onUpdate?: any;
|
|
878
|
-
autoincrement?: boolean | undefined;
|
|
879
869
|
type: string;
|
|
880
870
|
name: string;
|
|
881
871
|
primaryKey: boolean;
|
|
882
872
|
notNull: boolean;
|
|
873
|
+
default?: any;
|
|
874
|
+
onUpdate?: any;
|
|
875
|
+
autoincrement?: boolean | undefined;
|
|
883
876
|
}>;
|
|
884
877
|
indexes: Record<string, {
|
|
885
|
-
using?: "btree" | "hash" | undefined;
|
|
886
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
887
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
888
878
|
name: string;
|
|
889
879
|
columns: string[];
|
|
890
880
|
isUnique: boolean;
|
|
881
|
+
using?: "btree" | "hash" | undefined;
|
|
882
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
883
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
891
884
|
}>;
|
|
892
885
|
foreignKeys: Record<string, {
|
|
893
|
-
onUpdate?: string | undefined;
|
|
894
|
-
onDelete?: string | undefined;
|
|
895
886
|
name: string;
|
|
896
887
|
tableFrom: string;
|
|
897
888
|
columnsFrom: string[];
|
|
898
889
|
tableTo: string;
|
|
899
890
|
columnsTo: string[];
|
|
891
|
+
onUpdate?: string | undefined;
|
|
892
|
+
onDelete?: string | undefined;
|
|
900
893
|
}>;
|
|
901
894
|
compositePrimaryKeys: Record<string, {
|
|
902
895
|
name: string;
|
|
@@ -915,7 +908,6 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
915
908
|
columns: Record<string, string>;
|
|
916
909
|
tables: Record<string, string>;
|
|
917
910
|
};
|
|
918
|
-
}, {
|
|
919
911
|
internal?: {
|
|
920
912
|
tables: Record<string, {
|
|
921
913
|
columns: Record<string, {
|
|
@@ -923,42 +915,43 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
923
915
|
} | undefined>;
|
|
924
916
|
} | undefined>;
|
|
925
917
|
} | undefined;
|
|
918
|
+
}, {
|
|
926
919
|
tables: Record<string, {
|
|
927
|
-
uniqueConstraints?: Record<string, {
|
|
928
|
-
name: string;
|
|
929
|
-
columns: string[];
|
|
930
|
-
}> | undefined;
|
|
931
920
|
name: string;
|
|
932
921
|
columns: Record<string, {
|
|
933
|
-
default?: any;
|
|
934
|
-
onUpdate?: any;
|
|
935
|
-
autoincrement?: boolean | undefined;
|
|
936
922
|
type: string;
|
|
937
923
|
name: string;
|
|
938
924
|
primaryKey: boolean;
|
|
939
925
|
notNull: boolean;
|
|
926
|
+
default?: any;
|
|
927
|
+
onUpdate?: any;
|
|
928
|
+
autoincrement?: boolean | undefined;
|
|
940
929
|
}>;
|
|
941
930
|
indexes: Record<string, {
|
|
942
|
-
using?: "btree" | "hash" | undefined;
|
|
943
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
944
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
945
931
|
name: string;
|
|
946
932
|
columns: string[];
|
|
947
933
|
isUnique: boolean;
|
|
934
|
+
using?: "btree" | "hash" | undefined;
|
|
935
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
936
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
948
937
|
}>;
|
|
949
938
|
foreignKeys: Record<string, {
|
|
950
|
-
onUpdate?: string | undefined;
|
|
951
|
-
onDelete?: string | undefined;
|
|
952
939
|
name: string;
|
|
953
940
|
tableFrom: string;
|
|
954
941
|
columnsFrom: string[];
|
|
955
942
|
tableTo: string;
|
|
956
943
|
columnsTo: string[];
|
|
944
|
+
onUpdate?: string | undefined;
|
|
945
|
+
onDelete?: string | undefined;
|
|
957
946
|
}>;
|
|
958
947
|
compositePrimaryKeys: Record<string, {
|
|
959
948
|
name: string;
|
|
960
949
|
columns: string[];
|
|
961
950
|
}>;
|
|
951
|
+
uniqueConstraints?: Record<string, {
|
|
952
|
+
name: string;
|
|
953
|
+
columns: string[];
|
|
954
|
+
}> | undefined;
|
|
962
955
|
}>;
|
|
963
956
|
id: string;
|
|
964
957
|
prevId: string;
|
|
@@ -968,6 +961,13 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
968
961
|
columns: Record<string, string>;
|
|
969
962
|
tables: Record<string, string>;
|
|
970
963
|
};
|
|
964
|
+
internal?: {
|
|
965
|
+
tables: Record<string, {
|
|
966
|
+
columns: Record<string, {
|
|
967
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
968
|
+
} | undefined>;
|
|
969
|
+
} | undefined>;
|
|
970
|
+
} | undefined;
|
|
971
971
|
}>;
|
|
972
972
|
type MySqlSchema = TypeOf<typeof schema>;
|
|
973
973
|
|
|
@@ -999,30 +999,21 @@ declare const pushMySQLSchema: (imports: Record<string, unknown>, drizzleInstanc
|
|
|
999
999
|
apply: () => Promise<void>;
|
|
1000
1000
|
}>;
|
|
1001
1001
|
declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
1002
|
-
internal?: {
|
|
1003
|
-
tables: Record<string, {
|
|
1004
|
-
columns: Record<string, {
|
|
1005
|
-
isArray?: boolean | undefined;
|
|
1006
|
-
dimensions?: number | undefined;
|
|
1007
|
-
rawType?: string | undefined;
|
|
1008
|
-
} | undefined>;
|
|
1009
|
-
} | undefined>;
|
|
1010
|
-
} | undefined;
|
|
1011
1002
|
version: "6";
|
|
1012
1003
|
dialect: "postgresql";
|
|
1013
1004
|
tables: Record<string, {
|
|
1014
1005
|
name: string;
|
|
1015
1006
|
schema: string;
|
|
1016
1007
|
columns: Record<string, {
|
|
1008
|
+
type: string;
|
|
1009
|
+
name: string;
|
|
1010
|
+
primaryKey: boolean;
|
|
1011
|
+
notNull: boolean;
|
|
1017
1012
|
typeSchema?: string | undefined;
|
|
1018
1013
|
default?: any;
|
|
1019
1014
|
isUnique?: any;
|
|
1020
1015
|
uniqueName?: string | undefined;
|
|
1021
1016
|
nullsNotDistinct?: boolean | undefined;
|
|
1022
|
-
type: string;
|
|
1023
|
-
name: string;
|
|
1024
|
-
primaryKey: boolean;
|
|
1025
|
-
notNull: boolean;
|
|
1026
1017
|
}>;
|
|
1027
1018
|
indexes: Record<string, {
|
|
1028
1019
|
name: string;
|
|
@@ -1030,14 +1021,14 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
|
1030
1021
|
isUnique: boolean;
|
|
1031
1022
|
}>;
|
|
1032
1023
|
foreignKeys: Record<string, {
|
|
1033
|
-
schemaTo?: string | undefined;
|
|
1034
|
-
onUpdate?: string | undefined;
|
|
1035
|
-
onDelete?: string | undefined;
|
|
1036
1024
|
name: string;
|
|
1037
1025
|
tableFrom: string;
|
|
1038
1026
|
columnsFrom: string[];
|
|
1039
1027
|
tableTo: string;
|
|
1040
1028
|
columnsTo: string[];
|
|
1029
|
+
schemaTo?: string | undefined;
|
|
1030
|
+
onUpdate?: string | undefined;
|
|
1031
|
+
onDelete?: string | undefined;
|
|
1041
1032
|
}>;
|
|
1042
1033
|
compositePrimaryKeys: Record<string, {
|
|
1043
1034
|
name: string;
|
|
@@ -1062,6 +1053,15 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
|
1062
1053
|
};
|
|
1063
1054
|
id: string;
|
|
1064
1055
|
prevId: string;
|
|
1056
|
+
internal?: {
|
|
1057
|
+
tables: Record<string, {
|
|
1058
|
+
columns: Record<string, {
|
|
1059
|
+
isArray?: boolean | undefined;
|
|
1060
|
+
dimensions?: number | undefined;
|
|
1061
|
+
rawType?: string | undefined;
|
|
1062
|
+
} | undefined>;
|
|
1063
|
+
} | undefined>;
|
|
1064
|
+
} | undefined;
|
|
1065
1065
|
};
|
|
1066
1066
|
|
|
1067
1067
|
export { type DrizzleMySQLSnapshotJSON, type DrizzleSQLiteSnapshotJSON, type DrizzleSnapshotJSON, generateDrizzleJson, generateMigration, generateMySQLDrizzleJson, generateMySQLMigration, generateSQLiteDrizzleJson, generateSQLiteMigration, pushMySQLSchema, pushSQLiteSchema, pushSchema, upPgSnapshot };
|