import { MJAuthBase } from '../mjexplorer-auth-base.service';
import { AuthService, AuthGuard, Auth0ClientFactory, AuthClientConfig } from '@auth0/auth0-angular';
import { StandardUserInfo, StandardAuthToken, StandardAuthError, TokenRefreshResult } from '../auth-types';
import * as i0 from "@angular/core";
/**
 * Auth0 authentication provider implementation - v3.0.0
 *
 * Implements the abstract methods from MJAuthBase to hide Auth0-specific details.
 * The key abstraction is that Auth0 stores the JWT in `idTokenClaims.__raw`,
 * but consumers never need to know this detail.
 */
export declare class MJAuth0Provider extends MJAuthBase {
    auth: AuthService;
    static readonly PROVIDER_TYPE = "auth0";
    readonly type = "auth0";
    private _initialized;
    /**
     * Factory function to provide Angular dependencies required by Auth0
     * Stored as a static property for the factory to access without instantiation
     */
    static angularProviderFactory: (environment: Record<string, unknown>) => (typeof AuthService | typeof AuthGuard | {
        provide: import("@angular/core").InjectionToken<import("@auth0/auth0-angular").AuthConfig>;
        useValue: {
            domain: unknown;
            clientId: unknown;
            authorizationParams: {
                redirect_uri: string;
                scope: string;
            };
            cacheLocation: string;
            useRefreshTokens: boolean;
            useRefreshTokensFallback: boolean;
            skipRedirectCallback: boolean;
        };
        useFactory?: undefined;
        deps?: undefined;
    } | {
        provide: import("@angular/core").InjectionToken<import("@auth0/auth0-spa-js").Auth0Client>;
        useFactory: typeof Auth0ClientFactory.createClient;
        deps: (typeof AuthClientConfig)[];
        useValue?: undefined;
    })[];
    constructor(auth: AuthService);
    initialize(): Promise<void>;
    protected loginInternal(options?: Record<string, unknown>): Promise<void>;
    protected logoutInternal(): Promise<void>;
    handleCallback(): Promise<void>;
    /**
     * Extract ID token from Auth0's storage
     *
     * Auth0 stores the JWT string in idTokenClaims.__raw
     * This is the key abstraction - consumers never need to know about __raw!
     */
    protected extractIdTokenInternal(): Promise<string | null>;
    /**
     * Extract complete token info from Auth0
     *
     * Maps Auth0's token structure to StandardAuthToken
     */
    protected extractTokenInfoInternal(): Promise<StandardAuthToken | null>;
    /**
     * Extract user info from Auth0 claims
     *
     * Maps Auth0's user object structure to StandardUserInfo
     */
    protected extractUserInfoInternal(): Promise<StandardUserInfo | null>;
    /**
     * Refresh token using Auth0's silent authentication
     *
     * Uses cacheMode: 'off' to bypass cache and force token refresh
     * With useRefreshTokens: true and offline_access scope, this will use refresh tokens
     */
    protected refreshTokenInternal(): Promise<TokenRefreshResult>;
    /**
     * Classify Auth0-specific errors into semantic types
     *
     * Maps Auth0 error patterns to AuthErrorType enum
     */
    protected classifyErrorInternal(error: unknown): StandardAuthError;
    private ensureInitialized;
    /**
     * Map Auth0 User object to StandardUserInfo
     */
    private mapAuth0UserToStandard;
    /**
     * Get profile picture URL from Auth0
     *
     * Auth0 includes the picture URL directly in user claims.
     * No additional API call needed.
     */
    protected getProfilePictureUrlInternal(): Promise<string | null>;
    /**
     * Handle session expiry - no-op for Auth0
     *
     * Auth0 uses refresh tokens (offline_access scope), so it doesn't need
     * interactive re-authentication when tokens expire. If refresh fails,
     * the base class will throw an error and the user must log out/in manually.
     */
    protected handleSessionExpiryInternal(): Promise<void>;
    getRequiredConfig(): string[];
    validateConfig(_config: Record<string, unknown>): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<MJAuth0Provider, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MJAuth0Provider>;
}
//# sourceMappingURL=mjexplorer-auth0-provider.service.d.ts.map