drizzle-kit 0.30.6 → 0.31.0

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