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