drizzle-kit 0.31.1-9811cd4 → 0.31.1-a42461b

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 +48559 -0
  4. package/api.mjs +48547 -0
  5. package/bin.cjs +53123 -41985
  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 +6171 -36
  13. package/utils.mjs +6158 -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<zod.objectUtil.extendShape<{
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
+ name: string;
35
+ type: string;
36
+ primaryKey: boolean;
37
+ notNull: boolean;
38
+ default?: any;
39
+ onUpdate?: any;
40
+ autoincrement?: boolean | undefined;
41
+ generated?: {
42
+ type: "stored" | "virtual";
43
+ as: string;
44
+ } | undefined;
45
+ }, {
46
+ name: string;
47
+ type: string;
48
+ primaryKey: boolean;
49
+ notNull: boolean;
50
+ default?: any;
51
+ onUpdate?: any;
52
+ autoincrement?: boolean | undefined;
53
+ generated?: {
54
+ type: "stored" | "virtual";
55
+ as: string;
56
+ } | 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?: "none" | "default" | "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?: "none" | "default" | "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
+ name: string;
130
+ value: string;
131
+ }, {
132
+ name: string;
133
+ value: string;
134
+ }>>>;
135
+ }, "strict", zod.ZodTypeAny, {
136
+ name: string;
137
+ columns: Record<string, {
138
+ name: string;
139
+ type: string;
140
+ primaryKey: boolean;
141
+ notNull: boolean;
142
+ default?: any;
143
+ onUpdate?: any;
144
+ autoincrement?: boolean | undefined;
145
+ generated?: {
146
+ type: "stored" | "virtual";
147
+ as: string;
148
+ } | 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?: "none" | "default" | "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
+ name: string;
177
+ value: string;
178
+ }>;
179
+ }, {
180
+ name: string;
181
+ columns: Record<string, {
182
+ name: string;
183
+ type: string;
184
+ primaryKey: boolean;
185
+ notNull: boolean;
186
+ default?: any;
187
+ onUpdate?: any;
188
+ autoincrement?: boolean | undefined;
189
+ generated?: {
190
+ type: "stored" | "virtual";
191
+ as: string;
192
+ } | 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?: "none" | "default" | "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
+ name: string;
221
+ value: string;
222
+ }> | undefined;
223
+ }>>;
224
+ views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<zod.objectUtil.extendShape<{
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
+ name: string;
246
+ type: string;
247
+ primaryKey: boolean;
248
+ notNull: boolean;
249
+ default?: any;
250
+ onUpdate?: any;
251
+ autoincrement?: boolean | undefined;
252
+ generated?: {
253
+ type: "stored" | "virtual";
254
+ as: string;
255
+ } | undefined;
256
+ }, {
257
+ name: string;
258
+ type: string;
259
+ primaryKey: boolean;
260
+ notNull: boolean;
261
+ default?: any;
262
+ onUpdate?: any;
263
+ autoincrement?: boolean | undefined;
264
+ generated?: {
265
+ type: "stored" | "virtual";
266
+ as: string;
267
+ } | 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
+ name: string;
279
+ type: string;
280
+ primaryKey: boolean;
281
+ notNull: boolean;
282
+ default?: any;
283
+ onUpdate?: any;
284
+ autoincrement?: boolean | undefined;
285
+ generated?: {
286
+ type: "stored" | "virtual";
287
+ as: string;
288
+ } | undefined;
289
+ }>;
290
+ algorithm: "undefined" | "merge" | "temptable";
291
+ sqlSecurity: "definer" | "invoker";
292
+ isExisting: boolean;
293
+ withCheckOption?: "local" | "cascaded" | undefined;
294
+ definition?: string | undefined;
295
+ }, {
296
+ name: string;
297
+ columns: Record<string, {
298
+ name: string;
299
+ type: string;
300
+ primaryKey: boolean;
301
+ notNull: boolean;
302
+ default?: any;
303
+ onUpdate?: any;
304
+ autoincrement?: boolean | undefined;
305
+ generated?: {
306
+ type: "stored" | "virtual";
307
+ as: string;
308
+ } | undefined;
309
+ }>;
310
+ algorithm: "undefined" | "merge" | "temptable";
311
+ sqlSecurity: "definer" | "invoker";
312
+ isExisting: boolean;
313
+ withCheckOption?: "local" | "cascaded" | undefined;
314
+ definition?: string | 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
+ columns: Record<string, string>;
321
+ tables: Record<string, string>;
322
+ }, {
323
+ columns: Record<string, string>;
324
+ tables: 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
+ indexes?: Record<string, {
363
+ columns: Record<string, {
364
+ isExpression?: boolean | undefined;
365
+ } | undefined>;
366
+ } | undefined> | undefined;
367
+ tables?: Record<string, {
368
+ columns: Record<string, {
369
+ isDefaultAnExpression?: boolean | undefined;
370
+ } | undefined>;
371
+ } | undefined> | undefined;
372
+ }, {
373
+ indexes?: Record<string, {
374
+ columns: Record<string, {
375
+ isExpression?: boolean | undefined;
376
+ } | undefined>;
377
+ } | undefined> | undefined;
378
+ tables?: Record<string, {
379
+ columns: Record<string, {
380
+ isDefaultAnExpression?: boolean | undefined;
381
+ } | undefined>;
382
+ } | undefined> | undefined;
383
+ }>>;
384
+ }, {
385
+ id: zod.ZodString;
386
+ prevId: zod.ZodString;
387
+ }>, "strip", zod.ZodTypeAny, {
388
+ tables: Record<string, {
389
+ name: string;
390
+ columns: Record<string, {
391
+ name: string;
392
+ type: string;
393
+ primaryKey: boolean;
394
+ notNull: boolean;
395
+ default?: any;
396
+ onUpdate?: any;
397
+ autoincrement?: boolean | undefined;
398
+ generated?: {
399
+ type: "stored" | "virtual";
400
+ as: string;
401
+ } | undefined;
402
+ }>;
403
+ indexes: Record<string, {
404
+ name: string;
405
+ columns: string[];
406
+ isUnique: boolean;
407
+ using?: "btree" | "hash" | undefined;
408
+ algorithm?: "default" | "inplace" | "copy" | undefined;
409
+ lock?: "none" | "default" | "shared" | "exclusive" | undefined;
410
+ }>;
411
+ foreignKeys: Record<string, {
412
+ name: string;
413
+ tableFrom: string;
414
+ columnsFrom: string[];
415
+ tableTo: string;
416
+ columnsTo: string[];
417
+ onUpdate?: string | undefined;
418
+ onDelete?: string | undefined;
419
+ }>;
420
+ compositePrimaryKeys: Record<string, {
421
+ name: string;
422
+ columns: string[];
423
+ }>;
424
+ uniqueConstraints: Record<string, {
425
+ name: string;
426
+ columns: string[];
427
+ }>;
428
+ checkConstraint: Record<string, {
429
+ name: string;
430
+ value: string;
431
+ }>;
432
+ }>;
433
+ id: string;
434
+ prevId: string;
435
+ version: "5";
436
+ dialect: "mysql";
437
+ _meta: {
438
+ columns: Record<string, string>;
439
+ tables: Record<string, string>;
440
+ };
441
+ views: Record<string, {
442
+ name: string;
443
+ columns: Record<string, {
444
+ name: string;
445
+ type: string;
446
+ primaryKey: boolean;
447
+ notNull: boolean;
448
+ default?: any;
449
+ onUpdate?: any;
450
+ autoincrement?: boolean | undefined;
451
+ generated?: {
452
+ type: "stored" | "virtual";
453
+ as: string;
454
+ } | undefined;
455
+ }>;
456
+ algorithm: "undefined" | "merge" | "temptable";
457
+ sqlSecurity: "definer" | "invoker";
458
+ isExisting: boolean;
459
+ withCheckOption?: "local" | "cascaded" | undefined;
460
+ definition?: string | undefined;
461
+ }>;
462
+ internal?: {
463
+ indexes?: Record<string, {
464
+ columns: Record<string, {
465
+ isExpression?: boolean | undefined;
466
+ } | undefined>;
467
+ } | undefined> | undefined;
468
+ tables?: Record<string, {
469
+ columns: Record<string, {
470
+ isDefaultAnExpression?: boolean | undefined;
471
+ } | undefined>;
472
+ } | undefined> | undefined;
473
+ } | undefined;
474
+ }, {
475
+ tables: Record<string, {
476
+ name: string;
477
+ columns: Record<string, {
478
+ name: string;
479
+ type: string;
480
+ primaryKey: boolean;
481
+ notNull: boolean;
482
+ default?: any;
483
+ onUpdate?: any;
484
+ autoincrement?: boolean | undefined;
485
+ generated?: {
486
+ type: "stored" | "virtual";
487
+ as: string;
488
+ } | undefined;
489
+ }>;
490
+ indexes: Record<string, {
491
+ name: string;
492
+ columns: string[];
493
+ isUnique: boolean;
494
+ using?: "btree" | "hash" | undefined;
495
+ algorithm?: "default" | "inplace" | "copy" | undefined;
496
+ lock?: "none" | "default" | "shared" | "exclusive" | undefined;
497
+ }>;
498
+ foreignKeys: Record<string, {
499
+ name: string;
500
+ tableFrom: string;
501
+ columnsFrom: string[];
502
+ tableTo: string;
503
+ columnsTo: string[];
504
+ onUpdate?: string | undefined;
505
+ onDelete?: string | undefined;
506
+ }>;
507
+ compositePrimaryKeys: Record<string, {
508
+ name: string;
509
+ columns: string[];
510
+ }>;
511
+ uniqueConstraints?: Record<string, {
512
+ name: string;
513
+ columns: string[];
514
+ }> | undefined;
515
+ checkConstraint?: Record<string, {
516
+ name: string;
517
+ value: string;
518
+ }> | undefined;
519
+ }>;
520
+ id: string;
521
+ prevId: string;
522
+ version: "5";
523
+ dialect: "mysql";
524
+ _meta: {
525
+ columns: Record<string, string>;
526
+ tables: Record<string, string>;
527
+ };
528
+ internal?: {
529
+ indexes?: Record<string, {
530
+ columns: Record<string, {
531
+ isExpression?: boolean | undefined;
532
+ } | undefined>;
533
+ } | undefined> | undefined;
534
+ tables?: Record<string, {
535
+ columns: Record<string, {
536
+ isDefaultAnExpression?: boolean | undefined;
537
+ } | undefined>;
538
+ } | undefined> | undefined;
539
+ } | undefined;
540
+ views?: Record<string, {
541
+ name: string;
542
+ columns: Record<string, {
543
+ name: string;
544
+ type: string;
545
+ primaryKey: boolean;
546
+ notNull: boolean;
547
+ default?: any;
548
+ onUpdate?: any;
549
+ autoincrement?: boolean | undefined;
550
+ generated?: {
551
+ type: "stored" | "virtual";
552
+ as: string;
553
+ } | undefined;
554
+ }>;
555
+ algorithm: "undefined" | "merge" | "temptable";
556
+ sqlSecurity: "definer" | "invoker";
557
+ isExisting: boolean;
558
+ withCheckOption?: "local" | "cascaded" | undefined;
559
+ definition?: string | undefined;
560
+ }> | undefined;
561
+ }>;
562
+ type MySqlSchema = TypeOf<typeof schema$2>;
563
+
564
+ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{
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<zod.objectUtil.extendShape<{
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
+ name: string;
603
+ type: "always" | "byDefault";
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
+ name: string;
613
+ type: "always" | "byDefault";
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
+ name: string;
624
+ type: string;
625
+ primaryKey: boolean;
626
+ notNull: boolean;
627
+ default?: any;
628
+ isUnique?: any;
629
+ generated?: {
630
+ type: "stored";
631
+ as: string;
632
+ } | undefined;
633
+ typeSchema?: string | undefined;
634
+ uniqueName?: string | undefined;
635
+ nullsNotDistinct?: boolean | undefined;
636
+ identity?: {
637
+ name: string;
638
+ type: "always" | "byDefault";
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
+ name: string;
649
+ type: string;
650
+ primaryKey: boolean;
651
+ notNull: boolean;
652
+ default?: any;
653
+ isUnique?: any;
654
+ generated?: {
655
+ type: "stored";
656
+ as: string;
657
+ } | undefined;
658
+ typeSchema?: string | undefined;
659
+ uniqueName?: string | undefined;
660
+ nullsNotDistinct?: boolean | undefined;
661
+ identity?: {
662
+ name: string;
663
+ type: "always" | "byDefault";
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
+ isExpression: boolean;
683
+ expression: string;
684
+ asc: boolean;
685
+ nulls?: string | undefined;
686
+ opclass?: string | undefined;
687
+ }, {
688
+ isExpression: boolean;
689
+ expression: string;
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
+ isExpression: boolean;
703
+ expression: string;
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
+ isExpression: boolean;
717
+ expression: string;
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
+ onUpdate?: string | undefined;
744
+ onDelete?: string | undefined;
745
+ schemaTo?: string | undefined;
746
+ }, {
747
+ name: string;
748
+ tableFrom: string;
749
+ columnsFrom: string[];
750
+ tableTo: string;
751
+ columnsTo: string[];
752
+ onUpdate?: string | undefined;
753
+ onDelete?: string | undefined;
754
+ schemaTo?: 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
+ using?: string | undefined;
791
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
792
+ schema?: string | undefined;
793
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
794
+ to?: string[] | undefined;
795
+ withCheck?: string | undefined;
796
+ on?: string | undefined;
797
+ }, {
798
+ name: string;
799
+ using?: string | undefined;
800
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
801
+ schema?: string | undefined;
802
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
803
+ to?: 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
+ name: string;
812
+ value: string;
813
+ }, {
814
+ name: string;
815
+ value: string;
816
+ }>>>;
817
+ isRLSEnabled: zod.ZodDefault<zod.ZodBoolean>;
818
+ }, "strict", zod.ZodTypeAny, {
819
+ name: string;
820
+ columns: Record<string, {
821
+ name: string;
822
+ type: string;
823
+ primaryKey: boolean;
824
+ notNull: boolean;
825
+ default?: any;
826
+ isUnique?: any;
827
+ generated?: {
828
+ type: "stored";
829
+ as: string;
830
+ } | undefined;
831
+ typeSchema?: string | undefined;
832
+ uniqueName?: string | undefined;
833
+ nullsNotDistinct?: boolean | undefined;
834
+ identity?: {
835
+ name: string;
836
+ type: "always" | "byDefault";
837
+ schema: string;
838
+ increment?: string | undefined;
839
+ minValue?: string | undefined;
840
+ maxValue?: string | undefined;
841
+ startWith?: string | undefined;
842
+ cache?: string | undefined;
843
+ cycle?: boolean | undefined;
844
+ } | undefined;
845
+ }>;
846
+ indexes: Record<string, {
847
+ name: string;
848
+ columns: {
849
+ isExpression: boolean;
850
+ expression: string;
851
+ asc: boolean;
852
+ nulls?: string | undefined;
853
+ opclass?: string | undefined;
854
+ }[];
855
+ isUnique: boolean;
856
+ method: string;
857
+ concurrently: boolean;
858
+ with?: Record<string, any> | undefined;
859
+ where?: string | undefined;
860
+ }>;
861
+ foreignKeys: Record<string, {
862
+ name: string;
863
+ tableFrom: string;
864
+ columnsFrom: string[];
865
+ tableTo: string;
866
+ columnsTo: string[];
867
+ onUpdate?: string | undefined;
868
+ onDelete?: string | undefined;
869
+ schemaTo?: string | undefined;
870
+ }>;
871
+ schema: string;
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
+ checkConstraints: Record<string, {
882
+ name: string;
883
+ value: string;
884
+ }>;
885
+ policies: Record<string, {
886
+ name: string;
887
+ using?: string | undefined;
888
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
889
+ schema?: string | undefined;
890
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
891
+ to?: string[] | undefined;
892
+ withCheck?: string | undefined;
893
+ on?: string | undefined;
894
+ }>;
895
+ isRLSEnabled: boolean;
896
+ }, {
897
+ name: string;
898
+ columns: Record<string, {
899
+ name: string;
900
+ type: string;
901
+ primaryKey: boolean;
902
+ notNull: boolean;
903
+ default?: any;
904
+ isUnique?: any;
905
+ generated?: {
906
+ type: "stored";
907
+ as: string;
908
+ } | undefined;
909
+ typeSchema?: string | undefined;
910
+ uniqueName?: string | undefined;
911
+ nullsNotDistinct?: boolean | undefined;
912
+ identity?: {
913
+ name: string;
914
+ type: "always" | "byDefault";
915
+ schema: string;
916
+ increment?: string | undefined;
917
+ minValue?: string | undefined;
918
+ maxValue?: string | undefined;
919
+ startWith?: string | undefined;
920
+ cache?: string | undefined;
921
+ cycle?: boolean | undefined;
922
+ } | undefined;
923
+ }>;
924
+ indexes: Record<string, {
925
+ name: string;
926
+ columns: {
927
+ isExpression: boolean;
928
+ expression: string;
929
+ asc: boolean;
930
+ nulls?: string | undefined;
931
+ opclass?: string | undefined;
932
+ }[];
933
+ isUnique: boolean;
934
+ with?: Record<string, any> | undefined;
935
+ method?: string | undefined;
936
+ where?: string | undefined;
937
+ concurrently?: boolean | undefined;
938
+ }>;
939
+ foreignKeys: Record<string, {
940
+ name: string;
941
+ tableFrom: string;
942
+ columnsFrom: string[];
943
+ tableTo: string;
944
+ columnsTo: string[];
945
+ onUpdate?: string | undefined;
946
+ onDelete?: string | undefined;
947
+ schemaTo?: string | undefined;
948
+ }>;
949
+ schema: string;
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
+ checkConstraints?: Record<string, {
960
+ name: string;
961
+ value: string;
962
+ }> | undefined;
963
+ policies?: Record<string, {
964
+ name: string;
965
+ using?: string | undefined;
966
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
967
+ schema?: string | undefined;
968
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
969
+ to?: string[] | undefined;
970
+ withCheck?: string | undefined;
971
+ on?: string | undefined;
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
+ name: string;
981
+ values: string[];
982
+ schema: string;
983
+ }, {
984
+ name: string;
985
+ values: 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<zod.objectUtil.extendShape<{
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
+ name: string;
1025
+ type: "always" | "byDefault";
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
+ name: string;
1035
+ type: "always" | "byDefault";
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
+ name: string;
1046
+ type: string;
1047
+ primaryKey: boolean;
1048
+ notNull: boolean;
1049
+ default?: any;
1050
+ isUnique?: any;
1051
+ generated?: {
1052
+ type: "stored";
1053
+ as: string;
1054
+ } | undefined;
1055
+ typeSchema?: string | undefined;
1056
+ uniqueName?: string | undefined;
1057
+ nullsNotDistinct?: boolean | undefined;
1058
+ identity?: {
1059
+ name: string;
1060
+ type: "always" | "byDefault";
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
+ name: string;
1071
+ type: string;
1072
+ primaryKey: boolean;
1073
+ notNull: boolean;
1074
+ default?: any;
1075
+ isUnique?: any;
1076
+ generated?: {
1077
+ type: "stored";
1078
+ as: string;
1079
+ } | undefined;
1080
+ typeSchema?: string | undefined;
1081
+ uniqueName?: string | undefined;
1082
+ nullsNotDistinct?: boolean | undefined;
1083
+ identity?: {
1084
+ name: string;
1085
+ type: "always" | "byDefault";
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<zod.objectUtil.extendShape<{
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
+ columns: Record<string, {
1172
+ name: string;
1173
+ type: string;
1174
+ primaryKey: boolean;
1175
+ notNull: boolean;
1176
+ default?: any;
1177
+ isUnique?: any;
1178
+ generated?: {
1179
+ type: "stored";
1180
+ as: string;
1181
+ } | undefined;
1182
+ typeSchema?: string | undefined;
1183
+ uniqueName?: string | undefined;
1184
+ nullsNotDistinct?: boolean | undefined;
1185
+ identity?: {
1186
+ name: string;
1187
+ type: "always" | "byDefault";
1188
+ schema: string;
1189
+ increment?: string | undefined;
1190
+ minValue?: string | undefined;
1191
+ maxValue?: string | undefined;
1192
+ startWith?: string | undefined;
1193
+ cache?: string | undefined;
1194
+ cycle?: boolean | undefined;
1195
+ } | undefined;
1196
+ }>;
1197
+ schema: string;
1198
+ isExisting: boolean;
1199
+ materialized: boolean;
1200
+ using?: string | undefined;
1201
+ definition?: string | undefined;
1202
+ with?: {
1203
+ checkOption?: "local" | "cascaded" | undefined;
1204
+ securityBarrier?: boolean | undefined;
1205
+ securityInvoker?: boolean | undefined;
1206
+ fillfactor?: number | undefined;
1207
+ toastTupleTarget?: number | undefined;
1208
+ parallelWorkers?: number | undefined;
1209
+ autovacuumEnabled?: boolean | undefined;
1210
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
1211
+ vacuumTruncate?: boolean | undefined;
1212
+ autovacuumVacuumThreshold?: number | undefined;
1213
+ autovacuumVacuumScaleFactor?: number | undefined;
1214
+ autovacuumVacuumCostDelay?: number | undefined;
1215
+ autovacuumVacuumCostLimit?: number | undefined;
1216
+ autovacuumFreezeMinAge?: number | undefined;
1217
+ autovacuumFreezeMaxAge?: number | undefined;
1218
+ autovacuumFreezeTableAge?: number | undefined;
1219
+ autovacuumMultixactFreezeMinAge?: number | undefined;
1220
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
1221
+ autovacuumMultixactFreezeTableAge?: number | undefined;
1222
+ logAutovacuumMinDuration?: number | undefined;
1223
+ userCatalogTable?: boolean | undefined;
1224
+ } | undefined;
1225
+ withNoData?: boolean | undefined;
1226
+ tablespace?: string | undefined;
1227
+ }, {
1228
+ name: string;
1229
+ columns: Record<string, {
1230
+ name: string;
1231
+ type: string;
1232
+ primaryKey: boolean;
1233
+ notNull: boolean;
1234
+ default?: any;
1235
+ isUnique?: any;
1236
+ generated?: {
1237
+ type: "stored";
1238
+ as: string;
1239
+ } | undefined;
1240
+ typeSchema?: string | undefined;
1241
+ uniqueName?: string | undefined;
1242
+ nullsNotDistinct?: boolean | undefined;
1243
+ identity?: {
1244
+ name: string;
1245
+ type: "always" | "byDefault";
1246
+ schema: string;
1247
+ increment?: string | undefined;
1248
+ minValue?: string | undefined;
1249
+ maxValue?: string | undefined;
1250
+ startWith?: string | undefined;
1251
+ cache?: string | undefined;
1252
+ cycle?: boolean | undefined;
1253
+ } | undefined;
1254
+ }>;
1255
+ schema: string;
1256
+ isExisting: boolean;
1257
+ materialized: boolean;
1258
+ using?: string | undefined;
1259
+ definition?: string | undefined;
1260
+ with?: {
1261
+ checkOption?: "local" | "cascaded" | undefined;
1262
+ securityBarrier?: boolean | undefined;
1263
+ securityInvoker?: boolean | undefined;
1264
+ fillfactor?: number | undefined;
1265
+ toastTupleTarget?: number | undefined;
1266
+ parallelWorkers?: number | undefined;
1267
+ autovacuumEnabled?: boolean | undefined;
1268
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
1269
+ vacuumTruncate?: boolean | undefined;
1270
+ autovacuumVacuumThreshold?: number | undefined;
1271
+ autovacuumVacuumScaleFactor?: number | undefined;
1272
+ autovacuumVacuumCostDelay?: number | undefined;
1273
+ autovacuumVacuumCostLimit?: number | undefined;
1274
+ autovacuumFreezeMinAge?: number | undefined;
1275
+ autovacuumFreezeMaxAge?: number | undefined;
1276
+ autovacuumFreezeTableAge?: number | undefined;
1277
+ autovacuumMultixactFreezeMinAge?: number | undefined;
1278
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
1279
+ autovacuumMultixactFreezeTableAge?: number | undefined;
1280
+ logAutovacuumMinDuration?: number | undefined;
1281
+ userCatalogTable?: boolean | undefined;
1282
+ } | 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
+ using?: string | undefined;
1342
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1343
+ schema?: string | undefined;
1344
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1345
+ to?: string[] | undefined;
1346
+ withCheck?: string | undefined;
1347
+ on?: string | undefined;
1348
+ }, {
1349
+ name: string;
1350
+ using?: string | undefined;
1351
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1352
+ schema?: string | undefined;
1353
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1354
+ to?: 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
+ columns: Record<string, string>;
1364
+ tables: Record<string, string>;
1365
+ schemas: Record<string, string>;
1366
+ }, {
1367
+ columns: Record<string, string>;
1368
+ tables: 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
+ isDefaultAnExpression?: boolean | undefined;
1380
+ isArray?: boolean | undefined;
1381
+ dimensions?: number | undefined;
1382
+ rawType?: string | undefined;
1383
+ }, {
1384
+ isDefaultAnExpression?: boolean | undefined;
1385
+ isArray?: boolean | undefined;
1386
+ dimensions?: number | undefined;
1387
+ rawType?: string | undefined;
1388
+ }>>>;
1389
+ }, "strip", zod.ZodTypeAny, {
1390
+ columns: Record<string, {
1391
+ isDefaultAnExpression?: boolean | undefined;
1392
+ isArray?: boolean | undefined;
1393
+ dimensions?: number | undefined;
1394
+ rawType?: string | undefined;
1395
+ } | undefined>;
1396
+ }, {
1397
+ columns: Record<string, {
1398
+ isDefaultAnExpression?: boolean | undefined;
1399
+ isArray?: boolean | undefined;
1400
+ dimensions?: number | undefined;
1401
+ rawType?: string | undefined;
1402
+ } | undefined>;
1403
+ }>>>;
1404
+ }, "strip", zod.ZodTypeAny, {
1405
+ tables: Record<string, {
1406
+ columns: Record<string, {
1407
+ isDefaultAnExpression?: boolean | undefined;
1408
+ isArray?: boolean | undefined;
1409
+ dimensions?: number | undefined;
1410
+ rawType?: string | undefined;
1411
+ } | undefined>;
1412
+ } | undefined>;
1413
+ }, {
1414
+ tables: Record<string, {
1415
+ columns: Record<string, {
1416
+ isDefaultAnExpression?: boolean | undefined;
1417
+ isArray?: boolean | undefined;
1418
+ dimensions?: number | undefined;
1419
+ rawType?: string | undefined;
1420
+ } | undefined>;
1421
+ } | undefined>;
1422
+ }>>;
1423
+ }, {
1424
+ id: zod.ZodString;
1425
+ prevId: zod.ZodString;
1426
+ }>, "strip", zod.ZodTypeAny, {
1427
+ tables: Record<string, {
1428
+ name: string;
1429
+ columns: Record<string, {
1430
+ name: string;
1431
+ type: string;
1432
+ primaryKey: boolean;
1433
+ notNull: boolean;
1434
+ default?: any;
1435
+ isUnique?: any;
1436
+ generated?: {
1437
+ type: "stored";
1438
+ as: string;
1439
+ } | undefined;
1440
+ typeSchema?: string | undefined;
1441
+ uniqueName?: string | undefined;
1442
+ nullsNotDistinct?: boolean | undefined;
1443
+ identity?: {
1444
+ name: string;
1445
+ type: "always" | "byDefault";
1446
+ schema: string;
1447
+ increment?: string | undefined;
1448
+ minValue?: string | undefined;
1449
+ maxValue?: string | undefined;
1450
+ startWith?: string | undefined;
1451
+ cache?: string | undefined;
1452
+ cycle?: boolean | undefined;
1453
+ } | undefined;
1454
+ }>;
1455
+ indexes: Record<string, {
1456
+ name: string;
1457
+ columns: {
1458
+ isExpression: boolean;
1459
+ expression: string;
1460
+ asc: boolean;
1461
+ nulls?: string | undefined;
1462
+ opclass?: string | undefined;
1463
+ }[];
1464
+ isUnique: boolean;
1465
+ method: string;
1466
+ concurrently: boolean;
1467
+ with?: Record<string, any> | undefined;
1468
+ where?: string | undefined;
1469
+ }>;
1470
+ foreignKeys: Record<string, {
1471
+ name: string;
1472
+ tableFrom: string;
1473
+ columnsFrom: string[];
1474
+ tableTo: string;
1475
+ columnsTo: string[];
1476
+ onUpdate?: string | undefined;
1477
+ onDelete?: string | undefined;
1478
+ schemaTo?: string | undefined;
1479
+ }>;
1480
+ schema: string;
1481
+ compositePrimaryKeys: Record<string, {
1482
+ name: string;
1483
+ columns: string[];
1484
+ }>;
1485
+ uniqueConstraints: Record<string, {
1486
+ name: string;
1487
+ columns: string[];
1488
+ nullsNotDistinct: boolean;
1489
+ }>;
1490
+ checkConstraints: Record<string, {
1491
+ name: string;
1492
+ value: string;
1493
+ }>;
1494
+ policies: Record<string, {
1495
+ name: string;
1496
+ using?: string | undefined;
1497
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1498
+ schema?: string | undefined;
1499
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1500
+ to?: string[] | undefined;
1501
+ withCheck?: string | undefined;
1502
+ on?: string | undefined;
1503
+ }>;
1504
+ isRLSEnabled: boolean;
1505
+ }>;
1506
+ id: string;
1507
+ prevId: string;
1508
+ version: "7";
1509
+ dialect: "postgresql";
1510
+ schemas: Record<string, string>;
1511
+ _meta: {
1512
+ columns: Record<string, string>;
1513
+ tables: Record<string, string>;
1514
+ schemas: Record<string, string>;
1515
+ };
1516
+ views: Record<string, {
1517
+ name: string;
1518
+ columns: Record<string, {
1519
+ name: string;
1520
+ type: string;
1521
+ primaryKey: boolean;
1522
+ notNull: boolean;
1523
+ default?: any;
1524
+ isUnique?: any;
1525
+ generated?: {
1526
+ type: "stored";
1527
+ as: string;
1528
+ } | undefined;
1529
+ typeSchema?: string | undefined;
1530
+ uniqueName?: string | undefined;
1531
+ nullsNotDistinct?: boolean | undefined;
1532
+ identity?: {
1533
+ name: string;
1534
+ type: "always" | "byDefault";
1535
+ schema: string;
1536
+ increment?: string | undefined;
1537
+ minValue?: string | undefined;
1538
+ maxValue?: string | undefined;
1539
+ startWith?: string | undefined;
1540
+ cache?: string | undefined;
1541
+ cycle?: boolean | undefined;
1542
+ } | undefined;
1543
+ }>;
1544
+ schema: string;
1545
+ isExisting: boolean;
1546
+ materialized: boolean;
1547
+ using?: string | undefined;
1548
+ definition?: string | undefined;
1549
+ with?: {
1550
+ checkOption?: "local" | "cascaded" | undefined;
1551
+ securityBarrier?: boolean | undefined;
1552
+ securityInvoker?: boolean | undefined;
1553
+ fillfactor?: number | undefined;
1554
+ toastTupleTarget?: number | undefined;
1555
+ parallelWorkers?: number | undefined;
1556
+ autovacuumEnabled?: boolean | undefined;
1557
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
1558
+ vacuumTruncate?: boolean | undefined;
1559
+ autovacuumVacuumThreshold?: number | undefined;
1560
+ autovacuumVacuumScaleFactor?: number | undefined;
1561
+ autovacuumVacuumCostDelay?: number | undefined;
1562
+ autovacuumVacuumCostLimit?: number | undefined;
1563
+ autovacuumFreezeMinAge?: number | undefined;
1564
+ autovacuumFreezeMaxAge?: number | undefined;
1565
+ autovacuumFreezeTableAge?: number | undefined;
1566
+ autovacuumMultixactFreezeMinAge?: number | undefined;
1567
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
1568
+ autovacuumMultixactFreezeTableAge?: number | undefined;
1569
+ logAutovacuumMinDuration?: number | undefined;
1570
+ userCatalogTable?: boolean | undefined;
1571
+ } | undefined;
1572
+ withNoData?: boolean | undefined;
1573
+ tablespace?: string | undefined;
1574
+ }>;
1575
+ enums: Record<string, {
1576
+ name: string;
1577
+ values: string[];
1578
+ schema: string;
1579
+ }>;
1580
+ policies: Record<string, {
1581
+ name: string;
1582
+ using?: string | undefined;
1583
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1584
+ schema?: string | undefined;
1585
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1586
+ to?: string[] | undefined;
1587
+ withCheck?: string | undefined;
1588
+ on?: string | undefined;
1589
+ }>;
1590
+ sequences: Record<string, {
1591
+ name: string;
1592
+ schema: string;
1593
+ increment?: string | undefined;
1594
+ minValue?: string | undefined;
1595
+ maxValue?: string | undefined;
1596
+ startWith?: string | undefined;
1597
+ cache?: string | undefined;
1598
+ cycle?: boolean | undefined;
1599
+ }>;
1600
+ roles: Record<string, {
1601
+ name: string;
1602
+ createDb?: boolean | undefined;
1603
+ createRole?: boolean | undefined;
1604
+ inherit?: boolean | undefined;
1605
+ }>;
1606
+ internal?: {
1607
+ tables: Record<string, {
1608
+ columns: Record<string, {
1609
+ isDefaultAnExpression?: boolean | undefined;
1610
+ isArray?: boolean | undefined;
1611
+ dimensions?: number | undefined;
1612
+ rawType?: string | undefined;
1613
+ } | undefined>;
1614
+ } | undefined>;
1615
+ } | undefined;
1616
+ }, {
1617
+ tables: Record<string, {
1618
+ name: string;
1619
+ columns: Record<string, {
1620
+ name: string;
1621
+ type: string;
1622
+ primaryKey: boolean;
1623
+ notNull: boolean;
1624
+ default?: any;
1625
+ isUnique?: any;
1626
+ generated?: {
1627
+ type: "stored";
1628
+ as: string;
1629
+ } | undefined;
1630
+ typeSchema?: string | undefined;
1631
+ uniqueName?: string | undefined;
1632
+ nullsNotDistinct?: boolean | undefined;
1633
+ identity?: {
1634
+ name: string;
1635
+ type: "always" | "byDefault";
1636
+ schema: string;
1637
+ increment?: string | undefined;
1638
+ minValue?: string | undefined;
1639
+ maxValue?: string | undefined;
1640
+ startWith?: string | undefined;
1641
+ cache?: string | undefined;
1642
+ cycle?: boolean | undefined;
1643
+ } | undefined;
1644
+ }>;
1645
+ indexes: Record<string, {
1646
+ name: string;
1647
+ columns: {
1648
+ isExpression: boolean;
1649
+ expression: string;
1650
+ asc: boolean;
1651
+ nulls?: string | undefined;
1652
+ opclass?: string | undefined;
1653
+ }[];
1654
+ isUnique: boolean;
1655
+ with?: Record<string, any> | undefined;
1656
+ method?: string | undefined;
1657
+ where?: string | undefined;
1658
+ concurrently?: boolean | undefined;
1659
+ }>;
1660
+ foreignKeys: Record<string, {
1661
+ name: string;
1662
+ tableFrom: string;
1663
+ columnsFrom: string[];
1664
+ tableTo: string;
1665
+ columnsTo: string[];
1666
+ onUpdate?: string | undefined;
1667
+ onDelete?: string | undefined;
1668
+ schemaTo?: string | undefined;
1669
+ }>;
1670
+ schema: string;
1671
+ compositePrimaryKeys: Record<string, {
1672
+ name: string;
1673
+ columns: string[];
1674
+ }>;
1675
+ uniqueConstraints?: Record<string, {
1676
+ name: string;
1677
+ columns: string[];
1678
+ nullsNotDistinct: boolean;
1679
+ }> | undefined;
1680
+ checkConstraints?: Record<string, {
1681
+ name: string;
1682
+ value: string;
1683
+ }> | undefined;
1684
+ policies?: Record<string, {
1685
+ name: string;
1686
+ using?: string | undefined;
1687
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1688
+ schema?: string | undefined;
1689
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1690
+ to?: string[] | undefined;
1691
+ withCheck?: string | undefined;
1692
+ on?: string | undefined;
1693
+ }> | undefined;
1694
+ isRLSEnabled?: boolean | undefined;
1695
+ }>;
1696
+ id: string;
1697
+ prevId: string;
1698
+ version: "7";
1699
+ dialect: "postgresql";
1700
+ schemas: Record<string, string>;
1701
+ _meta: {
1702
+ columns: Record<string, string>;
1703
+ tables: Record<string, string>;
1704
+ schemas: Record<string, string>;
1705
+ };
1706
+ enums: Record<string, {
1707
+ name: string;
1708
+ values: string[];
1709
+ schema: string;
1710
+ }>;
1711
+ internal?: {
1712
+ tables: Record<string, {
1713
+ columns: Record<string, {
1714
+ isDefaultAnExpression?: boolean | undefined;
1715
+ isArray?: boolean | undefined;
1716
+ dimensions?: number | undefined;
1717
+ rawType?: string | undefined;
1718
+ } | undefined>;
1719
+ } | undefined>;
1720
+ } | undefined;
1721
+ views?: Record<string, {
1722
+ name: string;
1723
+ columns: Record<string, {
1724
+ name: string;
1725
+ type: string;
1726
+ primaryKey: boolean;
1727
+ notNull: boolean;
1728
+ default?: any;
1729
+ isUnique?: any;
1730
+ generated?: {
1731
+ type: "stored";
1732
+ as: string;
1733
+ } | undefined;
1734
+ typeSchema?: string | undefined;
1735
+ uniqueName?: string | undefined;
1736
+ nullsNotDistinct?: boolean | undefined;
1737
+ identity?: {
1738
+ name: string;
1739
+ type: "always" | "byDefault";
1740
+ schema: string;
1741
+ increment?: string | undefined;
1742
+ minValue?: string | undefined;
1743
+ maxValue?: string | undefined;
1744
+ startWith?: string | undefined;
1745
+ cache?: string | undefined;
1746
+ cycle?: boolean | undefined;
1747
+ } | undefined;
1748
+ }>;
1749
+ schema: string;
1750
+ isExisting: boolean;
1751
+ materialized: boolean;
1752
+ using?: string | undefined;
1753
+ definition?: string | undefined;
1754
+ with?: {
1755
+ checkOption?: "local" | "cascaded" | undefined;
1756
+ securityBarrier?: boolean | undefined;
1757
+ securityInvoker?: boolean | undefined;
1758
+ fillfactor?: number | undefined;
1759
+ toastTupleTarget?: number | undefined;
1760
+ parallelWorkers?: number | undefined;
1761
+ autovacuumEnabled?: boolean | undefined;
1762
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
1763
+ vacuumTruncate?: boolean | undefined;
1764
+ autovacuumVacuumThreshold?: number | undefined;
1765
+ autovacuumVacuumScaleFactor?: number | undefined;
1766
+ autovacuumVacuumCostDelay?: number | undefined;
1767
+ autovacuumVacuumCostLimit?: number | undefined;
1768
+ autovacuumFreezeMinAge?: number | undefined;
1769
+ autovacuumFreezeMaxAge?: number | undefined;
1770
+ autovacuumFreezeTableAge?: number | undefined;
1771
+ autovacuumMultixactFreezeMinAge?: number | undefined;
1772
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
1773
+ autovacuumMultixactFreezeTableAge?: number | undefined;
1774
+ logAutovacuumMinDuration?: number | undefined;
1775
+ userCatalogTable?: boolean | undefined;
1776
+ } | undefined;
1777
+ withNoData?: boolean | undefined;
1778
+ tablespace?: string | undefined;
1779
+ }> | undefined;
1780
+ policies?: Record<string, {
1781
+ name: string;
1782
+ using?: string | undefined;
1783
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
1784
+ schema?: string | undefined;
1785
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
1786
+ to?: string[] | undefined;
1787
+ withCheck?: string | undefined;
1788
+ on?: string | undefined;
1789
+ }> | undefined;
1790
+ sequences?: Record<string, {
1791
+ name: string;
1792
+ schema: string;
1793
+ increment?: string | undefined;
1794
+ minValue?: string | undefined;
1795
+ maxValue?: string | undefined;
1796
+ startWith?: string | undefined;
1797
+ cache?: string | undefined;
1798
+ cycle?: boolean | undefined;
1799
+ }> | undefined;
1800
+ roles?: Record<string, {
1801
+ name: string;
1802
+ createDb?: boolean | undefined;
1803
+ createRole?: boolean | undefined;
1804
+ inherit?: boolean | undefined;
1805
+ }> | undefined;
1806
+ }>;
1807
+ type PgSchema = TypeOf<typeof pgSchema>;
1808
+
1809
+ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{
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
+ name: string;
1834
+ type: string;
1835
+ primaryKey: boolean;
1836
+ notNull: boolean;
1837
+ default?: any;
1838
+ onUpdate?: any;
1839
+ autoincrement?: boolean | undefined;
1840
+ generated?: {
1841
+ type: "stored" | "virtual";
1842
+ as: string;
1843
+ } | undefined;
1844
+ }, {
1845
+ name: string;
1846
+ type: string;
1847
+ primaryKey: boolean;
1848
+ notNull: boolean;
1849
+ default?: any;
1850
+ onUpdate?: any;
1851
+ autoincrement?: boolean | undefined;
1852
+ generated?: {
1853
+ type: "stored" | "virtual";
1854
+ as: string;
1855
+ } | 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?: "none" | "default" | "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?: "none" | "default" | "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
+ name: string;
1903
+ type: string;
1904
+ primaryKey: boolean;
1905
+ notNull: boolean;
1906
+ default?: any;
1907
+ onUpdate?: any;
1908
+ autoincrement?: boolean | undefined;
1909
+ generated?: {
1910
+ type: "stored" | "virtual";
1911
+ as: string;
1912
+ } | 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?: "none" | "default" | "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
+ name: string;
1934
+ type: string;
1935
+ primaryKey: boolean;
1936
+ notNull: boolean;
1937
+ default?: any;
1938
+ onUpdate?: any;
1939
+ autoincrement?: boolean | undefined;
1940
+ generated?: {
1941
+ type: "stored" | "virtual";
1942
+ as: string;
1943
+ } | 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?: "none" | "default" | "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
+ columns: Record<string, string>;
1967
+ tables: Record<string, string>;
1968
+ }, {
1969
+ columns: Record<string, string>;
1970
+ tables: 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
+ indexes?: Record<string, {
2009
+ columns: Record<string, {
2010
+ isExpression?: boolean | undefined;
2011
+ } | undefined>;
2012
+ } | undefined> | undefined;
2013
+ tables?: Record<string, {
2014
+ columns: Record<string, {
2015
+ isDefaultAnExpression?: boolean | undefined;
2016
+ } | undefined>;
2017
+ } | undefined> | undefined;
2018
+ }, {
2019
+ indexes?: Record<string, {
2020
+ columns: Record<string, {
2021
+ isExpression?: boolean | undefined;
2022
+ } | undefined>;
2023
+ } | undefined> | undefined;
2024
+ tables?: Record<string, {
2025
+ columns: Record<string, {
2026
+ isDefaultAnExpression?: boolean | undefined;
2027
+ } | undefined>;
2028
+ } | undefined> | undefined;
2029
+ }>>;
2030
+ }, {
2031
+ id: zod.ZodString;
2032
+ prevId: zod.ZodString;
2033
+ }>, "strip", zod.ZodTypeAny, {
2034
+ tables: Record<string, {
2035
+ name: string;
2036
+ columns: Record<string, {
2037
+ name: string;
2038
+ type: string;
2039
+ primaryKey: boolean;
2040
+ notNull: boolean;
2041
+ default?: any;
2042
+ onUpdate?: any;
2043
+ autoincrement?: boolean | undefined;
2044
+ generated?: {
2045
+ type: "stored" | "virtual";
2046
+ as: string;
2047
+ } | undefined;
2048
+ }>;
2049
+ indexes: Record<string, {
2050
+ name: string;
2051
+ columns: string[];
2052
+ isUnique: boolean;
2053
+ using?: "btree" | "hash" | undefined;
2054
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2055
+ lock?: "none" | "default" | "shared" | "exclusive" | undefined;
2056
+ }>;
2057
+ compositePrimaryKeys: Record<string, {
2058
+ name: string;
2059
+ columns: string[];
2060
+ }>;
2061
+ uniqueConstraints: Record<string, {
2062
+ name: string;
2063
+ columns: string[];
2064
+ }>;
2065
+ }>;
2066
+ id: string;
2067
+ prevId: string;
2068
+ version: "1";
2069
+ dialect: "singlestore";
2070
+ _meta: {
2071
+ columns: Record<string, string>;
2072
+ tables: Record<string, string>;
2073
+ };
2074
+ internal?: {
2075
+ indexes?: Record<string, {
2076
+ columns: Record<string, {
2077
+ isExpression?: boolean | undefined;
2078
+ } | undefined>;
2079
+ } | undefined> | undefined;
2080
+ tables?: Record<string, {
2081
+ columns: Record<string, {
2082
+ isDefaultAnExpression?: boolean | undefined;
2083
+ } | undefined>;
2084
+ } | undefined> | undefined;
2085
+ } | undefined;
2086
+ }, {
2087
+ tables: Record<string, {
2088
+ name: string;
2089
+ columns: Record<string, {
2090
+ name: string;
2091
+ type: string;
2092
+ primaryKey: boolean;
2093
+ notNull: boolean;
2094
+ default?: any;
2095
+ onUpdate?: any;
2096
+ autoincrement?: boolean | undefined;
2097
+ generated?: {
2098
+ type: "stored" | "virtual";
2099
+ as: string;
2100
+ } | undefined;
2101
+ }>;
2102
+ indexes: Record<string, {
2103
+ name: string;
2104
+ columns: string[];
2105
+ isUnique: boolean;
2106
+ using?: "btree" | "hash" | undefined;
2107
+ algorithm?: "default" | "inplace" | "copy" | undefined;
2108
+ lock?: "none" | "default" | "shared" | "exclusive" | undefined;
2109
+ }>;
2110
+ compositePrimaryKeys: Record<string, {
2111
+ name: string;
2112
+ columns: string[];
2113
+ }>;
2114
+ uniqueConstraints?: Record<string, {
2115
+ name: string;
2116
+ columns: string[];
2117
+ }> | undefined;
2118
+ }>;
2119
+ id: string;
2120
+ prevId: string;
2121
+ version: "1";
2122
+ dialect: "singlestore";
2123
+ _meta: {
2124
+ columns: Record<string, string>;
2125
+ tables: Record<string, string>;
2126
+ };
2127
+ internal?: {
2128
+ indexes?: Record<string, {
2129
+ columns: Record<string, {
2130
+ isExpression?: boolean | undefined;
2131
+ } | undefined>;
2132
+ } | undefined> | undefined;
2133
+ tables?: Record<string, {
2134
+ columns: Record<string, {
2135
+ isDefaultAnExpression?: boolean | undefined;
2136
+ } | undefined>;
2137
+ } | undefined> | undefined;
2138
+ } | undefined;
2139
+ }>;
2140
+ type SingleStoreSchema = TypeOf<typeof schema$1>;
2141
+
2142
+ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{
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
+ name: string;
2166
+ type: string;
2167
+ primaryKey: boolean;
2168
+ notNull: boolean;
2169
+ default?: any;
2170
+ autoincrement?: boolean | undefined;
2171
+ generated?: {
2172
+ type: "stored" | "virtual";
2173
+ as: string;
2174
+ } | undefined;
2175
+ }, {
2176
+ name: string;
2177
+ type: string;
2178
+ primaryKey: boolean;
2179
+ notNull: boolean;
2180
+ default?: any;
2181
+ autoincrement?: boolean | undefined;
2182
+ generated?: {
2183
+ type: "stored" | "virtual";
2184
+ as: string;
2185
+ } | 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
+ name: string;
2253
+ value: string;
2254
+ }, {
2255
+ name: string;
2256
+ value: string;
2257
+ }>>>;
2258
+ }, "strict", zod.ZodTypeAny, {
2259
+ name: string;
2260
+ columns: Record<string, {
2261
+ name: string;
2262
+ type: string;
2263
+ primaryKey: boolean;
2264
+ notNull: boolean;
2265
+ default?: any;
2266
+ autoincrement?: boolean | undefined;
2267
+ generated?: {
2268
+ type: "stored" | "virtual";
2269
+ as: string;
2270
+ } | 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
+ name: string;
2297
+ value: string;
2298
+ }>;
2299
+ }, {
2300
+ name: string;
2301
+ columns: Record<string, {
2302
+ name: string;
2303
+ type: string;
2304
+ primaryKey: boolean;
2305
+ notNull: boolean;
2306
+ default?: any;
2307
+ autoincrement?: boolean | undefined;
2308
+ generated?: {
2309
+ type: "stored" | "virtual";
2310
+ as: string;
2311
+ } | 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
+ name: string;
2338
+ value: 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
+ name: string;
2362
+ type: string;
2363
+ primaryKey: boolean;
2364
+ notNull: boolean;
2365
+ default?: any;
2366
+ autoincrement?: boolean | undefined;
2367
+ generated?: {
2368
+ type: "stored" | "virtual";
2369
+ as: string;
2370
+ } | undefined;
2371
+ }, {
2372
+ name: string;
2373
+ type: string;
2374
+ primaryKey: boolean;
2375
+ notNull: boolean;
2376
+ default?: any;
2377
+ autoincrement?: boolean | undefined;
2378
+ generated?: {
2379
+ type: "stored" | "virtual";
2380
+ as: string;
2381
+ } | undefined;
2382
+ }>>;
2383
+ definition: zod.ZodOptional<zod.ZodString>;
2384
+ isExisting: zod.ZodBoolean;
2385
+ }, "strict", zod.ZodTypeAny, {
2386
+ name: string;
2387
+ columns: Record<string, {
2388
+ name: string;
2389
+ type: string;
2390
+ primaryKey: boolean;
2391
+ notNull: boolean;
2392
+ default?: any;
2393
+ autoincrement?: boolean | undefined;
2394
+ generated?: {
2395
+ type: "stored" | "virtual";
2396
+ as: string;
2397
+ } | undefined;
2398
+ }>;
2399
+ isExisting: boolean;
2400
+ definition?: string | undefined;
2401
+ }, {
2402
+ name: string;
2403
+ columns: Record<string, {
2404
+ name: string;
2405
+ type: string;
2406
+ primaryKey: boolean;
2407
+ notNull: boolean;
2408
+ default?: any;
2409
+ autoincrement?: boolean | undefined;
2410
+ generated?: {
2411
+ type: "stored" | "virtual";
2412
+ as: string;
2413
+ } | 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
+ columns: Record<string, string>;
2424
+ tables: Record<string, string>;
2425
+ }, {
2426
+ columns: Record<string, string>;
2427
+ tables: 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
+ tables: Record<string, {
2465
+ name: string;
2466
+ columns: Record<string, {
2467
+ name: string;
2468
+ type: string;
2469
+ primaryKey: boolean;
2470
+ notNull: boolean;
2471
+ default?: any;
2472
+ autoincrement?: boolean | undefined;
2473
+ generated?: {
2474
+ type: "stored" | "virtual";
2475
+ as: string;
2476
+ } | undefined;
2477
+ }>;
2478
+ indexes: Record<string, {
2479
+ name: string;
2480
+ columns: string[];
2481
+ isUnique: boolean;
2482
+ where?: string | undefined;
2483
+ }>;
2484
+ foreignKeys: Record<string, {
2485
+ name: string;
2486
+ tableFrom: string;
2487
+ columnsFrom: string[];
2488
+ tableTo: string;
2489
+ columnsTo: string[];
2490
+ onUpdate?: string | undefined;
2491
+ onDelete?: string | undefined;
2492
+ }>;
2493
+ compositePrimaryKeys: Record<string, {
2494
+ columns: string[];
2495
+ name?: string | undefined;
2496
+ }>;
2497
+ uniqueConstraints: Record<string, {
2498
+ name: string;
2499
+ columns: string[];
2500
+ }>;
2501
+ checkConstraints: Record<string, {
2502
+ name: string;
2503
+ value: string;
2504
+ }>;
2505
+ }>;
2506
+ id: string;
2507
+ prevId: string;
2508
+ version: "6";
2509
+ dialect: "sqlite";
2510
+ _meta: {
2511
+ columns: Record<string, string>;
2512
+ tables: Record<string, string>;
2513
+ };
2514
+ views: Record<string, {
2515
+ name: string;
2516
+ columns: Record<string, {
2517
+ name: string;
2518
+ type: string;
2519
+ primaryKey: boolean;
2520
+ notNull: boolean;
2521
+ default?: any;
2522
+ autoincrement?: boolean | undefined;
2523
+ generated?: {
2524
+ type: "stored" | "virtual";
2525
+ as: string;
2526
+ } | undefined;
2527
+ }>;
2528
+ isExisting: boolean;
2529
+ definition?: string | undefined;
2530
+ }>;
2531
+ enums: {};
2532
+ internal?: {
2533
+ indexes?: Record<string, {
2534
+ columns: Record<string, {
2535
+ isExpression?: boolean | undefined;
2536
+ } | undefined>;
2537
+ } | undefined> | undefined;
2538
+ } | undefined;
2539
+ }, {
2540
+ tables: Record<string, {
2541
+ name: string;
2542
+ columns: Record<string, {
2543
+ name: string;
2544
+ type: string;
2545
+ primaryKey: boolean;
2546
+ notNull: boolean;
2547
+ default?: any;
2548
+ autoincrement?: boolean | undefined;
2549
+ generated?: {
2550
+ type: "stored" | "virtual";
2551
+ as: string;
2552
+ } | undefined;
2553
+ }>;
2554
+ indexes: Record<string, {
2555
+ name: string;
2556
+ columns: string[];
2557
+ isUnique: boolean;
2558
+ where?: string | undefined;
2559
+ }>;
2560
+ foreignKeys: Record<string, {
2561
+ name: string;
2562
+ tableFrom: string;
2563
+ columnsFrom: string[];
2564
+ tableTo: string;
2565
+ columnsTo: string[];
2566
+ onUpdate?: string | undefined;
2567
+ onDelete?: string | undefined;
2568
+ }>;
2569
+ compositePrimaryKeys: Record<string, {
2570
+ columns: string[];
2571
+ name?: string | undefined;
2572
+ }>;
2573
+ uniqueConstraints?: Record<string, {
2574
+ name: string;
2575
+ columns: string[];
2576
+ }> | undefined;
2577
+ checkConstraints?: Record<string, {
2578
+ name: string;
2579
+ value: string;
2580
+ }> | undefined;
2581
+ }>;
2582
+ id: string;
2583
+ prevId: string;
2584
+ version: "6";
2585
+ dialect: "sqlite";
2586
+ _meta: {
2587
+ columns: Record<string, string>;
2588
+ tables: Record<string, string>;
2589
+ };
2590
+ enums: {};
2591
+ internal?: {
2592
+ indexes?: Record<string, {
2593
+ columns: Record<string, {
2594
+ isExpression?: boolean | undefined;
2595
+ } | undefined>;
2596
+ } | undefined> | undefined;
2597
+ } | undefined;
2598
+ views?: Record<string, {
2599
+ name: string;
2600
+ columns: Record<string, {
2601
+ name: string;
2602
+ type: string;
2603
+ primaryKey: boolean;
2604
+ notNull: boolean;
2605
+ default?: any;
2606
+ autoincrement?: boolean | undefined;
2607
+ generated?: {
2608
+ type: "stored" | "virtual";
2609
+ as: string;
2610
+ } | undefined;
2611
+ }>;
2612
+ isExisting: boolean;
2613
+ definition?: string | 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
+ tables: Record<string, {
2656
+ name: string;
2657
+ columns: Record<string, {
2658
+ name: string;
2659
+ type: string;
2660
+ primaryKey: boolean;
2661
+ notNull: boolean;
2662
+ default?: any;
2663
+ isUnique?: any;
2664
+ generated?: {
2665
+ type: "stored";
2666
+ as: string;
2667
+ } | undefined;
2668
+ typeSchema?: string | undefined;
2669
+ uniqueName?: string | undefined;
2670
+ nullsNotDistinct?: boolean | undefined;
2671
+ identity?: {
2672
+ name: string;
2673
+ type: "always" | "byDefault";
2674
+ schema: string;
2675
+ increment?: string | undefined;
2676
+ minValue?: string | undefined;
2677
+ maxValue?: string | undefined;
2678
+ startWith?: string | undefined;
2679
+ cache?: string | undefined;
2680
+ cycle?: boolean | undefined;
2681
+ } | undefined;
2682
+ }>;
2683
+ indexes: Record<string, {
2684
+ name: string;
2685
+ columns: {
2686
+ isExpression: boolean;
2687
+ expression: string;
2688
+ asc: boolean;
2689
+ nulls?: string | undefined;
2690
+ opclass?: string | undefined;
2691
+ }[];
2692
+ isUnique: boolean;
2693
+ method: string;
2694
+ concurrently: boolean;
2695
+ with?: Record<string, any> | undefined;
2696
+ where?: string | undefined;
2697
+ }>;
2698
+ foreignKeys: Record<string, {
2699
+ name: string;
2700
+ tableFrom: string;
2701
+ columnsFrom: string[];
2702
+ tableTo: string;
2703
+ columnsTo: string[];
2704
+ onUpdate?: string | undefined;
2705
+ onDelete?: string | undefined;
2706
+ schemaTo?: string | undefined;
2707
+ }>;
2708
+ schema: string;
2709
+ compositePrimaryKeys: Record<string, {
2710
+ name: string;
2711
+ columns: string[];
2712
+ }>;
2713
+ uniqueConstraints: Record<string, {
2714
+ name: string;
2715
+ columns: string[];
2716
+ nullsNotDistinct: boolean;
2717
+ }>;
2718
+ checkConstraints: Record<string, {
2719
+ name: string;
2720
+ value: string;
2721
+ }>;
2722
+ policies: Record<string, {
2723
+ name: string;
2724
+ using?: string | undefined;
2725
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
2726
+ schema?: string | undefined;
2727
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
2728
+ to?: string[] | undefined;
2729
+ withCheck?: string | undefined;
2730
+ on?: string | undefined;
2731
+ }>;
2732
+ isRLSEnabled: boolean;
2733
+ }>;
2734
+ id: string;
2735
+ prevId: string;
2736
+ version: "7";
2737
+ dialect: "postgresql";
2738
+ schemas: Record<string, string>;
2739
+ _meta: {
2740
+ columns: Record<string, string>;
2741
+ tables: Record<string, string>;
2742
+ schemas: Record<string, string>;
2743
+ };
2744
+ views: Record<string, {
2745
+ name: string;
2746
+ columns: Record<string, {
2747
+ name: string;
2748
+ type: string;
2749
+ primaryKey: boolean;
2750
+ notNull: boolean;
2751
+ default?: any;
2752
+ isUnique?: any;
2753
+ generated?: {
2754
+ type: "stored";
2755
+ as: string;
2756
+ } | undefined;
2757
+ typeSchema?: string | undefined;
2758
+ uniqueName?: string | undefined;
2759
+ nullsNotDistinct?: boolean | undefined;
2760
+ identity?: {
2761
+ name: string;
2762
+ type: "always" | "byDefault";
2763
+ schema: string;
2764
+ increment?: string | undefined;
2765
+ minValue?: string | undefined;
2766
+ maxValue?: string | undefined;
2767
+ startWith?: string | undefined;
2768
+ cache?: string | undefined;
2769
+ cycle?: boolean | undefined;
2770
+ } | undefined;
2771
+ }>;
2772
+ schema: string;
2773
+ isExisting: boolean;
2774
+ materialized: boolean;
2775
+ using?: string | undefined;
2776
+ definition?: string | undefined;
2777
+ with?: {
2778
+ checkOption?: "local" | "cascaded" | undefined;
2779
+ securityBarrier?: boolean | undefined;
2780
+ securityInvoker?: boolean | undefined;
2781
+ fillfactor?: number | undefined;
2782
+ toastTupleTarget?: number | undefined;
2783
+ parallelWorkers?: number | undefined;
2784
+ autovacuumEnabled?: boolean | undefined;
2785
+ vacuumIndexCleanup?: "on" | "auto" | "off" | undefined;
2786
+ vacuumTruncate?: boolean | undefined;
2787
+ autovacuumVacuumThreshold?: number | undefined;
2788
+ autovacuumVacuumScaleFactor?: number | undefined;
2789
+ autovacuumVacuumCostDelay?: number | undefined;
2790
+ autovacuumVacuumCostLimit?: number | undefined;
2791
+ autovacuumFreezeMinAge?: number | undefined;
2792
+ autovacuumFreezeMaxAge?: number | undefined;
2793
+ autovacuumFreezeTableAge?: number | undefined;
2794
+ autovacuumMultixactFreezeMinAge?: number | undefined;
2795
+ autovacuumMultixactFreezeMaxAge?: number | undefined;
2796
+ autovacuumMultixactFreezeTableAge?: number | undefined;
2797
+ logAutovacuumMinDuration?: number | undefined;
2798
+ userCatalogTable?: boolean | undefined;
2799
+ } | undefined;
2800
+ withNoData?: boolean | undefined;
2801
+ tablespace?: string | undefined;
2802
+ }>;
2803
+ enums: Record<string, {
2804
+ name: string;
2805
+ values: string[];
2806
+ schema: string;
2807
+ }>;
2808
+ policies: Record<string, {
2809
+ name: string;
2810
+ using?: string | undefined;
2811
+ as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
2812
+ schema?: string | undefined;
2813
+ for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
2814
+ to?: string[] | undefined;
2815
+ withCheck?: string | undefined;
2816
+ on?: string | undefined;
2817
+ }>;
2818
+ sequences: Record<string, {
2819
+ name: string;
2820
+ schema: string;
2821
+ increment?: string | undefined;
2822
+ minValue?: string | undefined;
2823
+ maxValue?: string | undefined;
2824
+ startWith?: string | undefined;
2825
+ cache?: string | undefined;
2826
+ cycle?: boolean | undefined;
2827
+ }>;
2828
+ roles: Record<string, {
2829
+ name: string;
2830
+ createDb?: boolean | undefined;
2831
+ createRole?: boolean | undefined;
2832
+ inherit?: boolean | undefined;
2833
+ }>;
2834
+ internal?: {
2835
+ tables: Record<string, {
2836
+ columns: Record<string, {
2837
+ isDefaultAnExpression?: boolean | undefined;
2838
+ isArray?: boolean | undefined;
2839
+ dimensions?: number | undefined;
2840
+ rawType?: string | 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 };