drizzle-kit 0.25.0-a5a41e0 → 0.25.0-a5ec472
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 +96 -473
- package/api.d.ts +96 -473
- package/api.js +16882 -96380
- package/api.mjs +16913 -96407
- package/bin.cjs +1673 -1677
- package/common-DYjgLS6u.d.mts +8 -0
- package/common-DYjgLS6u.d.ts +8 -0
- package/index.d.mts +9 -5
- package/index.d.ts +9 -5
- package/package.json +3 -3
- package/utils.js +37 -51
- package/utils.mjs +36 -51
    
        package/api.d.mts
    CHANGED
    
    | @@ -1,6 +1,7 @@ | |
| 1 1 | 
             
            import { LibSQLDatabase } from 'drizzle-orm/libsql';
         | 
| 2 2 | 
             
            import { MySql2Database } from 'drizzle-orm/mysql2';
         | 
| 3 3 | 
             
            import { PgDatabase } from 'drizzle-orm/pg-core';
         | 
| 4 | 
            +
            import { C as CasingType } from './common-DYjgLS6u.mjs';
         | 
| 4 5 | 
             
            import * as zod from 'zod';
         | 
| 5 6 | 
             
            import { TypeOf } from 'zod';
         | 
| 6 7 |  | 
| @@ -613,6 +614,28 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 613 614 | 
             
                        columns: string[];
         | 
| 614 615 | 
             
                        nullsNotDistinct: boolean;
         | 
| 615 616 | 
             
                    }>>>;
         | 
| 617 | 
            +
                    policies: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 618 | 
            +
                        name: zod.ZodString;
         | 
| 619 | 
            +
                        as: zod.ZodOptional<zod.ZodEnum<["PERMISSIVE", "RESTRICTIVE"]>>;
         | 
| 620 | 
            +
                        for: zod.ZodOptional<zod.ZodEnum<["ALL", "SELECT", "INSERT", "UPDATE", "DELETE"]>>;
         | 
| 621 | 
            +
                        to: zod.ZodOptional<zod.ZodArray<zod.ZodString, "many">>;
         | 
| 622 | 
            +
                        using: zod.ZodOptional<zod.ZodString>;
         | 
| 623 | 
            +
                        withCheck: zod.ZodOptional<zod.ZodString>;
         | 
| 624 | 
            +
                    }, "strict", zod.ZodTypeAny, {
         | 
| 625 | 
            +
                        name: string;
         | 
| 626 | 
            +
                        using?: string | undefined;
         | 
| 627 | 
            +
                        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
         | 
| 628 | 
            +
                        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
         | 
| 629 | 
            +
                        to?: string[] | undefined;
         | 
| 630 | 
            +
                        withCheck?: string | undefined;
         | 
| 631 | 
            +
                    }, {
         | 
| 632 | 
            +
                        name: string;
         | 
| 633 | 
            +
                        using?: string | undefined;
         | 
| 634 | 
            +
                        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
         | 
| 635 | 
            +
                        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
         | 
| 636 | 
            +
                        to?: string[] | undefined;
         | 
| 637 | 
            +
                        withCheck?: string | undefined;
         | 
| 638 | 
            +
                    }>>>;
         | 
| 616 639 | 
             
                }, "strict", zod.ZodTypeAny, {
         | 
| 617 640 | 
             
                    name: string;
         | 
| 618 641 | 
             
                    columns: Record<string, {
         | 
| @@ -676,6 +699,14 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 676 699 | 
             
                        columns: string[];
         | 
| 677 700 | 
             
                        nullsNotDistinct: boolean;
         | 
| 678 701 | 
             
                    }>;
         | 
| 702 | 
            +
                    policies: Record<string, {
         | 
| 703 | 
            +
                        name: string;
         | 
| 704 | 
            +
                        using?: string | undefined;
         | 
| 705 | 
            +
                        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
         | 
| 706 | 
            +
                        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
         | 
| 707 | 
            +
                        to?: string[] | undefined;
         | 
| 708 | 
            +
                        withCheck?: string | undefined;
         | 
| 709 | 
            +
                    }>;
         | 
| 679 710 | 
             
                }, {
         | 
| 680 711 | 
             
                    name: string;
         | 
| 681 712 | 
             
                    columns: Record<string, {
         | 
| @@ -739,6 +770,14 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 739 770 | 
             
                        columns: string[];
         | 
| 740 771 | 
             
                        nullsNotDistinct: boolean;
         | 
| 741 772 | 
             
                    }> | undefined;
         | 
| 773 | 
            +
                    policies?: Record<string, {
         | 
| 774 | 
            +
                        name: string;
         | 
| 775 | 
            +
                        using?: string | undefined;
         | 
| 776 | 
            +
                        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
         | 
| 777 | 
            +
                        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
         | 
| 778 | 
            +
                        to?: string[] | undefined;
         | 
| 779 | 
            +
                        withCheck?: string | undefined;
         | 
| 780 | 
            +
                    }> | undefined;
         | 
| 742 781 | 
             
                }>>;
         | 
| 743 782 | 
             
                enums: zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 744 783 | 
             
                    name: zod.ZodString;
         | 
| @@ -754,303 +793,6 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 754 793 | 
             
                    schema: string;
         | 
| 755 794 | 
             
                }>>;
         | 
| 756 795 | 
             
                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 796 | 
             
                sequences: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 1055 797 | 
             
                    name: zod.ZodString;
         | 
| 1056 798 | 
             
                    increment: zod.ZodOptional<zod.ZodString>;
         | 
| @@ -1079,6 +821,22 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1079 821 | 
             
                    cache?: string | undefined;
         | 
| 1080 822 | 
             
                    cycle?: boolean | undefined;
         | 
| 1081 823 | 
             
                }>>>;
         | 
| 824 | 
            +
                roles: zod.ZodDefault<zod.ZodRecord<zod.ZodString, zod.ZodObject<{
         | 
| 825 | 
            +
                    name: zod.ZodString;
         | 
| 826 | 
            +
                    createDb: zod.ZodOptional<zod.ZodBoolean>;
         | 
| 827 | 
            +
                    createRole: zod.ZodOptional<zod.ZodBoolean>;
         | 
| 828 | 
            +
                    inherit: zod.ZodOptional<zod.ZodBoolean>;
         | 
| 829 | 
            +
                }, "strict", zod.ZodTypeAny, {
         | 
| 830 | 
            +
                    name: string;
         | 
| 831 | 
            +
                    createDb?: boolean | undefined;
         | 
| 832 | 
            +
                    createRole?: boolean | undefined;
         | 
| 833 | 
            +
                    inherit?: boolean | undefined;
         | 
| 834 | 
            +
                }, {
         | 
| 835 | 
            +
                    name: string;
         | 
| 836 | 
            +
                    createDb?: boolean | undefined;
         | 
| 837 | 
            +
                    createRole?: boolean | undefined;
         | 
| 838 | 
            +
                    inherit?: boolean | undefined;
         | 
| 839 | 
            +
                }>>>;
         | 
| 1082 840 | 
             
                _meta: zod.ZodObject<{
         | 
| 1083 841 | 
             
                    schemas: zod.ZodRecord<zod.ZodString, zod.ZodString>;
         | 
| 1084 842 | 
             
                    tables: zod.ZodRecord<zod.ZodString, zod.ZodString>;
         | 
| @@ -1211,6 +969,14 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1211 969 | 
             
                        columns: string[];
         | 
| 1212 970 | 
             
                        nullsNotDistinct: boolean;
         | 
| 1213 971 | 
             
                    }>;
         | 
| 972 | 
            +
                    policies: Record<string, {
         | 
| 973 | 
            +
                        name: string;
         | 
| 974 | 
            +
                        using?: string | undefined;
         | 
| 975 | 
            +
                        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
         | 
| 976 | 
            +
                        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
         | 
| 977 | 
            +
                        to?: string[] | undefined;
         | 
| 978 | 
            +
                        withCheck?: string | undefined;
         | 
| 979 | 
            +
                    }>;
         | 
| 1214 980 | 
             
                }>;
         | 
| 1215 981 | 
             
                id: string;
         | 
| 1216 982 | 
             
                prevId: string;
         | 
| @@ -1237,64 +1003,11 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1237 1003 | 
             
                    cache?: string | undefined;
         | 
| 1238 1004 | 
             
                    cycle?: boolean | undefined;
         | 
| 1239 1005 | 
             
                }>;
         | 
| 1240 | 
            -
                 | 
| 1006 | 
            +
                roles: Record<string, {
         | 
| 1241 1007 | 
             
                    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;
         | 
| 1008 | 
            +
                    createDb?: boolean | undefined;
         | 
| 1009 | 
            +
                    createRole?: boolean | undefined;
         | 
| 1010 | 
            +
                    inherit?: boolean | undefined;
         | 
| 1298 1011 | 
             
                }>;
         | 
| 1299 1012 | 
             
                internal?: {
         | 
| 1300 1013 | 
             
                    tables: Record<string, {
         | 
| @@ -1370,6 +1083,14 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1370 1083 | 
             
                        columns: string[];
         | 
| 1371 1084 | 
             
                        nullsNotDistinct: boolean;
         | 
| 1372 1085 | 
             
                    }> | undefined;
         | 
| 1086 | 
            +
                    policies?: Record<string, {
         | 
| 1087 | 
            +
                        name: string;
         | 
| 1088 | 
            +
                        using?: string | undefined;
         | 
| 1089 | 
            +
                        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
         | 
| 1090 | 
            +
                        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
         | 
| 1091 | 
            +
                        to?: string[] | undefined;
         | 
| 1092 | 
            +
                        withCheck?: string | undefined;
         | 
| 1093 | 
            +
                    }> | undefined;
         | 
| 1373 1094 | 
             
                }>;
         | 
| 1374 1095 | 
             
                id: string;
         | 
| 1375 1096 | 
             
                prevId: string;
         | 
| @@ -1406,64 +1127,11 @@ declare const pgSchema: zod.ZodObject<zod.objectUtil.extendShape<{ | |
| 1406 1127 | 
             
                    cache?: string | undefined;
         | 
| 1407 1128 | 
             
                    cycle?: boolean | undefined;
         | 
| 1408 1129 | 
             
                }> | undefined;
         | 
| 1409 | 
            -
                 | 
| 1130 | 
            +
                roles?: Record<string, {
         | 
| 1410 1131 | 
             
                    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;
         | 
| 1132 | 
            +
                    createDb?: boolean | undefined;
         | 
| 1133 | 
            +
                    createRole?: boolean | undefined;
         | 
| 1134 | 
            +
                    inherit?: boolean | undefined;
         | 
| 1467 1135 | 
             
                }> | undefined;
         | 
| 1468 1136 | 
             
            }>;
         | 
| 1469 1137 | 
             
            type PgSchema = TypeOf<typeof pgSchema>;
         | 
| @@ -1810,7 +1478,7 @@ type SQLiteSchema = TypeOf<typeof schema>; | |
| 1810 1478 | 
             
            type DrizzleSnapshotJSON = PgSchema;
         | 
| 1811 1479 | 
             
            type DrizzleSQLiteSnapshotJSON = SQLiteSchema;
         | 
| 1812 1480 | 
             
            type DrizzleMySQLSnapshotJSON = MySqlSchema;
         | 
| 1813 | 
            -
            declare const generateDrizzleJson: (imports: Record<string, unknown>, prevId?: string, schemaFilters?: string[]) => PgSchema;
         | 
| 1481 | 
            +
            declare const generateDrizzleJson: (imports: Record<string, unknown>, prevId?: string, schemaFilters?: string[], casing?: CasingType) => PgSchema;
         | 
| 1814 1482 | 
             
            declare const generateMigration: (prev: DrizzleSnapshotJSON, cur: DrizzleSnapshotJSON) => Promise<string[]>;
         | 
| 1815 1483 | 
             
            declare const pushSchema: (imports: Record<string, unknown>, drizzleInstance: PgDatabase<any>, schemaFilters?: string[]) => Promise<{
         | 
| 1816 1484 | 
             
                hasDataLoss: boolean;
         | 
| @@ -1818,7 +1486,7 @@ declare const pushSchema: (imports: Record<string, unknown>, drizzleInstance: Pg | |
| 1818 1486 | 
             
                statementsToExecute: string[];
         | 
| 1819 1487 | 
             
                apply: () => Promise<void>;
         | 
| 1820 1488 | 
             
            }>;
         | 
| 1821 | 
            -
            declare const generateSQLiteDrizzleJson: (imports: Record<string, unknown>, prevId?: string) => Promise<SQLiteSchema>;
         | 
| 1489 | 
            +
            declare const generateSQLiteDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<SQLiteSchema>;
         | 
| 1822 1490 | 
             
            declare const generateSQLiteMigration: (prev: DrizzleSQLiteSnapshotJSON, cur: DrizzleSQLiteSnapshotJSON) => Promise<string[]>;
         | 
| 1823 1491 | 
             
            declare const pushSQLiteSchema: (imports: Record<string, unknown>, drizzleInstance: LibSQLDatabase<any>) => Promise<{
         | 
| 1824 1492 | 
             
                hasDataLoss: boolean;
         | 
| @@ -1826,7 +1494,7 @@ declare const pushSQLiteSchema: (imports: Record<string, unknown>, drizzleInstan | |
| 1826 1494 | 
             
                statementsToExecute: string[];
         | 
| 1827 1495 | 
             
                apply: () => Promise<void>;
         | 
| 1828 1496 | 
             
            }>;
         | 
| 1829 | 
            -
            declare const generateMySQLDrizzleJson: (imports: Record<string, unknown>, prevId?: string) => Promise<MySqlSchema>;
         | 
| 1497 | 
            +
            declare const generateMySQLDrizzleJson: (imports: Record<string, unknown>, prevId?: string, casing?: CasingType) => Promise<MySqlSchema>;
         | 
| 1830 1498 | 
             
            declare const generateMySQLMigration: (prev: DrizzleMySQLSnapshotJSON, cur: DrizzleMySQLSnapshotJSON) => Promise<string[]>;
         | 
| 1831 1499 | 
             
            declare const pushMySQLSchema: (imports: Record<string, unknown>, drizzleInstance: MySql2Database<any>, databaseName: string) => Promise<{
         | 
| 1832 1500 | 
             
                hasDataLoss: boolean;
         | 
| @@ -1900,6 +1568,14 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => { | |
| 1900 1568 | 
             
                        columns: string[];
         | 
| 1901 1569 | 
             
                        nullsNotDistinct: boolean;
         | 
| 1902 1570 | 
             
                    }>;
         | 
| 1571 | 
            +
                    policies: Record<string, {
         | 
| 1572 | 
            +
                        name: string;
         | 
| 1573 | 
            +
                        as?: "PERMISSIVE" | "RESTRICTIVE" | undefined;
         | 
| 1574 | 
            +
                        for?: "ALL" | "SELECT" | "INSERT" | "UPDATE" | "DELETE" | undefined;
         | 
| 1575 | 
            +
                        to?: string[] | undefined;
         | 
| 1576 | 
            +
                        using?: string | undefined;
         | 
| 1577 | 
            +
                        withCheck?: string | undefined;
         | 
| 1578 | 
            +
                    }>;
         | 
| 1903 1579 | 
             
                }>;
         | 
| 1904 1580 | 
             
                enums: Record<string, {
         | 
| 1905 1581 | 
             
                    values: string[];
         | 
| @@ -1907,65 +1583,6 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => { | |
| 1907 1583 | 
             
                    schema: string;
         | 
| 1908 1584 | 
             
                }>;
         | 
| 1909 1585 | 
             
                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 1586 | 
             
                sequences: Record<string, {
         | 
| 1970 1587 | 
             
                    name: string;
         | 
| 1971 1588 | 
             
                    schema: string;
         | 
| @@ -1976,6 +1593,12 @@ declare const upPgSnapshot: (snapshot: Record<string, unknown>) => { | |
| 1976 1593 | 
             
                    cache?: string | undefined;
         | 
| 1977 1594 | 
             
                    cycle?: boolean | undefined;
         | 
| 1978 1595 | 
             
                }>;
         | 
| 1596 | 
            +
                roles: Record<string, {
         | 
| 1597 | 
            +
                    name: string;
         | 
| 1598 | 
            +
                    createDb?: boolean | undefined;
         | 
| 1599 | 
            +
                    createRole?: boolean | undefined;
         | 
| 1600 | 
            +
                    inherit?: boolean | undefined;
         | 
| 1601 | 
            +
                }>;
         | 
| 1979 1602 | 
             
                _meta: {
         | 
| 1980 1603 | 
             
                    tables: Record<string, string>;
         | 
| 1981 1604 | 
             
                    columns: Record<string, string>;
         |