import { Helpers } from './helpers';
import { LogInstance } from 'larvitutils';
import { UserBase } from './userBase';
import { Users, UsersOptions } from './users';
export { Users } from './users';
export { UserBase } from './userBase';
export type UserLibOptions = {
    db: any;
    log?: LogInstance;
};
export type HistoricFieldData = {
    fieldData: string;
    timestamp: string;
};
export declare class UserLib {
    helpers: Helpers;
    private dataWriter;
    private log;
    private lUtils;
    private options;
    constructor(options: UserLibOptions);
    runDbMigrations(scriptPath?: string): Promise<void>;
    /**
     * Add a single user field to database
     *
     * @param {string} userUuid -
     * @param {string} fieldName -
     * @param {string} fieldValue -
     * @returns {Promise<void>} -
     */
    addUserDataField(userUuid: string, fieldName: string, fieldValue: string | string[]): Promise<void>;
    /**
     * Add user fields
     *
     * @param {string} userUuid -
     * @param {object} fields - field name as key, field values as array to that key - ex: {'role': ['admin','user']}
     * @returns {Promise<void>} -
     */
    addUserDataFields(userUuid: string, fields: Record<string, string | string[]>): Promise<void>;
    /**
     * Checks a password for validity
     * @param {string} password - plain text password
     * @param {string} hash - hash to check password against
     * @param {Promise<boolean>} - True if password matches
     */
    checkPassword(password: string, hash: string): Promise<boolean>;
    /**
     * Creates a new user (and adds to it to db)
     *
     * @param {string} username -
     * @param {string} password (plain text) or false for no password (user will not be able to login at all)
     * @param {object} userFields - key, value pairs, where value can be an array of values
     * @param {string} uuid - if not supplied a random will be generated
     * @returns {Promise<UserBase>} - The newly created user
     */
    create(username: string, password: string | boolean, userFields?: Record<string, string | string[]>, uuid?: string): Promise<UserBase>;
    /**
     * Checks if a unsername is available
     *
     * @param {string} username -
     * @returns {Promise<boolean>} -
     */
    usernameAvailable(username: string): Promise<boolean>;
    /**
     * Create a user object from a field
     * IMPORTANT! Only fetches first matching user!
     *
     * @param {string} fieldName -
     * @param {string} fieldValue -
     * @returns {Promise<UserBase | boolean>} - "user" being a new user object or boolean false on failed search
     */
    fromField(fieldName: string, fieldValue: string): Promise<UserBase | boolean>;
    /**
     * Create a user object from fields
     * IMPORTANT! Only fetches first matching user that matches all fields!
     *
     * @param {object} fields - {'fieldName': 'fieldValue', 'fieldName2': 'fieldValue2'}
     * @returns {Promise<UserBase | false>} - "user" being a new user object or boolean false on failed search
     */
    fromFields(fields: Record<string, string>): Promise<UserBase | boolean>;
    /**
     * Create a user object from username and password
     *
     * @param {string} username -
     * @param {string} password -
     * @returns {Promise<UserBase | boolean>} - "user" being a new user object or boolean false on failed login
     */
    fromUserAndPass(username: string, password: string): Promise<UserBase | boolean>;
    /**
     * Create a user object from username
     *
     * @param {string} username -
     * @returns {Promise<UserBase | boolean>} - "user" being a new user object
     */
    fromUsername(username: string): Promise<UserBase | boolean>;
    /**
     * Verify that a user exists in the database
     *
     * @param {string} userUuid - User UUID to check
     * @returns {Promise<boolean>} - True if user exists, false if not
     */
    userExists(userUuid: string): Promise<boolean>;
    /**
     * Instanciate user object from user id
     *
     * @param {number} userUuid -
     * @param {boolean} includeInactive - If true, will also load inactive users
     * @returns {Promise<UserBase>} userObj will be false if no user is found
     */
    fromUuid(userUuid: string, includeInactive?: boolean): Promise<UserBase | false>;
    /**
     * Get historic field data from user id
     *
     * @param {number} userUuid -
     * @param {date} [start] - Date object - Will show all historic changes if omitted. Will show all historic changes from start until now if used without end
     * @param {date} [end] - Date object - Must be used together with start
     * @returns {Promise<HistoricFieldData>} Historic field changes, will be false if no user is found
     */
    getHistoricFieldDataFromUuid(userUuid: string, start?: Date, end?: Date): Promise<Record<string, HistoricFieldData[]> | false>;
    /**
     * Remove historic field data
     *
     * @param {string} timestamp - Timestamp - Removes history up until this point in time. If omitted, all historic field data will be removed.
     * @returns {Promise<void>} -
     */
    rmHistoricFieldData(timestamp?: string): Promise<void>;
    /**
     * Get field data for a user
     *
     * @param {string} userUuid -
     * @param {string} fieldName -
     * @returns {Promise<string[]>} data is always an array of data (or empty array)
     */
    getFieldData(userUuid: string, fieldName: string): Promise<string[]>;
    /**
     * Hashes a new password
     *
     * @param {string} password -
     * @returns {Promise<string>} Hashed password
     */
    hashPassword(password: string): Promise<string>;
    /**
     * Replace all fields
     * IMPORTANT!!! Will clear all data not given in the fields parameter
     *
     * @param {string} userUuid -
     * @param {object} fields - field name as key, field values as array to that key - ex: {'role': ['admin','user']}
     * @returns {Promise<void>} -
     */
    replaceUserFields(userUuid: string, fields: Record<string, string | string[]>): Promise<void>;
    /**
     * Remove a user
     *
     * @param {string} userUuid -
     * @returns {Promise<void>} -
     */
    rmUser(userUuid: string): Promise<void>;
    /**
     * Remove a user field
     *
     * @param {string} userUuid -
     * @param {string} fieldName -
     * @returns {Promise<void>} -
     */
    rmUserField(userUuid: string, fieldName: string): Promise<void>;
    /**
     * Set password for a user
     *
     * @param {string} userUuid -
     * @param {string} newPassword (plain text) or false for no valid password (user will not be able to login at all)
     * @returns {Promise<void>} -
     */
    setPassword(userUuid: string, newPassword: string | boolean): Promise<void>;
    /**
     * Set the username for a user
     *
     * @param {string} userUuid -
     * @param {string} newUsername -
     * @returns {Promise<void>} -
     */
    setUsername(userUuid: string, newUsername: string): Promise<void>;
    /**
     * Set inactive for a user
     *
     * @param {string} userUuid -
     * @param {string} newInactive -
     * @returns {Promise<void>} -
     */
    setInactive(userUuid: string, newInactive: boolean): Promise<void>;
    getUsers(options?: Omit<UsersOptions, 'log' | 'db'>): ReturnType<Users['get']>;
}
//# sourceMappingURL=index.d.ts.map