drizzle-kit 0.21.2-ef624aa → 0.21.2-f3756f2
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 +15369 -13682
- package/package.json +3 -3
- package/payload.d.mts +273 -187
- package/payload.d.ts +273 -187
- package/payload.js +1671 -1167
- package/payload.mjs +1663 -1159
- package/utils-studio.js +1074 -813
- package/utils-studio.mjs +1047 -786
- package/utils.js +999 -290
- package/utils.mjs +974 -265
package/payload.d.ts
CHANGED
|
@@ -4,8 +4,8 @@ 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<{
|
|
8
|
-
version: zod.ZodLiteral<"
|
|
7
|
+
declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
8
|
+
version: zod.ZodLiteral<"7">;
|
|
9
9
|
dialect: zod.ZodLiteral<"postgresql">;
|
|
10
10
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
11
11
|
name: zod.ZodString;
|
|
@@ -21,38 +21,80 @@ 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;
|
|
46
|
-
columns: zod.ZodArray<zod.
|
|
46
|
+
columns: zod.ZodArray<zod.ZodObject<{
|
|
47
|
+
expression: zod.ZodString;
|
|
48
|
+
isExpression: zod.ZodBoolean;
|
|
49
|
+
asc: zod.ZodBoolean;
|
|
50
|
+
nulls: zod.ZodOptional<zod.ZodString>;
|
|
51
|
+
opclass: zod.ZodOptional<zod.ZodString>;
|
|
52
|
+
}, "strip", zod.ZodTypeAny, {
|
|
53
|
+
expression: string;
|
|
54
|
+
isExpression: boolean;
|
|
55
|
+
asc: boolean;
|
|
56
|
+
nulls?: string | undefined;
|
|
57
|
+
opclass?: string | undefined;
|
|
58
|
+
}, {
|
|
59
|
+
expression: string;
|
|
60
|
+
isExpression: boolean;
|
|
61
|
+
asc: boolean;
|
|
62
|
+
nulls?: string | undefined;
|
|
63
|
+
opclass?: string | undefined;
|
|
64
|
+
}>, "many">;
|
|
47
65
|
isUnique: zod.ZodBoolean;
|
|
66
|
+
with: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodAny>>;
|
|
67
|
+
method: zod.ZodDefault<zod.ZodString>;
|
|
68
|
+
where: zod.ZodOptional<zod.ZodString>;
|
|
69
|
+
concurrently: zod.ZodDefault<zod.ZodBoolean>;
|
|
48
70
|
}, "strict", zod.ZodTypeAny, {
|
|
49
71
|
name: string;
|
|
50
|
-
columns:
|
|
72
|
+
columns: {
|
|
73
|
+
expression: string;
|
|
74
|
+
isExpression: boolean;
|
|
75
|
+
asc: boolean;
|
|
76
|
+
nulls?: string | undefined;
|
|
77
|
+
opclass?: string | undefined;
|
|
78
|
+
}[];
|
|
51
79
|
isUnique: boolean;
|
|
80
|
+
method: string;
|
|
81
|
+
concurrently: boolean;
|
|
82
|
+
with?: Record<string, any> | undefined;
|
|
83
|
+
where?: string | undefined;
|
|
52
84
|
}, {
|
|
53
85
|
name: string;
|
|
54
|
-
columns:
|
|
86
|
+
columns: {
|
|
87
|
+
expression: string;
|
|
88
|
+
isExpression: boolean;
|
|
89
|
+
asc: boolean;
|
|
90
|
+
nulls?: string | undefined;
|
|
91
|
+
opclass?: string | undefined;
|
|
92
|
+
}[];
|
|
55
93
|
isUnique: boolean;
|
|
94
|
+
with?: Record<string, any> | undefined;
|
|
95
|
+
method?: string | undefined;
|
|
96
|
+
where?: string | undefined;
|
|
97
|
+
concurrently?: boolean | undefined;
|
|
56
98
|
}>>;
|
|
57
99
|
foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
58
100
|
name: zod.ZodString;
|
|
@@ -64,23 +106,23 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
64
106
|
onUpdate: zod.ZodOptional<zod.ZodString>;
|
|
65
107
|
onDelete: zod.ZodOptional<zod.ZodString>;
|
|
66
108
|
}, "strict", zod.ZodTypeAny, {
|
|
67
|
-
onUpdate?: string | undefined;
|
|
68
|
-
onDelete?: string | undefined;
|
|
69
|
-
schemaTo?: string | undefined;
|
|
70
109
|
name: string;
|
|
71
110
|
tableFrom: string;
|
|
72
111
|
columnsFrom: string[];
|
|
73
112
|
tableTo: string;
|
|
74
113
|
columnsTo: string[];
|
|
75
|
-
}, {
|
|
76
114
|
onUpdate?: string | undefined;
|
|
77
115
|
onDelete?: string | undefined;
|
|
78
116
|
schemaTo?: string | undefined;
|
|
117
|
+
}, {
|
|
79
118
|
name: string;
|
|
80
119
|
tableFrom: string;
|
|
81
120
|
columnsFrom: string[];
|
|
82
121
|
tableTo: string;
|
|
83
122
|
columnsTo: string[];
|
|
123
|
+
onUpdate?: string | undefined;
|
|
124
|
+
onDelete?: string | undefined;
|
|
125
|
+
schemaTo?: string | undefined;
|
|
84
126
|
}>>;
|
|
85
127
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
86
128
|
name: zod.ZodString;
|
|
@@ -108,30 +150,40 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
108
150
|
}, "strict", zod.ZodTypeAny, {
|
|
109
151
|
name: string;
|
|
110
152
|
columns: Record<string, {
|
|
153
|
+
type: string;
|
|
154
|
+
name: string;
|
|
155
|
+
primaryKey: boolean;
|
|
156
|
+
notNull: boolean;
|
|
111
157
|
isUnique?: any;
|
|
112
158
|
default?: any;
|
|
113
159
|
typeSchema?: string | undefined;
|
|
114
160
|
uniqueName?: string | undefined;
|
|
115
161
|
nullsNotDistinct?: boolean | undefined;
|
|
116
|
-
type: string;
|
|
117
|
-
name: string;
|
|
118
|
-
primaryKey: boolean;
|
|
119
|
-
notNull: boolean;
|
|
120
162
|
}>;
|
|
121
163
|
indexes: Record<string, {
|
|
122
164
|
name: string;
|
|
123
|
-
columns:
|
|
165
|
+
columns: {
|
|
166
|
+
expression: string;
|
|
167
|
+
isExpression: boolean;
|
|
168
|
+
asc: boolean;
|
|
169
|
+
nulls?: string | undefined;
|
|
170
|
+
opclass?: string | undefined;
|
|
171
|
+
}[];
|
|
124
172
|
isUnique: boolean;
|
|
173
|
+
method: string;
|
|
174
|
+
concurrently: boolean;
|
|
175
|
+
with?: Record<string, any> | undefined;
|
|
176
|
+
where?: string | undefined;
|
|
125
177
|
}>;
|
|
126
178
|
foreignKeys: Record<string, {
|
|
127
|
-
onUpdate?: string | undefined;
|
|
128
|
-
onDelete?: string | undefined;
|
|
129
|
-
schemaTo?: string | undefined;
|
|
130
179
|
name: string;
|
|
131
180
|
tableFrom: string;
|
|
132
181
|
columnsFrom: string[];
|
|
133
182
|
tableTo: string;
|
|
134
183
|
columnsTo: string[];
|
|
184
|
+
onUpdate?: string | undefined;
|
|
185
|
+
onDelete?: string | undefined;
|
|
186
|
+
schemaTo?: string | undefined;
|
|
135
187
|
}>;
|
|
136
188
|
schema: string;
|
|
137
189
|
compositePrimaryKeys: Record<string, {
|
|
@@ -144,43 +196,53 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
144
196
|
nullsNotDistinct: boolean;
|
|
145
197
|
}>;
|
|
146
198
|
}, {
|
|
147
|
-
uniqueConstraints?: Record<string, {
|
|
148
|
-
name: string;
|
|
149
|
-
columns: string[];
|
|
150
|
-
nullsNotDistinct: boolean;
|
|
151
|
-
}> | undefined;
|
|
152
199
|
name: string;
|
|
153
200
|
columns: Record<string, {
|
|
201
|
+
type: string;
|
|
202
|
+
name: string;
|
|
203
|
+
primaryKey: boolean;
|
|
204
|
+
notNull: boolean;
|
|
154
205
|
isUnique?: any;
|
|
155
206
|
default?: any;
|
|
156
207
|
typeSchema?: string | undefined;
|
|
157
208
|
uniqueName?: string | undefined;
|
|
158
209
|
nullsNotDistinct?: boolean | undefined;
|
|
159
|
-
type: string;
|
|
160
|
-
name: string;
|
|
161
|
-
primaryKey: boolean;
|
|
162
|
-
notNull: boolean;
|
|
163
210
|
}>;
|
|
164
211
|
indexes: Record<string, {
|
|
165
212
|
name: string;
|
|
166
|
-
columns:
|
|
213
|
+
columns: {
|
|
214
|
+
expression: string;
|
|
215
|
+
isExpression: boolean;
|
|
216
|
+
asc: boolean;
|
|
217
|
+
nulls?: string | undefined;
|
|
218
|
+
opclass?: string | undefined;
|
|
219
|
+
}[];
|
|
167
220
|
isUnique: boolean;
|
|
221
|
+
with?: Record<string, any> | undefined;
|
|
222
|
+
method?: string | undefined;
|
|
223
|
+
where?: string | undefined;
|
|
224
|
+
concurrently?: boolean | undefined;
|
|
168
225
|
}>;
|
|
169
226
|
foreignKeys: Record<string, {
|
|
170
|
-
onUpdate?: string | undefined;
|
|
171
|
-
onDelete?: string | undefined;
|
|
172
|
-
schemaTo?: string | undefined;
|
|
173
227
|
name: string;
|
|
174
228
|
tableFrom: string;
|
|
175
229
|
columnsFrom: string[];
|
|
176
230
|
tableTo: string;
|
|
177
231
|
columnsTo: string[];
|
|
232
|
+
onUpdate?: string | undefined;
|
|
233
|
+
onDelete?: string | undefined;
|
|
234
|
+
schemaTo?: string | undefined;
|
|
178
235
|
}>;
|
|
179
236
|
schema: string;
|
|
180
237
|
compositePrimaryKeys: Record<string, {
|
|
181
238
|
name: string;
|
|
182
239
|
columns: string[];
|
|
183
240
|
}>;
|
|
241
|
+
uniqueConstraints?: Record<string, {
|
|
242
|
+
name: string;
|
|
243
|
+
columns: string[];
|
|
244
|
+
nullsNotDistinct: boolean;
|
|
245
|
+
}> | undefined;
|
|
184
246
|
}>>;
|
|
185
247
|
enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
186
248
|
name: zod.ZodString;
|
|
@@ -258,42 +320,43 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
258
320
|
id: zod.ZodString;
|
|
259
321
|
prevId: zod.ZodString;
|
|
260
322
|
}>, "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
323
|
tables: Record<string, {
|
|
271
324
|
name: string;
|
|
272
325
|
columns: Record<string, {
|
|
326
|
+
type: string;
|
|
327
|
+
name: string;
|
|
328
|
+
primaryKey: boolean;
|
|
329
|
+
notNull: boolean;
|
|
273
330
|
isUnique?: any;
|
|
274
331
|
default?: any;
|
|
275
332
|
typeSchema?: string | undefined;
|
|
276
333
|
uniqueName?: string | undefined;
|
|
277
334
|
nullsNotDistinct?: boolean | undefined;
|
|
278
|
-
type: string;
|
|
279
|
-
name: string;
|
|
280
|
-
primaryKey: boolean;
|
|
281
|
-
notNull: boolean;
|
|
282
335
|
}>;
|
|
283
336
|
indexes: Record<string, {
|
|
284
337
|
name: string;
|
|
285
|
-
columns:
|
|
338
|
+
columns: {
|
|
339
|
+
expression: string;
|
|
340
|
+
isExpression: boolean;
|
|
341
|
+
asc: boolean;
|
|
342
|
+
nulls?: string | undefined;
|
|
343
|
+
opclass?: string | undefined;
|
|
344
|
+
}[];
|
|
286
345
|
isUnique: boolean;
|
|
346
|
+
method: string;
|
|
347
|
+
concurrently: boolean;
|
|
348
|
+
with?: Record<string, any> | undefined;
|
|
349
|
+
where?: string | undefined;
|
|
287
350
|
}>;
|
|
288
351
|
foreignKeys: Record<string, {
|
|
289
|
-
onUpdate?: string | undefined;
|
|
290
|
-
onDelete?: string | undefined;
|
|
291
|
-
schemaTo?: string | undefined;
|
|
292
352
|
name: string;
|
|
293
353
|
tableFrom: string;
|
|
294
354
|
columnsFrom: string[];
|
|
295
355
|
tableTo: string;
|
|
296
356
|
columnsTo: string[];
|
|
357
|
+
onUpdate?: string | undefined;
|
|
358
|
+
onDelete?: string | undefined;
|
|
359
|
+
schemaTo?: string | undefined;
|
|
297
360
|
}>;
|
|
298
361
|
schema: string;
|
|
299
362
|
compositePrimaryKeys: Record<string, {
|
|
@@ -308,7 +371,7 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
308
371
|
}>;
|
|
309
372
|
id: string;
|
|
310
373
|
prevId: string;
|
|
311
|
-
version: "
|
|
374
|
+
version: "7";
|
|
312
375
|
dialect: "postgresql";
|
|
313
376
|
schemas: Record<string, string>;
|
|
314
377
|
_meta: {
|
|
@@ -321,7 +384,6 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
321
384
|
name: string;
|
|
322
385
|
schema: string;
|
|
323
386
|
}>;
|
|
324
|
-
}, {
|
|
325
387
|
internal?: {
|
|
326
388
|
tables: Record<string, {
|
|
327
389
|
columns: Record<string, {
|
|
@@ -331,48 +393,59 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
331
393
|
} | undefined>;
|
|
332
394
|
} | undefined>;
|
|
333
395
|
} | undefined;
|
|
396
|
+
}, {
|
|
334
397
|
tables: Record<string, {
|
|
335
|
-
uniqueConstraints?: Record<string, {
|
|
336
|
-
name: string;
|
|
337
|
-
columns: string[];
|
|
338
|
-
nullsNotDistinct: boolean;
|
|
339
|
-
}> | undefined;
|
|
340
398
|
name: string;
|
|
341
399
|
columns: Record<string, {
|
|
400
|
+
type: string;
|
|
401
|
+
name: string;
|
|
402
|
+
primaryKey: boolean;
|
|
403
|
+
notNull: boolean;
|
|
342
404
|
isUnique?: any;
|
|
343
405
|
default?: any;
|
|
344
406
|
typeSchema?: string | undefined;
|
|
345
407
|
uniqueName?: string | undefined;
|
|
346
408
|
nullsNotDistinct?: boolean | undefined;
|
|
347
|
-
type: string;
|
|
348
|
-
name: string;
|
|
349
|
-
primaryKey: boolean;
|
|
350
|
-
notNull: boolean;
|
|
351
409
|
}>;
|
|
352
410
|
indexes: Record<string, {
|
|
353
411
|
name: string;
|
|
354
|
-
columns:
|
|
412
|
+
columns: {
|
|
413
|
+
expression: string;
|
|
414
|
+
isExpression: boolean;
|
|
415
|
+
asc: boolean;
|
|
416
|
+
nulls?: string | undefined;
|
|
417
|
+
opclass?: string | undefined;
|
|
418
|
+
}[];
|
|
355
419
|
isUnique: boolean;
|
|
420
|
+
with?: Record<string, any> | undefined;
|
|
421
|
+
method?: string | undefined;
|
|
422
|
+
where?: string | undefined;
|
|
423
|
+
concurrently?: boolean | undefined;
|
|
356
424
|
}>;
|
|
357
425
|
foreignKeys: Record<string, {
|
|
358
|
-
onUpdate?: string | undefined;
|
|
359
|
-
onDelete?: string | undefined;
|
|
360
|
-
schemaTo?: string | undefined;
|
|
361
426
|
name: string;
|
|
362
427
|
tableFrom: string;
|
|
363
428
|
columnsFrom: string[];
|
|
364
429
|
tableTo: string;
|
|
365
430
|
columnsTo: string[];
|
|
431
|
+
onUpdate?: string | undefined;
|
|
432
|
+
onDelete?: string | undefined;
|
|
433
|
+
schemaTo?: string | undefined;
|
|
366
434
|
}>;
|
|
367
435
|
schema: string;
|
|
368
436
|
compositePrimaryKeys: Record<string, {
|
|
369
437
|
name: string;
|
|
370
438
|
columns: string[];
|
|
371
439
|
}>;
|
|
440
|
+
uniqueConstraints?: Record<string, {
|
|
441
|
+
name: string;
|
|
442
|
+
columns: string[];
|
|
443
|
+
nullsNotDistinct: boolean;
|
|
444
|
+
}> | undefined;
|
|
372
445
|
}>;
|
|
373
446
|
id: string;
|
|
374
447
|
prevId: string;
|
|
375
|
-
version: "
|
|
448
|
+
version: "7";
|
|
376
449
|
dialect: "postgresql";
|
|
377
450
|
schemas: Record<string, string>;
|
|
378
451
|
_meta: {
|
|
@@ -385,10 +458,19 @@ declare const pgSchema: zod.ZodObject<zod.extendShape<{
|
|
|
385
458
|
name: string;
|
|
386
459
|
schema: string;
|
|
387
460
|
}>;
|
|
461
|
+
internal?: {
|
|
462
|
+
tables: Record<string, {
|
|
463
|
+
columns: Record<string, {
|
|
464
|
+
isArray?: boolean | undefined;
|
|
465
|
+
dimensions?: number | undefined;
|
|
466
|
+
rawType?: string | undefined;
|
|
467
|
+
} | undefined>;
|
|
468
|
+
} | undefined>;
|
|
469
|
+
} | undefined;
|
|
388
470
|
}>;
|
|
389
471
|
type PgSchema = TypeOf<typeof pgSchema>;
|
|
390
472
|
|
|
391
|
-
declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
473
|
+
declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
392
474
|
version: zod.ZodLiteral<"6">;
|
|
393
475
|
dialect: zod.ZodEnum<["sqlite"]>;
|
|
394
476
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -401,19 +483,19 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
401
483
|
autoincrement: zod.ZodOptional<zod.ZodBoolean>;
|
|
402
484
|
default: zod.ZodOptional<zod.ZodAny>;
|
|
403
485
|
}, "strict", zod.ZodTypeAny, {
|
|
404
|
-
default?: any;
|
|
405
|
-
autoincrement?: boolean | undefined;
|
|
406
486
|
type: string;
|
|
407
487
|
name: string;
|
|
408
488
|
primaryKey: boolean;
|
|
409
489
|
notNull: boolean;
|
|
410
|
-
}, {
|
|
411
490
|
default?: any;
|
|
412
491
|
autoincrement?: boolean | undefined;
|
|
492
|
+
}, {
|
|
413
493
|
type: string;
|
|
414
494
|
name: string;
|
|
415
495
|
primaryKey: boolean;
|
|
416
496
|
notNull: boolean;
|
|
497
|
+
default?: any;
|
|
498
|
+
autoincrement?: boolean | undefined;
|
|
417
499
|
}>>;
|
|
418
500
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
419
501
|
name: zod.ZodString;
|
|
@@ -421,15 +503,15 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
421
503
|
where: zod.ZodOptional<zod.ZodString>;
|
|
422
504
|
isUnique: zod.ZodBoolean;
|
|
423
505
|
}, "strict", zod.ZodTypeAny, {
|
|
424
|
-
where?: string | undefined;
|
|
425
506
|
name: string;
|
|
426
507
|
columns: string[];
|
|
427
508
|
isUnique: boolean;
|
|
428
|
-
}, {
|
|
429
509
|
where?: string | undefined;
|
|
510
|
+
}, {
|
|
430
511
|
name: string;
|
|
431
512
|
columns: string[];
|
|
432
513
|
isUnique: boolean;
|
|
514
|
+
where?: string | undefined;
|
|
433
515
|
}>>;
|
|
434
516
|
foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
435
517
|
name: zod.ZodString;
|
|
@@ -440,31 +522,31 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
440
522
|
onUpdate: zod.ZodOptional<zod.ZodString>;
|
|
441
523
|
onDelete: zod.ZodOptional<zod.ZodString>;
|
|
442
524
|
}, "strict", zod.ZodTypeAny, {
|
|
443
|
-
onUpdate?: string | undefined;
|
|
444
|
-
onDelete?: string | undefined;
|
|
445
525
|
name: string;
|
|
446
526
|
tableFrom: string;
|
|
447
527
|
columnsFrom: string[];
|
|
448
528
|
tableTo: string;
|
|
449
529
|
columnsTo: string[];
|
|
450
|
-
}, {
|
|
451
530
|
onUpdate?: string | undefined;
|
|
452
531
|
onDelete?: string | undefined;
|
|
532
|
+
}, {
|
|
453
533
|
name: string;
|
|
454
534
|
tableFrom: string;
|
|
455
535
|
columnsFrom: string[];
|
|
456
536
|
tableTo: string;
|
|
457
537
|
columnsTo: string[];
|
|
538
|
+
onUpdate?: string | undefined;
|
|
539
|
+
onDelete?: string | undefined;
|
|
458
540
|
}>>;
|
|
459
541
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
460
542
|
columns: zod.ZodArray<zod.ZodString, "many">;
|
|
461
543
|
name: zod.ZodOptional<zod.ZodString>;
|
|
462
544
|
}, "strict", zod.ZodTypeAny, {
|
|
463
|
-
name?: string | undefined;
|
|
464
545
|
columns: string[];
|
|
465
|
-
}, {
|
|
466
546
|
name?: string | undefined;
|
|
547
|
+
}, {
|
|
467
548
|
columns: string[];
|
|
549
|
+
name?: string | undefined;
|
|
468
550
|
}>>;
|
|
469
551
|
uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
470
552
|
name: zod.ZodString;
|
|
@@ -479,69 +561,69 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
479
561
|
}, "strict", zod.ZodTypeAny, {
|
|
480
562
|
name: string;
|
|
481
563
|
columns: Record<string, {
|
|
482
|
-
default?: any;
|
|
483
|
-
autoincrement?: boolean | undefined;
|
|
484
564
|
type: string;
|
|
485
565
|
name: string;
|
|
486
566
|
primaryKey: boolean;
|
|
487
567
|
notNull: boolean;
|
|
568
|
+
default?: any;
|
|
569
|
+
autoincrement?: boolean | undefined;
|
|
488
570
|
}>;
|
|
489
571
|
indexes: Record<string, {
|
|
490
|
-
where?: string | undefined;
|
|
491
572
|
name: string;
|
|
492
573
|
columns: string[];
|
|
493
574
|
isUnique: boolean;
|
|
575
|
+
where?: string | undefined;
|
|
494
576
|
}>;
|
|
495
577
|
foreignKeys: Record<string, {
|
|
496
|
-
onUpdate?: string | undefined;
|
|
497
|
-
onDelete?: string | undefined;
|
|
498
578
|
name: string;
|
|
499
579
|
tableFrom: string;
|
|
500
580
|
columnsFrom: string[];
|
|
501
581
|
tableTo: string;
|
|
502
582
|
columnsTo: string[];
|
|
583
|
+
onUpdate?: string | undefined;
|
|
584
|
+
onDelete?: string | undefined;
|
|
503
585
|
}>;
|
|
504
586
|
compositePrimaryKeys: Record<string, {
|
|
505
|
-
name?: string | undefined;
|
|
506
587
|
columns: string[];
|
|
588
|
+
name?: string | undefined;
|
|
507
589
|
}>;
|
|
508
590
|
uniqueConstraints: Record<string, {
|
|
509
591
|
name: string;
|
|
510
592
|
columns: string[];
|
|
511
593
|
}>;
|
|
512
594
|
}, {
|
|
513
|
-
uniqueConstraints?: Record<string, {
|
|
514
|
-
name: string;
|
|
515
|
-
columns: string[];
|
|
516
|
-
}> | undefined;
|
|
517
595
|
name: string;
|
|
518
596
|
columns: Record<string, {
|
|
519
|
-
default?: any;
|
|
520
|
-
autoincrement?: boolean | undefined;
|
|
521
597
|
type: string;
|
|
522
598
|
name: string;
|
|
523
599
|
primaryKey: boolean;
|
|
524
600
|
notNull: boolean;
|
|
601
|
+
default?: any;
|
|
602
|
+
autoincrement?: boolean | undefined;
|
|
525
603
|
}>;
|
|
526
604
|
indexes: Record<string, {
|
|
527
|
-
where?: string | undefined;
|
|
528
605
|
name: string;
|
|
529
606
|
columns: string[];
|
|
530
607
|
isUnique: boolean;
|
|
608
|
+
where?: string | undefined;
|
|
531
609
|
}>;
|
|
532
610
|
foreignKeys: Record<string, {
|
|
533
|
-
onUpdate?: string | undefined;
|
|
534
|
-
onDelete?: string | undefined;
|
|
535
611
|
name: string;
|
|
536
612
|
tableFrom: string;
|
|
537
613
|
columnsFrom: string[];
|
|
538
614
|
tableTo: string;
|
|
539
615
|
columnsTo: string[];
|
|
616
|
+
onUpdate?: string | undefined;
|
|
617
|
+
onDelete?: string | undefined;
|
|
540
618
|
}>;
|
|
541
619
|
compositePrimaryKeys: Record<string, {
|
|
542
|
-
name?: string | undefined;
|
|
543
620
|
columns: string[];
|
|
621
|
+
name?: string | undefined;
|
|
544
622
|
}>;
|
|
623
|
+
uniqueConstraints?: Record<string, {
|
|
624
|
+
name: string;
|
|
625
|
+
columns: string[];
|
|
626
|
+
}> | undefined;
|
|
545
627
|
}>>;
|
|
546
628
|
enums: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
|
|
547
629
|
_meta: zod.ZodObject<{
|
|
@@ -561,31 +643,31 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
561
643
|
tables: Record<string, {
|
|
562
644
|
name: string;
|
|
563
645
|
columns: Record<string, {
|
|
564
|
-
default?: any;
|
|
565
|
-
autoincrement?: boolean | undefined;
|
|
566
646
|
type: string;
|
|
567
647
|
name: string;
|
|
568
648
|
primaryKey: boolean;
|
|
569
649
|
notNull: boolean;
|
|
650
|
+
default?: any;
|
|
651
|
+
autoincrement?: boolean | undefined;
|
|
570
652
|
}>;
|
|
571
653
|
indexes: Record<string, {
|
|
572
|
-
where?: string | undefined;
|
|
573
654
|
name: string;
|
|
574
655
|
columns: string[];
|
|
575
656
|
isUnique: boolean;
|
|
657
|
+
where?: string | undefined;
|
|
576
658
|
}>;
|
|
577
659
|
foreignKeys: Record<string, {
|
|
578
|
-
onUpdate?: string | undefined;
|
|
579
|
-
onDelete?: string | undefined;
|
|
580
660
|
name: string;
|
|
581
661
|
tableFrom: string;
|
|
582
662
|
columnsFrom: string[];
|
|
583
663
|
tableTo: string;
|
|
584
664
|
columnsTo: string[];
|
|
665
|
+
onUpdate?: string | undefined;
|
|
666
|
+
onDelete?: string | undefined;
|
|
585
667
|
}>;
|
|
586
668
|
compositePrimaryKeys: Record<string, {
|
|
587
|
-
name?: string | undefined;
|
|
588
669
|
columns: string[];
|
|
670
|
+
name?: string | undefined;
|
|
589
671
|
}>;
|
|
590
672
|
uniqueConstraints: Record<string, {
|
|
591
673
|
name: string;
|
|
@@ -603,38 +685,38 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
603
685
|
enums: {};
|
|
604
686
|
}, {
|
|
605
687
|
tables: Record<string, {
|
|
606
|
-
uniqueConstraints?: Record<string, {
|
|
607
|
-
name: string;
|
|
608
|
-
columns: string[];
|
|
609
|
-
}> | undefined;
|
|
610
688
|
name: string;
|
|
611
689
|
columns: Record<string, {
|
|
612
|
-
default?: any;
|
|
613
|
-
autoincrement?: boolean | undefined;
|
|
614
690
|
type: string;
|
|
615
691
|
name: string;
|
|
616
692
|
primaryKey: boolean;
|
|
617
693
|
notNull: boolean;
|
|
694
|
+
default?: any;
|
|
695
|
+
autoincrement?: boolean | undefined;
|
|
618
696
|
}>;
|
|
619
697
|
indexes: Record<string, {
|
|
620
|
-
where?: string | undefined;
|
|
621
698
|
name: string;
|
|
622
699
|
columns: string[];
|
|
623
700
|
isUnique: boolean;
|
|
701
|
+
where?: string | undefined;
|
|
624
702
|
}>;
|
|
625
703
|
foreignKeys: Record<string, {
|
|
626
|
-
onUpdate?: string | undefined;
|
|
627
|
-
onDelete?: string | undefined;
|
|
628
704
|
name: string;
|
|
629
705
|
tableFrom: string;
|
|
630
706
|
columnsFrom: string[];
|
|
631
707
|
tableTo: string;
|
|
632
708
|
columnsTo: string[];
|
|
709
|
+
onUpdate?: string | undefined;
|
|
710
|
+
onDelete?: string | undefined;
|
|
633
711
|
}>;
|
|
634
712
|
compositePrimaryKeys: Record<string, {
|
|
635
|
-
name?: string | undefined;
|
|
636
713
|
columns: string[];
|
|
714
|
+
name?: string | undefined;
|
|
637
715
|
}>;
|
|
716
|
+
uniqueConstraints?: Record<string, {
|
|
717
|
+
name: string;
|
|
718
|
+
columns: string[];
|
|
719
|
+
}> | undefined;
|
|
638
720
|
}>;
|
|
639
721
|
id: string;
|
|
640
722
|
prevId: string;
|
|
@@ -648,7 +730,7 @@ declare const schema$1: zod.ZodObject<zod.extendShape<{
|
|
|
648
730
|
}>;
|
|
649
731
|
type SQLiteSchema = TypeOf<typeof schema$1>;
|
|
650
732
|
|
|
651
|
-
declare const schema: zod.ZodObject<zod.extendShape<{
|
|
733
|
+
declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
652
734
|
version: zod.ZodLiteral<"5">;
|
|
653
735
|
dialect: zod.ZodLiteral<"mysql">;
|
|
654
736
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -662,21 +744,21 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
662
744
|
default: zod.ZodOptional<zod.ZodAny>;
|
|
663
745
|
onUpdate: zod.ZodOptional<zod.ZodAny>;
|
|
664
746
|
}, "strict", zod.ZodTypeAny, {
|
|
665
|
-
default?: any;
|
|
666
|
-
onUpdate?: any;
|
|
667
|
-
autoincrement?: boolean | undefined;
|
|
668
747
|
type: string;
|
|
669
748
|
name: string;
|
|
670
749
|
primaryKey: boolean;
|
|
671
750
|
notNull: boolean;
|
|
672
|
-
}, {
|
|
673
751
|
default?: any;
|
|
674
752
|
onUpdate?: any;
|
|
675
753
|
autoincrement?: boolean | undefined;
|
|
754
|
+
}, {
|
|
676
755
|
type: string;
|
|
677
756
|
name: string;
|
|
678
757
|
primaryKey: boolean;
|
|
679
758
|
notNull: boolean;
|
|
759
|
+
default?: any;
|
|
760
|
+
onUpdate?: any;
|
|
761
|
+
autoincrement?: boolean | undefined;
|
|
680
762
|
}>>;
|
|
681
763
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
682
764
|
name: zod.ZodString;
|
|
@@ -686,19 +768,19 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
686
768
|
algorithm: zod.ZodOptional<zod.ZodEnum<["default", "inplace", "copy"]>>;
|
|
687
769
|
lock: zod.ZodOptional<zod.ZodEnum<["default", "none", "shared", "exclusive"]>>;
|
|
688
770
|
}, "strict", zod.ZodTypeAny, {
|
|
689
|
-
using?: "btree" | "hash" | undefined;
|
|
690
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
691
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
692
771
|
name: string;
|
|
693
772
|
columns: string[];
|
|
694
773
|
isUnique: boolean;
|
|
695
|
-
}, {
|
|
696
774
|
using?: "btree" | "hash" | undefined;
|
|
697
775
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
698
776
|
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
777
|
+
}, {
|
|
699
778
|
name: string;
|
|
700
779
|
columns: string[];
|
|
701
780
|
isUnique: boolean;
|
|
781
|
+
using?: "btree" | "hash" | undefined;
|
|
782
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
783
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
702
784
|
}>>;
|
|
703
785
|
foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
704
786
|
name: zod.ZodString;
|
|
@@ -709,21 +791,21 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
709
791
|
onUpdate: zod.ZodOptional<zod.ZodString>;
|
|
710
792
|
onDelete: zod.ZodOptional<zod.ZodString>;
|
|
711
793
|
}, "strict", zod.ZodTypeAny, {
|
|
712
|
-
onUpdate?: string | undefined;
|
|
713
|
-
onDelete?: string | undefined;
|
|
714
794
|
name: string;
|
|
715
795
|
tableFrom: string;
|
|
716
796
|
columnsFrom: string[];
|
|
717
797
|
tableTo: string;
|
|
718
798
|
columnsTo: string[];
|
|
719
|
-
}, {
|
|
720
799
|
onUpdate?: string | undefined;
|
|
721
800
|
onDelete?: string | undefined;
|
|
801
|
+
}, {
|
|
722
802
|
name: string;
|
|
723
803
|
tableFrom: string;
|
|
724
804
|
columnsFrom: string[];
|
|
725
805
|
tableTo: string;
|
|
726
806
|
columnsTo: string[];
|
|
807
|
+
onUpdate?: string | undefined;
|
|
808
|
+
onDelete?: string | undefined;
|
|
727
809
|
}>>;
|
|
728
810
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
729
811
|
name: zod.ZodString;
|
|
@@ -748,30 +830,30 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
748
830
|
}, "strict", zod.ZodTypeAny, {
|
|
749
831
|
name: string;
|
|
750
832
|
columns: Record<string, {
|
|
751
|
-
default?: any;
|
|
752
|
-
onUpdate?: any;
|
|
753
|
-
autoincrement?: boolean | undefined;
|
|
754
833
|
type: string;
|
|
755
834
|
name: string;
|
|
756
835
|
primaryKey: boolean;
|
|
757
836
|
notNull: boolean;
|
|
837
|
+
default?: any;
|
|
838
|
+
onUpdate?: any;
|
|
839
|
+
autoincrement?: boolean | undefined;
|
|
758
840
|
}>;
|
|
759
841
|
indexes: Record<string, {
|
|
760
|
-
using?: "btree" | "hash" | undefined;
|
|
761
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
762
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
763
842
|
name: string;
|
|
764
843
|
columns: string[];
|
|
765
844
|
isUnique: boolean;
|
|
845
|
+
using?: "btree" | "hash" | undefined;
|
|
846
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
847
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
766
848
|
}>;
|
|
767
849
|
foreignKeys: Record<string, {
|
|
768
|
-
onUpdate?: string | undefined;
|
|
769
|
-
onDelete?: string | undefined;
|
|
770
850
|
name: string;
|
|
771
851
|
tableFrom: string;
|
|
772
852
|
columnsFrom: string[];
|
|
773
853
|
tableTo: string;
|
|
774
854
|
columnsTo: string[];
|
|
855
|
+
onUpdate?: string | undefined;
|
|
856
|
+
onDelete?: string | undefined;
|
|
775
857
|
}>;
|
|
776
858
|
compositePrimaryKeys: Record<string, {
|
|
777
859
|
name: string;
|
|
@@ -782,41 +864,41 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
782
864
|
columns: string[];
|
|
783
865
|
}>;
|
|
784
866
|
}, {
|
|
785
|
-
uniqueConstraints?: Record<string, {
|
|
786
|
-
name: string;
|
|
787
|
-
columns: string[];
|
|
788
|
-
}> | undefined;
|
|
789
867
|
name: string;
|
|
790
868
|
columns: Record<string, {
|
|
791
|
-
default?: any;
|
|
792
|
-
onUpdate?: any;
|
|
793
|
-
autoincrement?: boolean | undefined;
|
|
794
869
|
type: string;
|
|
795
870
|
name: string;
|
|
796
871
|
primaryKey: boolean;
|
|
797
872
|
notNull: boolean;
|
|
873
|
+
default?: any;
|
|
874
|
+
onUpdate?: any;
|
|
875
|
+
autoincrement?: boolean | undefined;
|
|
798
876
|
}>;
|
|
799
877
|
indexes: Record<string, {
|
|
800
|
-
using?: "btree" | "hash" | undefined;
|
|
801
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
802
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
803
878
|
name: string;
|
|
804
879
|
columns: string[];
|
|
805
880
|
isUnique: boolean;
|
|
881
|
+
using?: "btree" | "hash" | undefined;
|
|
882
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
883
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
806
884
|
}>;
|
|
807
885
|
foreignKeys: Record<string, {
|
|
808
|
-
onUpdate?: string | undefined;
|
|
809
|
-
onDelete?: string | undefined;
|
|
810
886
|
name: string;
|
|
811
887
|
tableFrom: string;
|
|
812
888
|
columnsFrom: string[];
|
|
813
889
|
tableTo: string;
|
|
814
890
|
columnsTo: string[];
|
|
891
|
+
onUpdate?: string | undefined;
|
|
892
|
+
onDelete?: string | undefined;
|
|
815
893
|
}>;
|
|
816
894
|
compositePrimaryKeys: Record<string, {
|
|
817
895
|
name: string;
|
|
818
896
|
columns: string[];
|
|
819
897
|
}>;
|
|
898
|
+
uniqueConstraints?: Record<string, {
|
|
899
|
+
name: string;
|
|
900
|
+
columns: string[];
|
|
901
|
+
}> | undefined;
|
|
820
902
|
}>>;
|
|
821
903
|
_meta: zod.ZodObject<{
|
|
822
904
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
@@ -863,40 +945,33 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
863
945
|
id: zod.ZodString;
|
|
864
946
|
prevId: zod.ZodString;
|
|
865
947
|
}>, "strip", zod.ZodTypeAny, {
|
|
866
|
-
internal?: {
|
|
867
|
-
tables: Record<string, {
|
|
868
|
-
columns: Record<string, {
|
|
869
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
870
|
-
} | undefined>;
|
|
871
|
-
} | undefined>;
|
|
872
|
-
} | undefined;
|
|
873
948
|
tables: Record<string, {
|
|
874
949
|
name: string;
|
|
875
950
|
columns: Record<string, {
|
|
876
|
-
default?: any;
|
|
877
|
-
onUpdate?: any;
|
|
878
|
-
autoincrement?: boolean | undefined;
|
|
879
951
|
type: string;
|
|
880
952
|
name: string;
|
|
881
953
|
primaryKey: boolean;
|
|
882
954
|
notNull: boolean;
|
|
955
|
+
default?: any;
|
|
956
|
+
onUpdate?: any;
|
|
957
|
+
autoincrement?: boolean | undefined;
|
|
883
958
|
}>;
|
|
884
959
|
indexes: Record<string, {
|
|
885
|
-
using?: "btree" | "hash" | undefined;
|
|
886
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
887
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
888
960
|
name: string;
|
|
889
961
|
columns: string[];
|
|
890
962
|
isUnique: boolean;
|
|
963
|
+
using?: "btree" | "hash" | undefined;
|
|
964
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
965
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
891
966
|
}>;
|
|
892
967
|
foreignKeys: Record<string, {
|
|
893
|
-
onUpdate?: string | undefined;
|
|
894
|
-
onDelete?: string | undefined;
|
|
895
968
|
name: string;
|
|
896
969
|
tableFrom: string;
|
|
897
970
|
columnsFrom: string[];
|
|
898
971
|
tableTo: string;
|
|
899
972
|
columnsTo: string[];
|
|
973
|
+
onUpdate?: string | undefined;
|
|
974
|
+
onDelete?: string | undefined;
|
|
900
975
|
}>;
|
|
901
976
|
compositePrimaryKeys: Record<string, {
|
|
902
977
|
name: string;
|
|
@@ -915,7 +990,6 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
915
990
|
columns: Record<string, string>;
|
|
916
991
|
tables: Record<string, string>;
|
|
917
992
|
};
|
|
918
|
-
}, {
|
|
919
993
|
internal?: {
|
|
920
994
|
tables: Record<string, {
|
|
921
995
|
columns: Record<string, {
|
|
@@ -923,42 +997,43 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
923
997
|
} | undefined>;
|
|
924
998
|
} | undefined>;
|
|
925
999
|
} | undefined;
|
|
1000
|
+
}, {
|
|
926
1001
|
tables: Record<string, {
|
|
927
|
-
uniqueConstraints?: Record<string, {
|
|
928
|
-
name: string;
|
|
929
|
-
columns: string[];
|
|
930
|
-
}> | undefined;
|
|
931
1002
|
name: string;
|
|
932
1003
|
columns: Record<string, {
|
|
933
|
-
default?: any;
|
|
934
|
-
onUpdate?: any;
|
|
935
|
-
autoincrement?: boolean | undefined;
|
|
936
1004
|
type: string;
|
|
937
1005
|
name: string;
|
|
938
1006
|
primaryKey: boolean;
|
|
939
1007
|
notNull: boolean;
|
|
1008
|
+
default?: any;
|
|
1009
|
+
onUpdate?: any;
|
|
1010
|
+
autoincrement?: boolean | undefined;
|
|
940
1011
|
}>;
|
|
941
1012
|
indexes: Record<string, {
|
|
942
|
-
using?: "btree" | "hash" | undefined;
|
|
943
|
-
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
944
|
-
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
945
1013
|
name: string;
|
|
946
1014
|
columns: string[];
|
|
947
1015
|
isUnique: boolean;
|
|
1016
|
+
using?: "btree" | "hash" | undefined;
|
|
1017
|
+
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1018
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
948
1019
|
}>;
|
|
949
1020
|
foreignKeys: Record<string, {
|
|
950
|
-
onUpdate?: string | undefined;
|
|
951
|
-
onDelete?: string | undefined;
|
|
952
1021
|
name: string;
|
|
953
1022
|
tableFrom: string;
|
|
954
1023
|
columnsFrom: string[];
|
|
955
1024
|
tableTo: string;
|
|
956
1025
|
columnsTo: string[];
|
|
1026
|
+
onUpdate?: string | undefined;
|
|
1027
|
+
onDelete?: string | undefined;
|
|
957
1028
|
}>;
|
|
958
1029
|
compositePrimaryKeys: Record<string, {
|
|
959
1030
|
name: string;
|
|
960
1031
|
columns: string[];
|
|
961
1032
|
}>;
|
|
1033
|
+
uniqueConstraints?: Record<string, {
|
|
1034
|
+
name: string;
|
|
1035
|
+
columns: string[];
|
|
1036
|
+
}> | undefined;
|
|
962
1037
|
}>;
|
|
963
1038
|
id: string;
|
|
964
1039
|
prevId: string;
|
|
@@ -968,6 +1043,13 @@ declare const schema: zod.ZodObject<zod.extendShape<{
|
|
|
968
1043
|
columns: Record<string, string>;
|
|
969
1044
|
tables: Record<string, string>;
|
|
970
1045
|
};
|
|
1046
|
+
internal?: {
|
|
1047
|
+
tables: Record<string, {
|
|
1048
|
+
columns: Record<string, {
|
|
1049
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
1050
|
+
} | undefined>;
|
|
1051
|
+
} | undefined>;
|
|
1052
|
+
} | undefined;
|
|
971
1053
|
}>;
|
|
972
1054
|
type MySqlSchema = TypeOf<typeof schema>;
|
|
973
1055
|
|
|
@@ -999,45 +1081,40 @@ declare const pushMySQLSchema: (imports: Record<string, unknown>, drizzleInstanc
|
|
|
999
1081
|
apply: () => Promise<void>;
|
|
1000
1082
|
}>;
|
|
1001
1083
|
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
1084
|
version: "6";
|
|
1012
1085
|
dialect: "postgresql";
|
|
1013
1086
|
tables: Record<string, {
|
|
1014
1087
|
name: string;
|
|
1015
1088
|
schema: string;
|
|
1016
1089
|
columns: Record<string, {
|
|
1090
|
+
type: string;
|
|
1091
|
+
name: string;
|
|
1092
|
+
primaryKey: boolean;
|
|
1093
|
+
notNull: boolean;
|
|
1017
1094
|
typeSchema?: string | undefined;
|
|
1018
1095
|
default?: any;
|
|
1019
1096
|
isUnique?: any;
|
|
1020
1097
|
uniqueName?: string | undefined;
|
|
1021
1098
|
nullsNotDistinct?: boolean | undefined;
|
|
1022
|
-
type: string;
|
|
1023
|
-
name: string;
|
|
1024
|
-
primaryKey: boolean;
|
|
1025
|
-
notNull: boolean;
|
|
1026
1099
|
}>;
|
|
1027
1100
|
indexes: Record<string, {
|
|
1028
1101
|
name: string;
|
|
1029
1102
|
columns: string[];
|
|
1030
1103
|
isUnique: boolean;
|
|
1104
|
+
method: string;
|
|
1105
|
+
concurrently: boolean;
|
|
1106
|
+
with?: Record<string, string> | undefined;
|
|
1107
|
+
where?: string | undefined;
|
|
1031
1108
|
}>;
|
|
1032
1109
|
foreignKeys: Record<string, {
|
|
1033
|
-
schemaTo?: string | undefined;
|
|
1034
|
-
onUpdate?: string | undefined;
|
|
1035
|
-
onDelete?: string | undefined;
|
|
1036
1110
|
name: string;
|
|
1037
1111
|
tableFrom: string;
|
|
1038
1112
|
columnsFrom: string[];
|
|
1039
1113
|
tableTo: string;
|
|
1040
1114
|
columnsTo: string[];
|
|
1115
|
+
schemaTo?: string | undefined;
|
|
1116
|
+
onUpdate?: string | undefined;
|
|
1117
|
+
onDelete?: string | undefined;
|
|
1041
1118
|
}>;
|
|
1042
1119
|
compositePrimaryKeys: Record<string, {
|
|
1043
1120
|
name: string;
|
|
@@ -1062,6 +1139,15 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
|
|
|
1062
1139
|
};
|
|
1063
1140
|
id: string;
|
|
1064
1141
|
prevId: string;
|
|
1142
|
+
internal?: {
|
|
1143
|
+
tables: Record<string, {
|
|
1144
|
+
columns: Record<string, {
|
|
1145
|
+
isArray?: boolean | undefined;
|
|
1146
|
+
dimensions?: number | undefined;
|
|
1147
|
+
rawType?: string | undefined;
|
|
1148
|
+
} | undefined>;
|
|
1149
|
+
} | undefined>;
|
|
1150
|
+
} | undefined;
|
|
1065
1151
|
};
|
|
1066
1152
|
|
|
1067
1153
|
export { type DrizzleMySQLSnapshotJSON, type DrizzleSQLiteSnapshotJSON, type DrizzleSnapshotJSON, generateDrizzleJson, generateMigration, generateMySQLDrizzleJson, generateMySQLMigration, generateSQLiteDrizzleJson, generateSQLiteMigration, pushMySQLSchema, pushSQLiteSchema, pushSchema, upPgSnapshot };
|