drizzle-kit 0.30.6 → 0.31.0
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/api.d.mts +393 -393
- package/api.d.ts +393 -393
- package/api.js +1638 -1329
- package/api.mjs +1641 -1332
- package/bin.cjs +18883 -18385
- package/index.js +3 -3
- package/package.json +6 -6
- package/utils.js +193 -75
- package/utils.mjs +194 -77
package/api.d.mts
CHANGED
|
@@ -31,29 +31,29 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
31
31
|
as: string;
|
|
32
32
|
}>>;
|
|
33
33
|
}, "strict", zod.ZodTypeAny, {
|
|
34
|
-
name: string;
|
|
35
34
|
type: string;
|
|
35
|
+
name: string;
|
|
36
36
|
primaryKey: boolean;
|
|
37
37
|
notNull: boolean;
|
|
38
38
|
default?: any;
|
|
39
|
-
onUpdate?: any;
|
|
40
|
-
autoincrement?: boolean | undefined;
|
|
41
39
|
generated?: {
|
|
42
40
|
type: "stored" | "virtual";
|
|
43
41
|
as: string;
|
|
44
42
|
} | undefined;
|
|
43
|
+
onUpdate?: any;
|
|
44
|
+
autoincrement?: boolean | undefined;
|
|
45
45
|
}, {
|
|
46
|
-
name: string;
|
|
47
46
|
type: string;
|
|
47
|
+
name: string;
|
|
48
48
|
primaryKey: boolean;
|
|
49
49
|
notNull: boolean;
|
|
50
50
|
default?: any;
|
|
51
|
-
onUpdate?: any;
|
|
52
|
-
autoincrement?: boolean | undefined;
|
|
53
51
|
generated?: {
|
|
54
52
|
type: "stored" | "virtual";
|
|
55
53
|
as: string;
|
|
56
54
|
} | undefined;
|
|
55
|
+
onUpdate?: any;
|
|
56
|
+
autoincrement?: boolean | undefined;
|
|
57
57
|
}>>;
|
|
58
58
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
59
59
|
name: zod.ZodString;
|
|
@@ -68,14 +68,14 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
68
68
|
isUnique: boolean;
|
|
69
69
|
using?: "btree" | "hash" | undefined;
|
|
70
70
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
71
|
-
lock?: "
|
|
71
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
72
72
|
}, {
|
|
73
73
|
name: string;
|
|
74
74
|
columns: string[];
|
|
75
75
|
isUnique: boolean;
|
|
76
76
|
using?: "btree" | "hash" | undefined;
|
|
77
77
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
78
|
-
lock?: "
|
|
78
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
79
79
|
}>>;
|
|
80
80
|
foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
81
81
|
name: zod.ZodString;
|
|
@@ -126,26 +126,26 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
126
126
|
name: zod.ZodString;
|
|
127
127
|
value: zod.ZodString;
|
|
128
128
|
}, "strict", zod.ZodTypeAny, {
|
|
129
|
-
name: string;
|
|
130
129
|
value: string;
|
|
131
|
-
}, {
|
|
132
130
|
name: string;
|
|
131
|
+
}, {
|
|
133
132
|
value: string;
|
|
133
|
+
name: string;
|
|
134
134
|
}>>>;
|
|
135
135
|
}, "strict", zod.ZodTypeAny, {
|
|
136
136
|
name: string;
|
|
137
137
|
columns: Record<string, {
|
|
138
|
-
name: string;
|
|
139
138
|
type: string;
|
|
139
|
+
name: string;
|
|
140
140
|
primaryKey: boolean;
|
|
141
141
|
notNull: boolean;
|
|
142
142
|
default?: any;
|
|
143
|
-
onUpdate?: any;
|
|
144
|
-
autoincrement?: boolean | undefined;
|
|
145
143
|
generated?: {
|
|
146
144
|
type: "stored" | "virtual";
|
|
147
145
|
as: string;
|
|
148
146
|
} | undefined;
|
|
147
|
+
onUpdate?: any;
|
|
148
|
+
autoincrement?: boolean | undefined;
|
|
149
149
|
}>;
|
|
150
150
|
indexes: Record<string, {
|
|
151
151
|
name: string;
|
|
@@ -153,7 +153,7 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
153
153
|
isUnique: boolean;
|
|
154
154
|
using?: "btree" | "hash" | undefined;
|
|
155
155
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
156
|
-
lock?: "
|
|
156
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
157
157
|
}>;
|
|
158
158
|
foreignKeys: Record<string, {
|
|
159
159
|
name: string;
|
|
@@ -173,23 +173,23 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
173
173
|
columns: string[];
|
|
174
174
|
}>;
|
|
175
175
|
checkConstraint: Record<string, {
|
|
176
|
-
name: string;
|
|
177
176
|
value: string;
|
|
177
|
+
name: string;
|
|
178
178
|
}>;
|
|
179
179
|
}, {
|
|
180
180
|
name: string;
|
|
181
181
|
columns: Record<string, {
|
|
182
|
-
name: string;
|
|
183
182
|
type: string;
|
|
183
|
+
name: string;
|
|
184
184
|
primaryKey: boolean;
|
|
185
185
|
notNull: boolean;
|
|
186
186
|
default?: any;
|
|
187
|
-
onUpdate?: any;
|
|
188
|
-
autoincrement?: boolean | undefined;
|
|
189
187
|
generated?: {
|
|
190
188
|
type: "stored" | "virtual";
|
|
191
189
|
as: string;
|
|
192
190
|
} | undefined;
|
|
191
|
+
onUpdate?: any;
|
|
192
|
+
autoincrement?: boolean | undefined;
|
|
193
193
|
}>;
|
|
194
194
|
indexes: Record<string, {
|
|
195
195
|
name: string;
|
|
@@ -197,7 +197,7 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
197
197
|
isUnique: boolean;
|
|
198
198
|
using?: "btree" | "hash" | undefined;
|
|
199
199
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
200
|
-
lock?: "
|
|
200
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
201
201
|
}>;
|
|
202
202
|
foreignKeys: Record<string, {
|
|
203
203
|
name: string;
|
|
@@ -217,8 +217,8 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
217
217
|
columns: string[];
|
|
218
218
|
}> | undefined;
|
|
219
219
|
checkConstraint?: Record<string, {
|
|
220
|
-
name: string;
|
|
221
220
|
value: string;
|
|
221
|
+
name: string;
|
|
222
222
|
}> | undefined;
|
|
223
223
|
}>>;
|
|
224
224
|
views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<zod.objectUtil.extendShape<{
|
|
@@ -242,29 +242,29 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
242
242
|
as: string;
|
|
243
243
|
}>>;
|
|
244
244
|
}, "strict", zod.ZodTypeAny, {
|
|
245
|
-
name: string;
|
|
246
245
|
type: string;
|
|
246
|
+
name: string;
|
|
247
247
|
primaryKey: boolean;
|
|
248
248
|
notNull: boolean;
|
|
249
249
|
default?: any;
|
|
250
|
-
onUpdate?: any;
|
|
251
|
-
autoincrement?: boolean | undefined;
|
|
252
250
|
generated?: {
|
|
253
251
|
type: "stored" | "virtual";
|
|
254
252
|
as: string;
|
|
255
253
|
} | undefined;
|
|
254
|
+
onUpdate?: any;
|
|
255
|
+
autoincrement?: boolean | undefined;
|
|
256
256
|
}, {
|
|
257
|
-
name: string;
|
|
258
257
|
type: string;
|
|
258
|
+
name: string;
|
|
259
259
|
primaryKey: boolean;
|
|
260
260
|
notNull: boolean;
|
|
261
261
|
default?: any;
|
|
262
|
-
onUpdate?: any;
|
|
263
|
-
autoincrement?: boolean | undefined;
|
|
264
262
|
generated?: {
|
|
265
263
|
type: "stored" | "virtual";
|
|
266
264
|
as: string;
|
|
267
265
|
} | undefined;
|
|
266
|
+
onUpdate?: any;
|
|
267
|
+
autoincrement?: boolean | undefined;
|
|
268
268
|
}>>;
|
|
269
269
|
definition: zod.ZodOptional<zod.ZodString>;
|
|
270
270
|
isExisting: zod.ZodBoolean;
|
|
@@ -275,53 +275,53 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
275
275
|
}>, "strict", zod.ZodTypeAny, {
|
|
276
276
|
name: string;
|
|
277
277
|
columns: Record<string, {
|
|
278
|
-
name: string;
|
|
279
278
|
type: string;
|
|
279
|
+
name: string;
|
|
280
280
|
primaryKey: boolean;
|
|
281
281
|
notNull: boolean;
|
|
282
282
|
default?: any;
|
|
283
|
-
onUpdate?: any;
|
|
284
|
-
autoincrement?: boolean | undefined;
|
|
285
283
|
generated?: {
|
|
286
284
|
type: "stored" | "virtual";
|
|
287
285
|
as: string;
|
|
288
286
|
} | undefined;
|
|
287
|
+
onUpdate?: any;
|
|
288
|
+
autoincrement?: boolean | undefined;
|
|
289
289
|
}>;
|
|
290
|
+
isExisting: boolean;
|
|
290
291
|
algorithm: "undefined" | "merge" | "temptable";
|
|
291
292
|
sqlSecurity: "definer" | "invoker";
|
|
292
|
-
isExisting: boolean;
|
|
293
|
-
withCheckOption?: "local" | "cascaded" | undefined;
|
|
294
293
|
definition?: string | undefined;
|
|
294
|
+
withCheckOption?: "local" | "cascaded" | undefined;
|
|
295
295
|
}, {
|
|
296
296
|
name: string;
|
|
297
297
|
columns: Record<string, {
|
|
298
|
-
name: string;
|
|
299
298
|
type: string;
|
|
299
|
+
name: string;
|
|
300
300
|
primaryKey: boolean;
|
|
301
301
|
notNull: boolean;
|
|
302
302
|
default?: any;
|
|
303
|
-
onUpdate?: any;
|
|
304
|
-
autoincrement?: boolean | undefined;
|
|
305
303
|
generated?: {
|
|
306
304
|
type: "stored" | "virtual";
|
|
307
305
|
as: string;
|
|
308
306
|
} | undefined;
|
|
307
|
+
onUpdate?: any;
|
|
308
|
+
autoincrement?: boolean | undefined;
|
|
309
309
|
}>;
|
|
310
|
+
isExisting: boolean;
|
|
310
311
|
algorithm: "undefined" | "merge" | "temptable";
|
|
311
312
|
sqlSecurity: "definer" | "invoker";
|
|
312
|
-
isExisting: boolean;
|
|
313
|
-
withCheckOption?: "local" | "cascaded" | undefined;
|
|
314
313
|
definition?: string | undefined;
|
|
314
|
+
withCheckOption?: "local" | "cascaded" | undefined;
|
|
315
315
|
}>>>;
|
|
316
316
|
_meta: zod.ZodObject<{
|
|
317
317
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
318
318
|
columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
319
319
|
}, "strip", zod.ZodTypeAny, {
|
|
320
|
-
columns: Record<string, string>;
|
|
321
320
|
tables: Record<string, string>;
|
|
322
|
-
}, {
|
|
323
321
|
columns: Record<string, string>;
|
|
322
|
+
}, {
|
|
324
323
|
tables: Record<string, string>;
|
|
324
|
+
columns: Record<string, string>;
|
|
325
325
|
}>;
|
|
326
326
|
internal: zod.ZodOptional<zod.ZodObject<{
|
|
327
327
|
tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
|
|
@@ -359,46 +359,48 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
359
359
|
} | undefined>;
|
|
360
360
|
}>>>>;
|
|
361
361
|
}, "strip", zod.ZodTypeAny, {
|
|
362
|
-
indexes?: Record<string, {
|
|
363
|
-
columns: Record<string, {
|
|
364
|
-
isExpression?: boolean | undefined;
|
|
365
|
-
} | undefined>;
|
|
366
|
-
} | undefined> | undefined;
|
|
367
362
|
tables?: Record<string, {
|
|
368
363
|
columns: Record<string, {
|
|
369
364
|
isDefaultAnExpression?: boolean | undefined;
|
|
370
365
|
} | undefined>;
|
|
371
366
|
} | undefined> | undefined;
|
|
372
|
-
}, {
|
|
373
367
|
indexes?: Record<string, {
|
|
374
368
|
columns: Record<string, {
|
|
375
369
|
isExpression?: boolean | undefined;
|
|
376
370
|
} | undefined>;
|
|
377
371
|
} | undefined> | undefined;
|
|
372
|
+
}, {
|
|
378
373
|
tables?: Record<string, {
|
|
379
374
|
columns: Record<string, {
|
|
380
375
|
isDefaultAnExpression?: boolean | undefined;
|
|
381
376
|
} | undefined>;
|
|
382
377
|
} | undefined> | undefined;
|
|
378
|
+
indexes?: Record<string, {
|
|
379
|
+
columns: Record<string, {
|
|
380
|
+
isExpression?: boolean | undefined;
|
|
381
|
+
} | undefined>;
|
|
382
|
+
} | undefined> | undefined;
|
|
383
383
|
}>>;
|
|
384
384
|
}, {
|
|
385
385
|
id: zod.ZodString;
|
|
386
386
|
prevId: zod.ZodString;
|
|
387
387
|
}>, "strip", zod.ZodTypeAny, {
|
|
388
|
+
version: "5";
|
|
389
|
+
dialect: "mysql";
|
|
388
390
|
tables: Record<string, {
|
|
389
391
|
name: string;
|
|
390
392
|
columns: Record<string, {
|
|
391
|
-
name: string;
|
|
392
393
|
type: string;
|
|
394
|
+
name: string;
|
|
393
395
|
primaryKey: boolean;
|
|
394
396
|
notNull: boolean;
|
|
395
397
|
default?: any;
|
|
396
|
-
onUpdate?: any;
|
|
397
|
-
autoincrement?: boolean | undefined;
|
|
398
398
|
generated?: {
|
|
399
399
|
type: "stored" | "virtual";
|
|
400
400
|
as: string;
|
|
401
401
|
} | undefined;
|
|
402
|
+
onUpdate?: any;
|
|
403
|
+
autoincrement?: boolean | undefined;
|
|
402
404
|
}>;
|
|
403
405
|
indexes: Record<string, {
|
|
404
406
|
name: string;
|
|
@@ -406,7 +408,7 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
406
408
|
isUnique: boolean;
|
|
407
409
|
using?: "btree" | "hash" | undefined;
|
|
408
410
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
409
|
-
lock?: "
|
|
411
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
410
412
|
}>;
|
|
411
413
|
foreignKeys: Record<string, {
|
|
412
414
|
name: string;
|
|
@@ -426,66 +428,66 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
426
428
|
columns: string[];
|
|
427
429
|
}>;
|
|
428
430
|
checkConstraint: Record<string, {
|
|
429
|
-
name: string;
|
|
430
431
|
value: string;
|
|
432
|
+
name: string;
|
|
431
433
|
}>;
|
|
432
434
|
}>;
|
|
433
|
-
id: string;
|
|
434
|
-
prevId: string;
|
|
435
|
-
version: "5";
|
|
436
|
-
dialect: "mysql";
|
|
437
|
-
_meta: {
|
|
438
|
-
columns: Record<string, string>;
|
|
439
|
-
tables: Record<string, string>;
|
|
440
|
-
};
|
|
441
435
|
views: Record<string, {
|
|
442
436
|
name: string;
|
|
443
437
|
columns: Record<string, {
|
|
444
|
-
name: string;
|
|
445
438
|
type: string;
|
|
439
|
+
name: string;
|
|
446
440
|
primaryKey: boolean;
|
|
447
441
|
notNull: boolean;
|
|
448
442
|
default?: any;
|
|
449
|
-
onUpdate?: any;
|
|
450
|
-
autoincrement?: boolean | undefined;
|
|
451
443
|
generated?: {
|
|
452
444
|
type: "stored" | "virtual";
|
|
453
445
|
as: string;
|
|
454
446
|
} | undefined;
|
|
447
|
+
onUpdate?: any;
|
|
448
|
+
autoincrement?: boolean | undefined;
|
|
455
449
|
}>;
|
|
450
|
+
isExisting: boolean;
|
|
456
451
|
algorithm: "undefined" | "merge" | "temptable";
|
|
457
452
|
sqlSecurity: "definer" | "invoker";
|
|
458
|
-
isExisting: boolean;
|
|
459
|
-
withCheckOption?: "local" | "cascaded" | undefined;
|
|
460
453
|
definition?: string | undefined;
|
|
454
|
+
withCheckOption?: "local" | "cascaded" | undefined;
|
|
461
455
|
}>;
|
|
456
|
+
_meta: {
|
|
457
|
+
tables: Record<string, string>;
|
|
458
|
+
columns: Record<string, string>;
|
|
459
|
+
};
|
|
460
|
+
id: string;
|
|
461
|
+
prevId: string;
|
|
462
462
|
internal?: {
|
|
463
|
-
|
|
463
|
+
tables?: Record<string, {
|
|
464
464
|
columns: Record<string, {
|
|
465
|
-
|
|
465
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
466
466
|
} | undefined>;
|
|
467
467
|
} | undefined> | undefined;
|
|
468
|
-
|
|
468
|
+
indexes?: Record<string, {
|
|
469
469
|
columns: Record<string, {
|
|
470
|
-
|
|
470
|
+
isExpression?: boolean | undefined;
|
|
471
471
|
} | undefined>;
|
|
472
472
|
} | undefined> | undefined;
|
|
473
473
|
} | undefined;
|
|
474
474
|
}, {
|
|
475
|
+
version: "5";
|
|
476
|
+
dialect: "mysql";
|
|
475
477
|
tables: Record<string, {
|
|
476
478
|
name: string;
|
|
477
479
|
columns: Record<string, {
|
|
478
|
-
name: string;
|
|
479
480
|
type: string;
|
|
481
|
+
name: string;
|
|
480
482
|
primaryKey: boolean;
|
|
481
483
|
notNull: boolean;
|
|
482
484
|
default?: any;
|
|
483
|
-
onUpdate?: any;
|
|
484
|
-
autoincrement?: boolean | undefined;
|
|
485
485
|
generated?: {
|
|
486
486
|
type: "stored" | "virtual";
|
|
487
487
|
as: string;
|
|
488
488
|
} | undefined;
|
|
489
|
+
onUpdate?: any;
|
|
490
|
+
autoincrement?: boolean | undefined;
|
|
489
491
|
}>;
|
|
490
492
|
indexes: Record<string, {
|
|
491
493
|
name: string;
|
|
@@ -493,7 +495,7 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
493
495
|
isUnique: boolean;
|
|
494
496
|
using?: "btree" | "hash" | undefined;
|
|
495
497
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
496
|
-
lock?: "
|
|
498
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
497
499
|
}>;
|
|
498
500
|
foreignKeys: Record<string, {
|
|
499
501
|
name: string;
|
|
@@ -513,51 +515,49 @@ declare const schema$2: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
513
515
|
columns: string[];
|
|
514
516
|
}> | undefined;
|
|
515
517
|
checkConstraint?: Record<string, {
|
|
516
|
-
name: string;
|
|
517
518
|
value: string;
|
|
519
|
+
name: string;
|
|
518
520
|
}> | undefined;
|
|
519
521
|
}>;
|
|
520
|
-
id: string;
|
|
521
|
-
prevId: string;
|
|
522
|
-
version: "5";
|
|
523
|
-
dialect: "mysql";
|
|
524
522
|
_meta: {
|
|
525
|
-
columns: Record<string, string>;
|
|
526
523
|
tables: Record<string, string>;
|
|
524
|
+
columns: Record<string, string>;
|
|
527
525
|
};
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
columns: Record<string, {
|
|
531
|
-
isExpression?: boolean | undefined;
|
|
532
|
-
} | undefined>;
|
|
533
|
-
} | undefined> | undefined;
|
|
534
|
-
tables?: Record<string, {
|
|
535
|
-
columns: Record<string, {
|
|
536
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
537
|
-
} | undefined>;
|
|
538
|
-
} | undefined> | undefined;
|
|
539
|
-
} | undefined;
|
|
526
|
+
id: string;
|
|
527
|
+
prevId: string;
|
|
540
528
|
views?: Record<string, {
|
|
541
529
|
name: string;
|
|
542
530
|
columns: Record<string, {
|
|
543
|
-
name: string;
|
|
544
531
|
type: string;
|
|
532
|
+
name: string;
|
|
545
533
|
primaryKey: boolean;
|
|
546
534
|
notNull: boolean;
|
|
547
535
|
default?: any;
|
|
548
|
-
onUpdate?: any;
|
|
549
|
-
autoincrement?: boolean | undefined;
|
|
550
536
|
generated?: {
|
|
551
537
|
type: "stored" | "virtual";
|
|
552
538
|
as: string;
|
|
553
539
|
} | undefined;
|
|
540
|
+
onUpdate?: any;
|
|
541
|
+
autoincrement?: boolean | undefined;
|
|
554
542
|
}>;
|
|
543
|
+
isExisting: boolean;
|
|
555
544
|
algorithm: "undefined" | "merge" | "temptable";
|
|
556
545
|
sqlSecurity: "definer" | "invoker";
|
|
557
|
-
isExisting: boolean;
|
|
558
|
-
withCheckOption?: "local" | "cascaded" | undefined;
|
|
559
546
|
definition?: string | undefined;
|
|
547
|
+
withCheckOption?: "local" | "cascaded" | undefined;
|
|
560
548
|
}> | undefined;
|
|
549
|
+
internal?: {
|
|
550
|
+
tables?: Record<string, {
|
|
551
|
+
columns: Record<string, {
|
|
552
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
553
|
+
} | undefined>;
|
|
554
|
+
} | undefined> | undefined;
|
|
555
|
+
indexes?: Record<string, {
|
|
556
|
+
columns: Record<string, {
|
|
557
|
+
isExpression?: boolean | undefined;
|
|
558
|
+
} | undefined>;
|
|
559
|
+
} | undefined> | undefined;
|
|
560
|
+
} | undefined;
|
|
561
561
|
}>;
|
|
562
562
|
type MySqlSchema = TypeOf<typeof schema$2>;
|
|
563
563
|
|
|
@@ -599,8 +599,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
599
599
|
}, {
|
|
600
600
|
type: zod.ZodEnum<["always", "byDefault"]>;
|
|
601
601
|
}>, "strip", zod.ZodTypeAny, {
|
|
602
|
-
name: string;
|
|
603
602
|
type: "always" | "byDefault";
|
|
603
|
+
name: string;
|
|
604
604
|
schema: string;
|
|
605
605
|
increment?: string | undefined;
|
|
606
606
|
minValue?: string | undefined;
|
|
@@ -609,8 +609,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
609
609
|
cache?: string | undefined;
|
|
610
610
|
cycle?: boolean | undefined;
|
|
611
611
|
}, {
|
|
612
|
-
name: string;
|
|
613
612
|
type: "always" | "byDefault";
|
|
613
|
+
name: string;
|
|
614
614
|
schema: string;
|
|
615
615
|
increment?: string | undefined;
|
|
616
616
|
minValue?: string | undefined;
|
|
@@ -620,22 +620,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
620
620
|
cycle?: boolean | undefined;
|
|
621
621
|
}>>;
|
|
622
622
|
}, "strict", zod.ZodTypeAny, {
|
|
623
|
-
name: string;
|
|
624
623
|
type: string;
|
|
624
|
+
name: string;
|
|
625
625
|
primaryKey: boolean;
|
|
626
626
|
notNull: boolean;
|
|
627
|
+
typeSchema?: string | undefined;
|
|
627
628
|
default?: any;
|
|
628
629
|
isUnique?: any;
|
|
630
|
+
uniqueName?: string | undefined;
|
|
631
|
+
nullsNotDistinct?: boolean | undefined;
|
|
629
632
|
generated?: {
|
|
630
633
|
type: "stored";
|
|
631
634
|
as: string;
|
|
632
635
|
} | undefined;
|
|
633
|
-
typeSchema?: string | undefined;
|
|
634
|
-
uniqueName?: string | undefined;
|
|
635
|
-
nullsNotDistinct?: boolean | undefined;
|
|
636
636
|
identity?: {
|
|
637
|
-
name: string;
|
|
638
637
|
type: "always" | "byDefault";
|
|
638
|
+
name: string;
|
|
639
639
|
schema: string;
|
|
640
640
|
increment?: string | undefined;
|
|
641
641
|
minValue?: string | undefined;
|
|
@@ -645,22 +645,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
645
645
|
cycle?: boolean | undefined;
|
|
646
646
|
} | undefined;
|
|
647
647
|
}, {
|
|
648
|
-
name: string;
|
|
649
648
|
type: string;
|
|
649
|
+
name: string;
|
|
650
650
|
primaryKey: boolean;
|
|
651
651
|
notNull: boolean;
|
|
652
|
+
typeSchema?: string | undefined;
|
|
652
653
|
default?: any;
|
|
653
654
|
isUnique?: any;
|
|
655
|
+
uniqueName?: string | undefined;
|
|
656
|
+
nullsNotDistinct?: boolean | undefined;
|
|
654
657
|
generated?: {
|
|
655
658
|
type: "stored";
|
|
656
659
|
as: string;
|
|
657
660
|
} | undefined;
|
|
658
|
-
typeSchema?: string | undefined;
|
|
659
|
-
uniqueName?: string | undefined;
|
|
660
|
-
nullsNotDistinct?: boolean | undefined;
|
|
661
661
|
identity?: {
|
|
662
|
-
name: string;
|
|
663
662
|
type: "always" | "byDefault";
|
|
663
|
+
name: string;
|
|
664
664
|
schema: string;
|
|
665
665
|
increment?: string | undefined;
|
|
666
666
|
minValue?: string | undefined;
|
|
@@ -679,14 +679,14 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
679
679
|
nulls: zod.ZodOptional<zod.ZodString>;
|
|
680
680
|
opclass: zod.ZodOptional<zod.ZodString>;
|
|
681
681
|
}, "strip", zod.ZodTypeAny, {
|
|
682
|
-
isExpression: boolean;
|
|
683
682
|
expression: string;
|
|
683
|
+
isExpression: boolean;
|
|
684
684
|
asc: boolean;
|
|
685
685
|
nulls?: string | undefined;
|
|
686
686
|
opclass?: string | undefined;
|
|
687
687
|
}, {
|
|
688
|
-
isExpression: boolean;
|
|
689
688
|
expression: string;
|
|
689
|
+
isExpression: boolean;
|
|
690
690
|
asc: boolean;
|
|
691
691
|
nulls?: string | undefined;
|
|
692
692
|
opclass?: string | undefined;
|
|
@@ -699,8 +699,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
699
699
|
}, "strict", zod.ZodTypeAny, {
|
|
700
700
|
name: string;
|
|
701
701
|
columns: {
|
|
702
|
-
isExpression: boolean;
|
|
703
702
|
expression: string;
|
|
703
|
+
isExpression: boolean;
|
|
704
704
|
asc: boolean;
|
|
705
705
|
nulls?: string | undefined;
|
|
706
706
|
opclass?: string | undefined;
|
|
@@ -713,8 +713,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
713
713
|
}, {
|
|
714
714
|
name: string;
|
|
715
715
|
columns: {
|
|
716
|
-
isExpression: boolean;
|
|
717
716
|
expression: string;
|
|
717
|
+
isExpression: boolean;
|
|
718
718
|
asc: boolean;
|
|
719
719
|
nulls?: string | undefined;
|
|
720
720
|
opclass?: string | undefined;
|
|
@@ -740,18 +740,18 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
740
740
|
columnsFrom: string[];
|
|
741
741
|
tableTo: string;
|
|
742
742
|
columnsTo: string[];
|
|
743
|
+
schemaTo?: string | undefined;
|
|
743
744
|
onUpdate?: string | undefined;
|
|
744
745
|
onDelete?: string | undefined;
|
|
745
|
-
schemaTo?: string | undefined;
|
|
746
746
|
}, {
|
|
747
747
|
name: string;
|
|
748
748
|
tableFrom: string;
|
|
749
749
|
columnsFrom: string[];
|
|
750
750
|
tableTo: string;
|
|
751
751
|
columnsTo: string[];
|
|
752
|
+
schemaTo?: string | undefined;
|
|
752
753
|
onUpdate?: string | undefined;
|
|
753
754
|
onDelete?: string | undefined;
|
|
754
|
-
schemaTo?: string | undefined;
|
|
755
755
|
}>>;
|
|
756
756
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
757
757
|
name: zod.ZodString;
|
|
@@ -787,20 +787,20 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
787
787
|
schema: zod.ZodOptional<zod.ZodString>;
|
|
788
788
|
}, "strict", zod.ZodTypeAny, {
|
|
789
789
|
name: string;
|
|
790
|
-
using?: string | undefined;
|
|
791
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
792
790
|
schema?: string | undefined;
|
|
791
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
793
792
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
794
793
|
to?: string[] | undefined;
|
|
794
|
+
using?: string | undefined;
|
|
795
795
|
withCheck?: string | undefined;
|
|
796
796
|
on?: string | undefined;
|
|
797
797
|
}, {
|
|
798
798
|
name: string;
|
|
799
|
-
using?: string | undefined;
|
|
800
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
801
799
|
schema?: string | undefined;
|
|
800
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
802
801
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
803
802
|
to?: string[] | undefined;
|
|
803
|
+
using?: string | undefined;
|
|
804
804
|
withCheck?: string | undefined;
|
|
805
805
|
on?: string | undefined;
|
|
806
806
|
}>>>;
|
|
@@ -808,32 +808,33 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
808
808
|
name: zod.ZodString;
|
|
809
809
|
value: zod.ZodString;
|
|
810
810
|
}, "strict", zod.ZodTypeAny, {
|
|
811
|
-
name: string;
|
|
812
811
|
value: string;
|
|
813
|
-
}, {
|
|
814
812
|
name: string;
|
|
813
|
+
}, {
|
|
815
814
|
value: string;
|
|
815
|
+
name: string;
|
|
816
816
|
}>>>;
|
|
817
817
|
isRLSEnabled: zod.ZodDefault<zod.ZodBoolean>;
|
|
818
818
|
}, "strict", zod.ZodTypeAny, {
|
|
819
819
|
name: string;
|
|
820
|
+
schema: string;
|
|
820
821
|
columns: Record<string, {
|
|
821
|
-
name: string;
|
|
822
822
|
type: string;
|
|
823
|
+
name: string;
|
|
823
824
|
primaryKey: boolean;
|
|
824
825
|
notNull: boolean;
|
|
826
|
+
typeSchema?: string | undefined;
|
|
825
827
|
default?: any;
|
|
826
828
|
isUnique?: any;
|
|
829
|
+
uniqueName?: string | undefined;
|
|
830
|
+
nullsNotDistinct?: boolean | undefined;
|
|
827
831
|
generated?: {
|
|
828
832
|
type: "stored";
|
|
829
833
|
as: string;
|
|
830
834
|
} | undefined;
|
|
831
|
-
typeSchema?: string | undefined;
|
|
832
|
-
uniqueName?: string | undefined;
|
|
833
|
-
nullsNotDistinct?: boolean | undefined;
|
|
834
835
|
identity?: {
|
|
835
|
-
name: string;
|
|
836
836
|
type: "always" | "byDefault";
|
|
837
|
+
name: string;
|
|
837
838
|
schema: string;
|
|
838
839
|
increment?: string | undefined;
|
|
839
840
|
minValue?: string | undefined;
|
|
@@ -846,8 +847,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
846
847
|
indexes: Record<string, {
|
|
847
848
|
name: string;
|
|
848
849
|
columns: {
|
|
849
|
-
isExpression: boolean;
|
|
850
850
|
expression: string;
|
|
851
|
+
isExpression: boolean;
|
|
851
852
|
asc: boolean;
|
|
852
853
|
nulls?: string | undefined;
|
|
853
854
|
opclass?: string | undefined;
|
|
@@ -864,11 +865,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
864
865
|
columnsFrom: string[];
|
|
865
866
|
tableTo: string;
|
|
866
867
|
columnsTo: string[];
|
|
868
|
+
schemaTo?: string | undefined;
|
|
867
869
|
onUpdate?: string | undefined;
|
|
868
870
|
onDelete?: string | undefined;
|
|
869
|
-
schemaTo?: string | undefined;
|
|
870
871
|
}>;
|
|
871
|
-
schema: string;
|
|
872
872
|
compositePrimaryKeys: Record<string, {
|
|
873
873
|
name: string;
|
|
874
874
|
columns: string[];
|
|
@@ -878,40 +878,41 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
878
878
|
columns: string[];
|
|
879
879
|
nullsNotDistinct: boolean;
|
|
880
880
|
}>;
|
|
881
|
-
checkConstraints: Record<string, {
|
|
882
|
-
name: string;
|
|
883
|
-
value: string;
|
|
884
|
-
}>;
|
|
885
881
|
policies: Record<string, {
|
|
886
882
|
name: string;
|
|
887
|
-
using?: string | undefined;
|
|
888
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
889
883
|
schema?: string | undefined;
|
|
884
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
890
885
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
891
886
|
to?: string[] | undefined;
|
|
887
|
+
using?: string | undefined;
|
|
892
888
|
withCheck?: string | undefined;
|
|
893
889
|
on?: string | undefined;
|
|
894
890
|
}>;
|
|
891
|
+
checkConstraints: Record<string, {
|
|
892
|
+
value: string;
|
|
893
|
+
name: string;
|
|
894
|
+
}>;
|
|
895
895
|
isRLSEnabled: boolean;
|
|
896
896
|
}, {
|
|
897
897
|
name: string;
|
|
898
|
+
schema: string;
|
|
898
899
|
columns: Record<string, {
|
|
899
|
-
name: string;
|
|
900
900
|
type: string;
|
|
901
|
+
name: string;
|
|
901
902
|
primaryKey: boolean;
|
|
902
903
|
notNull: boolean;
|
|
904
|
+
typeSchema?: string | undefined;
|
|
903
905
|
default?: any;
|
|
904
906
|
isUnique?: any;
|
|
907
|
+
uniqueName?: string | undefined;
|
|
908
|
+
nullsNotDistinct?: boolean | undefined;
|
|
905
909
|
generated?: {
|
|
906
910
|
type: "stored";
|
|
907
911
|
as: string;
|
|
908
912
|
} | undefined;
|
|
909
|
-
typeSchema?: string | undefined;
|
|
910
|
-
uniqueName?: string | undefined;
|
|
911
|
-
nullsNotDistinct?: boolean | undefined;
|
|
912
913
|
identity?: {
|
|
913
|
-
name: string;
|
|
914
914
|
type: "always" | "byDefault";
|
|
915
|
+
name: string;
|
|
915
916
|
schema: string;
|
|
916
917
|
increment?: string | undefined;
|
|
917
918
|
minValue?: string | undefined;
|
|
@@ -924,8 +925,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
924
925
|
indexes: Record<string, {
|
|
925
926
|
name: string;
|
|
926
927
|
columns: {
|
|
927
|
-
isExpression: boolean;
|
|
928
928
|
expression: string;
|
|
929
|
+
isExpression: boolean;
|
|
929
930
|
asc: boolean;
|
|
930
931
|
nulls?: string | undefined;
|
|
931
932
|
opclass?: string | undefined;
|
|
@@ -942,11 +943,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
942
943
|
columnsFrom: string[];
|
|
943
944
|
tableTo: string;
|
|
944
945
|
columnsTo: string[];
|
|
946
|
+
schemaTo?: string | undefined;
|
|
945
947
|
onUpdate?: string | undefined;
|
|
946
948
|
onDelete?: string | undefined;
|
|
947
|
-
schemaTo?: string | undefined;
|
|
948
949
|
}>;
|
|
949
|
-
schema: string;
|
|
950
950
|
compositePrimaryKeys: Record<string, {
|
|
951
951
|
name: string;
|
|
952
952
|
columns: string[];
|
|
@@ -956,20 +956,20 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
956
956
|
columns: string[];
|
|
957
957
|
nullsNotDistinct: boolean;
|
|
958
958
|
}> | undefined;
|
|
959
|
-
checkConstraints?: Record<string, {
|
|
960
|
-
name: string;
|
|
961
|
-
value: string;
|
|
962
|
-
}> | undefined;
|
|
963
959
|
policies?: Record<string, {
|
|
964
960
|
name: string;
|
|
965
|
-
using?: string | undefined;
|
|
966
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
967
961
|
schema?: string | undefined;
|
|
962
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
968
963
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
969
964
|
to?: string[] | undefined;
|
|
965
|
+
using?: string | undefined;
|
|
970
966
|
withCheck?: string | undefined;
|
|
971
967
|
on?: string | undefined;
|
|
972
968
|
}> | undefined;
|
|
969
|
+
checkConstraints?: Record<string, {
|
|
970
|
+
value: string;
|
|
971
|
+
name: string;
|
|
972
|
+
}> | undefined;
|
|
973
973
|
isRLSEnabled?: boolean | undefined;
|
|
974
974
|
}>>;
|
|
975
975
|
enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -977,12 +977,12 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
977
977
|
schema: zod.ZodString;
|
|
978
978
|
values: zod.ZodArray<zod.ZodString, "many">;
|
|
979
979
|
}, "strict", zod.ZodTypeAny, {
|
|
980
|
-
name: string;
|
|
981
980
|
values: string[];
|
|
981
|
+
name: string;
|
|
982
982
|
schema: string;
|
|
983
983
|
}, {
|
|
984
|
-
name: string;
|
|
985
984
|
values: string[];
|
|
985
|
+
name: string;
|
|
986
986
|
schema: string;
|
|
987
987
|
}>>;
|
|
988
988
|
schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
@@ -1021,8 +1021,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1021
1021
|
}, {
|
|
1022
1022
|
type: zod.ZodEnum<["always", "byDefault"]>;
|
|
1023
1023
|
}>, "strip", zod.ZodTypeAny, {
|
|
1024
|
-
name: string;
|
|
1025
1024
|
type: "always" | "byDefault";
|
|
1025
|
+
name: string;
|
|
1026
1026
|
schema: string;
|
|
1027
1027
|
increment?: string | undefined;
|
|
1028
1028
|
minValue?: string | undefined;
|
|
@@ -1031,8 +1031,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1031
1031
|
cache?: string | undefined;
|
|
1032
1032
|
cycle?: boolean | undefined;
|
|
1033
1033
|
}, {
|
|
1034
|
-
name: string;
|
|
1035
1034
|
type: "always" | "byDefault";
|
|
1035
|
+
name: string;
|
|
1036
1036
|
schema: string;
|
|
1037
1037
|
increment?: string | undefined;
|
|
1038
1038
|
minValue?: string | undefined;
|
|
@@ -1042,22 +1042,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1042
1042
|
cycle?: boolean | undefined;
|
|
1043
1043
|
}>>;
|
|
1044
1044
|
}, "strict", zod.ZodTypeAny, {
|
|
1045
|
-
name: string;
|
|
1046
1045
|
type: string;
|
|
1046
|
+
name: string;
|
|
1047
1047
|
primaryKey: boolean;
|
|
1048
1048
|
notNull: boolean;
|
|
1049
|
+
typeSchema?: string | undefined;
|
|
1049
1050
|
default?: any;
|
|
1050
1051
|
isUnique?: any;
|
|
1052
|
+
uniqueName?: string | undefined;
|
|
1053
|
+
nullsNotDistinct?: boolean | undefined;
|
|
1051
1054
|
generated?: {
|
|
1052
1055
|
type: "stored";
|
|
1053
1056
|
as: string;
|
|
1054
1057
|
} | undefined;
|
|
1055
|
-
typeSchema?: string | undefined;
|
|
1056
|
-
uniqueName?: string | undefined;
|
|
1057
|
-
nullsNotDistinct?: boolean | undefined;
|
|
1058
1058
|
identity?: {
|
|
1059
|
-
name: string;
|
|
1060
1059
|
type: "always" | "byDefault";
|
|
1060
|
+
name: string;
|
|
1061
1061
|
schema: string;
|
|
1062
1062
|
increment?: string | undefined;
|
|
1063
1063
|
minValue?: string | undefined;
|
|
@@ -1067,22 +1067,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1067
1067
|
cycle?: boolean | undefined;
|
|
1068
1068
|
} | undefined;
|
|
1069
1069
|
}, {
|
|
1070
|
-
name: string;
|
|
1071
1070
|
type: string;
|
|
1071
|
+
name: string;
|
|
1072
1072
|
primaryKey: boolean;
|
|
1073
1073
|
notNull: boolean;
|
|
1074
|
+
typeSchema?: string | undefined;
|
|
1074
1075
|
default?: any;
|
|
1075
1076
|
isUnique?: any;
|
|
1077
|
+
uniqueName?: string | undefined;
|
|
1078
|
+
nullsNotDistinct?: boolean | undefined;
|
|
1076
1079
|
generated?: {
|
|
1077
1080
|
type: "stored";
|
|
1078
1081
|
as: string;
|
|
1079
1082
|
} | undefined;
|
|
1080
|
-
typeSchema?: string | undefined;
|
|
1081
|
-
uniqueName?: string | undefined;
|
|
1082
|
-
nullsNotDistinct?: boolean | undefined;
|
|
1083
1083
|
identity?: {
|
|
1084
|
-
name: string;
|
|
1085
1084
|
type: "always" | "byDefault";
|
|
1085
|
+
name: string;
|
|
1086
1086
|
schema: string;
|
|
1087
1087
|
increment?: string | undefined;
|
|
1088
1088
|
minValue?: string | undefined;
|
|
@@ -1168,23 +1168,24 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1168
1168
|
tablespace: zod.ZodOptional<zod.ZodString>;
|
|
1169
1169
|
}, "strict", zod.ZodTypeAny, {
|
|
1170
1170
|
name: string;
|
|
1171
|
+
schema: string;
|
|
1171
1172
|
columns: Record<string, {
|
|
1172
|
-
name: string;
|
|
1173
1173
|
type: string;
|
|
1174
|
+
name: string;
|
|
1174
1175
|
primaryKey: boolean;
|
|
1175
1176
|
notNull: boolean;
|
|
1177
|
+
typeSchema?: string | undefined;
|
|
1176
1178
|
default?: any;
|
|
1177
1179
|
isUnique?: any;
|
|
1180
|
+
uniqueName?: string | undefined;
|
|
1181
|
+
nullsNotDistinct?: boolean | undefined;
|
|
1178
1182
|
generated?: {
|
|
1179
1183
|
type: "stored";
|
|
1180
1184
|
as: string;
|
|
1181
1185
|
} | undefined;
|
|
1182
|
-
typeSchema?: string | undefined;
|
|
1183
|
-
uniqueName?: string | undefined;
|
|
1184
|
-
nullsNotDistinct?: boolean | undefined;
|
|
1185
1186
|
identity?: {
|
|
1186
|
-
name: string;
|
|
1187
1187
|
type: "always" | "byDefault";
|
|
1188
|
+
name: string;
|
|
1188
1189
|
schema: string;
|
|
1189
1190
|
increment?: string | undefined;
|
|
1190
1191
|
minValue?: string | undefined;
|
|
@@ -1194,11 +1195,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1194
1195
|
cycle?: boolean | undefined;
|
|
1195
1196
|
} | undefined;
|
|
1196
1197
|
}>;
|
|
1197
|
-
schema: string;
|
|
1198
|
-
isExisting: boolean;
|
|
1199
1198
|
materialized: boolean;
|
|
1200
|
-
|
|
1201
|
-
definition?: string | undefined;
|
|
1199
|
+
isExisting: boolean;
|
|
1202
1200
|
with?: {
|
|
1203
1201
|
checkOption?: "local" | "cascaded" | undefined;
|
|
1204
1202
|
securityBarrier?: boolean | undefined;
|
|
@@ -1222,27 +1220,30 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1222
1220
|
logAutovacuumMinDuration?: number | undefined;
|
|
1223
1221
|
userCatalogTable?: boolean | undefined;
|
|
1224
1222
|
} | undefined;
|
|
1223
|
+
using?: string | undefined;
|
|
1224
|
+
definition?: string | undefined;
|
|
1225
1225
|
withNoData?: boolean | undefined;
|
|
1226
1226
|
tablespace?: string | undefined;
|
|
1227
1227
|
}, {
|
|
1228
1228
|
name: string;
|
|
1229
|
+
schema: string;
|
|
1229
1230
|
columns: Record<string, {
|
|
1230
|
-
name: string;
|
|
1231
1231
|
type: string;
|
|
1232
|
+
name: string;
|
|
1232
1233
|
primaryKey: boolean;
|
|
1233
1234
|
notNull: boolean;
|
|
1235
|
+
typeSchema?: string | undefined;
|
|
1234
1236
|
default?: any;
|
|
1235
1237
|
isUnique?: any;
|
|
1238
|
+
uniqueName?: string | undefined;
|
|
1239
|
+
nullsNotDistinct?: boolean | undefined;
|
|
1236
1240
|
generated?: {
|
|
1237
1241
|
type: "stored";
|
|
1238
1242
|
as: string;
|
|
1239
1243
|
} | undefined;
|
|
1240
|
-
typeSchema?: string | undefined;
|
|
1241
|
-
uniqueName?: string | undefined;
|
|
1242
|
-
nullsNotDistinct?: boolean | undefined;
|
|
1243
1244
|
identity?: {
|
|
1244
|
-
name: string;
|
|
1245
1245
|
type: "always" | "byDefault";
|
|
1246
|
+
name: string;
|
|
1246
1247
|
schema: string;
|
|
1247
1248
|
increment?: string | undefined;
|
|
1248
1249
|
minValue?: string | undefined;
|
|
@@ -1252,11 +1253,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1252
1253
|
cycle?: boolean | undefined;
|
|
1253
1254
|
} | undefined;
|
|
1254
1255
|
}>;
|
|
1255
|
-
schema: string;
|
|
1256
|
-
isExisting: boolean;
|
|
1257
1256
|
materialized: boolean;
|
|
1258
|
-
|
|
1259
|
-
definition?: string | undefined;
|
|
1257
|
+
isExisting: boolean;
|
|
1260
1258
|
with?: {
|
|
1261
1259
|
checkOption?: "local" | "cascaded" | undefined;
|
|
1262
1260
|
securityBarrier?: boolean | undefined;
|
|
@@ -1280,6 +1278,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1280
1278
|
logAutovacuumMinDuration?: number | undefined;
|
|
1281
1279
|
userCatalogTable?: boolean | undefined;
|
|
1282
1280
|
} | undefined;
|
|
1281
|
+
using?: string | undefined;
|
|
1282
|
+
definition?: string | undefined;
|
|
1283
1283
|
withNoData?: boolean | undefined;
|
|
1284
1284
|
tablespace?: string | undefined;
|
|
1285
1285
|
}>>>;
|
|
@@ -1338,20 +1338,20 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1338
1338
|
schema: zod.ZodOptional<zod.ZodString>;
|
|
1339
1339
|
}, "strict", zod.ZodTypeAny, {
|
|
1340
1340
|
name: string;
|
|
1341
|
-
using?: string | undefined;
|
|
1342
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
1343
1341
|
schema?: string | undefined;
|
|
1342
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
1344
1343
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
1345
1344
|
to?: string[] | undefined;
|
|
1345
|
+
using?: string | undefined;
|
|
1346
1346
|
withCheck?: string | undefined;
|
|
1347
1347
|
on?: string | undefined;
|
|
1348
1348
|
}, {
|
|
1349
1349
|
name: string;
|
|
1350
|
-
using?: string | undefined;
|
|
1351
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
1352
1350
|
schema?: string | undefined;
|
|
1351
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
1353
1352
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
1354
1353
|
to?: string[] | undefined;
|
|
1354
|
+
using?: string | undefined;
|
|
1355
1355
|
withCheck?: string | undefined;
|
|
1356
1356
|
on?: string | undefined;
|
|
1357
1357
|
}>>>;
|
|
@@ -1360,12 +1360,12 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1360
1360
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
1361
1361
|
columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
1362
1362
|
}, "strip", zod.ZodTypeAny, {
|
|
1363
|
-
columns: Record<string, string>;
|
|
1364
1363
|
tables: Record<string, string>;
|
|
1364
|
+
columns: Record<string, string>;
|
|
1365
1365
|
schemas: Record<string, string>;
|
|
1366
1366
|
}, {
|
|
1367
|
-
columns: Record<string, string>;
|
|
1368
1367
|
tables: Record<string, string>;
|
|
1368
|
+
columns: Record<string, string>;
|
|
1369
1369
|
schemas: Record<string, string>;
|
|
1370
1370
|
}>;
|
|
1371
1371
|
internal: zod.ZodOptional<zod.ZodObject<{
|
|
@@ -1376,47 +1376,47 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1376
1376
|
rawType: zod.ZodOptional<zod.ZodString>;
|
|
1377
1377
|
isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
|
|
1378
1378
|
}, "strip", zod.ZodTypeAny, {
|
|
1379
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
1380
1379
|
isArray?: boolean | undefined;
|
|
1381
1380
|
dimensions?: number | undefined;
|
|
1382
1381
|
rawType?: string | undefined;
|
|
1383
|
-
}, {
|
|
1384
1382
|
isDefaultAnExpression?: boolean | undefined;
|
|
1383
|
+
}, {
|
|
1385
1384
|
isArray?: boolean | undefined;
|
|
1386
1385
|
dimensions?: number | undefined;
|
|
1387
1386
|
rawType?: string | undefined;
|
|
1387
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
1388
1388
|
}>>>;
|
|
1389
1389
|
}, "strip", zod.ZodTypeAny, {
|
|
1390
1390
|
columns: Record<string, {
|
|
1391
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
1392
1391
|
isArray?: boolean | undefined;
|
|
1393
1392
|
dimensions?: number | undefined;
|
|
1394
1393
|
rawType?: string | undefined;
|
|
1394
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
1395
1395
|
} | undefined>;
|
|
1396
1396
|
}, {
|
|
1397
1397
|
columns: Record<string, {
|
|
1398
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
1399
1398
|
isArray?: boolean | undefined;
|
|
1400
1399
|
dimensions?: number | undefined;
|
|
1401
1400
|
rawType?: string | undefined;
|
|
1401
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
1402
1402
|
} | undefined>;
|
|
1403
1403
|
}>>>;
|
|
1404
1404
|
}, "strip", zod.ZodTypeAny, {
|
|
1405
1405
|
tables: Record<string, {
|
|
1406
1406
|
columns: Record<string, {
|
|
1407
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
1408
1407
|
isArray?: boolean | undefined;
|
|
1409
1408
|
dimensions?: number | undefined;
|
|
1410
1409
|
rawType?: string | undefined;
|
|
1410
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
1411
1411
|
} | undefined>;
|
|
1412
1412
|
} | undefined>;
|
|
1413
1413
|
}, {
|
|
1414
1414
|
tables: Record<string, {
|
|
1415
1415
|
columns: Record<string, {
|
|
1416
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
1417
1416
|
isArray?: boolean | undefined;
|
|
1418
1417
|
dimensions?: number | undefined;
|
|
1419
1418
|
rawType?: string | undefined;
|
|
1419
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
1420
1420
|
} | undefined>;
|
|
1421
1421
|
} | undefined>;
|
|
1422
1422
|
}>>;
|
|
@@ -1424,25 +1424,28 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1424
1424
|
id: zod.ZodString;
|
|
1425
1425
|
prevId: zod.ZodString;
|
|
1426
1426
|
}>, "strip", zod.ZodTypeAny, {
|
|
1427
|
+
version: "7";
|
|
1428
|
+
dialect: "postgresql";
|
|
1427
1429
|
tables: Record<string, {
|
|
1428
1430
|
name: string;
|
|
1431
|
+
schema: string;
|
|
1429
1432
|
columns: Record<string, {
|
|
1430
|
-
name: string;
|
|
1431
1433
|
type: string;
|
|
1434
|
+
name: string;
|
|
1432
1435
|
primaryKey: boolean;
|
|
1433
1436
|
notNull: boolean;
|
|
1437
|
+
typeSchema?: string | undefined;
|
|
1434
1438
|
default?: any;
|
|
1435
1439
|
isUnique?: any;
|
|
1440
|
+
uniqueName?: string | undefined;
|
|
1441
|
+
nullsNotDistinct?: boolean | undefined;
|
|
1436
1442
|
generated?: {
|
|
1437
1443
|
type: "stored";
|
|
1438
1444
|
as: string;
|
|
1439
1445
|
} | undefined;
|
|
1440
|
-
typeSchema?: string | undefined;
|
|
1441
|
-
uniqueName?: string | undefined;
|
|
1442
|
-
nullsNotDistinct?: boolean | undefined;
|
|
1443
1446
|
identity?: {
|
|
1444
|
-
name: string;
|
|
1445
1447
|
type: "always" | "byDefault";
|
|
1448
|
+
name: string;
|
|
1446
1449
|
schema: string;
|
|
1447
1450
|
increment?: string | undefined;
|
|
1448
1451
|
minValue?: string | undefined;
|
|
@@ -1455,8 +1458,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1455
1458
|
indexes: Record<string, {
|
|
1456
1459
|
name: string;
|
|
1457
1460
|
columns: {
|
|
1458
|
-
isExpression: boolean;
|
|
1459
1461
|
expression: string;
|
|
1462
|
+
isExpression: boolean;
|
|
1460
1463
|
asc: boolean;
|
|
1461
1464
|
nulls?: string | undefined;
|
|
1462
1465
|
opclass?: string | undefined;
|
|
@@ -1473,11 +1476,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1473
1476
|
columnsFrom: string[];
|
|
1474
1477
|
tableTo: string;
|
|
1475
1478
|
columnsTo: string[];
|
|
1479
|
+
schemaTo?: string | undefined;
|
|
1476
1480
|
onUpdate?: string | undefined;
|
|
1477
1481
|
onDelete?: string | undefined;
|
|
1478
|
-
schemaTo?: string | undefined;
|
|
1479
1482
|
}>;
|
|
1480
|
-
schema: string;
|
|
1481
1483
|
compositePrimaryKeys: Record<string, {
|
|
1482
1484
|
name: string;
|
|
1483
1485
|
columns: string[];
|
|
@@ -1487,51 +1489,58 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1487
1489
|
columns: string[];
|
|
1488
1490
|
nullsNotDistinct: boolean;
|
|
1489
1491
|
}>;
|
|
1490
|
-
checkConstraints: Record<string, {
|
|
1491
|
-
name: string;
|
|
1492
|
-
value: string;
|
|
1493
|
-
}>;
|
|
1494
1492
|
policies: Record<string, {
|
|
1495
1493
|
name: string;
|
|
1496
|
-
using?: string | undefined;
|
|
1497
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
1498
1494
|
schema?: string | undefined;
|
|
1495
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
1499
1496
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
1500
1497
|
to?: string[] | undefined;
|
|
1498
|
+
using?: string | undefined;
|
|
1501
1499
|
withCheck?: string | undefined;
|
|
1502
1500
|
on?: string | undefined;
|
|
1503
1501
|
}>;
|
|
1502
|
+
checkConstraints: Record<string, {
|
|
1503
|
+
value: string;
|
|
1504
|
+
name: string;
|
|
1505
|
+
}>;
|
|
1504
1506
|
isRLSEnabled: boolean;
|
|
1505
1507
|
}>;
|
|
1506
|
-
|
|
1507
|
-
|
|
1508
|
-
|
|
1509
|
-
|
|
1508
|
+
policies: Record<string, {
|
|
1509
|
+
name: string;
|
|
1510
|
+
schema?: string | undefined;
|
|
1511
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
1512
|
+
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
1513
|
+
to?: string[] | undefined;
|
|
1514
|
+
using?: string | undefined;
|
|
1515
|
+
withCheck?: string | undefined;
|
|
1516
|
+
on?: string | undefined;
|
|
1517
|
+
}>;
|
|
1518
|
+
enums: Record<string, {
|
|
1519
|
+
values: string[];
|
|
1520
|
+
name: string;
|
|
1521
|
+
schema: string;
|
|
1522
|
+
}>;
|
|
1510
1523
|
schemas: Record<string, string>;
|
|
1511
|
-
_meta: {
|
|
1512
|
-
columns: Record<string, string>;
|
|
1513
|
-
tables: Record<string, string>;
|
|
1514
|
-
schemas: Record<string, string>;
|
|
1515
|
-
};
|
|
1516
1524
|
views: Record<string, {
|
|
1517
1525
|
name: string;
|
|
1526
|
+
schema: string;
|
|
1518
1527
|
columns: Record<string, {
|
|
1519
|
-
name: string;
|
|
1520
1528
|
type: string;
|
|
1529
|
+
name: string;
|
|
1521
1530
|
primaryKey: boolean;
|
|
1522
1531
|
notNull: boolean;
|
|
1532
|
+
typeSchema?: string | undefined;
|
|
1523
1533
|
default?: any;
|
|
1524
1534
|
isUnique?: any;
|
|
1535
|
+
uniqueName?: string | undefined;
|
|
1536
|
+
nullsNotDistinct?: boolean | undefined;
|
|
1525
1537
|
generated?: {
|
|
1526
1538
|
type: "stored";
|
|
1527
1539
|
as: string;
|
|
1528
1540
|
} | undefined;
|
|
1529
|
-
typeSchema?: string | undefined;
|
|
1530
|
-
uniqueName?: string | undefined;
|
|
1531
|
-
nullsNotDistinct?: boolean | undefined;
|
|
1532
1541
|
identity?: {
|
|
1533
|
-
name: string;
|
|
1534
1542
|
type: "always" | "byDefault";
|
|
1543
|
+
name: string;
|
|
1535
1544
|
schema: string;
|
|
1536
1545
|
increment?: string | undefined;
|
|
1537
1546
|
minValue?: string | undefined;
|
|
@@ -1541,11 +1550,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1541
1550
|
cycle?: boolean | undefined;
|
|
1542
1551
|
} | undefined;
|
|
1543
1552
|
}>;
|
|
1544
|
-
schema: string;
|
|
1545
|
-
isExisting: boolean;
|
|
1546
1553
|
materialized: boolean;
|
|
1547
|
-
|
|
1548
|
-
definition?: string | undefined;
|
|
1554
|
+
isExisting: boolean;
|
|
1549
1555
|
with?: {
|
|
1550
1556
|
checkOption?: "local" | "cascaded" | undefined;
|
|
1551
1557
|
securityBarrier?: boolean | undefined;
|
|
@@ -1569,24 +1575,11 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1569
1575
|
logAutovacuumMinDuration?: number | undefined;
|
|
1570
1576
|
userCatalogTable?: boolean | undefined;
|
|
1571
1577
|
} | undefined;
|
|
1578
|
+
using?: string | undefined;
|
|
1579
|
+
definition?: string | undefined;
|
|
1572
1580
|
withNoData?: boolean | undefined;
|
|
1573
1581
|
tablespace?: string | undefined;
|
|
1574
1582
|
}>;
|
|
1575
|
-
enums: Record<string, {
|
|
1576
|
-
name: string;
|
|
1577
|
-
values: string[];
|
|
1578
|
-
schema: string;
|
|
1579
|
-
}>;
|
|
1580
|
-
policies: Record<string, {
|
|
1581
|
-
name: string;
|
|
1582
|
-
using?: string | undefined;
|
|
1583
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
1584
|
-
schema?: string | undefined;
|
|
1585
|
-
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
1586
|
-
to?: string[] | undefined;
|
|
1587
|
-
withCheck?: string | undefined;
|
|
1588
|
-
on?: string | undefined;
|
|
1589
|
-
}>;
|
|
1590
1583
|
sequences: Record<string, {
|
|
1591
1584
|
name: string;
|
|
1592
1585
|
schema: string;
|
|
@@ -1603,36 +1596,46 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1603
1596
|
createRole?: boolean | undefined;
|
|
1604
1597
|
inherit?: boolean | undefined;
|
|
1605
1598
|
}>;
|
|
1599
|
+
_meta: {
|
|
1600
|
+
tables: Record<string, string>;
|
|
1601
|
+
columns: Record<string, string>;
|
|
1602
|
+
schemas: Record<string, string>;
|
|
1603
|
+
};
|
|
1604
|
+
id: string;
|
|
1605
|
+
prevId: string;
|
|
1606
1606
|
internal?: {
|
|
1607
1607
|
tables: Record<string, {
|
|
1608
1608
|
columns: Record<string, {
|
|
1609
|
-
isDefaultAnExpression?: boolean | undefined;
|
|
1610
1609
|
isArray?: boolean | undefined;
|
|
1611
1610
|
dimensions?: number | undefined;
|
|
1612
1611
|
rawType?: string | undefined;
|
|
1612
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
1613
1613
|
} | undefined>;
|
|
1614
1614
|
} | undefined>;
|
|
1615
1615
|
} | undefined;
|
|
1616
1616
|
}, {
|
|
1617
|
+
version: "7";
|
|
1618
|
+
dialect: "postgresql";
|
|
1617
1619
|
tables: Record<string, {
|
|
1618
1620
|
name: string;
|
|
1621
|
+
schema: string;
|
|
1619
1622
|
columns: Record<string, {
|
|
1620
|
-
name: string;
|
|
1621
1623
|
type: string;
|
|
1624
|
+
name: string;
|
|
1622
1625
|
primaryKey: boolean;
|
|
1623
1626
|
notNull: boolean;
|
|
1627
|
+
typeSchema?: string | undefined;
|
|
1624
1628
|
default?: any;
|
|
1625
1629
|
isUnique?: any;
|
|
1630
|
+
uniqueName?: string | undefined;
|
|
1631
|
+
nullsNotDistinct?: boolean | undefined;
|
|
1626
1632
|
generated?: {
|
|
1627
1633
|
type: "stored";
|
|
1628
1634
|
as: string;
|
|
1629
1635
|
} | undefined;
|
|
1630
|
-
typeSchema?: string | undefined;
|
|
1631
|
-
uniqueName?: string | undefined;
|
|
1632
|
-
nullsNotDistinct?: boolean | undefined;
|
|
1633
1636
|
identity?: {
|
|
1634
|
-
name: string;
|
|
1635
1637
|
type: "always" | "byDefault";
|
|
1638
|
+
name: string;
|
|
1636
1639
|
schema: string;
|
|
1637
1640
|
increment?: string | undefined;
|
|
1638
1641
|
minValue?: string | undefined;
|
|
@@ -1645,8 +1648,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1645
1648
|
indexes: Record<string, {
|
|
1646
1649
|
name: string;
|
|
1647
1650
|
columns: {
|
|
1648
|
-
isExpression: boolean;
|
|
1649
1651
|
expression: string;
|
|
1652
|
+
isExpression: boolean;
|
|
1650
1653
|
asc: boolean;
|
|
1651
1654
|
nulls?: string | undefined;
|
|
1652
1655
|
opclass?: string | undefined;
|
|
@@ -1663,11 +1666,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1663
1666
|
columnsFrom: string[];
|
|
1664
1667
|
tableTo: string;
|
|
1665
1668
|
columnsTo: string[];
|
|
1669
|
+
schemaTo?: string | undefined;
|
|
1666
1670
|
onUpdate?: string | undefined;
|
|
1667
1671
|
onDelete?: string | undefined;
|
|
1668
|
-
schemaTo?: string | undefined;
|
|
1669
1672
|
}>;
|
|
1670
|
-
schema: string;
|
|
1671
1673
|
compositePrimaryKeys: Record<string, {
|
|
1672
1674
|
name: string;
|
|
1673
1675
|
columns: string[];
|
|
@@ -1677,66 +1679,65 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1677
1679
|
columns: string[];
|
|
1678
1680
|
nullsNotDistinct: boolean;
|
|
1679
1681
|
}> | undefined;
|
|
1680
|
-
checkConstraints?: Record<string, {
|
|
1681
|
-
name: string;
|
|
1682
|
-
value: string;
|
|
1683
|
-
}> | undefined;
|
|
1684
1682
|
policies?: Record<string, {
|
|
1685
1683
|
name: string;
|
|
1686
|
-
using?: string | undefined;
|
|
1687
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
1688
1684
|
schema?: string | undefined;
|
|
1685
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
1689
1686
|
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
1690
1687
|
to?: string[] | undefined;
|
|
1688
|
+
using?: string | undefined;
|
|
1691
1689
|
withCheck?: string | undefined;
|
|
1692
1690
|
on?: string | undefined;
|
|
1693
1691
|
}> | undefined;
|
|
1692
|
+
checkConstraints?: Record<string, {
|
|
1693
|
+
value: string;
|
|
1694
|
+
name: string;
|
|
1695
|
+
}> | undefined;
|
|
1694
1696
|
isRLSEnabled?: boolean | undefined;
|
|
1695
1697
|
}>;
|
|
1696
|
-
|
|
1697
|
-
|
|
1698
|
-
|
|
1699
|
-
|
|
1698
|
+
enums: Record<string, {
|
|
1699
|
+
values: string[];
|
|
1700
|
+
name: string;
|
|
1701
|
+
schema: string;
|
|
1702
|
+
}>;
|
|
1700
1703
|
schemas: Record<string, string>;
|
|
1701
1704
|
_meta: {
|
|
1702
|
-
columns: Record<string, string>;
|
|
1703
1705
|
tables: Record<string, string>;
|
|
1706
|
+
columns: Record<string, string>;
|
|
1704
1707
|
schemas: Record<string, string>;
|
|
1705
1708
|
};
|
|
1706
|
-
|
|
1709
|
+
id: string;
|
|
1710
|
+
prevId: string;
|
|
1711
|
+
policies?: Record<string, {
|
|
1707
1712
|
name: string;
|
|
1708
|
-
|
|
1709
|
-
|
|
1710
|
-
|
|
1711
|
-
|
|
1712
|
-
|
|
1713
|
-
|
|
1714
|
-
|
|
1715
|
-
|
|
1716
|
-
dimensions?: number | undefined;
|
|
1717
|
-
rawType?: string | undefined;
|
|
1718
|
-
} | undefined>;
|
|
1719
|
-
} | undefined>;
|
|
1720
|
-
} | undefined;
|
|
1713
|
+
schema?: string | undefined;
|
|
1714
|
+
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
1715
|
+
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
1716
|
+
to?: string[] | undefined;
|
|
1717
|
+
using?: string | undefined;
|
|
1718
|
+
withCheck?: string | undefined;
|
|
1719
|
+
on?: string | undefined;
|
|
1720
|
+
}> | undefined;
|
|
1721
1721
|
views?: Record<string, {
|
|
1722
1722
|
name: string;
|
|
1723
|
+
schema: string;
|
|
1723
1724
|
columns: Record<string, {
|
|
1724
|
-
name: string;
|
|
1725
1725
|
type: string;
|
|
1726
|
+
name: string;
|
|
1726
1727
|
primaryKey: boolean;
|
|
1727
1728
|
notNull: boolean;
|
|
1729
|
+
typeSchema?: string | undefined;
|
|
1728
1730
|
default?: any;
|
|
1729
1731
|
isUnique?: any;
|
|
1732
|
+
uniqueName?: string | undefined;
|
|
1733
|
+
nullsNotDistinct?: boolean | undefined;
|
|
1730
1734
|
generated?: {
|
|
1731
1735
|
type: "stored";
|
|
1732
1736
|
as: string;
|
|
1733
1737
|
} | undefined;
|
|
1734
|
-
typeSchema?: string | undefined;
|
|
1735
|
-
uniqueName?: string | undefined;
|
|
1736
|
-
nullsNotDistinct?: boolean | undefined;
|
|
1737
1738
|
identity?: {
|
|
1738
|
-
name: string;
|
|
1739
1739
|
type: "always" | "byDefault";
|
|
1740
|
+
name: string;
|
|
1740
1741
|
schema: string;
|
|
1741
1742
|
increment?: string | undefined;
|
|
1742
1743
|
minValue?: string | undefined;
|
|
@@ -1746,11 +1747,8 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1746
1747
|
cycle?: boolean | undefined;
|
|
1747
1748
|
} | undefined;
|
|
1748
1749
|
}>;
|
|
1749
|
-
schema: string;
|
|
1750
|
-
isExisting: boolean;
|
|
1751
1750
|
materialized: boolean;
|
|
1752
|
-
|
|
1753
|
-
definition?: string | undefined;
|
|
1751
|
+
isExisting: boolean;
|
|
1754
1752
|
with?: {
|
|
1755
1753
|
checkOption?: "local" | "cascaded" | undefined;
|
|
1756
1754
|
securityBarrier?: boolean | undefined;
|
|
@@ -1774,19 +1772,11 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1774
1772
|
logAutovacuumMinDuration?: number | undefined;
|
|
1775
1773
|
userCatalogTable?: boolean | undefined;
|
|
1776
1774
|
} | undefined;
|
|
1775
|
+
using?: string | undefined;
|
|
1776
|
+
definition?: string | undefined;
|
|
1777
1777
|
withNoData?: boolean | undefined;
|
|
1778
1778
|
tablespace?: string | undefined;
|
|
1779
1779
|
}> | undefined;
|
|
1780
|
-
policies?: Record<string, {
|
|
1781
|
-
name: string;
|
|
1782
|
-
using?: string | undefined;
|
|
1783
|
-
as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
|
|
1784
|
-
schema?: string | undefined;
|
|
1785
|
-
for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
|
|
1786
|
-
to?: string[] | undefined;
|
|
1787
|
-
withCheck?: string | undefined;
|
|
1788
|
-
on?: string | undefined;
|
|
1789
|
-
}> | undefined;
|
|
1790
1780
|
sequences?: Record<string, {
|
|
1791
1781
|
name: string;
|
|
1792
1782
|
schema: string;
|
|
@@ -1803,6 +1793,16 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1803
1793
|
createRole?: boolean | undefined;
|
|
1804
1794
|
inherit?: boolean | undefined;
|
|
1805
1795
|
}> | undefined;
|
|
1796
|
+
internal?: {
|
|
1797
|
+
tables: Record<string, {
|
|
1798
|
+
columns: Record<string, {
|
|
1799
|
+
isArray?: boolean | undefined;
|
|
1800
|
+
dimensions?: number | undefined;
|
|
1801
|
+
rawType?: string | undefined;
|
|
1802
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
1803
|
+
} | undefined>;
|
|
1804
|
+
} | undefined>;
|
|
1805
|
+
} | undefined;
|
|
1806
1806
|
}>;
|
|
1807
1807
|
type PgSchema = TypeOf<typeof pgSchema>;
|
|
1808
1808
|
|
|
@@ -1830,29 +1830,29 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1830
1830
|
as: string;
|
|
1831
1831
|
}>>;
|
|
1832
1832
|
}, "strict", zod.ZodTypeAny, {
|
|
1833
|
-
name: string;
|
|
1834
1833
|
type: string;
|
|
1834
|
+
name: string;
|
|
1835
1835
|
primaryKey: boolean;
|
|
1836
1836
|
notNull: boolean;
|
|
1837
1837
|
default?: any;
|
|
1838
|
-
onUpdate?: any;
|
|
1839
|
-
autoincrement?: boolean | undefined;
|
|
1840
1838
|
generated?: {
|
|
1841
1839
|
type: "stored" | "virtual";
|
|
1842
1840
|
as: string;
|
|
1843
1841
|
} | undefined;
|
|
1842
|
+
onUpdate?: any;
|
|
1843
|
+
autoincrement?: boolean | undefined;
|
|
1844
1844
|
}, {
|
|
1845
|
-
name: string;
|
|
1846
1845
|
type: string;
|
|
1846
|
+
name: string;
|
|
1847
1847
|
primaryKey: boolean;
|
|
1848
1848
|
notNull: boolean;
|
|
1849
1849
|
default?: any;
|
|
1850
|
-
onUpdate?: any;
|
|
1851
|
-
autoincrement?: boolean | undefined;
|
|
1852
1850
|
generated?: {
|
|
1853
1851
|
type: "stored" | "virtual";
|
|
1854
1852
|
as: string;
|
|
1855
1853
|
} | undefined;
|
|
1854
|
+
onUpdate?: any;
|
|
1855
|
+
autoincrement?: boolean | undefined;
|
|
1856
1856
|
}>>;
|
|
1857
1857
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
1858
1858
|
name: zod.ZodString;
|
|
@@ -1867,14 +1867,14 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1867
1867
|
isUnique: boolean;
|
|
1868
1868
|
using?: "btree" | "hash" | undefined;
|
|
1869
1869
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1870
|
-
lock?: "
|
|
1870
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1871
1871
|
}, {
|
|
1872
1872
|
name: string;
|
|
1873
1873
|
columns: string[];
|
|
1874
1874
|
isUnique: boolean;
|
|
1875
1875
|
using?: "btree" | "hash" | undefined;
|
|
1876
1876
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1877
|
-
lock?: "
|
|
1877
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1878
1878
|
}>>;
|
|
1879
1879
|
compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
1880
1880
|
name: zod.ZodString;
|
|
@@ -1899,17 +1899,17 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1899
1899
|
}, "strict", zod.ZodTypeAny, {
|
|
1900
1900
|
name: string;
|
|
1901
1901
|
columns: Record<string, {
|
|
1902
|
-
name: string;
|
|
1903
1902
|
type: string;
|
|
1903
|
+
name: string;
|
|
1904
1904
|
primaryKey: boolean;
|
|
1905
1905
|
notNull: boolean;
|
|
1906
1906
|
default?: any;
|
|
1907
|
-
onUpdate?: any;
|
|
1908
|
-
autoincrement?: boolean | undefined;
|
|
1909
1907
|
generated?: {
|
|
1910
1908
|
type: "stored" | "virtual";
|
|
1911
1909
|
as: string;
|
|
1912
1910
|
} | undefined;
|
|
1911
|
+
onUpdate?: any;
|
|
1912
|
+
autoincrement?: boolean | undefined;
|
|
1913
1913
|
}>;
|
|
1914
1914
|
indexes: Record<string, {
|
|
1915
1915
|
name: string;
|
|
@@ -1917,7 +1917,7 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1917
1917
|
isUnique: boolean;
|
|
1918
1918
|
using?: "btree" | "hash" | undefined;
|
|
1919
1919
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1920
|
-
lock?: "
|
|
1920
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1921
1921
|
}>;
|
|
1922
1922
|
compositePrimaryKeys: Record<string, {
|
|
1923
1923
|
name: string;
|
|
@@ -1930,17 +1930,17 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1930
1930
|
}, {
|
|
1931
1931
|
name: string;
|
|
1932
1932
|
columns: Record<string, {
|
|
1933
|
-
name: string;
|
|
1934
1933
|
type: string;
|
|
1934
|
+
name: string;
|
|
1935
1935
|
primaryKey: boolean;
|
|
1936
1936
|
notNull: boolean;
|
|
1937
1937
|
default?: any;
|
|
1938
|
-
onUpdate?: any;
|
|
1939
|
-
autoincrement?: boolean | undefined;
|
|
1940
1938
|
generated?: {
|
|
1941
1939
|
type: "stored" | "virtual";
|
|
1942
1940
|
as: string;
|
|
1943
1941
|
} | undefined;
|
|
1942
|
+
onUpdate?: any;
|
|
1943
|
+
autoincrement?: boolean | undefined;
|
|
1944
1944
|
}>;
|
|
1945
1945
|
indexes: Record<string, {
|
|
1946
1946
|
name: string;
|
|
@@ -1948,7 +1948,7 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1948
1948
|
isUnique: boolean;
|
|
1949
1949
|
using?: "btree" | "hash" | undefined;
|
|
1950
1950
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
1951
|
-
lock?: "
|
|
1951
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
1952
1952
|
}>;
|
|
1953
1953
|
compositePrimaryKeys: Record<string, {
|
|
1954
1954
|
name: string;
|
|
@@ -1963,11 +1963,11 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
1963
1963
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
1964
1964
|
columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
1965
1965
|
}, "strip", zod.ZodTypeAny, {
|
|
1966
|
-
columns: Record<string, string>;
|
|
1967
1966
|
tables: Record<string, string>;
|
|
1968
|
-
}, {
|
|
1969
1967
|
columns: Record<string, string>;
|
|
1968
|
+
}, {
|
|
1970
1969
|
tables: Record<string, string>;
|
|
1970
|
+
columns: Record<string, string>;
|
|
1971
1971
|
}>;
|
|
1972
1972
|
internal: zod.ZodOptional<zod.ZodObject<{
|
|
1973
1973
|
tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
|
|
@@ -2005,46 +2005,48 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2005
2005
|
} | undefined>;
|
|
2006
2006
|
}>>>>;
|
|
2007
2007
|
}, "strip", zod.ZodTypeAny, {
|
|
2008
|
-
indexes?: Record<string, {
|
|
2009
|
-
columns: Record<string, {
|
|
2010
|
-
isExpression?: boolean | undefined;
|
|
2011
|
-
} | undefined>;
|
|
2012
|
-
} | undefined> | undefined;
|
|
2013
2008
|
tables?: Record<string, {
|
|
2014
2009
|
columns: Record<string, {
|
|
2015
2010
|
isDefaultAnExpression?: boolean | undefined;
|
|
2016
2011
|
} | undefined>;
|
|
2017
2012
|
} | undefined> | undefined;
|
|
2018
|
-
}, {
|
|
2019
2013
|
indexes?: Record<string, {
|
|
2020
2014
|
columns: Record<string, {
|
|
2021
2015
|
isExpression?: boolean | undefined;
|
|
2022
2016
|
} | undefined>;
|
|
2023
2017
|
} | undefined> | undefined;
|
|
2018
|
+
}, {
|
|
2024
2019
|
tables?: Record<string, {
|
|
2025
2020
|
columns: Record<string, {
|
|
2026
2021
|
isDefaultAnExpression?: boolean | undefined;
|
|
2027
2022
|
} | undefined>;
|
|
2028
2023
|
} | undefined> | undefined;
|
|
2024
|
+
indexes?: Record<string, {
|
|
2025
|
+
columns: Record<string, {
|
|
2026
|
+
isExpression?: boolean | undefined;
|
|
2027
|
+
} | undefined>;
|
|
2028
|
+
} | undefined> | undefined;
|
|
2029
2029
|
}>>;
|
|
2030
2030
|
}, {
|
|
2031
2031
|
id: zod.ZodString;
|
|
2032
2032
|
prevId: zod.ZodString;
|
|
2033
2033
|
}>, "strip", zod.ZodTypeAny, {
|
|
2034
|
+
version: "1";
|
|
2035
|
+
dialect: "singlestore";
|
|
2034
2036
|
tables: Record<string, {
|
|
2035
2037
|
name: string;
|
|
2036
2038
|
columns: Record<string, {
|
|
2037
|
-
name: string;
|
|
2038
2039
|
type: string;
|
|
2040
|
+
name: string;
|
|
2039
2041
|
primaryKey: boolean;
|
|
2040
2042
|
notNull: boolean;
|
|
2041
2043
|
default?: any;
|
|
2042
|
-
onUpdate?: any;
|
|
2043
|
-
autoincrement?: boolean | undefined;
|
|
2044
2044
|
generated?: {
|
|
2045
2045
|
type: "stored" | "virtual";
|
|
2046
2046
|
as: string;
|
|
2047
2047
|
} | undefined;
|
|
2048
|
+
onUpdate?: any;
|
|
2049
|
+
autoincrement?: boolean | undefined;
|
|
2048
2050
|
}>;
|
|
2049
2051
|
indexes: Record<string, {
|
|
2050
2052
|
name: string;
|
|
@@ -2052,7 +2054,7 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2052
2054
|
isUnique: boolean;
|
|
2053
2055
|
using?: "btree" | "hash" | undefined;
|
|
2054
2056
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2055
|
-
lock?: "
|
|
2057
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2056
2058
|
}>;
|
|
2057
2059
|
compositePrimaryKeys: Record<string, {
|
|
2058
2060
|
name: string;
|
|
@@ -2063,41 +2065,41 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2063
2065
|
columns: string[];
|
|
2064
2066
|
}>;
|
|
2065
2067
|
}>;
|
|
2066
|
-
id: string;
|
|
2067
|
-
prevId: string;
|
|
2068
|
-
version: "1";
|
|
2069
|
-
dialect: "singlestore";
|
|
2070
2068
|
_meta: {
|
|
2071
|
-
columns: Record<string, string>;
|
|
2072
2069
|
tables: Record<string, string>;
|
|
2070
|
+
columns: Record<string, string>;
|
|
2073
2071
|
};
|
|
2072
|
+
id: string;
|
|
2073
|
+
prevId: string;
|
|
2074
2074
|
internal?: {
|
|
2075
|
-
|
|
2075
|
+
tables?: Record<string, {
|
|
2076
2076
|
columns: Record<string, {
|
|
2077
|
-
|
|
2077
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
2078
2078
|
} | undefined>;
|
|
2079
2079
|
} | undefined> | undefined;
|
|
2080
|
-
|
|
2080
|
+
indexes?: Record<string, {
|
|
2081
2081
|
columns: Record<string, {
|
|
2082
|
-
|
|
2082
|
+
isExpression?: boolean | undefined;
|
|
2083
2083
|
} | undefined>;
|
|
2084
2084
|
} | undefined> | undefined;
|
|
2085
2085
|
} | undefined;
|
|
2086
2086
|
}, {
|
|
2087
|
+
version: "1";
|
|
2088
|
+
dialect: "singlestore";
|
|
2087
2089
|
tables: Record<string, {
|
|
2088
2090
|
name: string;
|
|
2089
2091
|
columns: Record<string, {
|
|
2090
|
-
name: string;
|
|
2091
2092
|
type: string;
|
|
2093
|
+
name: string;
|
|
2092
2094
|
primaryKey: boolean;
|
|
2093
2095
|
notNull: boolean;
|
|
2094
2096
|
default?: any;
|
|
2095
|
-
onUpdate?: any;
|
|
2096
|
-
autoincrement?: boolean | undefined;
|
|
2097
2097
|
generated?: {
|
|
2098
2098
|
type: "stored" | "virtual";
|
|
2099
2099
|
as: string;
|
|
2100
2100
|
} | undefined;
|
|
2101
|
+
onUpdate?: any;
|
|
2102
|
+
autoincrement?: boolean | undefined;
|
|
2101
2103
|
}>;
|
|
2102
2104
|
indexes: Record<string, {
|
|
2103
2105
|
name: string;
|
|
@@ -2105,7 +2107,7 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2105
2107
|
isUnique: boolean;
|
|
2106
2108
|
using?: "btree" | "hash" | undefined;
|
|
2107
2109
|
algorithm?: "default" | "inplace" | "copy" | undefined;
|
|
2108
|
-
lock?: "
|
|
2110
|
+
lock?: "default" | "none" | "shared" | "exclusive" | undefined;
|
|
2109
2111
|
}>;
|
|
2110
2112
|
compositePrimaryKeys: Record<string, {
|
|
2111
2113
|
name: string;
|
|
@@ -2116,23 +2118,21 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2116
2118
|
columns: string[];
|
|
2117
2119
|
}> | undefined;
|
|
2118
2120
|
}>;
|
|
2119
|
-
id: string;
|
|
2120
|
-
prevId: string;
|
|
2121
|
-
version: "1";
|
|
2122
|
-
dialect: "singlestore";
|
|
2123
2121
|
_meta: {
|
|
2124
|
-
columns: Record<string, string>;
|
|
2125
2122
|
tables: Record<string, string>;
|
|
2123
|
+
columns: Record<string, string>;
|
|
2126
2124
|
};
|
|
2125
|
+
id: string;
|
|
2126
|
+
prevId: string;
|
|
2127
2127
|
internal?: {
|
|
2128
|
-
|
|
2128
|
+
tables?: Record<string, {
|
|
2129
2129
|
columns: Record<string, {
|
|
2130
|
-
|
|
2130
|
+
isDefaultAnExpression?: boolean | undefined;
|
|
2131
2131
|
} | undefined>;
|
|
2132
2132
|
} | undefined> | undefined;
|
|
2133
|
-
|
|
2133
|
+
indexes?: Record<string, {
|
|
2134
2134
|
columns: Record<string, {
|
|
2135
|
-
|
|
2135
|
+
isExpression?: boolean | undefined;
|
|
2136
2136
|
} | undefined>;
|
|
2137
2137
|
} | undefined> | undefined;
|
|
2138
2138
|
} | undefined;
|
|
@@ -2162,27 +2162,27 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2162
2162
|
as: string;
|
|
2163
2163
|
}>>;
|
|
2164
2164
|
}, "strict", zod.ZodTypeAny, {
|
|
2165
|
-
name: string;
|
|
2166
2165
|
type: string;
|
|
2166
|
+
name: string;
|
|
2167
2167
|
primaryKey: boolean;
|
|
2168
2168
|
notNull: boolean;
|
|
2169
2169
|
default?: any;
|
|
2170
|
-
autoincrement?: boolean | undefined;
|
|
2171
2170
|
generated?: {
|
|
2172
2171
|
type: "stored" | "virtual";
|
|
2173
2172
|
as: string;
|
|
2174
2173
|
} | undefined;
|
|
2174
|
+
autoincrement?: boolean | undefined;
|
|
2175
2175
|
}, {
|
|
2176
|
-
name: string;
|
|
2177
2176
|
type: string;
|
|
2177
|
+
name: string;
|
|
2178
2178
|
primaryKey: boolean;
|
|
2179
2179
|
notNull: boolean;
|
|
2180
2180
|
default?: any;
|
|
2181
|
-
autoincrement?: boolean | undefined;
|
|
2182
2181
|
generated?: {
|
|
2183
2182
|
type: "stored" | "virtual";
|
|
2184
2183
|
as: string;
|
|
2185
2184
|
} | undefined;
|
|
2185
|
+
autoincrement?: boolean | undefined;
|
|
2186
2186
|
}>>;
|
|
2187
2187
|
indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
2188
2188
|
name: zod.ZodString;
|
|
@@ -2249,25 +2249,25 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2249
2249
|
name: zod.ZodString;
|
|
2250
2250
|
value: zod.ZodString;
|
|
2251
2251
|
}, "strict", zod.ZodTypeAny, {
|
|
2252
|
-
name: string;
|
|
2253
2252
|
value: string;
|
|
2254
|
-
}, {
|
|
2255
2253
|
name: string;
|
|
2254
|
+
}, {
|
|
2256
2255
|
value: string;
|
|
2256
|
+
name: string;
|
|
2257
2257
|
}>>>;
|
|
2258
2258
|
}, "strict", zod.ZodTypeAny, {
|
|
2259
2259
|
name: string;
|
|
2260
2260
|
columns: Record<string, {
|
|
2261
|
-
name: string;
|
|
2262
2261
|
type: string;
|
|
2262
|
+
name: string;
|
|
2263
2263
|
primaryKey: boolean;
|
|
2264
2264
|
notNull: boolean;
|
|
2265
2265
|
default?: any;
|
|
2266
|
-
autoincrement?: boolean | undefined;
|
|
2267
2266
|
generated?: {
|
|
2268
2267
|
type: "stored" | "virtual";
|
|
2269
2268
|
as: string;
|
|
2270
2269
|
} | undefined;
|
|
2270
|
+
autoincrement?: boolean | undefined;
|
|
2271
2271
|
}>;
|
|
2272
2272
|
indexes: Record<string, {
|
|
2273
2273
|
name: string;
|
|
@@ -2293,22 +2293,22 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2293
2293
|
columns: string[];
|
|
2294
2294
|
}>;
|
|
2295
2295
|
checkConstraints: Record<string, {
|
|
2296
|
-
name: string;
|
|
2297
2296
|
value: string;
|
|
2297
|
+
name: string;
|
|
2298
2298
|
}>;
|
|
2299
2299
|
}, {
|
|
2300
2300
|
name: string;
|
|
2301
2301
|
columns: Record<string, {
|
|
2302
|
-
name: string;
|
|
2303
2302
|
type: string;
|
|
2303
|
+
name: string;
|
|
2304
2304
|
primaryKey: boolean;
|
|
2305
2305
|
notNull: boolean;
|
|
2306
2306
|
default?: any;
|
|
2307
|
-
autoincrement?: boolean | undefined;
|
|
2308
2307
|
generated?: {
|
|
2309
2308
|
type: "stored" | "virtual";
|
|
2310
2309
|
as: string;
|
|
2311
2310
|
} | undefined;
|
|
2311
|
+
autoincrement?: boolean | undefined;
|
|
2312
2312
|
}>;
|
|
2313
2313
|
indexes: Record<string, {
|
|
2314
2314
|
name: string;
|
|
@@ -2334,8 +2334,8 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2334
2334
|
columns: string[];
|
|
2335
2335
|
}> | undefined;
|
|
2336
2336
|
checkConstraints?: Record<string, {
|
|
2337
|
-
name: string;
|
|
2338
2337
|
value: string;
|
|
2338
|
+
name: string;
|
|
2339
2339
|
}> | undefined;
|
|
2340
2340
|
}>>;
|
|
2341
2341
|
views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
|
|
@@ -2358,59 +2358,59 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2358
2358
|
as: string;
|
|
2359
2359
|
}>>;
|
|
2360
2360
|
}, "strict", zod.ZodTypeAny, {
|
|
2361
|
-
name: string;
|
|
2362
2361
|
type: string;
|
|
2362
|
+
name: string;
|
|
2363
2363
|
primaryKey: boolean;
|
|
2364
2364
|
notNull: boolean;
|
|
2365
2365
|
default?: any;
|
|
2366
|
-
autoincrement?: boolean | undefined;
|
|
2367
2366
|
generated?: {
|
|
2368
2367
|
type: "stored" | "virtual";
|
|
2369
2368
|
as: string;
|
|
2370
2369
|
} | undefined;
|
|
2370
|
+
autoincrement?: boolean | undefined;
|
|
2371
2371
|
}, {
|
|
2372
|
-
name: string;
|
|
2373
2372
|
type: string;
|
|
2373
|
+
name: string;
|
|
2374
2374
|
primaryKey: boolean;
|
|
2375
2375
|
notNull: boolean;
|
|
2376
2376
|
default?: any;
|
|
2377
|
-
autoincrement?: boolean | undefined;
|
|
2378
2377
|
generated?: {
|
|
2379
2378
|
type: "stored" | "virtual";
|
|
2380
2379
|
as: string;
|
|
2381
2380
|
} | undefined;
|
|
2381
|
+
autoincrement?: boolean | undefined;
|
|
2382
2382
|
}>>;
|
|
2383
2383
|
definition: zod.ZodOptional<zod.ZodString>;
|
|
2384
2384
|
isExisting: zod.ZodBoolean;
|
|
2385
2385
|
}, "strict", zod.ZodTypeAny, {
|
|
2386
2386
|
name: string;
|
|
2387
2387
|
columns: Record<string, {
|
|
2388
|
-
name: string;
|
|
2389
2388
|
type: string;
|
|
2389
|
+
name: string;
|
|
2390
2390
|
primaryKey: boolean;
|
|
2391
2391
|
notNull: boolean;
|
|
2392
2392
|
default?: any;
|
|
2393
|
-
autoincrement?: boolean | undefined;
|
|
2394
2393
|
generated?: {
|
|
2395
2394
|
type: "stored" | "virtual";
|
|
2396
2395
|
as: string;
|
|
2397
2396
|
} | undefined;
|
|
2397
|
+
autoincrement?: boolean | undefined;
|
|
2398
2398
|
}>;
|
|
2399
2399
|
isExisting: boolean;
|
|
2400
2400
|
definition?: string | undefined;
|
|
2401
2401
|
}, {
|
|
2402
2402
|
name: string;
|
|
2403
2403
|
columns: Record<string, {
|
|
2404
|
-
name: string;
|
|
2405
2404
|
type: string;
|
|
2405
|
+
name: string;
|
|
2406
2406
|
primaryKey: boolean;
|
|
2407
2407
|
notNull: boolean;
|
|
2408
2408
|
default?: any;
|
|
2409
|
-
autoincrement?: boolean | undefined;
|
|
2410
2409
|
generated?: {
|
|
2411
2410
|
type: "stored" | "virtual";
|
|
2412
2411
|
as: string;
|
|
2413
2412
|
} | undefined;
|
|
2413
|
+
autoincrement?: boolean | undefined;
|
|
2414
2414
|
}>;
|
|
2415
2415
|
isExisting: boolean;
|
|
2416
2416
|
definition?: string | undefined;
|
|
@@ -2420,11 +2420,11 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2420
2420
|
tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
2421
2421
|
columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
|
|
2422
2422
|
}, "strip", zod.ZodTypeAny, {
|
|
2423
|
-
columns: Record<string, string>;
|
|
2424
2423
|
tables: Record<string, string>;
|
|
2425
|
-
}, {
|
|
2426
2424
|
columns: Record<string, string>;
|
|
2425
|
+
}, {
|
|
2427
2426
|
tables: Record<string, string>;
|
|
2427
|
+
columns: Record<string, string>;
|
|
2428
2428
|
}>;
|
|
2429
2429
|
internal: zod.ZodOptional<zod.ZodObject<{
|
|
2430
2430
|
indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
|
|
@@ -2461,19 +2461,21 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2461
2461
|
id: zod.ZodString;
|
|
2462
2462
|
prevId: zod.ZodString;
|
|
2463
2463
|
}>, "strict", zod.ZodTypeAny, {
|
|
2464
|
+
version: "6";
|
|
2465
|
+
dialect: "sqlite";
|
|
2464
2466
|
tables: Record<string, {
|
|
2465
2467
|
name: string;
|
|
2466
2468
|
columns: Record<string, {
|
|
2467
|
-
name: string;
|
|
2468
2469
|
type: string;
|
|
2470
|
+
name: string;
|
|
2469
2471
|
primaryKey: boolean;
|
|
2470
2472
|
notNull: boolean;
|
|
2471
2473
|
default?: any;
|
|
2472
|
-
autoincrement?: boolean | undefined;
|
|
2473
2474
|
generated?: {
|
|
2474
2475
|
type: "stored" | "virtual";
|
|
2475
2476
|
as: string;
|
|
2476
2477
|
} | undefined;
|
|
2478
|
+
autoincrement?: boolean | undefined;
|
|
2477
2479
|
}>;
|
|
2478
2480
|
indexes: Record<string, {
|
|
2479
2481
|
name: string;
|
|
@@ -2499,36 +2501,34 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2499
2501
|
columns: string[];
|
|
2500
2502
|
}>;
|
|
2501
2503
|
checkConstraints: Record<string, {
|
|
2502
|
-
name: string;
|
|
2503
2504
|
value: string;
|
|
2505
|
+
name: string;
|
|
2504
2506
|
}>;
|
|
2505
2507
|
}>;
|
|
2506
|
-
|
|
2507
|
-
prevId: string;
|
|
2508
|
-
version: "6";
|
|
2509
|
-
dialect: "sqlite";
|
|
2510
|
-
_meta: {
|
|
2511
|
-
columns: Record<string, string>;
|
|
2512
|
-
tables: Record<string, string>;
|
|
2513
|
-
};
|
|
2508
|
+
enums: {};
|
|
2514
2509
|
views: Record<string, {
|
|
2515
2510
|
name: string;
|
|
2516
2511
|
columns: Record<string, {
|
|
2517
|
-
name: string;
|
|
2518
2512
|
type: string;
|
|
2513
|
+
name: string;
|
|
2519
2514
|
primaryKey: boolean;
|
|
2520
2515
|
notNull: boolean;
|
|
2521
2516
|
default?: any;
|
|
2522
|
-
autoincrement?: boolean | undefined;
|
|
2523
2517
|
generated?: {
|
|
2524
2518
|
type: "stored" | "virtual";
|
|
2525
2519
|
as: string;
|
|
2526
2520
|
} | undefined;
|
|
2521
|
+
autoincrement?: boolean | undefined;
|
|
2527
2522
|
}>;
|
|
2528
2523
|
isExisting: boolean;
|
|
2529
2524
|
definition?: string | undefined;
|
|
2530
2525
|
}>;
|
|
2531
|
-
|
|
2526
|
+
_meta: {
|
|
2527
|
+
tables: Record<string, string>;
|
|
2528
|
+
columns: Record<string, string>;
|
|
2529
|
+
};
|
|
2530
|
+
id: string;
|
|
2531
|
+
prevId: string;
|
|
2532
2532
|
internal?: {
|
|
2533
2533
|
indexes?: Record<string, {
|
|
2534
2534
|
columns: Record<string, {
|
|
@@ -2537,19 +2537,21 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2537
2537
|
} | undefined> | undefined;
|
|
2538
2538
|
} | undefined;
|
|
2539
2539
|
}, {
|
|
2540
|
+
version: "6";
|
|
2541
|
+
dialect: "sqlite";
|
|
2540
2542
|
tables: Record<string, {
|
|
2541
2543
|
name: string;
|
|
2542
2544
|
columns: Record<string, {
|
|
2543
|
-
name: string;
|
|
2544
2545
|
type: string;
|
|
2546
|
+
name: string;
|
|
2545
2547
|
primaryKey: boolean;
|
|
2546
2548
|
notNull: boolean;
|
|
2547
2549
|
default?: any;
|
|
2548
|
-
autoincrement?: boolean | undefined;
|
|
2549
2550
|
generated?: {
|
|
2550
2551
|
type: "stored" | "virtual";
|
|
2551
2552
|
as: string;
|
|
2552
2553
|
} | undefined;
|
|
2554
|
+
autoincrement?: boolean | undefined;
|
|
2553
2555
|
}>;
|
|
2554
2556
|
indexes: Record<string, {
|
|
2555
2557
|
name: string;
|
|
@@ -2575,43 +2577,41 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
|
|
|
2575
2577
|
columns: string[];
|
|
2576
2578
|
}> | undefined;
|
|
2577
2579
|
checkConstraints?: Record<string, {
|
|
2578
|
-
name: string;
|
|
2579
2580
|
value: string;
|
|
2581
|
+
name: string;
|
|
2580
2582
|
}> | undefined;
|
|
2581
2583
|
}>;
|
|
2582
|
-
|
|
2583
|
-
prevId: string;
|
|
2584
|
-
version: "6";
|
|
2585
|
-
dialect: "sqlite";
|
|
2584
|
+
enums: {};
|
|
2586
2585
|
_meta: {
|
|
2587
|
-
columns: Record<string, string>;
|
|
2588
2586
|
tables: Record<string, string>;
|
|
2587
|
+
columns: Record<string, string>;
|
|
2589
2588
|
};
|
|
2590
|
-
|
|
2591
|
-
|
|
2592
|
-
indexes?: Record<string, {
|
|
2593
|
-
columns: Record<string, {
|
|
2594
|
-
isExpression?: boolean | undefined;
|
|
2595
|
-
} | undefined>;
|
|
2596
|
-
} | undefined> | undefined;
|
|
2597
|
-
} | undefined;
|
|
2589
|
+
id: string;
|
|
2590
|
+
prevId: string;
|
|
2598
2591
|
views?: Record<string, {
|
|
2599
2592
|
name: string;
|
|
2600
2593
|
columns: Record<string, {
|
|
2601
|
-
name: string;
|
|
2602
2594
|
type: string;
|
|
2595
|
+
name: string;
|
|
2603
2596
|
primaryKey: boolean;
|
|
2604
2597
|
notNull: boolean;
|
|
2605
2598
|
default?: any;
|
|
2606
|
-
autoincrement?: boolean | undefined;
|
|
2607
2599
|
generated?: {
|
|
2608
2600
|
type: "stored" | "virtual";
|
|
2609
2601
|
as: string;
|
|
2610
2602
|
} | undefined;
|
|
2603
|
+
autoincrement?: boolean | undefined;
|
|
2611
2604
|
}>;
|
|
2612
2605
|
isExisting: boolean;
|
|
2613
2606
|
definition?: string | undefined;
|
|
2614
2607
|
}> | undefined;
|
|
2608
|
+
internal?: {
|
|
2609
|
+
indexes?: Record<string, {
|
|
2610
|
+
columns: Record<string, {
|
|
2611
|
+
isExpression?: boolean | undefined;
|
|
2612
|
+
} | undefined>;
|
|
2613
|
+
} | undefined> | undefined;
|
|
2614
|
+
} | undefined;
|
|
2615
2615
|
}>;
|
|
2616
2616
|
type SQLiteSchema = TypeOf<typeof schema>;
|
|
2617
2617
|
|