import { z } from 'zod';
export declare const AuthConfigSchema: z.ZodObject<{
    id: z.ZodOptional<z.ZodNumber>;
    enabledProviders: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    authPolicy: z.ZodObject<{
        emailVerificationRequired: z.ZodDefault<z.ZodBoolean>;
        passwordReset: z.ZodDefault<z.ZodBoolean>;
        passwordChange: z.ZodDefault<z.ZodBoolean>;
        accountDeletion: z.ZodDefault<z.ZodBoolean>;
        smsVerificationRequired: z.ZodDefault<z.ZodBoolean>;
        loginAfterRegistration: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        emailVerificationRequired: boolean;
        passwordReset: boolean;
        passwordChange: boolean;
        accountDeletion: boolean;
        smsVerificationRequired: boolean;
        loginAfterRegistration: boolean;
    }, {
        emailVerificationRequired?: boolean | undefined;
        passwordReset?: boolean | undefined;
        passwordChange?: boolean | undefined;
        accountDeletion?: boolean | undefined;
        smsVerificationRequired?: boolean | undefined;
        loginAfterRegistration?: boolean | undefined;
    }>;
    passwordPolicy: z.ZodObject<{
        minLength: z.ZodDefault<z.ZodNumber>;
        requireUppercase: z.ZodDefault<z.ZodBoolean>;
        requireLowercase: z.ZodDefault<z.ZodBoolean>;
        requireNumber: z.ZodDefault<z.ZodBoolean>;
        requireSpecialChar: z.ZodDefault<z.ZodBoolean>;
        maxAttempts: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        minLength: number;
        requireUppercase: boolean;
        requireLowercase: boolean;
        requireNumber: boolean;
        requireSpecialChar: boolean;
        maxAttempts: number;
    }, {
        minLength?: number | undefined;
        requireUppercase?: boolean | undefined;
        requireLowercase?: boolean | undefined;
        requireNumber?: boolean | undefined;
        requireSpecialChar?: boolean | undefined;
        maxAttempts?: number | undefined;
    }>;
    sessionSettings: z.ZodObject<{
        accessTokenTTL: z.ZodDefault<z.ZodString>;
        refreshTokenTTL: z.ZodDefault<z.ZodString>;
        tokenRotation: z.ZodDefault<z.ZodBoolean>;
        multipleSessions: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        accessTokenTTL: string;
        refreshTokenTTL: string;
        tokenRotation: boolean;
        multipleSessions: boolean;
    }, {
        accessTokenTTL?: string | undefined;
        refreshTokenTTL?: string | undefined;
        tokenRotation?: boolean | undefined;
        multipleSessions?: boolean | undefined;
    }>;
    mfaSettings: z.ZodObject<{
        required: z.ZodDefault<z.ZodBoolean>;
        allowedMethods: z.ZodDefault<z.ZodArray<z.ZodEnum<["totp", "sms", "email"]>, "many">>;
    }, "strip", z.ZodTypeAny, {
        required: boolean;
        allowedMethods: ("totp" | "sms" | "email")[];
    }, {
        required?: boolean | undefined;
        allowedMethods?: ("totp" | "sms" | "email")[] | undefined;
    }>;
    adminFeature: z.ZodDefault<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        createInitialApiKey: z.ZodDefault<z.ZodBoolean>;
        initialApiKeyName: z.ZodDefault<z.ZodString>;
        initialApiKeyScopes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
        createInitialApiKey: boolean;
        initialApiKeyName: string;
        initialApiKeyScopes: string[];
    }, {
        enabled?: boolean | undefined;
        createInitialApiKey?: boolean | undefined;
        initialApiKeyName?: string | undefined;
        initialApiKeyScopes?: string[] | undefined;
    }>>;
    rateLimiting: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        requests: z.ZodNumber;
        interval: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        requests: number;
        interval: string;
    }, {
        requests: number;
        interval: string;
    }>>>;
}, "strip", z.ZodTypeAny, {
    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;
}, {
    authPolicy: {
        emailVerificationRequired?: boolean | undefined;
        passwordReset?: boolean | undefined;
        passwordChange?: boolean | undefined;
        accountDeletion?: boolean | undefined;
        smsVerificationRequired?: boolean | undefined;
        loginAfterRegistration?: boolean | undefined;
    };
    passwordPolicy: {
        minLength?: number | undefined;
        requireUppercase?: boolean | undefined;
        requireLowercase?: boolean | undefined;
        requireNumber?: boolean | undefined;
        requireSpecialChar?: boolean | undefined;
        maxAttempts?: number | undefined;
    };
    sessionSettings: {
        accessTokenTTL?: string | undefined;
        refreshTokenTTL?: string | undefined;
        tokenRotation?: boolean | undefined;
        multipleSessions?: boolean | undefined;
    };
    mfaSettings: {
        required?: boolean | undefined;
        allowedMethods?: ("totp" | "sms" | "email")[] | undefined;
    };
    id?: number | undefined;
    enabledProviders?: string[] | undefined;
    adminFeature?: {
        enabled?: boolean | undefined;
        createInitialApiKey?: boolean | undefined;
        initialApiKeyName?: string | undefined;
        initialApiKeyScopes?: string[] | undefined;
    } | undefined;
    rateLimiting?: Record<string, {
        requests: number;
        interval: string;
    }> | undefined;
}>;
export type AuthConfig = z.infer<typeof AuthConfigSchema>;
export interface UserService {
    findUser(identifier: string): Promise<User | null>;
    createUser(user: Partial<User>, password?: string): Promise<User>;
    updateUser(userId: string, user: Partial<User>): Promise<User>;
    deleteUser(userId: string): Promise<void>;
    findUserById(userId: string): Promise<User | null>;
    findUserByEmail(email: string): Promise<User | null>;
    findUserByPhone(phone: string): Promise<User | null>;
    setRole(userId: string, role: string): Promise<void>;
    removeRTP(userId: string, list: string[], type: 'teams' | 'permissions' | 'labels'): Promise<string[]>;
    addRTP(userId: string, list: string[], type: 'teams' | 'permissions' | 'labels'): Promise<string[]>;
    setRTP(userId: string, list: string[], type: 'teams' | 'permissions' | 'labels'): Promise<string[]>;
}
export interface EmailVerificationService {
    /**
     * Send a verification email to the user
     * @param email The recipient's email address
     * @param user The user object
     * @param customVerificationUrlBase Optional custom base URL for verification link
     * @returns The generated verification token (optional)
     */
    sendVerificationEmail(email: string, user: User, customVerificationUrlBase?: string): Promise<string | void>;
    /**
     * Verify an email verification token
     * @param email The email address to verify
     * @param token The verification token
     * @param user The user object
     * @returns Whether the verification was successful
     */
    verifyEmail(email: string, token: string, user: User): Promise<boolean>;
    /**
     * Send a password reset email to the user
     * @param email The recipient's email address
     * @param user The user object
     * @param resetUrl Optional URL for password reset
     * @param customResetUrlBase Optional custom base URL for reset link
     * @returns The generated reset token
     */
    sendPasswordResetEmail(email: string, user: User, resetUrl?: string, customResetUrlBase?: string): Promise<string>;
    /**
     * Verify a password reset token
     * @param email The email address associated with the token
     * @param token The password reset token
     * @returns Whether the token is valid
     */
    verifyPasswordResetToken(email: string, token: string): Promise<boolean>;
    /**
     * Consume a verification token
     * @param token The verification token
     * @param userId The user ID
     * @returns Whether the token was successfully consumed
     */
    consumePasswordResetToken(token: string, userId: string): Promise<boolean>;
}
export interface SmsVerificationService {
    sendVerificationSms(phone: string, user: User): Promise<void>;
    verifySms?(token: string, phone: string, user: User): Promise<boolean>;
}
export interface PasswordHasher {
    hash(password: string): Promise<string>;
    compare(password: string, hash: string): Promise<boolean>;
}
export interface TokenStore {
    saveToken(userId: string, token: string): Promise<void>;
    getToken(userId: string): Promise<string | null>;
    deleteToken(userId: string): Promise<void>;
}
export interface ConfigStore {
    initialize?(): Promise<void | boolean>;
    getConfig(): Promise<AuthConfig>;
    updateConfig(update: Partial<AuthConfig>): Promise<AuthConfig>;
}
export interface BaseUser {
    id: string;
    email: string;
    name?: string;
    phone?: string;
    picture?: string;
    permissions?: string | string[];
    role?: string;
    labels?: string | string[];
    teams?: string | string[];
    password_hash?: string;
    email_verified: boolean;
    phone_verified: boolean;
    created_at: Date;
    updated_at: Date;
    mfa_enabled: boolean;
    mfa_secret?: string;
    mfa_recovery_codes?: string[];
    last_login_at?: Date;
}
export interface UserExtension {
}
export type User = BaseUser & UserExtension;
export interface AuthProvider {
    authenticate(credentials: Record<string, string>): Promise<User | null>;
    validate?(token: string): Promise<User>;
    register?(user: Partial<User>, password: string): Promise<User>;
    getConfig?(): Promise<Record<string, string>>;
    initialize?(): Promise<void>;
}
export interface AuthToken {
    accessToken: string;
    refreshToken: string;
}
export type AuthRequiredType = 'mfa-required' | 'sms-required' | 'email-required' | 'sms-required or email-required';
export interface SessionManager {
    initialize?(): Promise<void>;
    createSession(user: User): Promise<AuthToken | string>;
    destroySession(token: string, id?: string): Promise<void>;
    verifySession(token: string): Promise<{
        user: User;
        token?: string | AuthToken;
    }>;
    refreshSession?(refreshToken: string): Promise<AuthToken | string>;
    validateToken?(token: string): Promise<User>;
}
export declare class UserNotFoundError extends Error {
    constructor(identifier: string);
}
export declare class InvalidCodeError extends Error {
    constructor();
}
export declare class InvalidCredentialsError extends Error {
    constructor();
}
export declare class RateLimitExceededError extends Error {
    constructor();
}
export declare class MFARequiredError extends Error {
    constructor();
}
export declare class VerificationRequiredError extends Error {
    constructor(name: string);
}
export declare class InvalidMfaCodeError extends Error {
    constructor();
}
export declare class ProviderDoesNotSupportReg extends Error {
    constructor(name: string);
}
export declare class InvalidProvider extends Error {
    constructor();
}
export declare class ProviderNotEnabled extends Error {
    constructor(name: string);
}
export declare class ProviderNotExist extends Error {
    constructor(name: string);
}
export declare class OAuthProviderNotExist extends Error {
    constructor(name: string);
}
export declare class MfaAlreadyEnabledError extends Error {
    constructor(identifier: string);
}
export declare class MfaNotEnabledError extends Error {
    constructor();
}
export declare class MfaRecoveryCodeExpiredError extends Error {
    constructor();
}
export declare class MfaRecoveryCodeInvalid extends Error {
    constructor();
}
export declare class UserUnAuthorizedError extends Error {
    constructor(identifier: string, action: string);
}
export interface MfaService {
    generateSecret(email: string): Promise<{
        secret: string;
        uri: string;
    }>;
    verifyCode(secret: string, code: string): boolean;
    generateRecoveryCodes(): string[];
}
//# sourceMappingURL=types.d.ts.map