drizzle-kit 0.25.0-b4de377 → 0.25.0-b75016b
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 +92 -470
- package/api.d.ts +92 -470
- package/api.js +16200 -95875
- package/api.mjs +16240 -95911
- package/bin.cjs +1049 -1277
- package/index.d.mts +7 -0
- package/index.d.ts +7 -0
- package/package.json +2 -2
- package/utils.js +29 -51
- package/utils.mjs +29 -51
    
        package/api.d.mts
    CHANGED
    
    | @@ -613,6 +613,28 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 613 613 | 
             
                        columns: string[];
         | 
| 614 614 | 
             
                        nullsNotDistinct: boolean;
         | 
| 615 615 | 
             
                    }>>>;
         | 
| 616 | 
            +
                    policies: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 617 | 
            +
                        name: zod.ZodString;
         | 
| 618 | 
            +
                        as: zod.ZodOptional<zod.ZodEnum<["PERMISSIVE", "RESTRICTIVE"]>>;
         | 
| 619 | 
            +
                        for: zod.ZodOptional<zod.ZodEnum<["ALL", "SELECT", "INSERT", "UPDATE", "DELETE"]>>;
         | 
| 620 | 
            +
                        to: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
         | 
| 621 | 
            +
                        using: zod.ZodOptional<zod.ZodString>;
         | 
| 622 | 
            +
                        withCheck: zod.ZodOptional<zod.ZodString>;
         | 
| 623 | 
            +
                    }, "strict", zod.ZodTypeAny, {
         | 
| 624 | 
            +
                        name: string;
         | 
| 625 | 
            +
                        using?: string | undefined;
         | 
| 626 | 
            +
                        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
         | 
| 627 | 
            +
                        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
         | 
| 628 | 
            +
                        to?: string[] | undefined;
         | 
| 629 | 
            +
                        withCheck?: string | undefined;
         | 
| 630 | 
            +
                    }, {
         | 
| 631 | 
            +
                        name: string;
         | 
| 632 | 
            +
                        using?: string | undefined;
         | 
| 633 | 
            +
                        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
         | 
| 634 | 
            +
                        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
         | 
| 635 | 
            +
                        to?: string[] | undefined;
         | 
| 636 | 
            +
                        withCheck?: string | undefined;
         | 
| 637 | 
            +
                    }>>>;
         | 
| 616 638 | 
             
                }, "strict", zod.ZodTypeAny, {
         | 
| 617 639 | 
             
                    name: string;
         | 
| 618 640 | 
             
                    columns: Record<string, {
         | 
| @@ -676,6 +698,14 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 676 698 | 
             
                        columns: string[];
         | 
| 677 699 | 
             
                        nullsNotDistinct: boolean;
         | 
| 678 700 | 
             
                    }>;
         | 
| 701 | 
            +
                    policies: Record<string, {
         | 
| 702 | 
            +
                        name: string;
         | 
| 703 | 
            +
                        using?: string | undefined;
         | 
| 704 | 
            +
                        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
         | 
| 705 | 
            +
                        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
         | 
| 706 | 
            +
                        to?: string[] | undefined;
         | 
| 707 | 
            +
                        withCheck?: string | undefined;
         | 
| 708 | 
            +
                    }>;
         | 
| 679 709 | 
             
                }, {
         | 
| 680 710 | 
             
                    name: string;
         | 
| 681 711 | 
             
                    columns: Record<string, {
         | 
| @@ -739,6 +769,14 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 739 769 | 
             
                        columns: string[];
         | 
| 740 770 | 
             
                        nullsNotDistinct: boolean;
         | 
| 741 771 | 
             
                    }> | undefined;
         | 
| 772 | 
            +
                    policies?: Record<string, {
         | 
| 773 | 
            +
                        name: string;
         | 
| 774 | 
            +
                        using?: string | undefined;
         | 
| 775 | 
            +
                        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
         | 
| 776 | 
            +
                        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
         | 
| 777 | 
            +
                        to?: string[] | undefined;
         | 
| 778 | 
            +
                        withCheck?: string | undefined;
         | 
| 779 | 
            +
                    }> | undefined;
         | 
| 742 780 | 
             
                }>>;
         | 
| 743 781 | 
             
                enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 744 782 | 
             
                    name: zod.ZodString;
         | 
| @@ -754,303 +792,6 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 754 792 | 
             
                    schema: string;
         | 
| 755 793 | 
             
                }>>;
         | 
| 756 794 | 
             
                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 795 | 
             
                sequences: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 1055 796 | 
             
                    name: zod.ZodString;
         | 
| 1056 797 | 
             
                    increment: zod.ZodOptional<zod.ZodString>;
         | 
| @@ -1079,6 +820,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1079 820 | 
             
                    cache?: string | undefined;
         | 
| 1080 821 | 
             
                    cycle?: boolean | undefined;
         | 
| 1081 822 | 
             
                }>>>;
         | 
| 823 | 
            +
                roles: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 824 | 
            +
                    name: zod.ZodString;
         | 
| 825 | 
            +
                    createDb: zod.ZodOptional<zod.ZodBoolean>;
         | 
| 826 | 
            +
                    createRole: zod.ZodOptional<zod.ZodBoolean>;
         | 
| 827 | 
            +
                    inherit: zod.ZodOptional<zod.ZodBoolean>;
         | 
| 828 | 
            +
                }, "strict", zod.ZodTypeAny, {
         | 
| 829 | 
            +
                    name: string;
         | 
| 830 | 
            +
                    createDb?: boolean | undefined;
         | 
| 831 | 
            +
                    createRole?: boolean | undefined;
         | 
| 832 | 
            +
                    inherit?: boolean | undefined;
         | 
| 833 | 
            +
                }, {
         | 
| 834 | 
            +
                    name: string;
         | 
| 835 | 
            +
                    createDb?: boolean | undefined;
         | 
| 836 | 
            +
                    createRole?: boolean | undefined;
         | 
| 837 | 
            +
                    inherit?: boolean | undefined;
         | 
| 838 | 
            +
                }>>>;
         | 
| 1082 839 | 
             
                _meta: zod.ZodObject<{
         | 
| 1083 840 | 
             
                    schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
         | 
| 1084 841 | 
             
                    tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
         | 
| @@ -1211,6 +968,14 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1211 968 | 
             
                        columns: string[];
         | 
| 1212 969 | 
             
                        nullsNotDistinct: boolean;
         | 
| 1213 970 | 
             
                    }>;
         | 
| 971 | 
            +
                    policies: Record<string, {
         | 
| 972 | 
            +
                        name: string;
         | 
| 973 | 
            +
                        using?: string | undefined;
         | 
| 974 | 
            +
                        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
         | 
| 975 | 
            +
                        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
         | 
| 976 | 
            +
                        to?: string[] | undefined;
         | 
| 977 | 
            +
                        withCheck?: string | undefined;
         | 
| 978 | 
            +
                    }>;
         | 
| 1214 979 | 
             
                }>;
         | 
| 1215 980 | 
             
                id: string;
         | 
| 1216 981 | 
             
                prevId: string;
         | 
| @@ -1237,64 +1002,11 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1237 1002 | 
             
                    cache?: string | undefined;
         | 
| 1238 1003 | 
             
                    cycle?: boolean | undefined;
         | 
| 1239 1004 | 
             
                }>;
         | 
| 1240 | 
            -
                 | 
| 1005 | 
            +
                roles: Record<string, {
         | 
| 1241 1006 | 
             
                    name: string;
         | 
| 1242 | 
            -
                     | 
| 1243 | 
            -
             | 
| 1244 | 
            -
             | 
| 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;
         | 
| 1007 | 
            +
                    createDb?: boolean | undefined;
         | 
| 1008 | 
            +
                    createRole?: boolean | undefined;
         | 
| 1009 | 
            +
                    inherit?: boolean | undefined;
         | 
| 1298 1010 | 
             
                }>;
         | 
| 1299 1011 | 
             
                internal?: {
         | 
| 1300 1012 | 
             
                    tables: Record<string, {
         | 
| @@ -1370,6 +1082,14 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1370 1082 | 
             
                        columns: string[];
         | 
| 1371 1083 | 
             
                        nullsNotDistinct: boolean;
         | 
| 1372 1084 | 
             
                    }> | undefined;
         | 
| 1085 | 
            +
                    policies?: Record<string, {
         | 
| 1086 | 
            +
                        name: string;
         | 
| 1087 | 
            +
                        using?: string | undefined;
         | 
| 1088 | 
            +
                        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
         | 
| 1089 | 
            +
                        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
         | 
| 1090 | 
            +
                        to?: string[] | undefined;
         | 
| 1091 | 
            +
                        withCheck?: string | undefined;
         | 
| 1092 | 
            +
                    }> | undefined;
         | 
| 1373 1093 | 
             
                }>;
         | 
| 1374 1094 | 
             
                id: string;
         | 
| 1375 1095 | 
             
                prevId: string;
         | 
| @@ -1406,64 +1126,11 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1406 1126 | 
             
                    cache?: string | undefined;
         | 
| 1407 1127 | 
             
                    cycle?: boolean | undefined;
         | 
| 1408 1128 | 
             
                }> | undefined;
         | 
| 1409 | 
            -
                 | 
| 1129 | 
            +
                roles?: Record<string, {
         | 
| 1410 1130 | 
             
                    name: string;
         | 
| 1411 | 
            -
                     | 
| 1412 | 
            -
             | 
| 1413 | 
            -
             | 
| 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;
         | 
| 1131 | 
            +
                    createDb?: boolean | undefined;
         | 
| 1132 | 
            +
                    createRole?: boolean | undefined;
         | 
| 1133 | 
            +
                    inherit?: boolean | undefined;
         | 
| 1467 1134 | 
             
                }> | undefined;
         | 
| 1468 1135 | 
             
            }>;
         | 
| 1469 1136 | 
             
            type PgSchema = TypeOf<typeof pgSchema>;
         | 
| @@ -1900,6 +1567,14 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => { | |
| 1900 1567 | 
             
                        columns: string[];
         | 
| 1901 1568 | 
             
                        nullsNotDistinct: boolean;
         | 
| 1902 1569 | 
             
                    }>;
         | 
| 1570 | 
            +
                    policies: Record<string, {
         | 
| 1571 | 
            +
                        name: string;
         | 
| 1572 | 
            +
                        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
         | 
| 1573 | 
            +
                        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
         | 
| 1574 | 
            +
                        to?: string[] | undefined;
         | 
| 1575 | 
            +
                        using?: string | undefined;
         | 
| 1576 | 
            +
                        withCheck?: string | undefined;
         | 
| 1577 | 
            +
                    }>;
         | 
| 1903 1578 | 
             
                }>;
         | 
| 1904 1579 | 
             
                enums: Record<string, {
         | 
| 1905 1580 | 
             
                    values: string[];
         | 
| @@ -1907,65 +1582,6 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => { | |
| 1907 1582 | 
             
                    schema: string;
         | 
| 1908 1583 | 
             
                }>;
         | 
| 1909 1584 | 
             
                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 1585 | 
             
                sequences: Record<string, {
         | 
| 1970 1586 | 
             
                    name: string;
         | 
| 1971 1587 | 
             
                    schema: string;
         | 
| @@ -1976,6 +1592,12 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => { | |
| 1976 1592 | 
             
                    cache?: string | undefined;
         | 
| 1977 1593 | 
             
                    cycle?: boolean | undefined;
         | 
| 1978 1594 | 
             
                }>;
         | 
| 1595 | 
            +
                roles: Record<string, {
         | 
| 1596 | 
            +
                    name: string;
         | 
| 1597 | 
            +
                    createDb?: boolean | undefined;
         | 
| 1598 | 
            +
                    createRole?: boolean | undefined;
         | 
| 1599 | 
            +
                    inherit?: boolean | undefined;
         | 
| 1600 | 
            +
                }>;
         | 
| 1979 1601 | 
             
                _meta: {
         | 
| 1980 1602 | 
             
                    tables: Record<string, string>;
         | 
| 1981 1603 | 
             
                    columns: Record<string, string>;
         |