import type { TFunction } from 'i18next';
import type { IAbstractModel, IAbstractModelMethods } from '../modules/AbstractModel.ts';
import AbstractModel from '../modules/AbstractModel.ts';
import type { IApp } from '../server.ts';
interface IUser {
    avatar: string;
    name: {
        first: string;
        last: string;
        nick: string;
    };
    password: string;
    email: string;
    sessionTokens: {
        token: string;
        valid: Date;
    }[];
    verificationTokens: {
        until: Date;
        token: string;
    }[];
    passwordRecoveryTokens: {
        until: Date;
        token: string;
    }[];
    permissions: string[];
    roles: string[];
    isVerified: boolean;
    locale: string;
    languages: string[];
    id?: string;
}
interface IStatic extends IAbstractModel<IUser, IAbstractModelMethods<IUser>> {
    getUserByEmailAndPassword(email: string, password: string): Promise<InstanceType<UserOld['mongooseModel']> | false>;
    hashPassword(password: string): Promise<string>;
    getUserByToken(token: string): Promise<InstanceType<UserOld['mongooseModel']> | false>;
    getUserByEmail(email: string): Promise<InstanceType<UserOld['mongooseModel']> | false>;
    getUserByPasswordRecoveryToken(token: string): Promise<InstanceType<UserOld['mongooseModel']> | false>;
    generateUserPasswordRecoveryToken(user: InstanceType<UserOld['mongooseModel']>): Promise<{
        token: string;
        until: Date;
    }>;
    getUserByVerificationToken(token: string): Promise<InstanceType<UserOld['mongooseModel']> | false>;
    generateUserVerificationToken(user: InstanceType<UserOld['mongooseModel']>): Promise<{
        token: string;
        until: Date;
    }>;
}
/**
 * @deprecated use User Model instead of UserOld
 */
declare class UserOld extends AbstractModel<IUser, IAbstractModelMethods<IUser>, IStatic> {
    constructor(app: IApp);
    initHooks(): void;
    get modelSchema(): {
        avatar: {
            type: StringConstructor;
            maxlength: number;
        };
        name: {
            first: {
                type: StringConstructor;
                maxlength: number;
            };
            last: {
                type: StringConstructor;
                maxlength: number;
            };
            nick: {
                minlength: number;
                maxlength: number;
                type: StringConstructor;
                index: {
                    unique: boolean;
                    partialFilterExpression: {
                        'name.nick': {
                            $type: string;
                        };
                    };
                };
            };
        };
        password: StringConstructor;
        email: {
            type: StringConstructor;
            maxlength: number;
            index: {
                unique: boolean;
                partialFilterExpression: {
                    email: {
                        $type: string;
                    };
                };
            };
        };
        sessionTokens: {
            token: StringConstructor;
            valid: DateConstructor;
        }[];
        verificationTokens: {
            until: DateConstructor;
            token: StringConstructor;
        }[];
        passwordRecoveryTokens: {
            until: DateConstructor;
            token: StringConstructor;
        }[];
        permissions: never[];
        roles: never[];
        isVerified: {
            type: BooleanConstructor;
            default: boolean;
        };
        locale: {
            type: StringConstructor;
            default: string;
        };
        languages: StringConstructor[];
    };
    static getUserByEmailAndPassword(this: UserOld['mongooseModel'], email: string, password: string): Promise<false | (import("mongoose").Document<unknown, object, IUser, {}, import("mongoose").DefaultSchemaOptions> & Omit<IUser & {
        _id: import("mongoose").Types.ObjectId;
    } & {
        __v: number;
    }, "getSuper"> & IAbstractModelMethods<IUser>)>;
    generateToken(this: InstanceType<UserOld['mongooseModel']>): Promise<{
        token: string;
        valid: Date;
    }>;
    getPublic(this: InstanceType<UserOld['mongooseModel']>): {
        avatar: string;
        name: {
            first: string;
            last: string;
            nick: string;
        };
        email: string;
        id: string | undefined;
        isVerified: boolean;
        permissions: string[];
        locale: string;
    };
    static hashPassword(this: UserOld['mongooseModel'], password: string): Promise<string>;
    static getUserByToken(this: UserOld['mongooseModel'], token: string): Promise<false | (import("mongoose").Document<unknown, object, IUser, {}, import("mongoose").DefaultSchemaOptions> & Omit<IUser & {
        _id: import("mongoose").Types.ObjectId;
    } & {
        __v: number;
    }, "getSuper"> & IAbstractModelMethods<IUser>)>;
    static getUserByEmail(this: UserOld['mongooseModel'], email: string): Promise<false | (import("mongoose").Document<unknown, object, IUser, {}, import("mongoose").DefaultSchemaOptions> & Omit<IUser & {
        _id: import("mongoose").Types.ObjectId;
    } & {
        __v: number;
    }, "getSuper"> & IAbstractModelMethods<IUser>)>;
    static generateUserPasswordRecoveryToken(userMongoose: InstanceType<UserOld['mongooseModel']>): Promise<{
        token: string;
        until: number;
    }>;
    static getUserByPasswordRecoveryToken(this: UserOld['mongooseModel'], passwordRecoveryToken: string): Promise<import("mongoose").Document<unknown, object, IUser, {}, import("mongoose").DefaultSchemaOptions> & Omit<IUser & {
        _id: import("mongoose").Types.ObjectId;
    } & {
        __v: number;
    }, "getSuper"> & IAbstractModelMethods<IUser>>;
    sendPasswordRecoveryEmail(this: InstanceType<UserOld['mongooseModel']>, i18n: {
        t: TFunction;
        language: string;
    }): Promise<any>;
    static generateUserVerificationToken(userMongoose: InstanceType<UserOld['mongooseModel']>): Promise<{
        token: string;
        until: number;
    }>;
    static getUserByVerificationToken(this: UserOld['mongooseModel'], verificationToken: string): Promise<import("mongoose").Document<unknown, object, IUser, {}, import("mongoose").DefaultSchemaOptions> & Omit<IUser & {
        _id: import("mongoose").Types.ObjectId;
    } & {
        __v: number;
    }, "getSuper"> & IAbstractModelMethods<IUser>>;
    sendVerificationEmail(this: InstanceType<UserOld['mongooseModel']>, i18n: {
        t: TFunction;
        language: string;
    }): Promise<any>;
}
export default UserOld;