declare const _default: {
    User: {
        name: string;
        define: {
            userName: {
                type: import("sequelize/types").StringDataTypeConstructor;
                allowNull: boolean;
                unique: boolean;
            };
            disabled: {
                type: import("sequelize/types").AbstractDataTypeConstructor;
                allowNull: boolean;
                defaultValue: boolean;
            };
            email: {
                type: import("sequelize/types").TextDataTypeConstructor;
                allowNull: boolean;
            };
            firstName: {
                type: import("sequelize/types").StringDataTypeConstructor;
                allowNull: boolean;
            };
            lastName: {
                type: import("sequelize/types").StringDataTypeConstructor;
                allowNull: boolean;
            };
        };
        relationships: ({
            type: string;
            model: string;
            name: string;
            options: {
                foreignKey: string;
                as?: undefined;
            };
        } | {
            type: string;
            model: string;
            name: string;
            options: {
                as: string;
                foreignKey: string;
            };
        })[];
        expose: {
            instanceMethods: {
                query: {
                    permissions: {
                        type: import("graphql").GraphQLList<import("graphql").GraphQLObjectType<any, any>>;
                    };
                };
            };
            classMethods: {
                query: {
                    getCurrentUser: {
                        type: string;
                        args: {};
                    };
                    getPermissions: {
                        type: import("graphql").GraphQLList<import("graphql").GraphQLObjectType<any, any>>;
                        args: {};
                    };
                    isLoggedIn: {
                        type: import("graphql").GraphQLScalarType<boolean, boolean>;
                        args: {};
                    };
                };
                mutations: {
                    login: {
                        type: import("graphql").GraphQLScalarType<boolean, boolean>;
                        args: {
                            userName: {
                                type: import("graphql").GraphQLScalarType<string, string>;
                            };
                            password: {
                                type: import("graphql").GraphQLScalarType<string, string>;
                            };
                            captcha: {
                                type: import("graphql").GraphQLScalarType<string, string>;
                            };
                        };
                    };
                    register: {
                        type: string;
                        args: {
                            input: {
                                type: import("graphql").GraphQLInputObjectType;
                            };
                        };
                    };
                    logout: {
                        type: import("graphql").GraphQLScalarType<boolean, boolean>;
                    };
                    getToken: {
                        type: import("graphql").GraphQLScalarType<string, string>;
                        args: {
                            userName: {
                                type: import("graphql").GraphQLScalarType<string, string>;
                            };
                            password: {
                                type: import("graphql").GraphQLScalarType<string, string>;
                            };
                        };
                    };
                };
            };
        };
        options: {
            tableName: string;
            indexes: ({
                unique: boolean;
                fields: string[];
            } | {
                fields: string[];
                unique?: undefined;
            })[];
            hooks: {
                beforeValidate: ((model: {
                    id?: any;
                    userName: any;
                }, options?: {}) => Promise<{
                    id?: any;
                    userName: any;
                }>)[];
                beforeFind: ((options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<import("@vostro/c2-utils/lib/types").C2Utils.FindOptions>)[];
                beforeCreate: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
                beforeUpdate: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
                beforeDestroy: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
            };
            classMethods: {
                getToken(args: {
                    userName: any;
                    password: any;
                }, context: any): Promise<any>;
                getCurrentUser(args: any, context: {
                    getUser: () => any;
                }): any;
                isLoggedIn(args: any, context: {
                    getUser: () => any;
                }): Promise<boolean>;
                login(args: {
                    userName: any;
                    password: any;
                    captcha: any;
                    doNotLogin?: boolean | undefined;
                }, context: any): Promise<boolean>;
                loginWithUser({ userName, password, doNotLogin, }: {
                    userName: string;
                    password: string;
                    doNotLogin?: boolean | undefined;
                }, context: any): Promise<any>;
                register({ input, }: any, context: {
                    getRequest: () => any;
                    override: any;
                    login: (arg0: any) => any;
                }): Promise<any>;
                logout(args: any, context: import("@vostro/c2-utils/lib/types").C2Utils.DataContext): Promise<false | void>;
                getPermissions(args: any, context: import("@vostro/c2-utils/lib/types").C2Utils.DataContext): Promise<any>;
            };
            instanceMethods: {
                permission(this: any, args: any, context: import("@vostro/c2-utils/lib/types").C2Utils.DataContext): Promise<any>;
            };
        };
    };
    UserAuth: {
        name: string;
        comment: string;
        comments: {
            fields: {
                name: string;
                type: string;
                token: string;
            };
        };
        define: {
            name: {
                type: import("sequelize/types").StringDataTypeConstructor;
                allowNull: boolean;
                comment: string;
            };
            type: {
                type: import("sequelize/types").StringDataTypeConstructor;
                allowNull: boolean;
                comment: string;
            };
            token: {
                type: import("sequelize/types").TextDataTypeConstructor;
                allowNull: boolean;
                comment: string;
            };
        };
        relationships: {
            type: string;
            model: string;
            name: string;
            options: {
                foreignKey: string;
                target: string;
            };
        }[];
        options: {
            tableName: string;
            indexes: {
                unique: boolean;
                fields: string[];
            }[];
            hooks: {
                beforeFind: ((options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<import("@vostro/c2-utils/lib/types").C2Utils.FindOptions>)[];
                beforeCreate: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
                beforeUpdate: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
                beforeDestroy: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
                afterFind: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
            };
            classMethods: {};
            instanceMethods: {};
        };
    };
    Role: {
        name: string;
        comment: string;
        comments: {
            fields: {
                name: string;
                user: string;
                rolePermission: string;
                roleId: string;
            };
        };
        define: {
            name: {
                type: import("sequelize/types").StringDataTypeConstructor;
                allowNull: boolean;
                comment: string;
            };
        };
        override: {};
        relationships: ({
            type: string;
            model: string;
            name: string;
            options: {
                foreignKey: string;
                as?: undefined;
                sourceKey?: undefined;
            };
        } | {
            type: string;
            model: string;
            name: string;
            options: {
                as: string;
                sourceKey: string;
                foreignKey: string;
            };
        })[];
        options: {
            tableName: string;
            hooks: {
                beforeFind: ((options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<import("@vostro/c2-utils/lib/types").C2Utils.FindOptions>)[];
                beforeCreate: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
                beforeUpdate: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
                beforeDestroy: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
            };
        };
    };
    Permission: {
        name: string;
        comment: string;
        comments: {
            fields: {
                name: string;
                type: string;
                rolesPermission: string;
                permissionId: string;
            };
        };
        define: {
            name: {
                type: import("sequelize/types").StringDataTypeConstructor;
                allowNull: boolean;
                comment: string;
            };
            type: {
                type: import("sequelize/types").EnumDataTypeConstructor;
                values: string[];
                allowNull: boolean;
                comment: string;
            };
        };
        override: {};
        relationships: {
            type: string;
            model: string;
            name: string;
            options: {
                as: string;
                sourceKey: string;
                foreignKey: string;
            };
        }[];
        options: {
            tableName: string;
            indexes: ({
                unique: boolean;
                fields: string[];
            } | {
                fields: string[];
                unique?: undefined;
            })[];
            hooks: {
                beforeFind: ((options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<import("@vostro/c2-utils/lib/types").C2Utils.FindOptions>)[];
                beforeCreate: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
                beforeUpdate: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
                beforeDestroy: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
            };
        };
    };
    RolePermission: {
        name: string;
        comment: string;
        comments: {
            fields: {
                level: string;
                role: string;
                permission: string;
                roleId: string;
                permissionId: string;
            };
        };
        define: {
            level: {
                type: import("sequelize/types").EnumDataTypeConstructor;
                values: string[];
                allowNull: boolean;
                defaultValue: string;
                comment: string;
            };
        };
        override: {};
        relationships: {
            type: string;
            model: string;
            name: string;
            options: {
                as: string;
                foreignKey: string;
            };
        }[];
        options: {
            tableName: string;
            indexes: {
                unique: boolean;
                fields: string[];
            }[];
            hooks: {
                beforeFind: ((options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<import("@vostro/c2-utils/lib/types").C2Utils.FindOptions>)[];
                beforeCreate: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
                beforeUpdate: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
                beforeDestroy: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
            };
        };
    };
    EventLog: {
        name: string;
        define: {
            action: {
                type: import("sequelize/types").StringDataTypeConstructor;
                allowNull: boolean;
            };
            description: {
                type: import("sequelize/types").StringDataTypeConstructor;
            };
            changeset: {
                type: import("sequelize/types").AbstractDataTypeConstructor;
            };
            source: {
                type: import("sequelize/types").StringDataTypeConstructor;
            };
            model: {
                type: import("sequelize/types").StringDataTypeConstructor;
            };
        };
        relationships: {
            type: string;
            model: string;
            name: string;
            options: {
                foreignKey: string;
                target: string;
            };
        }[];
        override: {
            changeset: {
                type: {
                    name: string;
                    fields: {
                        previous: {
                            type: import("graphql").GraphQLScalarType<any, unknown>;
                        };
                        current: {
                            type: import("graphql").GraphQLScalarType<any, unknown>;
                        };
                    };
                };
                output(result: any): any;
                input(_field: any): never;
            };
        };
        options: {
            tableName: string;
            classMethods: {};
            instanceMethods: {};
            hooks: {
                beforeFind: ((options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<import("@vostro/c2-utils/lib/types").C2Utils.FindOptions>)[];
                beforeCreate: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
                beforeUpdate: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
                beforeDestroy: ((instance: any, options: import("@vostro/c2-utils/lib/types").C2Utils.FindOptions) => Promise<any>)[];
            };
        };
        whereOperatorTypes: {
            changesetFind: import("graphql").GraphQLInputObjectType;
            descriptionFind: import("graphql").GraphQLInputObjectType;
        };
        whereOperators: {
            changesetFind(args: any): Promise<any>;
            descriptionFind(args: any): Promise<any>;
        };
    };
    Config: {
        name: string;
        comment: string;
        define: {
            type: {
                type: import("sequelize/types").EnumDataTypeConstructor;
                values: string[];
                allowNull: boolean;
                defaultValue: string;
                unique: boolean;
                comment: string;
            };
            config: {
                type: import("sequelize/types").AbstractDataTypeConstructor;
                defaultValue: {};
                allowNull: boolean;
                comment: string;
            };
        };
        options: {
            tableName: string;
        };
    };
};
export default _default;
//# sourceMappingURL=index.d.ts.map