drizzle-kit 0.31.1-9811cd4 → 0.31.1-a2a1a62

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.
Files changed (13) hide show
  1. package/api.d.mts +2845 -1
  2. package/api.d.ts +2845 -1
  3. package/api.js +48758 -0
  4. package/api.mjs +48746 -0
  5. package/bin.cjs +61369 -50353
  6. package/index-BAUrj6Ib.d.mts +321 -0
  7. package/index-BAUrj6Ib.d.ts +321 -0
  8. package/index.d.mts +2 -319
  9. package/index.d.ts +2 -319
  10. package/index.js +3 -3
  11. package/package.json +9 -14
  12. package/utils.js +6285 -36
  13. package/utils.mjs +6272 -12
package/api.d.mts CHANGED
@@ -1,2 +1,2846 @@
1
+ import { LibSQLDatabase } from 'drizzle-orm/libsql';
2
+ import { MySql2Database } from 'drizzle-orm/mysql2';
3
+ import { PgDatabase } from 'drizzle-orm/pg-core';
4
+ import { SingleStoreDriverDatabase } from 'drizzle-orm/singlestore';
5
+ import { C as CasingType, a as Config } from './index-BAUrj6Ib.mjs';
6
+ import * as zod from 'zod';
7
+ import { TypeOf } from 'zod';
8
+ import 'tls';
1
9
 
2
- export { }
10
+ declare const schema$2: zod.ZodObject<{
11
+ version: zod.ZodLiteral<"5">;
12
+ dialect: zod.ZodLiteral<"mysql">;
13
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
14
+ name: zod.ZodString;
15
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
16
+ name: zod.ZodString;
17
+ type: zod.ZodString;
18
+ primaryKey: zod.ZodBoolean;
19
+ notNull: zod.ZodBoolean;
20
+ autoincrement: zod.ZodOptional<zod.ZodBoolean>;
21
+ default: zod.ZodOptional<zod.ZodAny>;
22
+ onUpdate: zod.ZodOptional<zod.ZodAny>;
23
+ generated: zod.ZodOptional<zod.ZodObject<{
24
+ type: zod.ZodEnum<["stored", "virtual"]>;
25
+ as: zod.ZodString;
26
+ }, "strip", zod.ZodTypeAny, {
27
+ type: "stored" | "virtual";
28
+ as: string;
29
+ }, {
30
+ type: "stored" | "virtual";
31
+ as: string;
32
+ }>>;
33
+ }, "strict", zod.ZodTypeAny, {
34
+ type: string;
35
+ name: string;
36
+ primaryKey: boolean;
37
+ notNull: boolean;
38
+ default?: any;
39
+ generated?: {
40
+ type: "stored" | "virtual";
41
+ as: string;
42
+ } | undefined;
43
+ onUpdate?: any;
44
+ autoincrement?: boolean | undefined;
45
+ }, {
46
+ type: string;
47
+ name: string;
48
+ primaryKey: boolean;
49
+ notNull: boolean;
50
+ default?: any;
51
+ generated?: {
52
+ type: "stored" | "virtual";
53
+ as: string;
54
+ } | undefined;
55
+ onUpdate?: any;
56
+ autoincrement?: boolean | undefined;
57
+ }>>;
58
+ indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
59
+ name: zod.ZodString;
60
+ columns: zod.ZodArray<zod.ZodString, "many">;
61
+ isUnique: zod.ZodBoolean;
62
+ using: zod.ZodOptional<zod.ZodEnum<["btree", "hash"]>>;
63
+ algorithm: zod.ZodOptional<zod.ZodEnum<["default", "inplace", "copy"]>>;
64
+ lock: zod.ZodOptional<zod.ZodEnum<["default", "none", "shared", "exclusive"]>>;
65
+ }, "strict", zod.ZodTypeAny, {
66
+ name: string;
67
+ columns: string[];
68
+ isUnique: boolean;
69
+ using?: "btree" | "hash" | undefined;
70
+ algorithm?: "default" | "inplace" | "copy" | undefined;
71
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
72
+ }, {
73
+ name: string;
74
+ columns: string[];
75
+ isUnique: boolean;
76
+ using?: "btree" | "hash" | undefined;
77
+ algorithm?: "default" | "inplace" | "copy" | undefined;
78
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
79
+ }>>;
80
+ foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
81
+ name: zod.ZodString;
82
+ tableFrom: zod.ZodString;
83
+ columnsFrom: zod.ZodArray<zod.ZodString, "many">;
84
+ tableTo: zod.ZodString;
85
+ columnsTo: zod.ZodArray<zod.ZodString, "many">;
86
+ onUpdate: zod.ZodOptional<zod.ZodString>;
87
+ onDelete: zod.ZodOptional<zod.ZodString>;
88
+ }, "strict", zod.ZodTypeAny, {
89
+ name: string;
90
+ tableFrom: string;
91
+ columnsFrom: string[];
92
+ tableTo: string;
93
+ columnsTo: string[];
94
+ onUpdate?: string | undefined;
95
+ onDelete?: string | undefined;
96
+ }, {
97
+ name: string;
98
+ tableFrom: string;
99
+ columnsFrom: string[];
100
+ tableTo: string;
101
+ columnsTo: string[];
102
+ onUpdate?: string | undefined;
103
+ onDelete?: string | undefined;
104
+ }>>;
105
+ compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
106
+ name: zod.ZodString;
107
+ columns: zod.ZodArray<zod.ZodString, "many">;
108
+ }, "strict", zod.ZodTypeAny, {
109
+ name: string;
110
+ columns: string[];
111
+ }, {
112
+ name: string;
113
+ columns: string[];
114
+ }>>;
115
+ uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
116
+ name: zod.ZodString;
117
+ columns: zod.ZodArray<zod.ZodString, "many">;
118
+ }, "strict", zod.ZodTypeAny, {
119
+ name: string;
120
+ columns: string[];
121
+ }, {
122
+ name: string;
123
+ columns: string[];
124
+ }>>>;
125
+ checkConstraint: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
126
+ name: zod.ZodString;
127
+ value: zod.ZodString;
128
+ }, "strict", zod.ZodTypeAny, {
129
+ value: string;
130
+ name: string;
131
+ }, {
132
+ value: string;
133
+ name: string;
134
+ }>>>;
135
+ }, "strict", zod.ZodTypeAny, {
136
+ name: string;
137
+ columns: Record<string, {
138
+ type: string;
139
+ name: string;
140
+ primaryKey: boolean;
141
+ notNull: boolean;
142
+ default?: any;
143
+ generated?: {
144
+ type: "stored" | "virtual";
145
+ as: string;
146
+ } | undefined;
147
+ onUpdate?: any;
148
+ autoincrement?: boolean | undefined;
149
+ }>;
150
+ indexes: Record<string, {
151
+ name: string;
152
+ columns: string[];
153
+ isUnique: boolean;
154
+ using?: "btree" | "hash" | undefined;
155
+ algorithm?: "default" | "inplace" | "copy" | undefined;
156
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
157
+ }>;
158
+ foreignKeys: Record<string, {
159
+ name: string;
160
+ tableFrom: string;
161
+ columnsFrom: string[];
162
+ tableTo: string;
163
+ columnsTo: string[];
164
+ onUpdate?: string | undefined;
165
+ onDelete?: string | undefined;
166
+ }>;
167
+ compositePrimaryKeys: Record<string, {
168
+ name: string;
169
+ columns: string[];
170
+ }>;
171
+ uniqueConstraints: Record<string, {
172
+ name: string;
173
+ columns: string[];
174
+ }>;
175
+ checkConstraint: Record<string, {
176
+ value: string;
177
+ name: string;
178
+ }>;
179
+ }, {
180
+ name: string;
181
+ columns: Record<string, {
182
+ type: string;
183
+ name: string;
184
+ primaryKey: boolean;
185
+ notNull: boolean;
186
+ default?: any;
187
+ generated?: {
188
+ type: "stored" | "virtual";
189
+ as: string;
190
+ } | undefined;
191
+ onUpdate?: any;
192
+ autoincrement?: boolean | undefined;
193
+ }>;
194
+ indexes: Record<string, {
195
+ name: string;
196
+ columns: string[];
197
+ isUnique: boolean;
198
+ using?: "btree" | "hash" | undefined;
199
+ algorithm?: "default" | "inplace" | "copy" | undefined;
200
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
201
+ }>;
202
+ foreignKeys: Record<string, {
203
+ name: string;
204
+ tableFrom: string;
205
+ columnsFrom: string[];
206
+ tableTo: string;
207
+ columnsTo: string[];
208
+ onUpdate?: string | undefined;
209
+ onDelete?: string | undefined;
210
+ }>;
211
+ compositePrimaryKeys: Record<string, {
212
+ name: string;
213
+ columns: string[];
214
+ }>;
215
+ uniqueConstraints?: Record<string, {
216
+ name: string;
217
+ columns: string[];
218
+ }> | undefined;
219
+ checkConstraint?: Record<string, {
220
+ value: string;
221
+ name: string;
222
+ }> | undefined;
223
+ }>>;
224
+ views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
225
+ name: zod.ZodString;
226
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
227
+ name: zod.ZodString;
228
+ type: zod.ZodString;
229
+ primaryKey: zod.ZodBoolean;
230
+ notNull: zod.ZodBoolean;
231
+ autoincrement: zod.ZodOptional<zod.ZodBoolean>;
232
+ default: zod.ZodOptional<zod.ZodAny>;
233
+ onUpdate: zod.ZodOptional<zod.ZodAny>;
234
+ generated: zod.ZodOptional<zod.ZodObject<{
235
+ type: zod.ZodEnum<["stored", "virtual"]>;
236
+ as: zod.ZodString;
237
+ }, "strip", zod.ZodTypeAny, {
238
+ type: "stored" | "virtual";
239
+ as: string;
240
+ }, {
241
+ type: "stored" | "virtual";
242
+ as: string;
243
+ }>>;
244
+ }, "strict", zod.ZodTypeAny, {
245
+ type: string;
246
+ name: string;
247
+ primaryKey: boolean;
248
+ notNull: boolean;
249
+ default?: any;
250
+ generated?: {
251
+ type: "stored" | "virtual";
252
+ as: string;
253
+ } | undefined;
254
+ onUpdate?: any;
255
+ autoincrement?: boolean | undefined;
256
+ }, {
257
+ type: string;
258
+ name: string;
259
+ primaryKey: boolean;
260
+ notNull: boolean;
261
+ default?: any;
262
+ generated?: {
263
+ type: "stored" | "virtual";
264
+ as: string;
265
+ } | undefined;
266
+ onUpdate?: any;
267
+ autoincrement?: boolean | undefined;
268
+ }>>;
269
+ definition: zod.ZodOptional<zod.ZodString>;
270
+ isExisting: zod.ZodBoolean;
271
+ } & {
272
+ algorithm: zod.ZodEnum<["undefined", "merge", "temptable"]>;
273
+ sqlSecurity: zod.ZodEnum<["definer", "invoker"]>;
274
+ withCheckOption: zod.ZodOptional<zod.ZodEnum<["local", "cascaded"]>>;
275
+ }, "strict", zod.ZodTypeAny, {
276
+ name: string;
277
+ columns: Record<string, {
278
+ type: string;
279
+ name: string;
280
+ primaryKey: boolean;
281
+ notNull: boolean;
282
+ default?: any;
283
+ generated?: {
284
+ type: "stored" | "virtual";
285
+ as: string;
286
+ } | undefined;
287
+ onUpdate?: any;
288
+ autoincrement?: boolean | undefined;
289
+ }>;
290
+ isExisting: boolean;
291
+ algorithm: "undefined" | "merge" | "temptable";
292
+ sqlSecurity: "definer" | "invoker";
293
+ definition?: string | undefined;
294
+ withCheckOption?: "local" | "cascaded" | undefined;
295
+ }, {
296
+ name: string;
297
+ columns: Record<string, {
298
+ type: string;
299
+ name: string;
300
+ primaryKey: boolean;
301
+ notNull: boolean;
302
+ default?: any;
303
+ generated?: {
304
+ type: "stored" | "virtual";
305
+ as: string;
306
+ } | undefined;
307
+ onUpdate?: any;
308
+ autoincrement?: boolean | undefined;
309
+ }>;
310
+ isExisting: boolean;
311
+ algorithm: "undefined" | "merge" | "temptable";
312
+ sqlSecurity: "definer" | "invoker";
313
+ definition?: string | undefined;
314
+ withCheckOption?: "local" | "cascaded" | undefined;
315
+ }>>>;
316
+ _meta: zod.ZodObject<{
317
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
318
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
319
+ }, "strip", zod.ZodTypeAny, {
320
+ tables: Record<string, string>;
321
+ columns: Record<string, string>;
322
+ }, {
323
+ tables: Record<string, string>;
324
+ columns: Record<string, string>;
325
+ }>;
326
+ internal: zod.ZodOptional<zod.ZodObject<{
327
+ tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
328
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
329
+ isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
330
+ }, "strip", zod.ZodTypeAny, {
331
+ isDefaultAnExpression?: boolean | undefined;
332
+ }, {
333
+ isDefaultAnExpression?: boolean | undefined;
334
+ }>>>;
335
+ }, "strip", zod.ZodTypeAny, {
336
+ columns: Record<string, {
337
+ isDefaultAnExpression?: boolean | undefined;
338
+ } | undefined>;
339
+ }, {
340
+ columns: Record<string, {
341
+ isDefaultAnExpression?: boolean | undefined;
342
+ } | undefined>;
343
+ }>>>>;
344
+ indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
345
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
346
+ isExpression: zod.ZodOptional<zod.ZodBoolean>;
347
+ }, "strip", zod.ZodTypeAny, {
348
+ isExpression?: boolean | undefined;
349
+ }, {
350
+ isExpression?: boolean | undefined;
351
+ }>>>;
352
+ }, "strip", zod.ZodTypeAny, {
353
+ columns: Record<string, {
354
+ isExpression?: boolean | undefined;
355
+ } | undefined>;
356
+ }, {
357
+ columns: Record<string, {
358
+ isExpression?: boolean | undefined;
359
+ } | undefined>;
360
+ }>>>>;
361
+ }, "strip", zod.ZodTypeAny, {
362
+ tables?: Record<string, {
363
+ columns: Record<string, {
364
+ isDefaultAnExpression?: boolean | undefined;
365
+ } | undefined>;
366
+ } | undefined> | undefined;
367
+ indexes?: Record<string, {
368
+ columns: Record<string, {
369
+ isExpression?: boolean | undefined;
370
+ } | undefined>;
371
+ } | undefined> | undefined;
372
+ }, {
373
+ tables?: Record<string, {
374
+ columns: Record<string, {
375
+ isDefaultAnExpression?: boolean | undefined;
376
+ } | undefined>;
377
+ } | undefined> | undefined;
378
+ indexes?: Record<string, {
379
+ columns: Record<string, {
380
+ isExpression?: boolean | undefined;
381
+ } | undefined>;
382
+ } | undefined> | undefined;
383
+ }>>;
384
+ } & {
385
+ id: zod.ZodString;
386
+ prevId: zod.ZodString;
387
+ }, "strip", zod.ZodTypeAny, {
388
+ version: "5";
389
+ dialect: "mysql";
390
+ tables: Record<string, {
391
+ name: string;
392
+ columns: Record<string, {
393
+ type: string;
394
+ name: string;
395
+ primaryKey: boolean;
396
+ notNull: boolean;
397
+ default?: any;
398
+ generated?: {
399
+ type: "stored" | "virtual";
400
+ as: string;
401
+ } | undefined;
402
+ onUpdate?: any;
403
+ autoincrement?: boolean | undefined;
404
+ }>;
405
+ indexes: Record<string, {
406
+ name: string;
407
+ columns: string[];
408
+ isUnique: boolean;
409
+ using?: "btree" | "hash" | undefined;
410
+ algorithm?: "default" | "inplace" | "copy" | undefined;
411
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
412
+ }>;
413
+ foreignKeys: Record<string, {
414
+ name: string;
415
+ tableFrom: string;
416
+ columnsFrom: string[];
417
+ tableTo: string;
418
+ columnsTo: string[];
419
+ onUpdate?: string | undefined;
420
+ onDelete?: string | undefined;
421
+ }>;
422
+ compositePrimaryKeys: Record<string, {
423
+ name: string;
424
+ columns: string[];
425
+ }>;
426
+ uniqueConstraints: Record<string, {
427
+ name: string;
428
+ columns: string[];
429
+ }>;
430
+ checkConstraint: Record<string, {
431
+ value: string;
432
+ name: string;
433
+ }>;
434
+ }>;
435
+ views: Record<string, {
436
+ name: string;
437
+ columns: Record<string, {
438
+ type: string;
439
+ name: string;
440
+ primaryKey: boolean;
441
+ notNull: boolean;
442
+ default?: any;
443
+ generated?: {
444
+ type: "stored" | "virtual";
445
+ as: string;
446
+ } | undefined;
447
+ onUpdate?: any;
448
+ autoincrement?: boolean | undefined;
449
+ }>;
450
+ isExisting: boolean;
451
+ algorithm: "undefined" | "merge" | "temptable";
452
+ sqlSecurity: "definer" | "invoker";
453
+ definition?: string | undefined;
454
+ withCheckOption?: "local" | "cascaded" | undefined;
455
+ }>;
456
+ _meta: {
457
+ tables: Record<string, string>;
458
+ columns: Record<string, string>;
459
+ };
460
+ id: string;
461
+ prevId: string;
462
+ internal?: {
463
+ tables?: Record<string, {
464
+ columns: Record<string, {
465
+ isDefaultAnExpression?: boolean | undefined;
466
+ } | undefined>;
467
+ } | undefined> | undefined;
468
+ indexes?: Record<string, {
469
+ columns: Record<string, {
470
+ isExpression?: boolean | undefined;
471
+ } | undefined>;
472
+ } | undefined> | undefined;
473
+ } | undefined;
474
+ }, {
475
+ version: "5";
476
+ dialect: "mysql";
477
+ tables: Record<string, {
478
+ name: string;
479
+ columns: Record<string, {
480
+ type: string;
481
+ name: string;
482
+ primaryKey: boolean;
483
+ notNull: boolean;
484
+ default?: any;
485
+ generated?: {
486
+ type: "stored" | "virtual";
487
+ as: string;
488
+ } | undefined;
489
+ onUpdate?: any;
490
+ autoincrement?: boolean | undefined;
491
+ }>;
492
+ indexes: Record<string, {
493
+ name: string;
494
+ columns: string[];
495
+ isUnique: boolean;
496
+ using?: "btree" | "hash" | undefined;
497
+ algorithm?: "default" | "inplace" | "copy" | undefined;
498
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
499
+ }>;
500
+ foreignKeys: Record<string, {
501
+ name: string;
502
+ tableFrom: string;
503
+ columnsFrom: string[];
504
+ tableTo: string;
505
+ columnsTo: string[];
506
+ onUpdate?: string | undefined;
507
+ onDelete?: string | undefined;
508
+ }>;
509
+ compositePrimaryKeys: Record<string, {
510
+ name: string;
511
+ columns: string[];
512
+ }>;
513
+ uniqueConstraints?: Record<string, {
514
+ name: string;
515
+ columns: string[];
516
+ }> | undefined;
517
+ checkConstraint?: Record<string, {
518
+ value: string;
519
+ name: string;
520
+ }> | undefined;
521
+ }>;
522
+ _meta: {
523
+ tables: Record<string, string>;
524
+ columns: Record<string, string>;
525
+ };
526
+ id: string;
527
+ prevId: string;
528
+ views?: Record<string, {
529
+ name: string;
530
+ columns: Record<string, {
531
+ type: string;
532
+ name: string;
533
+ primaryKey: boolean;
534
+ notNull: boolean;
535
+ default?: any;
536
+ generated?: {
537
+ type: "stored" | "virtual";
538
+ as: string;
539
+ } | undefined;
540
+ onUpdate?: any;
541
+ autoincrement?: boolean | undefined;
542
+ }>;
543
+ isExisting: boolean;
544
+ algorithm: "undefined" | "merge" | "temptable";
545
+ sqlSecurity: "definer" | "invoker";
546
+ definition?: string | undefined;
547
+ withCheckOption?: "local" | "cascaded" | undefined;
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
+ }>;
562
+ type MySqlSchema = TypeOf<typeof schema$2>;
563
+
564
+ declare const pgSchema: zod.ZodObject<{
565
+ version: zod.ZodLiteral<"7">;
566
+ dialect: zod.ZodLiteral<"postgresql">;
567
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
568
+ name: zod.ZodString;
569
+ schema: zod.ZodString;
570
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
571
+ name: zod.ZodString;
572
+ type: zod.ZodString;
573
+ typeSchema: zod.ZodOptional<zod.ZodString>;
574
+ primaryKey: zod.ZodBoolean;
575
+ notNull: zod.ZodBoolean;
576
+ default: zod.ZodOptional<zod.ZodAny>;
577
+ isUnique: zod.ZodOptional<zod.ZodAny>;
578
+ uniqueName: zod.ZodOptional<zod.ZodString>;
579
+ nullsNotDistinct: zod.ZodOptional<zod.ZodBoolean>;
580
+ generated: zod.ZodOptional<zod.ZodObject<{
581
+ type: zod.ZodLiteral<"stored">;
582
+ as: zod.ZodString;
583
+ }, "strip", zod.ZodTypeAny, {
584
+ type: "stored";
585
+ as: string;
586
+ }, {
587
+ type: "stored";
588
+ as: string;
589
+ }>>;
590
+ identity: zod.ZodOptional<zod.ZodObject<{
591
+ name: zod.ZodString;
592
+ increment: zod.ZodOptional<zod.ZodString>;
593
+ minValue: zod.ZodOptional<zod.ZodString>;
594
+ maxValue: zod.ZodOptional<zod.ZodString>;
595
+ startWith: zod.ZodOptional<zod.ZodString>;
596
+ cache: zod.ZodOptional<zod.ZodString>;
597
+ cycle: zod.ZodOptional<zod.ZodBoolean>;
598
+ schema: zod.ZodString;
599
+ } & {
600
+ type: zod.ZodEnum<["always", "byDefault"]>;
601
+ }, "strip", zod.ZodTypeAny, {
602
+ type: "always" | "byDefault";
603
+ name: string;
604
+ schema: string;
605
+ increment?: string | undefined;
606
+ minValue?: string | undefined;
607
+ maxValue?: string | undefined;
608
+ startWith?: string | undefined;
609
+ cache?: string | undefined;
610
+ cycle?: boolean | undefined;
611
+ }, {
612
+ type: "always" | "byDefault";
613
+ name: string;
614
+ schema: string;
615
+ increment?: string | undefined;
616
+ minValue?: string | undefined;
617
+ maxValue?: string | undefined;
618
+ startWith?: string | undefined;
619
+ cache?: string | undefined;
620
+ cycle?: boolean | undefined;
621
+ }>>;
622
+ }, "strict", zod.ZodTypeAny, {
623
+ type: string;
624
+ name: string;
625
+ primaryKey: boolean;
626
+ notNull: boolean;
627
+ typeSchema?: string | undefined;
628
+ default?: any;
629
+ isUnique?: any;
630
+ uniqueName?: string | undefined;
631
+ nullsNotDistinct?: boolean | undefined;
632
+ generated?: {
633
+ type: "stored";
634
+ as: string;
635
+ } | undefined;
636
+ identity?: {
637
+ type: "always" | "byDefault";
638
+ name: string;
639
+ schema: string;
640
+ increment?: string | undefined;
641
+ minValue?: string | undefined;
642
+ maxValue?: string | undefined;
643
+ startWith?: string | undefined;
644
+ cache?: string | undefined;
645
+ cycle?: boolean | undefined;
646
+ } | undefined;
647
+ }, {
648
+ type: string;
649
+ name: string;
650
+ primaryKey: boolean;
651
+ notNull: boolean;
652
+ typeSchema?: string | undefined;
653
+ default?: any;
654
+ isUnique?: any;
655
+ uniqueName?: string | undefined;
656
+ nullsNotDistinct?: boolean | undefined;
657
+ generated?: {
658
+ type: "stored";
659
+ as: string;
660
+ } | undefined;
661
+ identity?: {
662
+ type: "always" | "byDefault";
663
+ name: string;
664
+ schema: string;
665
+ increment?: string | undefined;
666
+ minValue?: string | undefined;
667
+ maxValue?: string | undefined;
668
+ startWith?: string | undefined;
669
+ cache?: string | undefined;
670
+ cycle?: boolean | undefined;
671
+ } | undefined;
672
+ }>>;
673
+ indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
674
+ name: zod.ZodString;
675
+ columns: zod.ZodArray<zod.ZodObject<{
676
+ expression: zod.ZodString;
677
+ isExpression: zod.ZodBoolean;
678
+ asc: zod.ZodBoolean;
679
+ nulls: zod.ZodOptional<zod.ZodString>;
680
+ opclass: zod.ZodOptional<zod.ZodString>;
681
+ }, "strip", zod.ZodTypeAny, {
682
+ expression: string;
683
+ isExpression: boolean;
684
+ asc: boolean;
685
+ nulls?: string | undefined;
686
+ opclass?: string | undefined;
687
+ }, {
688
+ expression: string;
689
+ isExpression: boolean;
690
+ asc: boolean;
691
+ nulls?: string | undefined;
692
+ opclass?: string | undefined;
693
+ }>, "many">;
694
+ isUnique: zod.ZodBoolean;
695
+ with: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodAny>>;
696
+ method: zod.ZodDefault<zod.ZodString>;
697
+ where: zod.ZodOptional<zod.ZodString>;
698
+ concurrently: zod.ZodDefault<zod.ZodBoolean>;
699
+ }, "strict", zod.ZodTypeAny, {
700
+ name: string;
701
+ columns: {
702
+ expression: string;
703
+ isExpression: boolean;
704
+ asc: boolean;
705
+ nulls?: string | undefined;
706
+ opclass?: string | undefined;
707
+ }[];
708
+ isUnique: boolean;
709
+ method: string;
710
+ concurrently: boolean;
711
+ with?: Record<string, any> | undefined;
712
+ where?: string | undefined;
713
+ }, {
714
+ name: string;
715
+ columns: {
716
+ expression: string;
717
+ isExpression: boolean;
718
+ asc: boolean;
719
+ nulls?: string | undefined;
720
+ opclass?: string | undefined;
721
+ }[];
722
+ isUnique: boolean;
723
+ with?: Record<string, any> | undefined;
724
+ method?: string | undefined;
725
+ where?: string | undefined;
726
+ concurrently?: boolean | undefined;
727
+ }>>;
728
+ foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
729
+ name: zod.ZodString;
730
+ tableFrom: zod.ZodString;
731
+ columnsFrom: zod.ZodArray<zod.ZodString, "many">;
732
+ tableTo: zod.ZodString;
733
+ schemaTo: zod.ZodOptional<zod.ZodString>;
734
+ columnsTo: zod.ZodArray<zod.ZodString, "many">;
735
+ onUpdate: zod.ZodOptional<zod.ZodString>;
736
+ onDelete: zod.ZodOptional<zod.ZodString>;
737
+ }, "strict", zod.ZodTypeAny, {
738
+ name: string;
739
+ tableFrom: string;
740
+ columnsFrom: string[];
741
+ tableTo: string;
742
+ columnsTo: string[];
743
+ schemaTo?: string | undefined;
744
+ onUpdate?: string | undefined;
745
+ onDelete?: string | undefined;
746
+ }, {
747
+ name: string;
748
+ tableFrom: string;
749
+ columnsFrom: string[];
750
+ tableTo: string;
751
+ columnsTo: string[];
752
+ schemaTo?: string | undefined;
753
+ onUpdate?: string | undefined;
754
+ onDelete?: string | undefined;
755
+ }>>;
756
+ compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
757
+ name: zod.ZodString;
758
+ columns: zod.ZodArray<zod.ZodString, "many">;
759
+ }, "strict", zod.ZodTypeAny, {
760
+ name: string;
761
+ columns: string[];
762
+ }, {
763
+ name: string;
764
+ columns: string[];
765
+ }>>;
766
+ uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
767
+ name: zod.ZodString;
768
+ columns: zod.ZodArray<zod.ZodString, "many">;
769
+ nullsNotDistinct: zod.ZodBoolean;
770
+ }, "strict", zod.ZodTypeAny, {
771
+ name: string;
772
+ columns: string[];
773
+ nullsNotDistinct: boolean;
774
+ }, {
775
+ name: string;
776
+ columns: string[];
777
+ nullsNotDistinct: boolean;
778
+ }>>>;
779
+ policies: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
780
+ name: zod.ZodString;
781
+ as: zod.ZodOptional<zod.ZodEnum<["PERMISSIVE", "RESTRICTIVE"]>>;
782
+ for: zod.ZodOptional<zod.ZodEnum<["ALL", "SELECT", "INSERT", "UPDATE", "DELETE"]>>;
783
+ to: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
784
+ using: zod.ZodOptional<zod.ZodString>;
785
+ withCheck: zod.ZodOptional<zod.ZodString>;
786
+ on: zod.ZodOptional<zod.ZodString>;
787
+ schema: zod.ZodOptional<zod.ZodString>;
788
+ }, "strict", zod.ZodTypeAny, {
789
+ name: string;
790
+ schema?: string | undefined;
791
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
792
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
793
+ to?: string[] | undefined;
794
+ using?: string | undefined;
795
+ withCheck?: string | undefined;
796
+ on?: string | undefined;
797
+ }, {
798
+ name: string;
799
+ schema?: string | undefined;
800
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
801
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
802
+ to?: string[] | undefined;
803
+ using?: string | undefined;
804
+ withCheck?: string | undefined;
805
+ on?: string | undefined;
806
+ }>>>;
807
+ checkConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
808
+ name: zod.ZodString;
809
+ value: zod.ZodString;
810
+ }, "strict", zod.ZodTypeAny, {
811
+ value: string;
812
+ name: string;
813
+ }, {
814
+ value: string;
815
+ name: string;
816
+ }>>>;
817
+ isRLSEnabled: zod.ZodDefault<zod.ZodBoolean>;
818
+ }, "strict", zod.ZodTypeAny, {
819
+ name: string;
820
+ schema: string;
821
+ columns: Record<string, {
822
+ type: string;
823
+ name: string;
824
+ primaryKey: boolean;
825
+ notNull: boolean;
826
+ typeSchema?: string | undefined;
827
+ default?: any;
828
+ isUnique?: any;
829
+ uniqueName?: string | undefined;
830
+ nullsNotDistinct?: boolean | undefined;
831
+ generated?: {
832
+ type: "stored";
833
+ as: string;
834
+ } | undefined;
835
+ identity?: {
836
+ type: "always" | "byDefault";
837
+ name: string;
838
+ schema: string;
839
+ increment?: string | undefined;
840
+ minValue?: string | undefined;
841
+ maxValue?: string | undefined;
842
+ startWith?: string | undefined;
843
+ cache?: string | undefined;
844
+ cycle?: boolean | undefined;
845
+ } | undefined;
846
+ }>;
847
+ indexes: Record<string, {
848
+ name: string;
849
+ columns: {
850
+ expression: string;
851
+ isExpression: boolean;
852
+ asc: boolean;
853
+ nulls?: string | undefined;
854
+ opclass?: string | undefined;
855
+ }[];
856
+ isUnique: boolean;
857
+ method: string;
858
+ concurrently: boolean;
859
+ with?: Record<string, any> | undefined;
860
+ where?: string | undefined;
861
+ }>;
862
+ foreignKeys: Record<string, {
863
+ name: string;
864
+ tableFrom: string;
865
+ columnsFrom: string[];
866
+ tableTo: string;
867
+ columnsTo: string[];
868
+ schemaTo?: string | undefined;
869
+ onUpdate?: string | undefined;
870
+ onDelete?: string | undefined;
871
+ }>;
872
+ compositePrimaryKeys: Record<string, {
873
+ name: string;
874
+ columns: string[];
875
+ }>;
876
+ uniqueConstraints: Record<string, {
877
+ name: string;
878
+ columns: string[];
879
+ nullsNotDistinct: boolean;
880
+ }>;
881
+ policies: Record<string, {
882
+ name: string;
883
+ schema?: string | undefined;
884
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
885
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
886
+ to?: string[] | undefined;
887
+ using?: string | undefined;
888
+ withCheck?: string | undefined;
889
+ on?: string | undefined;
890
+ }>;
891
+ checkConstraints: Record<string, {
892
+ value: string;
893
+ name: string;
894
+ }>;
895
+ isRLSEnabled: boolean;
896
+ }, {
897
+ name: string;
898
+ schema: string;
899
+ columns: Record<string, {
900
+ type: string;
901
+ name: string;
902
+ primaryKey: boolean;
903
+ notNull: boolean;
904
+ typeSchema?: string | undefined;
905
+ default?: any;
906
+ isUnique?: any;
907
+ uniqueName?: string | undefined;
908
+ nullsNotDistinct?: boolean | undefined;
909
+ generated?: {
910
+ type: "stored";
911
+ as: string;
912
+ } | undefined;
913
+ identity?: {
914
+ type: "always" | "byDefault";
915
+ name: string;
916
+ schema: string;
917
+ increment?: string | undefined;
918
+ minValue?: string | undefined;
919
+ maxValue?: string | undefined;
920
+ startWith?: string | undefined;
921
+ cache?: string | undefined;
922
+ cycle?: boolean | undefined;
923
+ } | undefined;
924
+ }>;
925
+ indexes: Record<string, {
926
+ name: string;
927
+ columns: {
928
+ expression: string;
929
+ isExpression: boolean;
930
+ asc: boolean;
931
+ nulls?: string | undefined;
932
+ opclass?: string | undefined;
933
+ }[];
934
+ isUnique: boolean;
935
+ with?: Record<string, any> | undefined;
936
+ method?: string | undefined;
937
+ where?: string | undefined;
938
+ concurrently?: boolean | undefined;
939
+ }>;
940
+ foreignKeys: Record<string, {
941
+ name: string;
942
+ tableFrom: string;
943
+ columnsFrom: string[];
944
+ tableTo: string;
945
+ columnsTo: string[];
946
+ schemaTo?: string | undefined;
947
+ onUpdate?: string | undefined;
948
+ onDelete?: string | undefined;
949
+ }>;
950
+ compositePrimaryKeys: Record<string, {
951
+ name: string;
952
+ columns: string[];
953
+ }>;
954
+ uniqueConstraints?: Record<string, {
955
+ name: string;
956
+ columns: string[];
957
+ nullsNotDistinct: boolean;
958
+ }> | undefined;
959
+ policies?: Record<string, {
960
+ name: string;
961
+ schema?: string | undefined;
962
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
963
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
964
+ to?: string[] | undefined;
965
+ using?: string | undefined;
966
+ withCheck?: string | undefined;
967
+ on?: string | undefined;
968
+ }> | undefined;
969
+ checkConstraints?: Record<string, {
970
+ value: string;
971
+ name: string;
972
+ }> | undefined;
973
+ isRLSEnabled?: boolean | undefined;
974
+ }>>;
975
+ enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
976
+ name: zod.ZodString;
977
+ schema: zod.ZodString;
978
+ values: zod.ZodArray<zod.ZodString, "many">;
979
+ }, "strict", zod.ZodTypeAny, {
980
+ values: string[];
981
+ name: string;
982
+ schema: string;
983
+ }, {
984
+ values: string[];
985
+ name: string;
986
+ schema: string;
987
+ }>>;
988
+ schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
989
+ views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
990
+ name: zod.ZodString;
991
+ schema: zod.ZodString;
992
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
993
+ name: zod.ZodString;
994
+ type: zod.ZodString;
995
+ typeSchema: zod.ZodOptional<zod.ZodString>;
996
+ primaryKey: zod.ZodBoolean;
997
+ notNull: zod.ZodBoolean;
998
+ default: zod.ZodOptional<zod.ZodAny>;
999
+ isUnique: zod.ZodOptional<zod.ZodAny>;
1000
+ uniqueName: zod.ZodOptional<zod.ZodString>;
1001
+ nullsNotDistinct: zod.ZodOptional<zod.ZodBoolean>;
1002
+ generated: zod.ZodOptional<zod.ZodObject<{
1003
+ type: zod.ZodLiteral<"stored">;
1004
+ as: zod.ZodString;
1005
+ }, "strip", zod.ZodTypeAny, {
1006
+ type: "stored";
1007
+ as: string;
1008
+ }, {
1009
+ type: "stored";
1010
+ as: string;
1011
+ }>>;
1012
+ identity: zod.ZodOptional<zod.ZodObject<{
1013
+ name: zod.ZodString;
1014
+ increment: zod.ZodOptional<zod.ZodString>;
1015
+ minValue: zod.ZodOptional<zod.ZodString>;
1016
+ maxValue: zod.ZodOptional<zod.ZodString>;
1017
+ startWith: zod.ZodOptional<zod.ZodString>;
1018
+ cache: zod.ZodOptional<zod.ZodString>;
1019
+ cycle: zod.ZodOptional<zod.ZodBoolean>;
1020
+ schema: zod.ZodString;
1021
+ } & {
1022
+ type: zod.ZodEnum<["always", "byDefault"]>;
1023
+ }, "strip", zod.ZodTypeAny, {
1024
+ type: "always" | "byDefault";
1025
+ name: string;
1026
+ schema: string;
1027
+ increment?: string | undefined;
1028
+ minValue?: string | undefined;
1029
+ maxValue?: string | undefined;
1030
+ startWith?: string | undefined;
1031
+ cache?: string | undefined;
1032
+ cycle?: boolean | undefined;
1033
+ }, {
1034
+ type: "always" | "byDefault";
1035
+ name: string;
1036
+ schema: string;
1037
+ increment?: string | undefined;
1038
+ minValue?: string | undefined;
1039
+ maxValue?: string | undefined;
1040
+ startWith?: string | undefined;
1041
+ cache?: string | undefined;
1042
+ cycle?: boolean | undefined;
1043
+ }>>;
1044
+ }, "strict", zod.ZodTypeAny, {
1045
+ type: string;
1046
+ name: string;
1047
+ primaryKey: boolean;
1048
+ notNull: boolean;
1049
+ typeSchema?: string | undefined;
1050
+ default?: any;
1051
+ isUnique?: any;
1052
+ uniqueName?: string | undefined;
1053
+ nullsNotDistinct?: boolean | undefined;
1054
+ generated?: {
1055
+ type: "stored";
1056
+ as: string;
1057
+ } | undefined;
1058
+ identity?: {
1059
+ type: "always" | "byDefault";
1060
+ name: string;
1061
+ schema: string;
1062
+ increment?: string | undefined;
1063
+ minValue?: string | undefined;
1064
+ maxValue?: string | undefined;
1065
+ startWith?: string | undefined;
1066
+ cache?: string | undefined;
1067
+ cycle?: boolean | undefined;
1068
+ } | undefined;
1069
+ }, {
1070
+ type: string;
1071
+ name: string;
1072
+ primaryKey: boolean;
1073
+ notNull: boolean;
1074
+ typeSchema?: string | undefined;
1075
+ default?: any;
1076
+ isUnique?: any;
1077
+ uniqueName?: string | undefined;
1078
+ nullsNotDistinct?: boolean | undefined;
1079
+ generated?: {
1080
+ type: "stored";
1081
+ as: string;
1082
+ } | undefined;
1083
+ identity?: {
1084
+ type: "always" | "byDefault";
1085
+ name: string;
1086
+ schema: string;
1087
+ increment?: string | undefined;
1088
+ minValue?: string | undefined;
1089
+ maxValue?: string | undefined;
1090
+ startWith?: string | undefined;
1091
+ cache?: string | undefined;
1092
+ cycle?: boolean | undefined;
1093
+ } | undefined;
1094
+ }>>;
1095
+ definition: zod.ZodOptional<zod.ZodString>;
1096
+ materialized: zod.ZodBoolean;
1097
+ with: zod.ZodOptional<zod.ZodObject<{
1098
+ checkOption: zod.ZodOptional<zod.ZodEnum<["local", "cascaded"]>>;
1099
+ securityBarrier: zod.ZodOptional<zod.ZodBoolean>;
1100
+ securityInvoker: zod.ZodOptional<zod.ZodBoolean>;
1101
+ } & {
1102
+ fillfactor: zod.ZodOptional<zod.ZodNumber>;
1103
+ toastTupleTarget: zod.ZodOptional<zod.ZodNumber>;
1104
+ parallelWorkers: zod.ZodOptional<zod.ZodNumber>;
1105
+ autovacuumEnabled: zod.ZodOptional<zod.ZodBoolean>;
1106
+ vacuumIndexCleanup: zod.ZodOptional<zod.ZodEnum<["auto", "off", "on"]>>;
1107
+ vacuumTruncate: zod.ZodOptional<zod.ZodBoolean>;
1108
+ autovacuumVacuumThreshold: zod.ZodOptional<zod.ZodNumber>;
1109
+ autovacuumVacuumScaleFactor: zod.ZodOptional<zod.ZodNumber>;
1110
+ autovacuumVacuumCostDelay: zod.ZodOptional<zod.ZodNumber>;
1111
+ autovacuumVacuumCostLimit: zod.ZodOptional<zod.ZodNumber>;
1112
+ autovacuumFreezeMinAge: zod.ZodOptional<zod.ZodNumber>;
1113
+ autovacuumFreezeMaxAge: zod.ZodOptional<zod.ZodNumber>;
1114
+ autovacuumFreezeTableAge: zod.ZodOptional<zod.ZodNumber>;
1115
+ autovacuumMultixactFreezeMinAge: zod.ZodOptional<zod.ZodNumber>;
1116
+ autovacuumMultixactFreezeMaxAge: zod.ZodOptional<zod.ZodNumber>;
1117
+ autovacuumMultixactFreezeTableAge: zod.ZodOptional<zod.ZodNumber>;
1118
+ logAutovacuumMinDuration: zod.ZodOptional<zod.ZodNumber>;
1119
+ userCatalogTable: zod.ZodOptional<zod.ZodBoolean>;
1120
+ }, "strict", zod.ZodTypeAny, {
1121
+ checkOption?: "local" | "cascaded" | undefined;
1122
+ securityBarrier?: boolean | undefined;
1123
+ securityInvoker?: boolean | undefined;
1124
+ fillfactor?: number | undefined;
1125
+ toastTupleTarget?: number | undefined;
1126
+ parallelWorkers?: number | undefined;
1127
+ autovacuumEnabled?: boolean | undefined;
1128
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
1129
+ vacuumTruncate?: boolean | undefined;
1130
+ autovacuumVacuumThreshold?: number | undefined;
1131
+ autovacuumVacuumScaleFactor?: number | undefined;
1132
+ autovacuumVacuumCostDelay?: number | undefined;
1133
+ autovacuumVacuumCostLimit?: number | undefined;
1134
+ autovacuumFreezeMinAge?: number | undefined;
1135
+ autovacuumFreezeMaxAge?: number | undefined;
1136
+ autovacuumFreezeTableAge?: number | undefined;
1137
+ autovacuumMultixactFreezeMinAge?: number | undefined;
1138
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
1139
+ autovacuumMultixactFreezeTableAge?: number | undefined;
1140
+ logAutovacuumMinDuration?: number | undefined;
1141
+ userCatalogTable?: boolean | undefined;
1142
+ }, {
1143
+ checkOption?: "local" | "cascaded" | undefined;
1144
+ securityBarrier?: boolean | undefined;
1145
+ securityInvoker?: boolean | undefined;
1146
+ fillfactor?: number | undefined;
1147
+ toastTupleTarget?: number | undefined;
1148
+ parallelWorkers?: number | undefined;
1149
+ autovacuumEnabled?: boolean | undefined;
1150
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
1151
+ vacuumTruncate?: boolean | undefined;
1152
+ autovacuumVacuumThreshold?: number | undefined;
1153
+ autovacuumVacuumScaleFactor?: number | undefined;
1154
+ autovacuumVacuumCostDelay?: number | undefined;
1155
+ autovacuumVacuumCostLimit?: number | undefined;
1156
+ autovacuumFreezeMinAge?: number | undefined;
1157
+ autovacuumFreezeMaxAge?: number | undefined;
1158
+ autovacuumFreezeTableAge?: number | undefined;
1159
+ autovacuumMultixactFreezeMinAge?: number | undefined;
1160
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
1161
+ autovacuumMultixactFreezeTableAge?: number | undefined;
1162
+ logAutovacuumMinDuration?: number | undefined;
1163
+ userCatalogTable?: boolean | undefined;
1164
+ }>>;
1165
+ isExisting: zod.ZodBoolean;
1166
+ withNoData: zod.ZodOptional<zod.ZodBoolean>;
1167
+ using: zod.ZodOptional<zod.ZodString>;
1168
+ tablespace: zod.ZodOptional<zod.ZodString>;
1169
+ }, "strict", zod.ZodTypeAny, {
1170
+ name: string;
1171
+ schema: string;
1172
+ columns: Record<string, {
1173
+ type: string;
1174
+ name: string;
1175
+ primaryKey: boolean;
1176
+ notNull: boolean;
1177
+ typeSchema?: string | undefined;
1178
+ default?: any;
1179
+ isUnique?: any;
1180
+ uniqueName?: string | undefined;
1181
+ nullsNotDistinct?: boolean | undefined;
1182
+ generated?: {
1183
+ type: "stored";
1184
+ as: string;
1185
+ } | undefined;
1186
+ identity?: {
1187
+ type: "always" | "byDefault";
1188
+ name: string;
1189
+ schema: string;
1190
+ increment?: string | undefined;
1191
+ minValue?: string | undefined;
1192
+ maxValue?: string | undefined;
1193
+ startWith?: string | undefined;
1194
+ cache?: string | undefined;
1195
+ cycle?: boolean | undefined;
1196
+ } | undefined;
1197
+ }>;
1198
+ materialized: boolean;
1199
+ isExisting: boolean;
1200
+ with?: {
1201
+ checkOption?: "local" | "cascaded" | undefined;
1202
+ securityBarrier?: boolean | undefined;
1203
+ securityInvoker?: boolean | undefined;
1204
+ fillfactor?: number | undefined;
1205
+ toastTupleTarget?: number | undefined;
1206
+ parallelWorkers?: number | undefined;
1207
+ autovacuumEnabled?: boolean | undefined;
1208
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
1209
+ vacuumTruncate?: boolean | undefined;
1210
+ autovacuumVacuumThreshold?: number | undefined;
1211
+ autovacuumVacuumScaleFactor?: number | undefined;
1212
+ autovacuumVacuumCostDelay?: number | undefined;
1213
+ autovacuumVacuumCostLimit?: number | undefined;
1214
+ autovacuumFreezeMinAge?: number | undefined;
1215
+ autovacuumFreezeMaxAge?: number | undefined;
1216
+ autovacuumFreezeTableAge?: number | undefined;
1217
+ autovacuumMultixactFreezeMinAge?: number | undefined;
1218
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
1219
+ autovacuumMultixactFreezeTableAge?: number | undefined;
1220
+ logAutovacuumMinDuration?: number | undefined;
1221
+ userCatalogTable?: boolean | undefined;
1222
+ } | undefined;
1223
+ using?: string | undefined;
1224
+ definition?: string | undefined;
1225
+ withNoData?: boolean | undefined;
1226
+ tablespace?: string | undefined;
1227
+ }, {
1228
+ name: string;
1229
+ schema: string;
1230
+ columns: Record<string, {
1231
+ type: string;
1232
+ name: string;
1233
+ primaryKey: boolean;
1234
+ notNull: boolean;
1235
+ typeSchema?: string | undefined;
1236
+ default?: any;
1237
+ isUnique?: any;
1238
+ uniqueName?: string | undefined;
1239
+ nullsNotDistinct?: boolean | undefined;
1240
+ generated?: {
1241
+ type: "stored";
1242
+ as: string;
1243
+ } | undefined;
1244
+ identity?: {
1245
+ type: "always" | "byDefault";
1246
+ name: string;
1247
+ schema: string;
1248
+ increment?: string | undefined;
1249
+ minValue?: string | undefined;
1250
+ maxValue?: string | undefined;
1251
+ startWith?: string | undefined;
1252
+ cache?: string | undefined;
1253
+ cycle?: boolean | undefined;
1254
+ } | undefined;
1255
+ }>;
1256
+ materialized: boolean;
1257
+ isExisting: boolean;
1258
+ with?: {
1259
+ checkOption?: "local" | "cascaded" | undefined;
1260
+ securityBarrier?: boolean | undefined;
1261
+ securityInvoker?: boolean | undefined;
1262
+ fillfactor?: number | undefined;
1263
+ toastTupleTarget?: number | undefined;
1264
+ parallelWorkers?: number | undefined;
1265
+ autovacuumEnabled?: boolean | undefined;
1266
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
1267
+ vacuumTruncate?: boolean | undefined;
1268
+ autovacuumVacuumThreshold?: number | undefined;
1269
+ autovacuumVacuumScaleFactor?: number | undefined;
1270
+ autovacuumVacuumCostDelay?: number | undefined;
1271
+ autovacuumVacuumCostLimit?: number | undefined;
1272
+ autovacuumFreezeMinAge?: number | undefined;
1273
+ autovacuumFreezeMaxAge?: number | undefined;
1274
+ autovacuumFreezeTableAge?: number | undefined;
1275
+ autovacuumMultixactFreezeMinAge?: number | undefined;
1276
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
1277
+ autovacuumMultixactFreezeTableAge?: number | undefined;
1278
+ logAutovacuumMinDuration?: number | undefined;
1279
+ userCatalogTable?: boolean | undefined;
1280
+ } | undefined;
1281
+ using?: string | undefined;
1282
+ definition?: string | undefined;
1283
+ withNoData?: boolean | undefined;
1284
+ tablespace?: string | undefined;
1285
+ }>>>;
1286
+ sequences: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1287
+ name: zod.ZodString;
1288
+ increment: zod.ZodOptional<zod.ZodString>;
1289
+ minValue: zod.ZodOptional<zod.ZodString>;
1290
+ maxValue: zod.ZodOptional<zod.ZodString>;
1291
+ startWith: zod.ZodOptional<zod.ZodString>;
1292
+ cache: zod.ZodOptional<zod.ZodString>;
1293
+ cycle: zod.ZodOptional<zod.ZodBoolean>;
1294
+ schema: zod.ZodString;
1295
+ }, "strict", zod.ZodTypeAny, {
1296
+ name: string;
1297
+ schema: string;
1298
+ increment?: string | undefined;
1299
+ minValue?: string | undefined;
1300
+ maxValue?: string | undefined;
1301
+ startWith?: string | undefined;
1302
+ cache?: string | undefined;
1303
+ cycle?: boolean | undefined;
1304
+ }, {
1305
+ name: string;
1306
+ schema: string;
1307
+ increment?: string | undefined;
1308
+ minValue?: string | undefined;
1309
+ maxValue?: string | undefined;
1310
+ startWith?: string | undefined;
1311
+ cache?: string | undefined;
1312
+ cycle?: boolean | undefined;
1313
+ }>>>;
1314
+ roles: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1315
+ name: zod.ZodString;
1316
+ createDb: zod.ZodOptional<zod.ZodBoolean>;
1317
+ createRole: zod.ZodOptional<zod.ZodBoolean>;
1318
+ inherit: zod.ZodOptional<zod.ZodBoolean>;
1319
+ }, "strict", zod.ZodTypeAny, {
1320
+ name: string;
1321
+ createDb?: boolean | undefined;
1322
+ createRole?: boolean | undefined;
1323
+ inherit?: boolean | undefined;
1324
+ }, {
1325
+ name: string;
1326
+ createDb?: boolean | undefined;
1327
+ createRole?: boolean | undefined;
1328
+ inherit?: boolean | undefined;
1329
+ }>>>;
1330
+ policies: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1331
+ name: zod.ZodString;
1332
+ as: zod.ZodOptional<zod.ZodEnum<["PERMISSIVE", "RESTRICTIVE"]>>;
1333
+ for: zod.ZodOptional<zod.ZodEnum<["ALL", "SELECT", "INSERT", "UPDATE", "DELETE"]>>;
1334
+ to: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
1335
+ using: zod.ZodOptional<zod.ZodString>;
1336
+ withCheck: zod.ZodOptional<zod.ZodString>;
1337
+ on: zod.ZodOptional<zod.ZodString>;
1338
+ schema: zod.ZodOptional<zod.ZodString>;
1339
+ }, "strict", zod.ZodTypeAny, {
1340
+ name: string;
1341
+ schema?: string | undefined;
1342
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1343
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1344
+ to?: string[] | undefined;
1345
+ using?: string | undefined;
1346
+ withCheck?: string | undefined;
1347
+ on?: string | undefined;
1348
+ }, {
1349
+ name: string;
1350
+ schema?: string | undefined;
1351
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1352
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1353
+ to?: string[] | undefined;
1354
+ using?: string | undefined;
1355
+ withCheck?: string | undefined;
1356
+ on?: string | undefined;
1357
+ }>>>;
1358
+ _meta: zod.ZodObject<{
1359
+ schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
1360
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
1361
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
1362
+ }, "strip", zod.ZodTypeAny, {
1363
+ tables: Record<string, string>;
1364
+ columns: Record<string, string>;
1365
+ schemas: Record<string, string>;
1366
+ }, {
1367
+ tables: Record<string, string>;
1368
+ columns: Record<string, string>;
1369
+ schemas: Record<string, string>;
1370
+ }>;
1371
+ internal: zod.ZodOptional<zod.ZodObject<{
1372
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
1373
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
1374
+ isArray: zod.ZodOptional<zod.ZodBoolean>;
1375
+ dimensions: zod.ZodOptional<zod.ZodNumber>;
1376
+ rawType: zod.ZodOptional<zod.ZodString>;
1377
+ isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
1378
+ }, "strip", zod.ZodTypeAny, {
1379
+ isArray?: boolean | undefined;
1380
+ dimensions?: number | undefined;
1381
+ rawType?: string | undefined;
1382
+ isDefaultAnExpression?: boolean | undefined;
1383
+ }, {
1384
+ isArray?: boolean | undefined;
1385
+ dimensions?: number | undefined;
1386
+ rawType?: string | undefined;
1387
+ isDefaultAnExpression?: boolean | undefined;
1388
+ }>>>;
1389
+ }, "strip", zod.ZodTypeAny, {
1390
+ columns: Record<string, {
1391
+ isArray?: boolean | undefined;
1392
+ dimensions?: number | undefined;
1393
+ rawType?: string | undefined;
1394
+ isDefaultAnExpression?: boolean | undefined;
1395
+ } | undefined>;
1396
+ }, {
1397
+ columns: Record<string, {
1398
+ isArray?: boolean | undefined;
1399
+ dimensions?: number | undefined;
1400
+ rawType?: string | undefined;
1401
+ isDefaultAnExpression?: boolean | undefined;
1402
+ } | undefined>;
1403
+ }>>>;
1404
+ }, "strip", zod.ZodTypeAny, {
1405
+ tables: Record<string, {
1406
+ columns: Record<string, {
1407
+ isArray?: boolean | undefined;
1408
+ dimensions?: number | undefined;
1409
+ rawType?: string | undefined;
1410
+ isDefaultAnExpression?: boolean | undefined;
1411
+ } | undefined>;
1412
+ } | undefined>;
1413
+ }, {
1414
+ tables: Record<string, {
1415
+ columns: Record<string, {
1416
+ isArray?: boolean | undefined;
1417
+ dimensions?: number | undefined;
1418
+ rawType?: string | undefined;
1419
+ isDefaultAnExpression?: boolean | undefined;
1420
+ } | undefined>;
1421
+ } | undefined>;
1422
+ }>>;
1423
+ } & {
1424
+ id: zod.ZodString;
1425
+ prevId: zod.ZodString;
1426
+ }, "strip", zod.ZodTypeAny, {
1427
+ version: "7";
1428
+ dialect: "postgresql";
1429
+ tables: Record<string, {
1430
+ name: string;
1431
+ schema: string;
1432
+ columns: Record<string, {
1433
+ type: string;
1434
+ name: string;
1435
+ primaryKey: boolean;
1436
+ notNull: boolean;
1437
+ typeSchema?: string | undefined;
1438
+ default?: any;
1439
+ isUnique?: any;
1440
+ uniqueName?: string | undefined;
1441
+ nullsNotDistinct?: boolean | undefined;
1442
+ generated?: {
1443
+ type: "stored";
1444
+ as: string;
1445
+ } | undefined;
1446
+ identity?: {
1447
+ type: "always" | "byDefault";
1448
+ name: string;
1449
+ schema: string;
1450
+ increment?: string | undefined;
1451
+ minValue?: string | undefined;
1452
+ maxValue?: string | undefined;
1453
+ startWith?: string | undefined;
1454
+ cache?: string | undefined;
1455
+ cycle?: boolean | undefined;
1456
+ } | undefined;
1457
+ }>;
1458
+ indexes: Record<string, {
1459
+ name: string;
1460
+ columns: {
1461
+ expression: string;
1462
+ isExpression: boolean;
1463
+ asc: boolean;
1464
+ nulls?: string | undefined;
1465
+ opclass?: string | undefined;
1466
+ }[];
1467
+ isUnique: boolean;
1468
+ method: string;
1469
+ concurrently: boolean;
1470
+ with?: Record<string, any> | undefined;
1471
+ where?: string | undefined;
1472
+ }>;
1473
+ foreignKeys: Record<string, {
1474
+ name: string;
1475
+ tableFrom: string;
1476
+ columnsFrom: string[];
1477
+ tableTo: string;
1478
+ columnsTo: string[];
1479
+ schemaTo?: string | undefined;
1480
+ onUpdate?: string | undefined;
1481
+ onDelete?: string | undefined;
1482
+ }>;
1483
+ compositePrimaryKeys: Record<string, {
1484
+ name: string;
1485
+ columns: string[];
1486
+ }>;
1487
+ uniqueConstraints: Record<string, {
1488
+ name: string;
1489
+ columns: string[];
1490
+ nullsNotDistinct: boolean;
1491
+ }>;
1492
+ policies: Record<string, {
1493
+ name: string;
1494
+ schema?: string | undefined;
1495
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1496
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1497
+ to?: string[] | undefined;
1498
+ using?: string | undefined;
1499
+ withCheck?: string | undefined;
1500
+ on?: string | undefined;
1501
+ }>;
1502
+ checkConstraints: Record<string, {
1503
+ value: string;
1504
+ name: string;
1505
+ }>;
1506
+ isRLSEnabled: boolean;
1507
+ }>;
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
+ }>;
1523
+ schemas: Record<string, string>;
1524
+ views: Record<string, {
1525
+ name: string;
1526
+ schema: string;
1527
+ columns: Record<string, {
1528
+ type: string;
1529
+ name: string;
1530
+ primaryKey: boolean;
1531
+ notNull: boolean;
1532
+ typeSchema?: string | undefined;
1533
+ default?: any;
1534
+ isUnique?: any;
1535
+ uniqueName?: string | undefined;
1536
+ nullsNotDistinct?: boolean | undefined;
1537
+ generated?: {
1538
+ type: "stored";
1539
+ as: string;
1540
+ } | undefined;
1541
+ identity?: {
1542
+ type: "always" | "byDefault";
1543
+ name: string;
1544
+ schema: string;
1545
+ increment?: string | undefined;
1546
+ minValue?: string | undefined;
1547
+ maxValue?: string | undefined;
1548
+ startWith?: string | undefined;
1549
+ cache?: string | undefined;
1550
+ cycle?: boolean | undefined;
1551
+ } | undefined;
1552
+ }>;
1553
+ materialized: boolean;
1554
+ isExisting: boolean;
1555
+ with?: {
1556
+ checkOption?: "local" | "cascaded" | undefined;
1557
+ securityBarrier?: boolean | undefined;
1558
+ securityInvoker?: boolean | undefined;
1559
+ fillfactor?: number | undefined;
1560
+ toastTupleTarget?: number | undefined;
1561
+ parallelWorkers?: number | undefined;
1562
+ autovacuumEnabled?: boolean | undefined;
1563
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
1564
+ vacuumTruncate?: boolean | undefined;
1565
+ autovacuumVacuumThreshold?: number | undefined;
1566
+ autovacuumVacuumScaleFactor?: number | undefined;
1567
+ autovacuumVacuumCostDelay?: number | undefined;
1568
+ autovacuumVacuumCostLimit?: number | undefined;
1569
+ autovacuumFreezeMinAge?: number | undefined;
1570
+ autovacuumFreezeMaxAge?: number | undefined;
1571
+ autovacuumFreezeTableAge?: number | undefined;
1572
+ autovacuumMultixactFreezeMinAge?: number | undefined;
1573
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
1574
+ autovacuumMultixactFreezeTableAge?: number | undefined;
1575
+ logAutovacuumMinDuration?: number | undefined;
1576
+ userCatalogTable?: boolean | undefined;
1577
+ } | undefined;
1578
+ using?: string | undefined;
1579
+ definition?: string | undefined;
1580
+ withNoData?: boolean | undefined;
1581
+ tablespace?: string | undefined;
1582
+ }>;
1583
+ sequences: Record<string, {
1584
+ name: string;
1585
+ schema: string;
1586
+ increment?: string | undefined;
1587
+ minValue?: string | undefined;
1588
+ maxValue?: string | undefined;
1589
+ startWith?: string | undefined;
1590
+ cache?: string | undefined;
1591
+ cycle?: boolean | undefined;
1592
+ }>;
1593
+ roles: Record<string, {
1594
+ name: string;
1595
+ createDb?: boolean | undefined;
1596
+ createRole?: boolean | undefined;
1597
+ inherit?: boolean | undefined;
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
+ internal?: {
1607
+ tables: Record<string, {
1608
+ columns: Record<string, {
1609
+ isArray?: boolean | undefined;
1610
+ dimensions?: number | undefined;
1611
+ rawType?: string | undefined;
1612
+ isDefaultAnExpression?: boolean | undefined;
1613
+ } | undefined>;
1614
+ } | undefined>;
1615
+ } | undefined;
1616
+ }, {
1617
+ version: "7";
1618
+ dialect: "postgresql";
1619
+ tables: Record<string, {
1620
+ name: string;
1621
+ schema: string;
1622
+ columns: Record<string, {
1623
+ type: string;
1624
+ name: string;
1625
+ primaryKey: boolean;
1626
+ notNull: boolean;
1627
+ typeSchema?: string | undefined;
1628
+ default?: any;
1629
+ isUnique?: any;
1630
+ uniqueName?: string | undefined;
1631
+ nullsNotDistinct?: boolean | undefined;
1632
+ generated?: {
1633
+ type: "stored";
1634
+ as: string;
1635
+ } | undefined;
1636
+ identity?: {
1637
+ type: "always" | "byDefault";
1638
+ name: string;
1639
+ schema: string;
1640
+ increment?: string | undefined;
1641
+ minValue?: string | undefined;
1642
+ maxValue?: string | undefined;
1643
+ startWith?: string | undefined;
1644
+ cache?: string | undefined;
1645
+ cycle?: boolean | undefined;
1646
+ } | undefined;
1647
+ }>;
1648
+ indexes: Record<string, {
1649
+ name: string;
1650
+ columns: {
1651
+ expression: string;
1652
+ isExpression: boolean;
1653
+ asc: boolean;
1654
+ nulls?: string | undefined;
1655
+ opclass?: string | undefined;
1656
+ }[];
1657
+ isUnique: boolean;
1658
+ with?: Record<string, any> | undefined;
1659
+ method?: string | undefined;
1660
+ where?: string | undefined;
1661
+ concurrently?: boolean | undefined;
1662
+ }>;
1663
+ foreignKeys: Record<string, {
1664
+ name: string;
1665
+ tableFrom: string;
1666
+ columnsFrom: string[];
1667
+ tableTo: string;
1668
+ columnsTo: string[];
1669
+ schemaTo?: string | undefined;
1670
+ onUpdate?: string | undefined;
1671
+ onDelete?: string | undefined;
1672
+ }>;
1673
+ compositePrimaryKeys: Record<string, {
1674
+ name: string;
1675
+ columns: string[];
1676
+ }>;
1677
+ uniqueConstraints?: Record<string, {
1678
+ name: string;
1679
+ columns: string[];
1680
+ nullsNotDistinct: boolean;
1681
+ }> | undefined;
1682
+ policies?: Record<string, {
1683
+ name: string;
1684
+ schema?: string | undefined;
1685
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1686
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1687
+ to?: string[] | undefined;
1688
+ using?: string | undefined;
1689
+ withCheck?: string | undefined;
1690
+ on?: string | undefined;
1691
+ }> | undefined;
1692
+ checkConstraints?: Record<string, {
1693
+ value: string;
1694
+ name: string;
1695
+ }> | undefined;
1696
+ isRLSEnabled?: boolean | undefined;
1697
+ }>;
1698
+ enums: Record<string, {
1699
+ values: string[];
1700
+ name: string;
1701
+ schema: string;
1702
+ }>;
1703
+ schemas: Record<string, string>;
1704
+ _meta: {
1705
+ tables: Record<string, string>;
1706
+ columns: Record<string, string>;
1707
+ schemas: Record<string, string>;
1708
+ };
1709
+ id: string;
1710
+ prevId: string;
1711
+ policies?: Record<string, {
1712
+ name: string;
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
+ views?: Record<string, {
1722
+ name: string;
1723
+ schema: string;
1724
+ columns: Record<string, {
1725
+ type: string;
1726
+ name: string;
1727
+ primaryKey: boolean;
1728
+ notNull: boolean;
1729
+ typeSchema?: string | undefined;
1730
+ default?: any;
1731
+ isUnique?: any;
1732
+ uniqueName?: string | undefined;
1733
+ nullsNotDistinct?: boolean | undefined;
1734
+ generated?: {
1735
+ type: "stored";
1736
+ as: string;
1737
+ } | undefined;
1738
+ identity?: {
1739
+ type: "always" | "byDefault";
1740
+ name: string;
1741
+ schema: string;
1742
+ increment?: string | undefined;
1743
+ minValue?: string | undefined;
1744
+ maxValue?: string | undefined;
1745
+ startWith?: string | undefined;
1746
+ cache?: string | undefined;
1747
+ cycle?: boolean | undefined;
1748
+ } | undefined;
1749
+ }>;
1750
+ materialized: boolean;
1751
+ isExisting: boolean;
1752
+ with?: {
1753
+ checkOption?: "local" | "cascaded" | undefined;
1754
+ securityBarrier?: boolean | undefined;
1755
+ securityInvoker?: boolean | undefined;
1756
+ fillfactor?: number | undefined;
1757
+ toastTupleTarget?: number | undefined;
1758
+ parallelWorkers?: number | undefined;
1759
+ autovacuumEnabled?: boolean | undefined;
1760
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
1761
+ vacuumTruncate?: boolean | undefined;
1762
+ autovacuumVacuumThreshold?: number | undefined;
1763
+ autovacuumVacuumScaleFactor?: number | undefined;
1764
+ autovacuumVacuumCostDelay?: number | undefined;
1765
+ autovacuumVacuumCostLimit?: number | undefined;
1766
+ autovacuumFreezeMinAge?: number | undefined;
1767
+ autovacuumFreezeMaxAge?: number | undefined;
1768
+ autovacuumFreezeTableAge?: number | undefined;
1769
+ autovacuumMultixactFreezeMinAge?: number | undefined;
1770
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
1771
+ autovacuumMultixactFreezeTableAge?: number | undefined;
1772
+ logAutovacuumMinDuration?: number | undefined;
1773
+ userCatalogTable?: boolean | undefined;
1774
+ } | undefined;
1775
+ using?: string | undefined;
1776
+ definition?: string | undefined;
1777
+ withNoData?: boolean | undefined;
1778
+ tablespace?: string | undefined;
1779
+ }> | undefined;
1780
+ sequences?: Record<string, {
1781
+ name: string;
1782
+ schema: string;
1783
+ increment?: string | undefined;
1784
+ minValue?: string | undefined;
1785
+ maxValue?: string | undefined;
1786
+ startWith?: string | undefined;
1787
+ cache?: string | undefined;
1788
+ cycle?: boolean | undefined;
1789
+ }> | undefined;
1790
+ roles?: Record<string, {
1791
+ name: string;
1792
+ createDb?: boolean | undefined;
1793
+ createRole?: boolean | undefined;
1794
+ inherit?: boolean | undefined;
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
+ }>;
1807
+ type PgSchema = TypeOf<typeof pgSchema>;
1808
+
1809
+ declare const schema$1: zod.ZodObject<{
1810
+ version: zod.ZodLiteral<"1">;
1811
+ dialect: zod.ZodLiteral<"singlestore">;
1812
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1813
+ name: zod.ZodString;
1814
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1815
+ name: zod.ZodString;
1816
+ type: zod.ZodString;
1817
+ primaryKey: zod.ZodBoolean;
1818
+ notNull: zod.ZodBoolean;
1819
+ autoincrement: zod.ZodOptional<zod.ZodBoolean>;
1820
+ default: zod.ZodOptional<zod.ZodAny>;
1821
+ onUpdate: zod.ZodOptional<zod.ZodAny>;
1822
+ generated: zod.ZodOptional<zod.ZodObject<{
1823
+ type: zod.ZodEnum<["stored", "virtual"]>;
1824
+ as: zod.ZodString;
1825
+ }, "strip", zod.ZodTypeAny, {
1826
+ type: "stored" | "virtual";
1827
+ as: string;
1828
+ }, {
1829
+ type: "stored" | "virtual";
1830
+ as: string;
1831
+ }>>;
1832
+ }, "strict", zod.ZodTypeAny, {
1833
+ type: string;
1834
+ name: string;
1835
+ primaryKey: boolean;
1836
+ notNull: boolean;
1837
+ default?: any;
1838
+ generated?: {
1839
+ type: "stored" | "virtual";
1840
+ as: string;
1841
+ } | undefined;
1842
+ onUpdate?: any;
1843
+ autoincrement?: boolean | undefined;
1844
+ }, {
1845
+ type: string;
1846
+ name: string;
1847
+ primaryKey: boolean;
1848
+ notNull: boolean;
1849
+ default?: any;
1850
+ generated?: {
1851
+ type: "stored" | "virtual";
1852
+ as: string;
1853
+ } | undefined;
1854
+ onUpdate?: any;
1855
+ autoincrement?: boolean | undefined;
1856
+ }>>;
1857
+ indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1858
+ name: zod.ZodString;
1859
+ columns: zod.ZodArray<zod.ZodString, "many">;
1860
+ isUnique: zod.ZodBoolean;
1861
+ using: zod.ZodOptional<zod.ZodEnum<["btree", "hash"]>>;
1862
+ algorithm: zod.ZodOptional<zod.ZodEnum<["default", "inplace", "copy"]>>;
1863
+ lock: zod.ZodOptional<zod.ZodEnum<["default", "none", "shared", "exclusive"]>>;
1864
+ }, "strict", zod.ZodTypeAny, {
1865
+ name: string;
1866
+ columns: string[];
1867
+ isUnique: boolean;
1868
+ using?: "btree" | "hash" | undefined;
1869
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1870
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1871
+ }, {
1872
+ name: string;
1873
+ columns: string[];
1874
+ isUnique: boolean;
1875
+ using?: "btree" | "hash" | undefined;
1876
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1877
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1878
+ }>>;
1879
+ compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1880
+ name: zod.ZodString;
1881
+ columns: zod.ZodArray<zod.ZodString, "many">;
1882
+ }, "strict", zod.ZodTypeAny, {
1883
+ name: string;
1884
+ columns: string[];
1885
+ }, {
1886
+ name: string;
1887
+ columns: string[];
1888
+ }>>;
1889
+ uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
1890
+ name: zod.ZodString;
1891
+ columns: zod.ZodArray<zod.ZodString, "many">;
1892
+ }, "strict", zod.ZodTypeAny, {
1893
+ name: string;
1894
+ columns: string[];
1895
+ }, {
1896
+ name: string;
1897
+ columns: string[];
1898
+ }>>>;
1899
+ }, "strict", zod.ZodTypeAny, {
1900
+ name: string;
1901
+ columns: Record<string, {
1902
+ type: string;
1903
+ name: string;
1904
+ primaryKey: boolean;
1905
+ notNull: boolean;
1906
+ default?: any;
1907
+ generated?: {
1908
+ type: "stored" | "virtual";
1909
+ as: string;
1910
+ } | undefined;
1911
+ onUpdate?: any;
1912
+ autoincrement?: boolean | undefined;
1913
+ }>;
1914
+ indexes: Record<string, {
1915
+ name: string;
1916
+ columns: string[];
1917
+ isUnique: boolean;
1918
+ using?: "btree" | "hash" | undefined;
1919
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1920
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1921
+ }>;
1922
+ compositePrimaryKeys: Record<string, {
1923
+ name: string;
1924
+ columns: string[];
1925
+ }>;
1926
+ uniqueConstraints: Record<string, {
1927
+ name: string;
1928
+ columns: string[];
1929
+ }>;
1930
+ }, {
1931
+ name: string;
1932
+ columns: Record<string, {
1933
+ type: string;
1934
+ name: string;
1935
+ primaryKey: boolean;
1936
+ notNull: boolean;
1937
+ default?: any;
1938
+ generated?: {
1939
+ type: "stored" | "virtual";
1940
+ as: string;
1941
+ } | undefined;
1942
+ onUpdate?: any;
1943
+ autoincrement?: boolean | undefined;
1944
+ }>;
1945
+ indexes: Record<string, {
1946
+ name: string;
1947
+ columns: string[];
1948
+ isUnique: boolean;
1949
+ using?: "btree" | "hash" | undefined;
1950
+ algorithm?: "default" | "inplace" | "copy" | undefined;
1951
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
1952
+ }>;
1953
+ compositePrimaryKeys: Record<string, {
1954
+ name: string;
1955
+ columns: string[];
1956
+ }>;
1957
+ uniqueConstraints?: Record<string, {
1958
+ name: string;
1959
+ columns: string[];
1960
+ }> | undefined;
1961
+ }>>;
1962
+ _meta: zod.ZodObject<{
1963
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
1964
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
1965
+ }, "strip", zod.ZodTypeAny, {
1966
+ tables: Record<string, string>;
1967
+ columns: Record<string, string>;
1968
+ }, {
1969
+ tables: Record<string, string>;
1970
+ columns: Record<string, string>;
1971
+ }>;
1972
+ internal: zod.ZodOptional<zod.ZodObject<{
1973
+ tables: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
1974
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
1975
+ isDefaultAnExpression: zod.ZodOptional<zod.ZodBoolean>;
1976
+ }, "strip", zod.ZodTypeAny, {
1977
+ isDefaultAnExpression?: boolean | undefined;
1978
+ }, {
1979
+ isDefaultAnExpression?: boolean | undefined;
1980
+ }>>>;
1981
+ }, "strip", zod.ZodTypeAny, {
1982
+ columns: Record<string, {
1983
+ isDefaultAnExpression?: boolean | undefined;
1984
+ } | undefined>;
1985
+ }, {
1986
+ columns: Record<string, {
1987
+ isDefaultAnExpression?: boolean | undefined;
1988
+ } | undefined>;
1989
+ }>>>>;
1990
+ indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
1991
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
1992
+ isExpression: zod.ZodOptional<zod.ZodBoolean>;
1993
+ }, "strip", zod.ZodTypeAny, {
1994
+ isExpression?: boolean | undefined;
1995
+ }, {
1996
+ isExpression?: boolean | undefined;
1997
+ }>>>;
1998
+ }, "strip", zod.ZodTypeAny, {
1999
+ columns: Record<string, {
2000
+ isExpression?: boolean | undefined;
2001
+ } | undefined>;
2002
+ }, {
2003
+ columns: Record<string, {
2004
+ isExpression?: boolean | undefined;
2005
+ } | undefined>;
2006
+ }>>>>;
2007
+ }, "strip", zod.ZodTypeAny, {
2008
+ tables?: Record<string, {
2009
+ columns: Record<string, {
2010
+ isDefaultAnExpression?: boolean | undefined;
2011
+ } | undefined>;
2012
+ } | undefined> | undefined;
2013
+ indexes?: Record<string, {
2014
+ columns: Record<string, {
2015
+ isExpression?: boolean | undefined;
2016
+ } | undefined>;
2017
+ } | undefined> | undefined;
2018
+ }, {
2019
+ tables?: Record<string, {
2020
+ columns: Record<string, {
2021
+ isDefaultAnExpression?: boolean | undefined;
2022
+ } | undefined>;
2023
+ } | undefined> | undefined;
2024
+ indexes?: Record<string, {
2025
+ columns: Record<string, {
2026
+ isExpression?: boolean | undefined;
2027
+ } | undefined>;
2028
+ } | undefined> | undefined;
2029
+ }>>;
2030
+ } & {
2031
+ id: zod.ZodString;
2032
+ prevId: zod.ZodString;
2033
+ }, "strip", zod.ZodTypeAny, {
2034
+ version: "1";
2035
+ dialect: "singlestore";
2036
+ tables: Record<string, {
2037
+ name: string;
2038
+ columns: Record<string, {
2039
+ type: string;
2040
+ name: string;
2041
+ primaryKey: boolean;
2042
+ notNull: boolean;
2043
+ default?: any;
2044
+ generated?: {
2045
+ type: "stored" | "virtual";
2046
+ as: string;
2047
+ } | undefined;
2048
+ onUpdate?: any;
2049
+ autoincrement?: boolean | undefined;
2050
+ }>;
2051
+ indexes: Record<string, {
2052
+ name: string;
2053
+ columns: string[];
2054
+ isUnique: boolean;
2055
+ using?: "btree" | "hash" | undefined;
2056
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2057
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2058
+ }>;
2059
+ compositePrimaryKeys: Record<string, {
2060
+ name: string;
2061
+ columns: string[];
2062
+ }>;
2063
+ uniqueConstraints: Record<string, {
2064
+ name: string;
2065
+ columns: string[];
2066
+ }>;
2067
+ }>;
2068
+ _meta: {
2069
+ tables: Record<string, string>;
2070
+ columns: Record<string, string>;
2071
+ };
2072
+ id: string;
2073
+ prevId: string;
2074
+ internal?: {
2075
+ tables?: Record<string, {
2076
+ columns: Record<string, {
2077
+ isDefaultAnExpression?: boolean | undefined;
2078
+ } | undefined>;
2079
+ } | undefined> | undefined;
2080
+ indexes?: Record<string, {
2081
+ columns: Record<string, {
2082
+ isExpression?: boolean | undefined;
2083
+ } | undefined>;
2084
+ } | undefined> | undefined;
2085
+ } | undefined;
2086
+ }, {
2087
+ version: "1";
2088
+ dialect: "singlestore";
2089
+ tables: Record<string, {
2090
+ name: string;
2091
+ columns: Record<string, {
2092
+ type: string;
2093
+ name: string;
2094
+ primaryKey: boolean;
2095
+ notNull: boolean;
2096
+ default?: any;
2097
+ generated?: {
2098
+ type: "stored" | "virtual";
2099
+ as: string;
2100
+ } | undefined;
2101
+ onUpdate?: any;
2102
+ autoincrement?: boolean | undefined;
2103
+ }>;
2104
+ indexes: Record<string, {
2105
+ name: string;
2106
+ columns: string[];
2107
+ isUnique: boolean;
2108
+ using?: "btree" | "hash" | undefined;
2109
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2110
+ lock?: "default" | "none" | "shared" | "exclusive" | undefined;
2111
+ }>;
2112
+ compositePrimaryKeys: Record<string, {
2113
+ name: string;
2114
+ columns: string[];
2115
+ }>;
2116
+ uniqueConstraints?: Record<string, {
2117
+ name: string;
2118
+ columns: string[];
2119
+ }> | undefined;
2120
+ }>;
2121
+ _meta: {
2122
+ tables: Record<string, string>;
2123
+ columns: Record<string, string>;
2124
+ };
2125
+ id: string;
2126
+ prevId: string;
2127
+ internal?: {
2128
+ tables?: Record<string, {
2129
+ columns: Record<string, {
2130
+ isDefaultAnExpression?: boolean | undefined;
2131
+ } | undefined>;
2132
+ } | undefined> | undefined;
2133
+ indexes?: Record<string, {
2134
+ columns: Record<string, {
2135
+ isExpression?: boolean | undefined;
2136
+ } | undefined>;
2137
+ } | undefined> | undefined;
2138
+ } | undefined;
2139
+ }>;
2140
+ type SingleStoreSchema = TypeOf<typeof schema$1>;
2141
+
2142
+ declare const schema: zod.ZodObject<{
2143
+ version: zod.ZodLiteral<"6">;
2144
+ dialect: zod.ZodEnum<["sqlite"]>;
2145
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2146
+ name: zod.ZodString;
2147
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2148
+ name: zod.ZodString;
2149
+ type: zod.ZodString;
2150
+ primaryKey: zod.ZodBoolean;
2151
+ notNull: zod.ZodBoolean;
2152
+ autoincrement: zod.ZodOptional<zod.ZodBoolean>;
2153
+ default: zod.ZodOptional<zod.ZodAny>;
2154
+ generated: zod.ZodOptional<zod.ZodObject<{
2155
+ type: zod.ZodEnum<["stored", "virtual"]>;
2156
+ as: zod.ZodString;
2157
+ }, "strip", zod.ZodTypeAny, {
2158
+ type: "stored" | "virtual";
2159
+ as: string;
2160
+ }, {
2161
+ type: "stored" | "virtual";
2162
+ as: string;
2163
+ }>>;
2164
+ }, "strict", zod.ZodTypeAny, {
2165
+ type: string;
2166
+ name: string;
2167
+ primaryKey: boolean;
2168
+ notNull: boolean;
2169
+ default?: any;
2170
+ generated?: {
2171
+ type: "stored" | "virtual";
2172
+ as: string;
2173
+ } | undefined;
2174
+ autoincrement?: boolean | undefined;
2175
+ }, {
2176
+ type: string;
2177
+ name: string;
2178
+ primaryKey: boolean;
2179
+ notNull: boolean;
2180
+ default?: any;
2181
+ generated?: {
2182
+ type: "stored" | "virtual";
2183
+ as: string;
2184
+ } | undefined;
2185
+ autoincrement?: boolean | undefined;
2186
+ }>>;
2187
+ indexes: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2188
+ name: zod.ZodString;
2189
+ columns: zod.ZodArray<zod.ZodString, "many">;
2190
+ where: zod.ZodOptional<zod.ZodString>;
2191
+ isUnique: zod.ZodBoolean;
2192
+ }, "strict", zod.ZodTypeAny, {
2193
+ name: string;
2194
+ columns: string[];
2195
+ isUnique: boolean;
2196
+ where?: string | undefined;
2197
+ }, {
2198
+ name: string;
2199
+ columns: string[];
2200
+ isUnique: boolean;
2201
+ where?: string | undefined;
2202
+ }>>;
2203
+ foreignKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2204
+ name: zod.ZodString;
2205
+ tableFrom: zod.ZodString;
2206
+ columnsFrom: zod.ZodArray<zod.ZodString, "many">;
2207
+ tableTo: zod.ZodString;
2208
+ columnsTo: zod.ZodArray<zod.ZodString, "many">;
2209
+ onUpdate: zod.ZodOptional<zod.ZodString>;
2210
+ onDelete: zod.ZodOptional<zod.ZodString>;
2211
+ }, "strict", zod.ZodTypeAny, {
2212
+ name: string;
2213
+ tableFrom: string;
2214
+ columnsFrom: string[];
2215
+ tableTo: string;
2216
+ columnsTo: string[];
2217
+ onUpdate?: string | undefined;
2218
+ onDelete?: string | undefined;
2219
+ }, {
2220
+ name: string;
2221
+ tableFrom: string;
2222
+ columnsFrom: string[];
2223
+ tableTo: string;
2224
+ columnsTo: string[];
2225
+ onUpdate?: string | undefined;
2226
+ onDelete?: string | undefined;
2227
+ }>>;
2228
+ compositePrimaryKeys: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2229
+ columns: zod.ZodArray<zod.ZodString, "many">;
2230
+ name: zod.ZodOptional<zod.ZodString>;
2231
+ }, "strict", zod.ZodTypeAny, {
2232
+ columns: string[];
2233
+ name?: string | undefined;
2234
+ }, {
2235
+ columns: string[];
2236
+ name?: string | undefined;
2237
+ }>>;
2238
+ uniqueConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2239
+ name: zod.ZodString;
2240
+ columns: zod.ZodArray<zod.ZodString, "many">;
2241
+ }, "strict", zod.ZodTypeAny, {
2242
+ name: string;
2243
+ columns: string[];
2244
+ }, {
2245
+ name: string;
2246
+ columns: string[];
2247
+ }>>>;
2248
+ checkConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2249
+ name: zod.ZodString;
2250
+ value: zod.ZodString;
2251
+ }, "strict", zod.ZodTypeAny, {
2252
+ value: string;
2253
+ name: string;
2254
+ }, {
2255
+ value: string;
2256
+ name: string;
2257
+ }>>>;
2258
+ }, "strict", zod.ZodTypeAny, {
2259
+ name: string;
2260
+ columns: Record<string, {
2261
+ type: string;
2262
+ name: string;
2263
+ primaryKey: boolean;
2264
+ notNull: boolean;
2265
+ default?: any;
2266
+ generated?: {
2267
+ type: "stored" | "virtual";
2268
+ as: string;
2269
+ } | undefined;
2270
+ autoincrement?: boolean | undefined;
2271
+ }>;
2272
+ indexes: Record<string, {
2273
+ name: string;
2274
+ columns: string[];
2275
+ isUnique: boolean;
2276
+ where?: string | undefined;
2277
+ }>;
2278
+ foreignKeys: Record<string, {
2279
+ name: string;
2280
+ tableFrom: string;
2281
+ columnsFrom: string[];
2282
+ tableTo: string;
2283
+ columnsTo: string[];
2284
+ onUpdate?: string | undefined;
2285
+ onDelete?: string | undefined;
2286
+ }>;
2287
+ compositePrimaryKeys: Record<string, {
2288
+ columns: string[];
2289
+ name?: string | undefined;
2290
+ }>;
2291
+ uniqueConstraints: Record<string, {
2292
+ name: string;
2293
+ columns: string[];
2294
+ }>;
2295
+ checkConstraints: Record<string, {
2296
+ value: string;
2297
+ name: string;
2298
+ }>;
2299
+ }, {
2300
+ name: string;
2301
+ columns: Record<string, {
2302
+ type: string;
2303
+ name: string;
2304
+ primaryKey: boolean;
2305
+ notNull: boolean;
2306
+ default?: any;
2307
+ generated?: {
2308
+ type: "stored" | "virtual";
2309
+ as: string;
2310
+ } | undefined;
2311
+ autoincrement?: boolean | undefined;
2312
+ }>;
2313
+ indexes: Record<string, {
2314
+ name: string;
2315
+ columns: string[];
2316
+ isUnique: boolean;
2317
+ where?: string | undefined;
2318
+ }>;
2319
+ foreignKeys: Record<string, {
2320
+ name: string;
2321
+ tableFrom: string;
2322
+ columnsFrom: string[];
2323
+ tableTo: string;
2324
+ columnsTo: string[];
2325
+ onUpdate?: string | undefined;
2326
+ onDelete?: string | undefined;
2327
+ }>;
2328
+ compositePrimaryKeys: Record<string, {
2329
+ columns: string[];
2330
+ name?: string | undefined;
2331
+ }>;
2332
+ uniqueConstraints?: Record<string, {
2333
+ name: string;
2334
+ columns: string[];
2335
+ }> | undefined;
2336
+ checkConstraints?: Record<string, {
2337
+ value: string;
2338
+ name: string;
2339
+ }> | undefined;
2340
+ }>>;
2341
+ views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2342
+ name: zod.ZodString;
2343
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
2344
+ name: zod.ZodString;
2345
+ type: zod.ZodString;
2346
+ primaryKey: zod.ZodBoolean;
2347
+ notNull: zod.ZodBoolean;
2348
+ autoincrement: zod.ZodOptional<zod.ZodBoolean>;
2349
+ default: zod.ZodOptional<zod.ZodAny>;
2350
+ generated: zod.ZodOptional<zod.ZodObject<{
2351
+ type: zod.ZodEnum<["stored", "virtual"]>;
2352
+ as: zod.ZodString;
2353
+ }, "strip", zod.ZodTypeAny, {
2354
+ type: "stored" | "virtual";
2355
+ as: string;
2356
+ }, {
2357
+ type: "stored" | "virtual";
2358
+ as: string;
2359
+ }>>;
2360
+ }, "strict", zod.ZodTypeAny, {
2361
+ type: string;
2362
+ name: string;
2363
+ primaryKey: boolean;
2364
+ notNull: boolean;
2365
+ default?: any;
2366
+ generated?: {
2367
+ type: "stored" | "virtual";
2368
+ as: string;
2369
+ } | undefined;
2370
+ autoincrement?: boolean | undefined;
2371
+ }, {
2372
+ type: string;
2373
+ name: string;
2374
+ primaryKey: boolean;
2375
+ notNull: boolean;
2376
+ default?: any;
2377
+ generated?: {
2378
+ type: "stored" | "virtual";
2379
+ as: string;
2380
+ } | undefined;
2381
+ autoincrement?: boolean | undefined;
2382
+ }>>;
2383
+ definition: zod.ZodOptional<zod.ZodString>;
2384
+ isExisting: zod.ZodBoolean;
2385
+ }, "strict", zod.ZodTypeAny, {
2386
+ name: string;
2387
+ columns: Record<string, {
2388
+ type: string;
2389
+ name: string;
2390
+ primaryKey: boolean;
2391
+ notNull: boolean;
2392
+ default?: any;
2393
+ generated?: {
2394
+ type: "stored" | "virtual";
2395
+ as: string;
2396
+ } | undefined;
2397
+ autoincrement?: boolean | undefined;
2398
+ }>;
2399
+ isExisting: boolean;
2400
+ definition?: string | undefined;
2401
+ }, {
2402
+ name: string;
2403
+ columns: Record<string, {
2404
+ type: string;
2405
+ name: string;
2406
+ primaryKey: boolean;
2407
+ notNull: boolean;
2408
+ default?: any;
2409
+ generated?: {
2410
+ type: "stored" | "virtual";
2411
+ as: string;
2412
+ } | undefined;
2413
+ autoincrement?: boolean | undefined;
2414
+ }>;
2415
+ isExisting: boolean;
2416
+ definition?: string | undefined;
2417
+ }>>>;
2418
+ enums: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
2419
+ _meta: zod.ZodObject<{
2420
+ tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
2421
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodString>;
2422
+ }, "strip", zod.ZodTypeAny, {
2423
+ tables: Record<string, string>;
2424
+ columns: Record<string, string>;
2425
+ }, {
2426
+ tables: Record<string, string>;
2427
+ columns: Record<string, string>;
2428
+ }>;
2429
+ internal: zod.ZodOptional<zod.ZodObject<{
2430
+ indexes: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
2431
+ columns: zod.ZodRecord<zod.ZodString, zod.ZodOptional<zod.ZodObject<{
2432
+ isExpression: zod.ZodOptional<zod.ZodBoolean>;
2433
+ }, "strip", zod.ZodTypeAny, {
2434
+ isExpression?: boolean | undefined;
2435
+ }, {
2436
+ isExpression?: boolean | undefined;
2437
+ }>>>;
2438
+ }, "strip", zod.ZodTypeAny, {
2439
+ columns: Record<string, {
2440
+ isExpression?: boolean | undefined;
2441
+ } | undefined>;
2442
+ }, {
2443
+ columns: Record<string, {
2444
+ isExpression?: boolean | undefined;
2445
+ } | undefined>;
2446
+ }>>>>;
2447
+ }, "strip", zod.ZodTypeAny, {
2448
+ indexes?: Record<string, {
2449
+ columns: Record<string, {
2450
+ isExpression?: boolean | undefined;
2451
+ } | undefined>;
2452
+ } | undefined> | undefined;
2453
+ }, {
2454
+ indexes?: Record<string, {
2455
+ columns: Record<string, {
2456
+ isExpression?: boolean | undefined;
2457
+ } | undefined>;
2458
+ } | undefined> | undefined;
2459
+ }>>;
2460
+ } & {
2461
+ id: zod.ZodString;
2462
+ prevId: zod.ZodString;
2463
+ }, "strict", zod.ZodTypeAny, {
2464
+ version: "6";
2465
+ dialect: "sqlite";
2466
+ tables: Record<string, {
2467
+ name: string;
2468
+ columns: Record<string, {
2469
+ type: string;
2470
+ name: string;
2471
+ primaryKey: boolean;
2472
+ notNull: boolean;
2473
+ default?: any;
2474
+ generated?: {
2475
+ type: "stored" | "virtual";
2476
+ as: string;
2477
+ } | undefined;
2478
+ autoincrement?: boolean | undefined;
2479
+ }>;
2480
+ indexes: Record<string, {
2481
+ name: string;
2482
+ columns: string[];
2483
+ isUnique: boolean;
2484
+ where?: string | undefined;
2485
+ }>;
2486
+ foreignKeys: Record<string, {
2487
+ name: string;
2488
+ tableFrom: string;
2489
+ columnsFrom: string[];
2490
+ tableTo: string;
2491
+ columnsTo: string[];
2492
+ onUpdate?: string | undefined;
2493
+ onDelete?: string | undefined;
2494
+ }>;
2495
+ compositePrimaryKeys: Record<string, {
2496
+ columns: string[];
2497
+ name?: string | undefined;
2498
+ }>;
2499
+ uniqueConstraints: Record<string, {
2500
+ name: string;
2501
+ columns: string[];
2502
+ }>;
2503
+ checkConstraints: Record<string, {
2504
+ value: string;
2505
+ name: string;
2506
+ }>;
2507
+ }>;
2508
+ enums: {};
2509
+ views: Record<string, {
2510
+ name: string;
2511
+ columns: Record<string, {
2512
+ type: string;
2513
+ name: string;
2514
+ primaryKey: boolean;
2515
+ notNull: boolean;
2516
+ default?: any;
2517
+ generated?: {
2518
+ type: "stored" | "virtual";
2519
+ as: string;
2520
+ } | undefined;
2521
+ autoincrement?: boolean | undefined;
2522
+ }>;
2523
+ isExisting: boolean;
2524
+ definition?: string | undefined;
2525
+ }>;
2526
+ _meta: {
2527
+ tables: Record<string, string>;
2528
+ columns: Record<string, string>;
2529
+ };
2530
+ id: string;
2531
+ prevId: string;
2532
+ internal?: {
2533
+ indexes?: Record<string, {
2534
+ columns: Record<string, {
2535
+ isExpression?: boolean | undefined;
2536
+ } | undefined>;
2537
+ } | undefined> | undefined;
2538
+ } | undefined;
2539
+ }, {
2540
+ version: "6";
2541
+ dialect: "sqlite";
2542
+ tables: Record<string, {
2543
+ name: string;
2544
+ columns: Record<string, {
2545
+ type: string;
2546
+ name: string;
2547
+ primaryKey: boolean;
2548
+ notNull: boolean;
2549
+ default?: any;
2550
+ generated?: {
2551
+ type: "stored" | "virtual";
2552
+ as: string;
2553
+ } | undefined;
2554
+ autoincrement?: boolean | undefined;
2555
+ }>;
2556
+ indexes: Record<string, {
2557
+ name: string;
2558
+ columns: string[];
2559
+ isUnique: boolean;
2560
+ where?: string | undefined;
2561
+ }>;
2562
+ foreignKeys: Record<string, {
2563
+ name: string;
2564
+ tableFrom: string;
2565
+ columnsFrom: string[];
2566
+ tableTo: string;
2567
+ columnsTo: string[];
2568
+ onUpdate?: string | undefined;
2569
+ onDelete?: string | undefined;
2570
+ }>;
2571
+ compositePrimaryKeys: Record<string, {
2572
+ columns: string[];
2573
+ name?: string | undefined;
2574
+ }>;
2575
+ uniqueConstraints?: Record<string, {
2576
+ name: string;
2577
+ columns: string[];
2578
+ }> | undefined;
2579
+ checkConstraints?: Record<string, {
2580
+ value: string;
2581
+ name: string;
2582
+ }> | undefined;
2583
+ }>;
2584
+ enums: {};
2585
+ _meta: {
2586
+ tables: Record<string, string>;
2587
+ columns: Record<string, string>;
2588
+ };
2589
+ id: string;
2590
+ prevId: string;
2591
+ views?: Record<string, {
2592
+ name: string;
2593
+ columns: Record<string, {
2594
+ type: string;
2595
+ name: string;
2596
+ primaryKey: boolean;
2597
+ notNull: boolean;
2598
+ default?: any;
2599
+ generated?: {
2600
+ type: "stored" | "virtual";
2601
+ as: string;
2602
+ } | undefined;
2603
+ autoincrement?: boolean | undefined;
2604
+ }>;
2605
+ isExisting: boolean;
2606
+ definition?: string | undefined;
2607
+ }> | undefined;
2608
+ internal?: {
2609
+ indexes?: Record<string, {
2610
+ columns: Record<string, {
2611
+ isExpression?: boolean | undefined;
2612
+ } | undefined>;
2613
+ } | undefined> | undefined;
2614
+ } | undefined;
2615
+ }>;
2616
+ type SQLiteSchema = TypeOf<typeof schema>;
2617
+
2618
+ type DrizzleSnapshotJSON = PgSchema;
2619
+ type DrizzleSQLiteSnapshotJSON = SQLiteSchema;
2620
+ type DrizzleMySQLSnapshotJSON = MySqlSchema;
2621
+ type DrizzleSingleStoreSnapshotJSON = SingleStoreSchema;
2622
+ declare const generateDrizzleJson: (imports: Record<string, unknown>, prevId?: string, schemaFilters?: string[], casing?: CasingType) => PgSchema;
2623
+ declare const generateMigration: (prev: DrizzleSnapshotJSON, cur: DrizzleSnapshotJSON) => Promise<string[]>;
2624
+ declare const pushSchema: (imports: Record<string, unknown>, drizzleInstance: PgDatabase<any>, schemaFilters?: string[], tablesFilter?: string[], extensionsFilters?: Config["extensionsFilters"]) => Promise<{
2625
+ hasDataLoss: boolean;
2626
+ warnings: string[];
2627
+ statementsToExecute: string[];
2628
+ apply: () => Promise<void>;
2629
+ }>;
2630
+ declare const generateSQLiteDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<SQLiteSchema>;
2631
+ declare const generateSQLiteMigration: (prev: DrizzleSQLiteSnapshotJSON, cur: DrizzleSQLiteSnapshotJSON) => Promise<string[]>;
2632
+ declare const pushSQLiteSchema: (imports: Record<string, unknown>, drizzleInstance: LibSQLDatabase<any>) => Promise<{
2633
+ hasDataLoss: boolean;
2634
+ warnings: string[];
2635
+ statementsToExecute: string[];
2636
+ apply: () => Promise<void>;
2637
+ }>;
2638
+ declare const generateMySQLDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<MySqlSchema>;
2639
+ declare const generateMySQLMigration: (prev: DrizzleMySQLSnapshotJSON, cur: DrizzleMySQLSnapshotJSON) => Promise<string[]>;
2640
+ declare const pushMySQLSchema: (imports: Record<string, unknown>, drizzleInstance: MySql2Database<any>, databaseName: string) => Promise<{
2641
+ hasDataLoss: boolean;
2642
+ warnings: string[];
2643
+ statementsToExecute: string[];
2644
+ apply: () => Promise<void>;
2645
+ }>;
2646
+ declare const generateSingleStoreDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<SingleStoreSchema>;
2647
+ declare const generateSingleStoreMigration: (prev: DrizzleSingleStoreSnapshotJSON, cur: DrizzleSingleStoreSnapshotJSON) => Promise<string[]>;
2648
+ declare const pushSingleStoreSchema: (imports: Record<string, unknown>, drizzleInstance: SingleStoreDriverDatabase<any>, databaseName: string) => Promise<{
2649
+ hasDataLoss: boolean;
2650
+ warnings: string[];
2651
+ statementsToExecute: string[];
2652
+ apply: () => Promise<void>;
2653
+ }>;
2654
+ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => {
2655
+ version: "7";
2656
+ dialect: "postgresql";
2657
+ tables: Record<string, {
2658
+ name: string;
2659
+ schema: string;
2660
+ columns: Record<string, {
2661
+ type: string;
2662
+ name: string;
2663
+ primaryKey: boolean;
2664
+ notNull: boolean;
2665
+ typeSchema?: string | undefined;
2666
+ default?: any;
2667
+ isUnique?: any;
2668
+ uniqueName?: string | undefined;
2669
+ nullsNotDistinct?: boolean | undefined;
2670
+ generated?: {
2671
+ type: "stored";
2672
+ as: string;
2673
+ } | undefined;
2674
+ identity?: {
2675
+ type: "always" | "byDefault";
2676
+ name: string;
2677
+ schema: string;
2678
+ increment?: string | undefined;
2679
+ minValue?: string | undefined;
2680
+ maxValue?: string | undefined;
2681
+ startWith?: string | undefined;
2682
+ cache?: string | undefined;
2683
+ cycle?: boolean | undefined;
2684
+ } | undefined;
2685
+ }>;
2686
+ indexes: Record<string, {
2687
+ name: string;
2688
+ columns: {
2689
+ expression: string;
2690
+ isExpression: boolean;
2691
+ asc: boolean;
2692
+ nulls?: string | undefined;
2693
+ opclass?: string | undefined;
2694
+ }[];
2695
+ isUnique: boolean;
2696
+ method: string;
2697
+ concurrently: boolean;
2698
+ with?: Record<string, any> | undefined;
2699
+ where?: string | undefined;
2700
+ }>;
2701
+ foreignKeys: Record<string, {
2702
+ name: string;
2703
+ tableFrom: string;
2704
+ columnsFrom: string[];
2705
+ tableTo: string;
2706
+ columnsTo: string[];
2707
+ schemaTo?: string | undefined;
2708
+ onUpdate?: string | undefined;
2709
+ onDelete?: string | undefined;
2710
+ }>;
2711
+ compositePrimaryKeys: Record<string, {
2712
+ name: string;
2713
+ columns: string[];
2714
+ }>;
2715
+ uniqueConstraints: Record<string, {
2716
+ name: string;
2717
+ columns: string[];
2718
+ nullsNotDistinct: boolean;
2719
+ }>;
2720
+ policies: Record<string, {
2721
+ name: string;
2722
+ schema?: string | undefined;
2723
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
2724
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
2725
+ to?: string[] | undefined;
2726
+ using?: string | undefined;
2727
+ withCheck?: string | undefined;
2728
+ on?: string | undefined;
2729
+ }>;
2730
+ checkConstraints: Record<string, {
2731
+ value: string;
2732
+ name: string;
2733
+ }>;
2734
+ isRLSEnabled: boolean;
2735
+ }>;
2736
+ policies: Record<string, {
2737
+ name: string;
2738
+ schema?: string | undefined;
2739
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
2740
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
2741
+ to?: string[] | undefined;
2742
+ using?: string | undefined;
2743
+ withCheck?: string | undefined;
2744
+ on?: string | undefined;
2745
+ }>;
2746
+ enums: Record<string, {
2747
+ values: string[];
2748
+ name: string;
2749
+ schema: string;
2750
+ }>;
2751
+ schemas: Record<string, string>;
2752
+ views: Record<string, {
2753
+ name: string;
2754
+ schema: string;
2755
+ columns: Record<string, {
2756
+ type: string;
2757
+ name: string;
2758
+ primaryKey: boolean;
2759
+ notNull: boolean;
2760
+ typeSchema?: string | undefined;
2761
+ default?: any;
2762
+ isUnique?: any;
2763
+ uniqueName?: string | undefined;
2764
+ nullsNotDistinct?: boolean | undefined;
2765
+ generated?: {
2766
+ type: "stored";
2767
+ as: string;
2768
+ } | undefined;
2769
+ identity?: {
2770
+ type: "always" | "byDefault";
2771
+ name: string;
2772
+ schema: string;
2773
+ increment?: string | undefined;
2774
+ minValue?: string | undefined;
2775
+ maxValue?: string | undefined;
2776
+ startWith?: string | undefined;
2777
+ cache?: string | undefined;
2778
+ cycle?: boolean | undefined;
2779
+ } | undefined;
2780
+ }>;
2781
+ materialized: boolean;
2782
+ isExisting: boolean;
2783
+ with?: {
2784
+ checkOption?: "local" | "cascaded" | undefined;
2785
+ securityBarrier?: boolean | undefined;
2786
+ securityInvoker?: boolean | undefined;
2787
+ fillfactor?: number | undefined;
2788
+ toastTupleTarget?: number | undefined;
2789
+ parallelWorkers?: number | undefined;
2790
+ autovacuumEnabled?: boolean | undefined;
2791
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
2792
+ vacuumTruncate?: boolean | undefined;
2793
+ autovacuumVacuumThreshold?: number | undefined;
2794
+ autovacuumVacuumScaleFactor?: number | undefined;
2795
+ autovacuumVacuumCostDelay?: number | undefined;
2796
+ autovacuumVacuumCostLimit?: number | undefined;
2797
+ autovacuumFreezeMinAge?: number | undefined;
2798
+ autovacuumFreezeMaxAge?: number | undefined;
2799
+ autovacuumFreezeTableAge?: number | undefined;
2800
+ autovacuumMultixactFreezeMinAge?: number | undefined;
2801
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
2802
+ autovacuumMultixactFreezeTableAge?: number | undefined;
2803
+ logAutovacuumMinDuration?: number | undefined;
2804
+ userCatalogTable?: boolean | undefined;
2805
+ } | undefined;
2806
+ using?: string | undefined;
2807
+ definition?: string | undefined;
2808
+ withNoData?: boolean | undefined;
2809
+ tablespace?: string | undefined;
2810
+ }>;
2811
+ sequences: Record<string, {
2812
+ name: string;
2813
+ schema: string;
2814
+ increment?: string | undefined;
2815
+ minValue?: string | undefined;
2816
+ maxValue?: string | undefined;
2817
+ startWith?: string | undefined;
2818
+ cache?: string | undefined;
2819
+ cycle?: boolean | undefined;
2820
+ }>;
2821
+ roles: Record<string, {
2822
+ name: string;
2823
+ createDb?: boolean | undefined;
2824
+ createRole?: boolean | undefined;
2825
+ inherit?: boolean | undefined;
2826
+ }>;
2827
+ _meta: {
2828
+ tables: Record<string, string>;
2829
+ columns: Record<string, string>;
2830
+ schemas: Record<string, string>;
2831
+ };
2832
+ id: string;
2833
+ prevId: string;
2834
+ internal?: {
2835
+ tables: Record<string, {
2836
+ columns: Record<string, {
2837
+ isArray?: boolean | undefined;
2838
+ dimensions?: number | undefined;
2839
+ rawType?: string | undefined;
2840
+ isDefaultAnExpression?: boolean | undefined;
2841
+ } | undefined>;
2842
+ } | undefined>;
2843
+ } | undefined;
2844
+ } | Record<string, unknown>;
2845
+
2846
+ export { type DrizzleMySQLSnapshotJSON, type DrizzleSQLiteSnapshotJSON, type DrizzleSingleStoreSnapshotJSON, type DrizzleSnapshotJSON, generateDrizzleJson, generateMigration, generateMySQLDrizzleJson, generateMySQLMigration, generateSQLiteDrizzleJson, generateSQLiteMigration, generateSingleStoreDrizzleJson, generateSingleStoreMigration, pushMySQLSchema, pushSQLiteSchema, pushSchema, pushSingleStoreSchema, upPgSnapshot };