drizzle-kit 0.31.1 → 0.31.2

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