drizzle-kit 0.25.0-05b9e35 → 0.25.0-06c725b
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/api.d.mts +82 -474
- package/api.d.ts +82 -474
- package/api.js +16085 -95988
- package/api.mjs +16084 -95983
- package/bin.cjs +843 -1198
- package/package.json +1 -1
- package/utils.js +35 -57
- package/utils.mjs +35 -57
    
        package/api.d.mts
    CHANGED
    
    | @@ -119,6 +119,16 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 119 119 | 
             
                        name: string;
         | 
| 120 120 | 
             
                        columns: string[];
         | 
| 121 121 | 
             
                    }>>>;
         | 
| 122 | 
            +
                    checkConstraint: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 123 | 
            +
                        name: zod.ZodString;
         | 
| 124 | 
            +
                        value: zod.ZodString;
         | 
| 125 | 
            +
                    }, "strict", zod.ZodTypeAny, {
         | 
| 126 | 
            +
                        name: string;
         | 
| 127 | 
            +
                        value: string;
         | 
| 128 | 
            +
                    }, {
         | 
| 129 | 
            +
                        name: string;
         | 
| 130 | 
            +
                        value: string;
         | 
| 131 | 
            +
                    }>>>;
         | 
| 122 132 | 
             
                }, "strict", zod.ZodTypeAny, {
         | 
| 123 133 | 
             
                    name: string;
         | 
| 124 134 | 
             
                    columns: Record<string, {
         | 
| @@ -159,6 +169,10 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 159 169 | 
             
                        name: string;
         | 
| 160 170 | 
             
                        columns: string[];
         | 
| 161 171 | 
             
                    }>;
         | 
| 172 | 
            +
                    checkConstraint: Record<string, {
         | 
| 173 | 
            +
                        name: string;
         | 
| 174 | 
            +
                        value: string;
         | 
| 175 | 
            +
                    }>;
         | 
| 162 176 | 
             
                }, {
         | 
| 163 177 | 
             
                    name: string;
         | 
| 164 178 | 
             
                    columns: Record<string, {
         | 
| @@ -199,6 +213,10 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 199 213 | 
             
                        name: string;
         | 
| 200 214 | 
             
                        columns: string[];
         | 
| 201 215 | 
             
                    }> | undefined;
         | 
| 216 | 
            +
                    checkConstraint?: Record<string, {
         | 
| 217 | 
            +
                        name: string;
         | 
| 218 | 
            +
                        value: string;
         | 
| 219 | 
            +
                    }> | undefined;
         | 
| 202 220 | 
             
                }>>;
         | 
| 203 221 | 
             
                _meta: zod.ZodObject<{
         | 
| 204 222 | 
             
                    tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
         | 
| @@ -312,6 +330,10 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 312 330 | 
             
                        name: string;
         | 
| 313 331 | 
             
                        columns: string[];
         | 
| 314 332 | 
             
                    }>;
         | 
| 333 | 
            +
                    checkConstraint: Record<string, {
         | 
| 334 | 
            +
                        name: string;
         | 
| 335 | 
            +
                        value: string;
         | 
| 336 | 
            +
                    }>;
         | 
| 315 337 | 
             
                }>;
         | 
| 316 338 | 
             
                id: string;
         | 
| 317 339 | 
             
                prevId: string;
         | 
| @@ -374,6 +396,10 @@ declare const schema$1: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 374 396 | 
             
                        name: string;
         | 
| 375 397 | 
             
                        columns: string[];
         | 
| 376 398 | 
             
                    }> | undefined;
         | 
| 399 | 
            +
                    checkConstraint?: Record<string, {
         | 
| 400 | 
            +
                        name: string;
         | 
| 401 | 
            +
                        value: string;
         | 
| 402 | 
            +
                    }> | undefined;
         | 
| 377 403 | 
             
                }>;
         | 
| 378 404 | 
             
                id: string;
         | 
| 379 405 | 
             
                prevId: string;
         | 
| @@ -613,6 +639,16 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 613 639 | 
             
                        columns: string[];
         | 
| 614 640 | 
             
                        nullsNotDistinct: boolean;
         | 
| 615 641 | 
             
                    }>>>;
         | 
| 642 | 
            +
                    checkConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 643 | 
            +
                        name: zod.ZodString;
         | 
| 644 | 
            +
                        value: zod.ZodString;
         | 
| 645 | 
            +
                    }, "strict", zod.ZodTypeAny, {
         | 
| 646 | 
            +
                        name: string;
         | 
| 647 | 
            +
                        value: string;
         | 
| 648 | 
            +
                    }, {
         | 
| 649 | 
            +
                        name: string;
         | 
| 650 | 
            +
                        value: string;
         | 
| 651 | 
            +
                    }>>>;
         | 
| 616 652 | 
             
                }, "strict", zod.ZodTypeAny, {
         | 
| 617 653 | 
             
                    name: string;
         | 
| 618 654 | 
             
                    columns: Record<string, {
         | 
| @@ -676,6 +712,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 676 712 | 
             
                        columns: string[];
         | 
| 677 713 | 
             
                        nullsNotDistinct: boolean;
         | 
| 678 714 | 
             
                    }>;
         | 
| 715 | 
            +
                    checkConstraints: Record<string, {
         | 
| 716 | 
            +
                        name: string;
         | 
| 717 | 
            +
                        value: string;
         | 
| 718 | 
            +
                    }>;
         | 
| 679 719 | 
             
                }, {
         | 
| 680 720 | 
             
                    name: string;
         | 
| 681 721 | 
             
                    columns: Record<string, {
         | 
| @@ -739,6 +779,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 739 779 | 
             
                        columns: string[];
         | 
| 740 780 | 
             
                        nullsNotDistinct: boolean;
         | 
| 741 781 | 
             
                    }> | undefined;
         | 
| 782 | 
            +
                    checkConstraints?: Record<string, {
         | 
| 783 | 
            +
                        name: string;
         | 
| 784 | 
            +
                        value: string;
         | 
| 785 | 
            +
                    }> | undefined;
         | 
| 742 786 | 
             
                }>>;
         | 
| 743 787 | 
             
                enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 744 788 | 
             
                    name: zod.ZodString;
         | 
| @@ -754,303 +798,6 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 754 798 | 
             
                    schema: string;
         | 
| 755 799 | 
             
                }>>;
         | 
| 756 800 | 
             
                schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
         | 
| 757 | 
            -
                views: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 758 | 
            -
                    name: zod.ZodString;
         | 
| 759 | 
            -
                    schema: zod.ZodString;
         | 
| 760 | 
            -
                    columns: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 761 | 
            -
                        name: zod.ZodString;
         | 
| 762 | 
            -
                        type: zod.ZodString;
         | 
| 763 | 
            -
                        typeSchema: zod.ZodOptional<zod.ZodString>;
         | 
| 764 | 
            -
                        primaryKey: zod.ZodBoolean;
         | 
| 765 | 
            -
                        notNull: zod.ZodBoolean;
         | 
| 766 | 
            -
                        default: zod.ZodOptional<zod.ZodAny>;
         | 
| 767 | 
            -
                        isUnique: zod.ZodOptional<zod.ZodAny>;
         | 
| 768 | 
            -
                        uniqueName: zod.ZodOptional<zod.ZodString>;
         | 
| 769 | 
            -
                        nullsNotDistinct: zod.ZodOptional<zod.ZodBoolean>;
         | 
| 770 | 
            -
                        generated: zod.ZodOptional<zod.ZodObject<{
         | 
| 771 | 
            -
                            type: zod.ZodLiteral<"stored">;
         | 
| 772 | 
            -
                            as: zod.ZodString;
         | 
| 773 | 
            -
                        }, "strip", zod.ZodTypeAny, {
         | 
| 774 | 
            -
                            type: "stored";
         | 
| 775 | 
            -
                            as: string;
         | 
| 776 | 
            -
                        }, {
         | 
| 777 | 
            -
                            type: "stored";
         | 
| 778 | 
            -
                            as: string;
         | 
| 779 | 
            -
                        }>>;
         | 
| 780 | 
            -
                        identity: zod.ZodOptional<zod.ZodObject<zod.objectUtil.extendShape<{
         | 
| 781 | 
            -
                            name: zod.ZodString;
         | 
| 782 | 
            -
                            increment: zod.ZodOptional<zod.ZodString>;
         | 
| 783 | 
            -
                            minValue: zod.ZodOptional<zod.ZodString>;
         | 
| 784 | 
            -
                            maxValue: zod.ZodOptional<zod.ZodString>;
         | 
| 785 | 
            -
                            startWith: zod.ZodOptional<zod.ZodString>;
         | 
| 786 | 
            -
                            cache: zod.ZodOptional<zod.ZodString>;
         | 
| 787 | 
            -
                            cycle: zod.ZodOptional<zod.ZodBoolean>;
         | 
| 788 | 
            -
                            schema: zod.ZodString;
         | 
| 789 | 
            -
                        }, {
         | 
| 790 | 
            -
                            type: zod.ZodEnum<["always", "byDefault"]>;
         | 
| 791 | 
            -
                        }>, "strip", zod.ZodTypeAny, {
         | 
| 792 | 
            -
                            name: string;
         | 
| 793 | 
            -
                            type: "always" | "byDefault";
         | 
| 794 | 
            -
                            schema: string;
         | 
| 795 | 
            -
                            increment?: string | undefined;
         | 
| 796 | 
            -
                            minValue?: string | undefined;
         | 
| 797 | 
            -
                            maxValue?: string | undefined;
         | 
| 798 | 
            -
                            startWith?: string | undefined;
         | 
| 799 | 
            -
                            cache?: string | undefined;
         | 
| 800 | 
            -
                            cycle?: boolean | undefined;
         | 
| 801 | 
            -
                        }, {
         | 
| 802 | 
            -
                            name: string;
         | 
| 803 | 
            -
                            type: "always" | "byDefault";
         | 
| 804 | 
            -
                            schema: string;
         | 
| 805 | 
            -
                            increment?: string | undefined;
         | 
| 806 | 
            -
                            minValue?: string | undefined;
         | 
| 807 | 
            -
                            maxValue?: string | undefined;
         | 
| 808 | 
            -
                            startWith?: string | undefined;
         | 
| 809 | 
            -
                            cache?: string | undefined;
         | 
| 810 | 
            -
                            cycle?: boolean | undefined;
         | 
| 811 | 
            -
                        }>>;
         | 
| 812 | 
            -
                    }, "strict", zod.ZodTypeAny, {
         | 
| 813 | 
            -
                        name: string;
         | 
| 814 | 
            -
                        type: string;
         | 
| 815 | 
            -
                        primaryKey: boolean;
         | 
| 816 | 
            -
                        notNull: boolean;
         | 
| 817 | 
            -
                        isUnique?: any;
         | 
| 818 | 
            -
                        default?: any;
         | 
| 819 | 
            -
                        generated?: {
         | 
| 820 | 
            -
                            type: "stored";
         | 
| 821 | 
            -
                            as: string;
         | 
| 822 | 
            -
                        } | undefined;
         | 
| 823 | 
            -
                        typeSchema?: string | undefined;
         | 
| 824 | 
            -
                        uniqueName?: string | undefined;
         | 
| 825 | 
            -
                        nullsNotDistinct?: boolean | undefined;
         | 
| 826 | 
            -
                        identity?: {
         | 
| 827 | 
            -
                            name: string;
         | 
| 828 | 
            -
                            type: "always" | "byDefault";
         | 
| 829 | 
            -
                            schema: string;
         | 
| 830 | 
            -
                            increment?: string | undefined;
         | 
| 831 | 
            -
                            minValue?: string | undefined;
         | 
| 832 | 
            -
                            maxValue?: string | undefined;
         | 
| 833 | 
            -
                            startWith?: string | undefined;
         | 
| 834 | 
            -
                            cache?: string | undefined;
         | 
| 835 | 
            -
                            cycle?: boolean | undefined;
         | 
| 836 | 
            -
                        } | undefined;
         | 
| 837 | 
            -
                    }, {
         | 
| 838 | 
            -
                        name: string;
         | 
| 839 | 
            -
                        type: string;
         | 
| 840 | 
            -
                        primaryKey: boolean;
         | 
| 841 | 
            -
                        notNull: boolean;
         | 
| 842 | 
            -
                        isUnique?: any;
         | 
| 843 | 
            -
                        default?: any;
         | 
| 844 | 
            -
                        generated?: {
         | 
| 845 | 
            -
                            type: "stored";
         | 
| 846 | 
            -
                            as: string;
         | 
| 847 | 
            -
                        } | undefined;
         | 
| 848 | 
            -
                        typeSchema?: string | undefined;
         | 
| 849 | 
            -
                        uniqueName?: string | undefined;
         | 
| 850 | 
            -
                        nullsNotDistinct?: boolean | undefined;
         | 
| 851 | 
            -
                        identity?: {
         | 
| 852 | 
            -
                            name: string;
         | 
| 853 | 
            -
                            type: "always" | "byDefault";
         | 
| 854 | 
            -
                            schema: string;
         | 
| 855 | 
            -
                            increment?: string | undefined;
         | 
| 856 | 
            -
                            minValue?: string | undefined;
         | 
| 857 | 
            -
                            maxValue?: string | undefined;
         | 
| 858 | 
            -
                            startWith?: string | undefined;
         | 
| 859 | 
            -
                            cache?: string | undefined;
         | 
| 860 | 
            -
                            cycle?: boolean | undefined;
         | 
| 861 | 
            -
                        } | undefined;
         | 
| 862 | 
            -
                    }>>;
         | 
| 863 | 
            -
                    definition: zod.ZodOptional<zod.ZodString>;
         | 
| 864 | 
            -
                    materialized: zod.ZodBoolean;
         | 
| 865 | 
            -
                    with: zod.ZodOptional<zod.ZodObject<zod.objectUtil.extendShape<{
         | 
| 866 | 
            -
                        checkOption: zod.ZodOptional<zod.ZodEnum<["local", "cascaded"]>>;
         | 
| 867 | 
            -
                        securityBarrier: zod.ZodOptional<zod.ZodBoolean>;
         | 
| 868 | 
            -
                        securityInvoker: zod.ZodOptional<zod.ZodBoolean>;
         | 
| 869 | 
            -
                    }, {
         | 
| 870 | 
            -
                        fillfactor: zod.ZodOptional<zod.ZodNumber>;
         | 
| 871 | 
            -
                        toastTupleTarget: zod.ZodOptional<zod.ZodNumber>;
         | 
| 872 | 
            -
                        parallelWorkers: zod.ZodOptional<zod.ZodNumber>;
         | 
| 873 | 
            -
                        autovacuumEnabled: zod.ZodOptional<zod.ZodBoolean>;
         | 
| 874 | 
            -
                        vacuumIndexCleanup: zod.ZodOptional<zod.ZodEnum<["auto", "off", "on"]>>;
         | 
| 875 | 
            -
                        vacuumTruncate: zod.ZodOptional<zod.ZodBoolean>;
         | 
| 876 | 
            -
                        autovacuumVacuumThreshold: zod.ZodOptional<zod.ZodNumber>;
         | 
| 877 | 
            -
                        autovacuumVacuumScaleFactor: zod.ZodOptional<zod.ZodNumber>;
         | 
| 878 | 
            -
                        autovacuumVacuumCostDelay: zod.ZodOptional<zod.ZodNumber>;
         | 
| 879 | 
            -
                        autovacuumVacuumCostLimit: zod.ZodOptional<zod.ZodNumber>;
         | 
| 880 | 
            -
                        autovacuumFreezeMinAge: zod.ZodOptional<zod.ZodNumber>;
         | 
| 881 | 
            -
                        autovacuumFreezeMaxAge: zod.ZodOptional<zod.ZodNumber>;
         | 
| 882 | 
            -
                        autovacuumFreezeTableAge: zod.ZodOptional<zod.ZodNumber>;
         | 
| 883 | 
            -
                        autovacuumMultixactFreezeMinAge: zod.ZodOptional<zod.ZodNumber>;
         | 
| 884 | 
            -
                        autovacuumMultixactFreezeMaxAge: zod.ZodOptional<zod.ZodNumber>;
         | 
| 885 | 
            -
                        autovacuumMultixactFreezeTableAge: zod.ZodOptional<zod.ZodNumber>;
         | 
| 886 | 
            -
                        logAutovacuumMinDuration: zod.ZodOptional<zod.ZodNumber>;
         | 
| 887 | 
            -
                        userCatalogTable: zod.ZodOptional<zod.ZodBoolean>;
         | 
| 888 | 
            -
                    }>, "strict", zod.ZodTypeAny, {
         | 
| 889 | 
            -
                        checkOption?: "local" | "cascaded" | undefined;
         | 
| 890 | 
            -
                        securityBarrier?: boolean | undefined;
         | 
| 891 | 
            -
                        securityInvoker?: boolean | undefined;
         | 
| 892 | 
            -
                        fillfactor?: number | undefined;
         | 
| 893 | 
            -
                        toastTupleTarget?: number | undefined;
         | 
| 894 | 
            -
                        parallelWorkers?: number | undefined;
         | 
| 895 | 
            -
                        autovacuumEnabled?: boolean | undefined;
         | 
| 896 | 
            -
                        vacuumIndexCleanup?: "auto" | "off" | "on" | undefined;
         | 
| 897 | 
            -
                        vacuumTruncate?: boolean | undefined;
         | 
| 898 | 
            -
                        autovacuumVacuumThreshold?: number | undefined;
         | 
| 899 | 
            -
                        autovacuumVacuumScaleFactor?: number | undefined;
         | 
| 900 | 
            -
                        autovacuumVacuumCostDelay?: number | undefined;
         | 
| 901 | 
            -
                        autovacuumVacuumCostLimit?: number | undefined;
         | 
| 902 | 
            -
                        autovacuumFreezeMinAge?: number | undefined;
         | 
| 903 | 
            -
                        autovacuumFreezeMaxAge?: number | undefined;
         | 
| 904 | 
            -
                        autovacuumFreezeTableAge?: number | undefined;
         | 
| 905 | 
            -
                        autovacuumMultixactFreezeMinAge?: number | undefined;
         | 
| 906 | 
            -
                        autovacuumMultixactFreezeMaxAge?: number | undefined;
         | 
| 907 | 
            -
                        autovacuumMultixactFreezeTableAge?: number | undefined;
         | 
| 908 | 
            -
                        logAutovacuumMinDuration?: number | undefined;
         | 
| 909 | 
            -
                        userCatalogTable?: boolean | undefined;
         | 
| 910 | 
            -
                    }, {
         | 
| 911 | 
            -
                        checkOption?: "local" | "cascaded" | undefined;
         | 
| 912 | 
            -
                        securityBarrier?: boolean | undefined;
         | 
| 913 | 
            -
                        securityInvoker?: boolean | undefined;
         | 
| 914 | 
            -
                        fillfactor?: number | undefined;
         | 
| 915 | 
            -
                        toastTupleTarget?: number | undefined;
         | 
| 916 | 
            -
                        parallelWorkers?: number | undefined;
         | 
| 917 | 
            -
                        autovacuumEnabled?: boolean | undefined;
         | 
| 918 | 
            -
                        vacuumIndexCleanup?: "auto" | "off" | "on" | undefined;
         | 
| 919 | 
            -
                        vacuumTruncate?: boolean | undefined;
         | 
| 920 | 
            -
                        autovacuumVacuumThreshold?: number | undefined;
         | 
| 921 | 
            -
                        autovacuumVacuumScaleFactor?: number | undefined;
         | 
| 922 | 
            -
                        autovacuumVacuumCostDelay?: number | undefined;
         | 
| 923 | 
            -
                        autovacuumVacuumCostLimit?: number | undefined;
         | 
| 924 | 
            -
                        autovacuumFreezeMinAge?: number | undefined;
         | 
| 925 | 
            -
                        autovacuumFreezeMaxAge?: number | undefined;
         | 
| 926 | 
            -
                        autovacuumFreezeTableAge?: number | undefined;
         | 
| 927 | 
            -
                        autovacuumMultixactFreezeMinAge?: number | undefined;
         | 
| 928 | 
            -
                        autovacuumMultixactFreezeMaxAge?: number | undefined;
         | 
| 929 | 
            -
                        autovacuumMultixactFreezeTableAge?: number | undefined;
         | 
| 930 | 
            -
                        logAutovacuumMinDuration?: number | undefined;
         | 
| 931 | 
            -
                        userCatalogTable?: boolean | undefined;
         | 
| 932 | 
            -
                    }>>;
         | 
| 933 | 
            -
                    isExisting: zod.ZodBoolean;
         | 
| 934 | 
            -
                    withNoData: zod.ZodOptional<zod.ZodBoolean>;
         | 
| 935 | 
            -
                    using: zod.ZodOptional<zod.ZodString>;
         | 
| 936 | 
            -
                    tablespace: zod.ZodOptional<zod.ZodString>;
         | 
| 937 | 
            -
                }, "strict", zod.ZodTypeAny, {
         | 
| 938 | 
            -
                    name: string;
         | 
| 939 | 
            -
                    columns: Record<string, {
         | 
| 940 | 
            -
                        name: string;
         | 
| 941 | 
            -
                        type: string;
         | 
| 942 | 
            -
                        primaryKey: boolean;
         | 
| 943 | 
            -
                        notNull: boolean;
         | 
| 944 | 
            -
                        isUnique?: any;
         | 
| 945 | 
            -
                        default?: any;
         | 
| 946 | 
            -
                        generated?: {
         | 
| 947 | 
            -
                            type: "stored";
         | 
| 948 | 
            -
                            as: string;
         | 
| 949 | 
            -
                        } | undefined;
         | 
| 950 | 
            -
                        typeSchema?: string | undefined;
         | 
| 951 | 
            -
                        uniqueName?: string | undefined;
         | 
| 952 | 
            -
                        nullsNotDistinct?: boolean | undefined;
         | 
| 953 | 
            -
                        identity?: {
         | 
| 954 | 
            -
                            name: string;
         | 
| 955 | 
            -
                            type: "always" | "byDefault";
         | 
| 956 | 
            -
                            schema: string;
         | 
| 957 | 
            -
                            increment?: string | undefined;
         | 
| 958 | 
            -
                            minValue?: string | undefined;
         | 
| 959 | 
            -
                            maxValue?: string | undefined;
         | 
| 960 | 
            -
                            startWith?: string | undefined;
         | 
| 961 | 
            -
                            cache?: string | undefined;
         | 
| 962 | 
            -
                            cycle?: boolean | undefined;
         | 
| 963 | 
            -
                        } | undefined;
         | 
| 964 | 
            -
                    }>;
         | 
| 965 | 
            -
                    schema: string;
         | 
| 966 | 
            -
                    materialized: boolean;
         | 
| 967 | 
            -
                    isExisting: boolean;
         | 
| 968 | 
            -
                    using?: string | undefined;
         | 
| 969 | 
            -
                    with?: {
         | 
| 970 | 
            -
                        checkOption?: "local" | "cascaded" | undefined;
         | 
| 971 | 
            -
                        securityBarrier?: boolean | undefined;
         | 
| 972 | 
            -
                        securityInvoker?: boolean | undefined;
         | 
| 973 | 
            -
                        fillfactor?: number | undefined;
         | 
| 974 | 
            -
                        toastTupleTarget?: number | undefined;
         | 
| 975 | 
            -
                        parallelWorkers?: number | undefined;
         | 
| 976 | 
            -
                        autovacuumEnabled?: boolean | undefined;
         | 
| 977 | 
            -
                        vacuumIndexCleanup?: "auto" | "off" | "on" | undefined;
         | 
| 978 | 
            -
                        vacuumTruncate?: boolean | undefined;
         | 
| 979 | 
            -
                        autovacuumVacuumThreshold?: number | undefined;
         | 
| 980 | 
            -
                        autovacuumVacuumScaleFactor?: number | undefined;
         | 
| 981 | 
            -
                        autovacuumVacuumCostDelay?: number | undefined;
         | 
| 982 | 
            -
                        autovacuumVacuumCostLimit?: number | undefined;
         | 
| 983 | 
            -
                        autovacuumFreezeMinAge?: number | undefined;
         | 
| 984 | 
            -
                        autovacuumFreezeMaxAge?: number | undefined;
         | 
| 985 | 
            -
                        autovacuumFreezeTableAge?: number | undefined;
         | 
| 986 | 
            -
                        autovacuumMultixactFreezeMinAge?: number | undefined;
         | 
| 987 | 
            -
                        autovacuumMultixactFreezeMaxAge?: number | undefined;
         | 
| 988 | 
            -
                        autovacuumMultixactFreezeTableAge?: number | undefined;
         | 
| 989 | 
            -
                        logAutovacuumMinDuration?: number | undefined;
         | 
| 990 | 
            -
                        userCatalogTable?: boolean | undefined;
         | 
| 991 | 
            -
                    } | undefined;
         | 
| 992 | 
            -
                    definition?: string | undefined;
         | 
| 993 | 
            -
                    withNoData?: boolean | undefined;
         | 
| 994 | 
            -
                    tablespace?: string | undefined;
         | 
| 995 | 
            -
                }, {
         | 
| 996 | 
            -
                    name: string;
         | 
| 997 | 
            -
                    columns: Record<string, {
         | 
| 998 | 
            -
                        name: string;
         | 
| 999 | 
            -
                        type: string;
         | 
| 1000 | 
            -
                        primaryKey: boolean;
         | 
| 1001 | 
            -
                        notNull: boolean;
         | 
| 1002 | 
            -
                        isUnique?: any;
         | 
| 1003 | 
            -
                        default?: any;
         | 
| 1004 | 
            -
                        generated?: {
         | 
| 1005 | 
            -
                            type: "stored";
         | 
| 1006 | 
            -
                            as: string;
         | 
| 1007 | 
            -
                        } | undefined;
         | 
| 1008 | 
            -
                        typeSchema?: string | undefined;
         | 
| 1009 | 
            -
                        uniqueName?: string | undefined;
         | 
| 1010 | 
            -
                        nullsNotDistinct?: boolean | undefined;
         | 
| 1011 | 
            -
                        identity?: {
         | 
| 1012 | 
            -
                            name: string;
         | 
| 1013 | 
            -
                            type: "always" | "byDefault";
         | 
| 1014 | 
            -
                            schema: string;
         | 
| 1015 | 
            -
                            increment?: string | undefined;
         | 
| 1016 | 
            -
                            minValue?: string | undefined;
         | 
| 1017 | 
            -
                            maxValue?: string | undefined;
         | 
| 1018 | 
            -
                            startWith?: string | undefined;
         | 
| 1019 | 
            -
                            cache?: string | undefined;
         | 
| 1020 | 
            -
                            cycle?: boolean | undefined;
         | 
| 1021 | 
            -
                        } | undefined;
         | 
| 1022 | 
            -
                    }>;
         | 
| 1023 | 
            -
                    schema: string;
         | 
| 1024 | 
            -
                    materialized: boolean;
         | 
| 1025 | 
            -
                    isExisting: boolean;
         | 
| 1026 | 
            -
                    using?: string | undefined;
         | 
| 1027 | 
            -
                    with?: {
         | 
| 1028 | 
            -
                        checkOption?: "local" | "cascaded" | undefined;
         | 
| 1029 | 
            -
                        securityBarrier?: boolean | undefined;
         | 
| 1030 | 
            -
                        securityInvoker?: boolean | undefined;
         | 
| 1031 | 
            -
                        fillfactor?: number | undefined;
         | 
| 1032 | 
            -
                        toastTupleTarget?: number | undefined;
         | 
| 1033 | 
            -
                        parallelWorkers?: number | undefined;
         | 
| 1034 | 
            -
                        autovacuumEnabled?: boolean | undefined;
         | 
| 1035 | 
            -
                        vacuumIndexCleanup?: "auto" | "off" | "on" | undefined;
         | 
| 1036 | 
            -
                        vacuumTruncate?: boolean | undefined;
         | 
| 1037 | 
            -
                        autovacuumVacuumThreshold?: number | undefined;
         | 
| 1038 | 
            -
                        autovacuumVacuumScaleFactor?: number | undefined;
         | 
| 1039 | 
            -
                        autovacuumVacuumCostDelay?: number | undefined;
         | 
| 1040 | 
            -
                        autovacuumVacuumCostLimit?: number | undefined;
         | 
| 1041 | 
            -
                        autovacuumFreezeMinAge?: number | undefined;
         | 
| 1042 | 
            -
                        autovacuumFreezeMaxAge?: number | undefined;
         | 
| 1043 | 
            -
                        autovacuumFreezeTableAge?: number | undefined;
         | 
| 1044 | 
            -
                        autovacuumMultixactFreezeMinAge?: number | undefined;
         | 
| 1045 | 
            -
                        autovacuumMultixactFreezeMaxAge?: number | undefined;
         | 
| 1046 | 
            -
                        autovacuumMultixactFreezeTableAge?: number | undefined;
         | 
| 1047 | 
            -
                        logAutovacuumMinDuration?: number | undefined;
         | 
| 1048 | 
            -
                        userCatalogTable?: boolean | undefined;
         | 
| 1049 | 
            -
                    } | undefined;
         | 
| 1050 | 
            -
                    definition?: string | undefined;
         | 
| 1051 | 
            -
                    withNoData?: boolean | undefined;
         | 
| 1052 | 
            -
                    tablespace?: string | undefined;
         | 
| 1053 | 
            -
                }>>>;
         | 
| 1054 801 | 
             
                sequences: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 1055 802 | 
             
                    name: zod.ZodString;
         | 
| 1056 803 | 
             
                    increment: zod.ZodOptional<zod.ZodString>;
         | 
| @@ -1211,6 +958,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1211 958 | 
             
                        columns: string[];
         | 
| 1212 959 | 
             
                        nullsNotDistinct: boolean;
         | 
| 1213 960 | 
             
                    }>;
         | 
| 961 | 
            +
                    checkConstraints: Record<string, {
         | 
| 962 | 
            +
                        name: string;
         | 
| 963 | 
            +
                        value: string;
         | 
| 964 | 
            +
                    }>;
         | 
| 1214 965 | 
             
                }>;
         | 
| 1215 966 | 
             
                id: string;
         | 
| 1216 967 | 
             
                prevId: string;
         | 
| @@ -1237,65 +988,6 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1237 988 | 
             
                    cache?: string | undefined;
         | 
| 1238 989 | 
             
                    cycle?: boolean | undefined;
         | 
| 1239 990 | 
             
                }>;
         | 
| 1240 | 
            -
                views: Record<string, {
         | 
| 1241 | 
            -
                    name: string;
         | 
| 1242 | 
            -
                    columns: Record<string, {
         | 
| 1243 | 
            -
                        name: string;
         | 
| 1244 | 
            -
                        type: string;
         | 
| 1245 | 
            -
                        primaryKey: boolean;
         | 
| 1246 | 
            -
                        notNull: boolean;
         | 
| 1247 | 
            -
                        isUnique?: any;
         | 
| 1248 | 
            -
                        default?: any;
         | 
| 1249 | 
            -
                        generated?: {
         | 
| 1250 | 
            -
                            type: "stored";
         | 
| 1251 | 
            -
                            as: string;
         | 
| 1252 | 
            -
                        } | undefined;
         | 
| 1253 | 
            -
                        typeSchema?: string | undefined;
         | 
| 1254 | 
            -
                        uniqueName?: string | undefined;
         | 
| 1255 | 
            -
                        nullsNotDistinct?: boolean | undefined;
         | 
| 1256 | 
            -
                        identity?: {
         | 
| 1257 | 
            -
                            name: string;
         | 
| 1258 | 
            -
                            type: "always" | "byDefault";
         | 
| 1259 | 
            -
                            schema: string;
         | 
| 1260 | 
            -
                            increment?: string | undefined;
         | 
| 1261 | 
            -
                            minValue?: string | undefined;
         | 
| 1262 | 
            -
                            maxValue?: string | undefined;
         | 
| 1263 | 
            -
                            startWith?: string | undefined;
         | 
| 1264 | 
            -
                            cache?: string | undefined;
         | 
| 1265 | 
            -
                            cycle?: boolean | undefined;
         | 
| 1266 | 
            -
                        } | undefined;
         | 
| 1267 | 
            -
                    }>;
         | 
| 1268 | 
            -
                    schema: string;
         | 
| 1269 | 
            -
                    materialized: boolean;
         | 
| 1270 | 
            -
                    isExisting: boolean;
         | 
| 1271 | 
            -
                    using?: string | undefined;
         | 
| 1272 | 
            -
                    with?: {
         | 
| 1273 | 
            -
                        checkOption?: "local" | "cascaded" | undefined;
         | 
| 1274 | 
            -
                        securityBarrier?: boolean | undefined;
         | 
| 1275 | 
            -
                        securityInvoker?: boolean | undefined;
         | 
| 1276 | 
            -
                        fillfactor?: number | undefined;
         | 
| 1277 | 
            -
                        toastTupleTarget?: number | undefined;
         | 
| 1278 | 
            -
                        parallelWorkers?: number | undefined;
         | 
| 1279 | 
            -
                        autovacuumEnabled?: boolean | undefined;
         | 
| 1280 | 
            -
                        vacuumIndexCleanup?: "auto" | "off" | "on" | undefined;
         | 
| 1281 | 
            -
                        vacuumTruncate?: boolean | undefined;
         | 
| 1282 | 
            -
                        autovacuumVacuumThreshold?: number | undefined;
         | 
| 1283 | 
            -
                        autovacuumVacuumScaleFactor?: number | undefined;
         | 
| 1284 | 
            -
                        autovacuumVacuumCostDelay?: number | undefined;
         | 
| 1285 | 
            -
                        autovacuumVacuumCostLimit?: number | undefined;
         | 
| 1286 | 
            -
                        autovacuumFreezeMinAge?: number | undefined;
         | 
| 1287 | 
            -
                        autovacuumFreezeMaxAge?: number | undefined;
         | 
| 1288 | 
            -
                        autovacuumFreezeTableAge?: number | undefined;
         | 
| 1289 | 
            -
                        autovacuumMultixactFreezeMinAge?: number | undefined;
         | 
| 1290 | 
            -
                        autovacuumMultixactFreezeMaxAge?: number | undefined;
         | 
| 1291 | 
            -
                        autovacuumMultixactFreezeTableAge?: number | undefined;
         | 
| 1292 | 
            -
                        logAutovacuumMinDuration?: number | undefined;
         | 
| 1293 | 
            -
                        userCatalogTable?: boolean | undefined;
         | 
| 1294 | 
            -
                    } | undefined;
         | 
| 1295 | 
            -
                    definition?: string | undefined;
         | 
| 1296 | 
            -
                    withNoData?: boolean | undefined;
         | 
| 1297 | 
            -
                    tablespace?: string | undefined;
         | 
| 1298 | 
            -
                }>;
         | 
| 1299 991 | 
             
                internal?: {
         | 
| 1300 992 | 
             
                    tables: Record<string, {
         | 
| 1301 993 | 
             
                        columns: Record<string, {
         | 
| @@ -1370,6 +1062,10 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1370 1062 | 
             
                        columns: string[];
         | 
| 1371 1063 | 
             
                        nullsNotDistinct: boolean;
         | 
| 1372 1064 | 
             
                    }> | undefined;
         | 
| 1065 | 
            +
                    checkConstraints?: Record<string, {
         | 
| 1066 | 
            +
                        name: string;
         | 
| 1067 | 
            +
                        value: string;
         | 
| 1068 | 
            +
                    }> | undefined;
         | 
| 1373 1069 | 
             
                }>;
         | 
| 1374 1070 | 
             
                id: string;
         | 
| 1375 1071 | 
             
                prevId: string;
         | 
| @@ -1406,65 +1102,6 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1406 1102 | 
             
                    cache?: string | undefined;
         | 
| 1407 1103 | 
             
                    cycle?: boolean | undefined;
         | 
| 1408 1104 | 
             
                }> | undefined;
         | 
| 1409 | 
            -
                views?: Record<string, {
         | 
| 1410 | 
            -
                    name: string;
         | 
| 1411 | 
            -
                    columns: Record<string, {
         | 
| 1412 | 
            -
                        name: string;
         | 
| 1413 | 
            -
                        type: string;
         | 
| 1414 | 
            -
                        primaryKey: boolean;
         | 
| 1415 | 
            -
                        notNull: boolean;
         | 
| 1416 | 
            -
                        isUnique?: any;
         | 
| 1417 | 
            -
                        default?: any;
         | 
| 1418 | 
            -
                        generated?: {
         | 
| 1419 | 
            -
                            type: "stored";
         | 
| 1420 | 
            -
                            as: string;
         | 
| 1421 | 
            -
                        } | undefined;
         | 
| 1422 | 
            -
                        typeSchema?: string | undefined;
         | 
| 1423 | 
            -
                        uniqueName?: string | undefined;
         | 
| 1424 | 
            -
                        nullsNotDistinct?: boolean | undefined;
         | 
| 1425 | 
            -
                        identity?: {
         | 
| 1426 | 
            -
                            name: string;
         | 
| 1427 | 
            -
                            type: "always" | "byDefault";
         | 
| 1428 | 
            -
                            schema: string;
         | 
| 1429 | 
            -
                            increment?: string | undefined;
         | 
| 1430 | 
            -
                            minValue?: string | undefined;
         | 
| 1431 | 
            -
                            maxValue?: string | undefined;
         | 
| 1432 | 
            -
                            startWith?: string | undefined;
         | 
| 1433 | 
            -
                            cache?: string | undefined;
         | 
| 1434 | 
            -
                            cycle?: boolean | undefined;
         | 
| 1435 | 
            -
                        } | undefined;
         | 
| 1436 | 
            -
                    }>;
         | 
| 1437 | 
            -
                    schema: string;
         | 
| 1438 | 
            -
                    materialized: boolean;
         | 
| 1439 | 
            -
                    isExisting: boolean;
         | 
| 1440 | 
            -
                    using?: string | undefined;
         | 
| 1441 | 
            -
                    with?: {
         | 
| 1442 | 
            -
                        checkOption?: "local" | "cascaded" | undefined;
         | 
| 1443 | 
            -
                        securityBarrier?: boolean | undefined;
         | 
| 1444 | 
            -
                        securityInvoker?: boolean | undefined;
         | 
| 1445 | 
            -
                        fillfactor?: number | undefined;
         | 
| 1446 | 
            -
                        toastTupleTarget?: number | undefined;
         | 
| 1447 | 
            -
                        parallelWorkers?: number | undefined;
         | 
| 1448 | 
            -
                        autovacuumEnabled?: boolean | undefined;
         | 
| 1449 | 
            -
                        vacuumIndexCleanup?: "auto" | "off" | "on" | undefined;
         | 
| 1450 | 
            -
                        vacuumTruncate?: boolean | undefined;
         | 
| 1451 | 
            -
                        autovacuumVacuumThreshold?: number | undefined;
         | 
| 1452 | 
            -
                        autovacuumVacuumScaleFactor?: number | undefined;
         | 
| 1453 | 
            -
                        autovacuumVacuumCostDelay?: number | undefined;
         | 
| 1454 | 
            -
                        autovacuumVacuumCostLimit?: number | undefined;
         | 
| 1455 | 
            -
                        autovacuumFreezeMinAge?: number | undefined;
         | 
| 1456 | 
            -
                        autovacuumFreezeMaxAge?: number | undefined;
         | 
| 1457 | 
            -
                        autovacuumFreezeTableAge?: number | undefined;
         | 
| 1458 | 
            -
                        autovacuumMultixactFreezeMinAge?: number | undefined;
         | 
| 1459 | 
            -
                        autovacuumMultixactFreezeMaxAge?: number | undefined;
         | 
| 1460 | 
            -
                        autovacuumMultixactFreezeTableAge?: number | undefined;
         | 
| 1461 | 
            -
                        logAutovacuumMinDuration?: number | undefined;
         | 
| 1462 | 
            -
                        userCatalogTable?: boolean | undefined;
         | 
| 1463 | 
            -
                    } | undefined;
         | 
| 1464 | 
            -
                    definition?: string | undefined;
         | 
| 1465 | 
            -
                    withNoData?: boolean | undefined;
         | 
| 1466 | 
            -
                    tablespace?: string | undefined;
         | 
| 1467 | 
            -
                }> | undefined;
         | 
| 1468 1105 | 
             
            }>;
         | 
| 1469 1106 | 
             
            type PgSchema = TypeOf<typeof pgSchema>;
         | 
| 1470 1107 |  | 
| @@ -1574,6 +1211,16 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1574 1211 | 
             
                        name: string;
         | 
| 1575 1212 | 
             
                        columns: string[];
         | 
| 1576 1213 | 
             
                    }>>>;
         | 
| 1214 | 
            +
                    checkConstraints: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 1215 | 
            +
                        name: zod.ZodString;
         | 
| 1216 | 
            +
                        value: zod.ZodString;
         | 
| 1217 | 
            +
                    }, "strict", zod.ZodTypeAny, {
         | 
| 1218 | 
            +
                        name: string;
         | 
| 1219 | 
            +
                        value: string;
         | 
| 1220 | 
            +
                    }, {
         | 
| 1221 | 
            +
                        name: string;
         | 
| 1222 | 
            +
                        value: string;
         | 
| 1223 | 
            +
                    }>>>;
         | 
| 1577 1224 | 
             
                }, "strict", zod.ZodTypeAny, {
         | 
| 1578 1225 | 
             
                    name: string;
         | 
| 1579 1226 | 
             
                    columns: Record<string, {
         | 
| @@ -1611,6 +1258,10 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1611 1258 | 
             
                        name: string;
         | 
| 1612 1259 | 
             
                        columns: string[];
         | 
| 1613 1260 | 
             
                    }>;
         | 
| 1261 | 
            +
                    checkConstraints: Record<string, {
         | 
| 1262 | 
            +
                        name: string;
         | 
| 1263 | 
            +
                        value: string;
         | 
| 1264 | 
            +
                    }>;
         | 
| 1614 1265 | 
             
                }, {
         | 
| 1615 1266 | 
             
                    name: string;
         | 
| 1616 1267 | 
             
                    columns: Record<string, {
         | 
| @@ -1648,6 +1299,10 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1648 1299 | 
             
                        name: string;
         | 
| 1649 1300 | 
             
                        columns: string[];
         | 
| 1650 1301 | 
             
                    }> | undefined;
         | 
| 1302 | 
            +
                    checkConstraints?: Record<string, {
         | 
| 1303 | 
            +
                        name: string;
         | 
| 1304 | 
            +
                        value: string;
         | 
| 1305 | 
            +
                    }> | undefined;
         | 
| 1651 1306 | 
             
                }>>;
         | 
| 1652 1307 | 
             
                enums: zod.ZodObject<{}, "strip", zod.ZodTypeAny, {}, {}>;
         | 
| 1653 1308 | 
             
                _meta: zod.ZodObject<{
         | 
| @@ -1732,6 +1387,10 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1732 1387 | 
             
                        name: string;
         | 
| 1733 1388 | 
             
                        columns: string[];
         | 
| 1734 1389 | 
             
                    }>;
         | 
| 1390 | 
            +
                    checkConstraints: Record<string, {
         | 
| 1391 | 
            +
                        name: string;
         | 
| 1392 | 
            +
                        value: string;
         | 
| 1393 | 
            +
                    }>;
         | 
| 1735 1394 | 
             
                }>;
         | 
| 1736 1395 | 
             
                id: string;
         | 
| 1737 1396 | 
             
                prevId: string;
         | 
| @@ -1787,6 +1446,10 @@ declare const schema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1787 1446 | 
             
                        name: string;
         | 
| 1788 1447 | 
             
                        columns: string[];
         | 
| 1789 1448 | 
             
                    }> | undefined;
         | 
| 1449 | 
            +
                    checkConstraints?: Record<string, {
         | 
| 1450 | 
            +
                        name: string;
         | 
| 1451 | 
            +
                        value: string;
         | 
| 1452 | 
            +
                    }> | undefined;
         | 
| 1790 1453 | 
             
                }>;
         | 
| 1791 1454 | 
             
                id: string;
         | 
| 1792 1455 | 
             
                prevId: string;
         | 
| @@ -1900,6 +1563,10 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => { | |
| 1900 1563 | 
             
                        columns: string[];
         | 
| 1901 1564 | 
             
                        nullsNotDistinct: boolean;
         | 
| 1902 1565 | 
             
                    }>;
         | 
| 1566 | 
            +
                    checkConstraints: Record<string, {
         | 
| 1567 | 
            +
                        value: string;
         | 
| 1568 | 
            +
                        name: string;
         | 
| 1569 | 
            +
                    }>;
         | 
| 1903 1570 | 
             
                }>;
         | 
| 1904 1571 | 
             
                enums: Record<string, {
         | 
| 1905 1572 | 
             
                    values: string[];
         | 
| @@ -1907,65 +1574,6 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => { | |
| 1907 1574 | 
             
                    schema: string;
         | 
| 1908 1575 | 
             
                }>;
         | 
| 1909 1576 | 
             
                schemas: Record<string, string>;
         | 
| 1910 | 
            -
                views: Record<string, {
         | 
| 1911 | 
            -
                    name: string;
         | 
| 1912 | 
            -
                    schema: string;
         | 
| 1913 | 
            -
                    columns: Record<string, {
         | 
| 1914 | 
            -
                        type: string;
         | 
| 1915 | 
            -
                        name: string;
         | 
| 1916 | 
            -
                        primaryKey: boolean;
         | 
| 1917 | 
            -
                        notNull: boolean;
         | 
| 1918 | 
            -
                        typeSchema?: string | undefined;
         | 
| 1919 | 
            -
                        default?: any;
         | 
| 1920 | 
            -
                        isUnique?: any;
         | 
| 1921 | 
            -
                        uniqueName?: string | undefined;
         | 
| 1922 | 
            -
                        nullsNotDistinct?: boolean | undefined;
         | 
| 1923 | 
            -
                        generated?: {
         | 
| 1924 | 
            -
                            type: "stored";
         | 
| 1925 | 
            -
                            as: string;
         | 
| 1926 | 
            -
                        } | undefined;
         | 
| 1927 | 
            -
                        identity?: {
         | 
| 1928 | 
            -
                            type: "always" | "byDefault";
         | 
| 1929 | 
            -
                            name: string;
         | 
| 1930 | 
            -
                            schema: string;
         | 
| 1931 | 
            -
                            increment?: string | undefined;
         | 
| 1932 | 
            -
                            minValue?: string | undefined;
         | 
| 1933 | 
            -
                            maxValue?: string | undefined;
         | 
| 1934 | 
            -
                            startWith?: string | undefined;
         | 
| 1935 | 
            -
                            cache?: string | undefined;
         | 
| 1936 | 
            -
                            cycle?: boolean | undefined;
         | 
| 1937 | 
            -
                        } | undefined;
         | 
| 1938 | 
            -
                    }>;
         | 
| 1939 | 
            -
                    materialized: boolean;
         | 
| 1940 | 
            -
                    isExisting: boolean;
         | 
| 1941 | 
            -
                    with?: {
         | 
| 1942 | 
            -
                        checkOption?: "local" | "cascaded" | undefined;
         | 
| 1943 | 
            -
                        securityBarrier?: boolean | undefined;
         | 
| 1944 | 
            -
                        securityInvoker?: boolean | undefined;
         | 
| 1945 | 
            -
                        fillfactor?: number | undefined;
         | 
| 1946 | 
            -
                        toastTupleTarget?: number | undefined;
         | 
| 1947 | 
            -
                        parallelWorkers?: number | undefined;
         | 
| 1948 | 
            -
                        autovacuumEnabled?: boolean | undefined;
         | 
| 1949 | 
            -
                        vacuumIndexCleanup?: "auto" | "off" | "on" | undefined;
         | 
| 1950 | 
            -
                        vacuumTruncate?: boolean | undefined;
         | 
| 1951 | 
            -
                        autovacuumVacuumThreshold?: number | undefined;
         | 
| 1952 | 
            -
                        autovacuumVacuumScaleFactor?: number | undefined;
         | 
| 1953 | 
            -
                        autovacuumVacuumCostDelay?: number | undefined;
         | 
| 1954 | 
            -
                        autovacuumVacuumCostLimit?: number | undefined;
         | 
| 1955 | 
            -
                        autovacuumFreezeMinAge?: number | undefined;
         | 
| 1956 | 
            -
                        autovacuumFreezeMaxAge?: number | undefined;
         | 
| 1957 | 
            -
                        autovacuumFreezeTableAge?: number | undefined;
         | 
| 1958 | 
            -
                        autovacuumMultixactFreezeMinAge?: number | undefined;
         | 
| 1959 | 
            -
                        autovacuumMultixactFreezeMaxAge?: number | undefined;
         | 
| 1960 | 
            -
                        autovacuumMultixactFreezeTableAge?: number | undefined;
         | 
| 1961 | 
            -
                        logAutovacuumMinDuration?: number | undefined;
         | 
| 1962 | 
            -
                        userCatalogTable?: boolean | undefined;
         | 
| 1963 | 
            -
                    } | undefined;
         | 
| 1964 | 
            -
                    definition?: string | undefined;
         | 
| 1965 | 
            -
                    withNoData?: boolean | undefined;
         | 
| 1966 | 
            -
                    using?: string | undefined;
         | 
| 1967 | 
            -
                    tablespace?: string | undefined;
         | 
| 1968 | 
            -
                }>;
         | 
| 1969 1577 | 
             
                sequences: Record<string, {
         | 
| 1970 1578 | 
             
                    name: string;
         | 
| 1971 1579 | 
             
                    schema: string;
         |