import { BaseOAuthProvider } from './providers/index.js';
import { AuthConfig, AuthProvider, AuthRequiredType, AuthToken, ConfigStore, MfaService, SessionManager, User, EmailVerificationService, SmsVerificationService } from './types.js';
import { KnexUserService } from './userService.js';
import { AuthPlugin } from './plugins/types.js';
import { Knex } from 'knex';
export declare class DynamicAuthManager {
    private config;
    private pluginRegistry;
    private knex;
    private configStore;
    providers: Record<string, AuthProvider | BaseOAuthProvider>;
    private sessionManager;
    private userService;
    private refreshInterval;
    private enableConfigIntervalCheck;
    private emailVerificationService?;
    private smsVerificationService?;
    private mfaService?;
    constructor(knex: Knex, configStore: ConfigStore, sessionManager: SessionManager, userService: KnexUserService, refreshInterval?: number, enableConfigIntervalCheck?: boolean, emailVerificationService?: EmailVerificationService | null, smsVerificationService?: SmsVerificationService | null, mfaService?: MfaService | null);
    getUserService(): KnexUserService;
    registerProvider(provider: string, authProvider: AuthProvider | BaseOAuthProvider): void;
    private watchConfig;
    private executeHooks;
    registerPlugin(plugin: AuthPlugin): Promise<void>;
    getPlugins(): AuthPlugin[];
    getPlugin(name: string): AuthPlugin;
    getEmailVerificationService(): EmailVerificationService | undefined;
    getProviders(): Record<string, AuthProvider | BaseOAuthProvider>;
    getProvider(provider: string): AuthProvider | BaseOAuthProvider | undefined;
    getProviderConfig(provider: string): Promise<Record<string, string>> | Promise<{
        clientID: any;
        clientSecret: any;
        callbackURL: string;
        scopes: any;
        redirect_url: string;
    }>;
    getConfig(): {
        enabledProviders: string[];
        authPolicy: {
            emailVerificationRequired: boolean;
            passwordReset: boolean;
            passwordChange: boolean;
            accountDeletion: boolean;
            smsVerificationRequired: boolean;
            loginAfterRegistration: boolean;
        };
        passwordPolicy: {
            minLength: number;
            requireUppercase: boolean;
            requireLowercase: boolean;
            requireNumber: boolean;
            requireSpecialChar: boolean;
            maxAttempts: number;
        };
        sessionSettings: {
            accessTokenTTL: string;
            refreshTokenTTL: string;
            tokenRotation: boolean;
            multipleSessions: boolean;
        };
        mfaSettings: {
            required: boolean;
            allowedMethods: ("totp" | "sms" | "email")[];
        };
        adminFeature: {
            enabled: boolean;
            createInitialApiKey: boolean;
            initialApiKeyName: string;
            initialApiKeyScopes: string[];
        };
        rateLimiting: Record<string, {
            requests: number;
            interval: string;
        }>;
        id?: number | undefined;
    };
    getMfaStatus(): boolean;
    register(provider: string, credentials: Partial<User>, password: string): Promise<{
        user?: User;
        token: AuthToken | string | AuthRequiredType;
        url?: URL;
        verificationToken?: string;
    }>;
    oauthCallback(provider: string, { code, state }: {
        code: string;
        state: string;
    }): Promise<{
        user?: User;
        token: AuthToken | string | AuthRequiredType;
    }>;
    login(provider: string, credentials: Record<string, string>): Promise<{
        user?: User;
        token: AuthToken | string | AuthRequiredType;
        url?: URL;
    }>;
    refreshToken(refreshToken: string): Promise<string | AuthToken>;
    createToken(user: User): Promise<AuthToken | string>;
    validateSessionToken(token: string): Promise<User>;
    validateToken(token: string, provider: string): Promise<{
        user: User;
        token?: string | AuthToken;
    }>;
    logout(token: string): Promise<void>;
    verifyEmail(userId: string, verificationCode: string): Promise<{
        user: User;
        token: AuthToken | string;
    }>;
    /**
     * Send a verification email to the user
     * @param email The recipient's email address
     * @param verificationUrl Optional custom verification URL base
     * @returns The generated verification token if the service returns one
     */
    sendVerificationEmail(email: string, verificationUrl?: string): Promise<string | void>;
    /**
     * Send a password reset email to the user
     * @param email The recipient's email address
     * @param resetUrl Optional custom reset URL base
     * @returns The generated reset token if the service returns one
     */
    sendPasswordResetEmail(email: string, resetUrl?: string): Promise<string | void>;
    /**
     * Verify a password reset token
     * @param userId The user ID
     * @param token The reset token
     * @returns Whether the token is valid
     */
    verifyPasswordResetToken(userId: string, token: string): Promise<boolean>;
    sendVerificationSms(phone: string): Promise<void>;
    verifySms(userId: string, verificationCode: string): Promise<{
        user: User;
        token: string | AuthToken;
    }>;
    /**
     * Reset a user's password
     * @param userId The user ID
     * @param newPassword The new password
     * @param token Optional reset token for token-based password reset
     * @returns True if the password was reset successfully
     */
    resetPassword(userId: string, newPassword: string, token?: string): Promise<boolean>;
    verifyMfa(userId: string, code: string): Promise<string | AuthToken>;
    enableMfa(userId: string, code?: string): Promise<{
        secret?: string;
        uri?: string;
    } | {
        recoveryCodes: string[];
    }>;
    disableMfa(userId: string, code: string): Promise<void>;
    /**
     * Change a user's password (requires authentication)
     * @param userId The user ID
     * @param oldPassword The current password
     * @param newPassword The new password
     * @returns True if the password was changed successfully
     */
    changePassword(userId: string, oldPassword: string, newPassword: string): Promise<boolean>;
    updateConfig(update: Partial<AuthConfig>): Promise<{
        enabledProviders: string[];
        authPolicy: {
            emailVerificationRequired: boolean;
            passwordReset: boolean;
            passwordChange: boolean;
            accountDeletion: boolean;
            smsVerificationRequired: boolean;
            loginAfterRegistration: boolean;
        };
        passwordPolicy: {
            minLength: number;
            requireUppercase: boolean;
            requireLowercase: boolean;
            requireNumber: boolean;
            requireSpecialChar: boolean;
            maxAttempts: number;
        };
        sessionSettings: {
            accessTokenTTL: string;
            refreshTokenTTL: string;
            tokenRotation: boolean;
            multipleSessions: boolean;
        };
        mfaSettings: {
            required: boolean;
            allowedMethods: ("totp" | "sms" | "email")[];
        };
        adminFeature: {
            enabled: boolean;
            createInitialApiKey: boolean;
            initialApiKeyName: string;
            initialApiKeyScopes: string[];
        };
        rateLimiting: Record<string, {
            requests: number;
            interval: string;
        }>;
        id?: number | undefined;
    }>;
    setRTP(userId: string, list: string[], type: 'teams' | 'permissions' | 'labels'): Promise<string[]>;
    removeRTP(userId: string, list: string[], type: 'teams' | 'permissions' | 'labels'): Promise<string[]>;
    addRTP(userId: string, list: string[], type: 'teams' | 'permissions' | 'labels'): Promise<string[]>;
    setRole(userId: string, role: string): Promise<void>;
}
export declare class AuthConfigAPI {
    private configStore;
    constructor(configStore: ConfigStore);
    getConfig(): Promise<{
        enabledProviders: string[];
        authPolicy: {
            emailVerificationRequired: boolean;
            passwordReset: boolean;
            passwordChange: boolean;
            accountDeletion: boolean;
            smsVerificationRequired: boolean;
            loginAfterRegistration: boolean;
        };
        passwordPolicy: {
            minLength: number;
            requireUppercase: boolean;
            requireLowercase: boolean;
            requireNumber: boolean;
            requireSpecialChar: boolean;
            maxAttempts: number;
        };
        sessionSettings: {
            accessTokenTTL: string;
            refreshTokenTTL: string;
            tokenRotation: boolean;
            multipleSessions: boolean;
        };
        mfaSettings: {
            required: boolean;
            allowedMethods: ("totp" | "sms" | "email")[];
        };
        adminFeature: {
            enabled: boolean;
            createInitialApiKey: boolean;
            initialApiKeyName: string;
            initialApiKeyScopes: string[];
        };
        rateLimiting: Record<string, {
            requests: number;
            interval: string;
        }>;
        id?: number | undefined;
    }>;
    updateConfig(update: Partial<AuthConfig>, initiator: string): Promise<{
        enabledProviders: string[];
        authPolicy: {
            emailVerificationRequired: boolean;
            passwordReset: boolean;
            passwordChange: boolean;
            accountDeletion: boolean;
            smsVerificationRequired: boolean;
            loginAfterRegistration: boolean;
        };
        passwordPolicy: {
            minLength: number;
            requireUppercase: boolean;
            requireLowercase: boolean;
            requireNumber: boolean;
            requireSpecialChar: boolean;
            maxAttempts: number;
        };
        sessionSettings: {
            accessTokenTTL: string;
            refreshTokenTTL: string;
            tokenRotation: boolean;
            multipleSessions: boolean;
        };
        mfaSettings: {
            required: boolean;
            allowedMethods: ("totp" | "sms" | "email")[];
        };
        adminFeature: {
            enabled: boolean;
            createInitialApiKey: boolean;
            initialApiKeyName: string;
            initialApiKeyScopes: string[];
        };
        rateLimiting: Record<string, {
            requests: number;
            interval: string;
        }>;
        id?: number | undefined;
    }>;
    private auditLog;
}
//# sourceMappingURL=authManager.d.ts.map