unleash-server/dist/lib/services/user-service.d.ts

Unleash is an enterprise ready feature flag service. It provides different strategies for handling feature flags.

import type { URL } from 'url';
import { type IAuditUser, type IUser, type IUserWithRootRole } from '../types/user.js';
import type { AccessService } from './access-service.js';
import type ResetTokenService from './reset-token-service.js';
import type { EmailService } from './email-service.js';
import type { IAuthOption, IUnleashConfig, UsernameAdminUser } from '../types/option.js';
import type SessionService from './session-service.js';
import type { IUnleashStores } from '../types/stores.js';
import { RoleName } from '../types/model.js';
import type SettingService from './setting-service.js';
import type { TokenUserSchema } from '../openapi/index.js';
import type EventService from '../features/events/event-service.js';
export interface ICreateUserWithRole {
    name?: string;
    email?: string;
    username?: string;
    password?: string;
    rootRole: number | RoleName;
}
export interface IUpdateUser {
    id: number;
    name?: string;
    email?: string;
    rootRole?: number | RoleName;
}
export interface ILoginUserRequest {
    email: string;
    name?: string;
    rootRole?: number | RoleName;
    autoCreate?: boolean;
}
export declare class UserService {
    private logger;
    private store;
    private eventService;
    private eventBus;
    private accessService;
    private resetTokenService;
    private sessionService;
    private emailService;
    private settingService;
    private flagResolver;
    private passwordResetTimeouts;
    private baseUriPath;
    readonly unleashUrl: string;
    readonly maxParallelSessions: number;
    constructor(stores: Pick<IUnleashStores, 'userStore'>, { server, getLogger, eventBus, flagResolver, session, }: Pick<IUnleashConfig, 'getLogger' | 'server' | 'eventBus' | 'flagResolver' | 'session'>, services: {
        accessService: AccessService;
        resetTokenService: ResetTokenService;
        emailService: EmailService;
        eventService: EventService;
        sessionService: SessionService;
        settingService: SettingService;
    });
    validatePassword(password: string): boolean;
    initAdminUser({ createAdminUser, initialAdminUser, }: Pick<IAuthOption, 'createAdminUser' | 'initialAdminUser'>): Promise<void>;
    initAdminUsernameUser(usernameAdminUser?: UsernameAdminUser): Promise<void>;
    getAll(): Promise<IUserWithRootRole[]>;
    getUser(id: number): Promise<IUserWithRootRole>;
    search(query: string): Promise<IUser[]>;
    getByEmail(email: string): Promise<IUser>;
    private validateEmail;
    createUser({ username, email, name, password, rootRole }: ICreateUserWithRole, auditUser?: IAuditUser): Promise<IUserWithRootRole>;
    newUserInviteLink({ id: userId }: Pick<IUserWithRootRole, 'id'>, auditUser?: IAuditUser): Promise<string>;
    sendWelcomeEmail(user: IUserWithRootRole, inviteLink: string): Promise<boolean>;
    updateUser({ id, name, email, rootRole }: IUpdateUser, auditUser: IAuditUser): Promise<IUserWithRootRole>;
    deleteUser(userId: number, auditUser: IAuditUser): Promise<void>;
    deleteScimUsers(auditUser: IAuditUser): Promise<void>;
    loginUser(usernameOrEmail: string, password: string, device?: {
        userAgent?: string;
        ip: string;
    }): Promise<IUser>;
    /**
     * Used to login users without specifying password. Used when integrating
     * with external identity providers.
     *
     * @param usernameOrEmail
     * @param autoCreateUser
     * @returns
     */
    loginUserWithoutPassword(email: string, autoCreateUser?: boolean): Promise<IUser>;
    loginUserSSO({ email, name, rootRole, autoCreate, }: ILoginUserRequest): Promise<IUser>;
    loginDemoAuthDefaultAdmin(): Promise<IUser>;
    changePassword(userId: number, password: string): Promise<void>;
    changePasswordWithPreviouslyUsedPasswordCheck(userId: number, password: string): Promise<void>;
    changePasswordWithVerification(userId: number, newPassword: string, oldPassword: string): Promise<void>;
    getUserForToken(token: string): Promise<TokenUserSchema>;
    /**
     * If the password is a strong password will update password and delete all sessions for the user we're changing the password for
     * @param token - the token authenticating this request
     * @param password - new password
     */
    resetPassword(token: string, password: string): Promise<void>;
    createResetPasswordEmail(receiverEmail: string, user?: IUser): Promise<URL>;
}
export default UserService;
//# sourceMappingURL=user-service.d.ts.map