@ztimson/momentum/dist/auth.d.ts

Client library for momentum

import { Api } from './api';
import { PathEvent, PathEventEmitter } from '@ztimson/utils';
import { Meta } from './core';
import { User } from './users';
export type AuthOptions = {
    /** Path to login page */
    loginUrl?: string;
};
export type UserToken = Meta & {
    /** User defined name */
    name: string;
    /** Assigned to */
    owner: string;
    /** Token value */
    token: string;
    /** Expiration */
    expire: null | Date;
};
/** Manage user tokens */
export declare class Token extends PathEventEmitter {
    private api;
    constructor(api: Api);
    /**
     * Fetch all tokens for user
     * @param {string} username User to search
     * @return {Promise<UserToken[]>} List of tokens
     */
    all(username: string): Promise<UserToken[]>;
    /**
     * Create a new user token
     * @param {{name: string, owner: string, expire: null | Date}} token Token settings
     * @return {Promise<UserToken>} Crated token
     */
    create(token: {
        name: string;
        owner: string;
        expire: null | Date;
    }): Promise<UserToken>;
    /**
     * Delete an existing user token
     * @param {string} id Token ID
     * @return {Promise<void>} Resolves once complete
     */
    delete(id: string): Promise<void>;
}
/** Mange user 2FA */
export declare class Totp {
    private api;
    constructor(api: Api);
    /**
     * Disable 2FA for user
     * @param {string} username User to disable 2FA for
     * @return {Promise<void>} Resolves once complete
     */
    disable(username: string): import('@ztimson/utils').PromiseProgress<void>;
    /**
     * Enable 2FA for user
     * @param {string} username User to reset
     * @return {Promise<void>} Resolves once complete
     */
    enable: (username: string) => Promise<void>;
    /**
     * Reset users 2FA
     * @param {string} username User to reset
     * @return {Promise<void>} Resolves once complete
     */
    reset(username: string): Promise<void>;
    /**
     * Setup 2FA authentication method
     * @param {string} username User to setup
     * @param {string} method Authenticator type
     * @param {string | null} totp null to being process, 2FA code to validate method
     * @return {Promise<void>} Resolves once complete
     */
    setup(username: string, method?: string, totp?: string): import('@ztimson/utils').PromiseProgress<void>;
}
/** Manage User Authentication */
export declare class Auth extends PathEventEmitter {
    private readonly opts;
    private readonly api;
    /** Manage user tokens */
    token: Token;
    /** Manage user 2FA */
    totp: Totp;
    private _permissions;
    /** Get current user permissions */
    get permissions(): string[];
    private set permissions(value);
    private _user?;
    /** Get current user, undefined if not yet initialized */
    get user(): User | null | undefined;
    /** Update user info without changing the session */
    set user(user: User | null | undefined);
    constructor(api: Api | string, opts?: AuthOptions);
    filter: (...events: (string | PathEvent)[]) => PathEvent[];
    has: (...events: (string | PathEvent)[]) => boolean;
    hasAll: (...events: (string | PathEvent)[]) => boolean;
    hasFatal: (...events: (string | PathEvent)[]) => void;
    hasAllFatal: (...events: (string | PathEvent)[]) => void;
    /**
     * Check if origin is recognized & whitelisted
     * @param {string} host Origin to check
     * @return {Promise<void>} Resolves in known, 401 code otherwise
     */
    knownHost(host?: string): Promise<void>;
    /**
     * Login a user & return the account
     * @param {string} username username
     * @param {string} password user's password
     * @param {{totp: string, expire: null | number | Date}} opts 2FA code and expiry options (null to never expire)
     * @return {Promise<User | null>} User account on success
     */
    login(username: string, password: string, opts?: {
        totp?: string;
        expire?: number | Date | null;
    }): Promise<User | null>;
    /**
     * Login via Momentum single sign on
     * @param {string} host Host origin attempting to login
     * @return {Promise<string>} Token on success
     */
    loginRedirect(host?: string): Promise<string>;
    /**
     * Logout current user
     */
    logout(): void;
    /**
     * Create a new user with login
     * @param {Partial<User> & {password: string}} user User data with password
     * @return {Promise<User>} Registered user data
     */
    register(user: Partial<User> & {
        username: string;
        password: string;
    }): Promise<User>;
    /**
     * Finish user account reset
     * @param password New password
     * @param token Reset token
     * @return {Promise<void>} Resolves once complete
     */
    reset(password: string, token?: string): Promise<void>;
    /**
     * Initiate user account reset
     * @param email New password
     * @return {Promise<void>} Resolves once complete
     */
    reset(email: string): Promise<void>;
    /**
     * Get session information
     * @param {string} token Token to fetch session info for
     * @param {boolean} set Set as current active session
     * @return {Promise<{token: string, user: User, permissions: string[], custom: any} | null>} Session information
     */
    session(token?: string, set?: boolean): Promise<{
        token: string;
        user: User;
        permissions: string[];
        custom: any;
    } | null>;
    /**
     * Update password for user
     * @param {string} username User to reset
     * @param {string} password New user password
     * @param {string} oldPassword Old password for validation
     * @return {Promise<void>} Resolves once complete
     */
    updatePassword(username: string, password: string, oldPassword?: string): Promise<void>;
}
//# sourceMappingURL=auth.d.ts.map