import { ActivatedRouteSnapshot, RouterStateSnapshot, UrlTree, CanActivateFn } from '@angular/router';
import { StorageOption, StorageStrategy } from '@bravobit/bb-foundation/storage';
import * as i0 from '@angular/core';
import { InjectionToken, OnInit, OnDestroy, TemplateRef, EnvironmentProviders, ModuleWithProviders } from '@angular/core';
import * as _angular_common_http from '@angular/common/http';
import { HttpClient, HttpContextToken, HttpInterceptor, HttpRequest, HttpHandler, HttpHeaders, HttpParams } from '@angular/common/http';
import * as rxjs from 'rxjs';
import { Observable } from 'rxjs';

interface AuthToken {
    id?: string;
    type?: string;
    audience?: string;
    issuer?: string;
    subject?: string;
    notValidBefore?: Date;
    expiresAt?: Date;
    issuedAt?: Date;
    role?: string;
}

type AuthStrategy = 'httpOnlyCookie' | 'browserStorage';
interface AuthConfig {
    applicationId: string;
    strategy: AuthStrategy;
    preferredStorageOptions?: StorageOption[];
    http?: {
        scheme?: string;
        header?: string;
    };
    redirects?: {
        authenticated?: string | string[];
        unauthenticated?: string | string[];
    };
    setRedirectOnFailedAuth?: boolean;
    interceptActing?: boolean;
    providers?: string[];
    autoRefresh?: boolean;
}
declare const AUTH_CONFIG: InjectionToken<AuthConfig>;
declare const AUTH_REDIRECT_HANDLER: InjectionToken<AuthRedirectHandler>;
interface AuthRedirectHandler {
    onFailedAuthenticated(snapshot?: ActivatedRouteSnapshot, state?: RouterStateSnapshot): boolean | UrlTree;
    onFailedAnonymous(snapshot?: ActivatedRouteSnapshot, state?: RouterStateSnapshot): boolean | UrlTree;
}

interface AuthProvider {
    authenticate(httpClient: HttpClient): Promise<AuthProviderResult>;
}
interface AuthProviderResponse {
    token: string;
    refresh_token?: string;
    provider?: string;
    verify_token?: string;
    user?: any;
}
interface AuthProviderResult {
    accessToken?: string;
    refreshToken?: string;
    provider?: string;
    verifyToken?: string;
    user?: any;
}
interface AuthSignInResponse {
    user?: unknown;
    provider?: string;
    verifyToken?: string;
}

declare const USE_AUTHORIZATION: HttpContextToken<boolean>;

declare class JwtHelper {
    decode(token: string): AuthToken;
    private urlDecode;
    private baseDecodeUnicode;
    private parse;
    private parseDate;
}

declare class BbAuthenticated implements OnInit, OnDestroy {
    private readonly _auth;
    private readonly _templateRef;
    private readonly _viewContainerRef;
    private _valid;
    private _elseTemplateRef;
    private _thenViewRef;
    private _elseViewRef;
    private _subscription;
    set bbAuthenticatedElse(templateRef: TemplateRef<any>);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private updateView;
    private assertTemplate;
    static ngAcceptInputType_bbAuthenticatedElse: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbAuthenticated, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BbAuthenticated, "ng-template[bbAuthenticated]", never, { "bbAuthenticatedElse": { "alias": "bbAuthenticatedElse"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BbAnonymous implements OnInit, OnDestroy {
    private readonly _auth;
    private readonly _templateRef;
    private readonly _viewContainerRef;
    private _valid;
    private _elseTemplateRef;
    private _thenViewRef;
    private _elseViewRef;
    private _subscription;
    set bbAnonymousElse(templateRef: TemplateRef<any>);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private updateView;
    private assertTemplate;
    static ngAcceptInputType_bbAnonymousElse: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<BbAnonymous, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BbAnonymous, "ng-template[bbAnonymous]", never, { "bbAnonymousElse": { "alias": "bbAnonymousElse"; "required": false; }; }, {}, never, never, true, never>;
}

declare const bbAnonymousGuard: CanActivateFn;

declare const bbAuthenticatedGuard: CanActivateFn;

declare class AuthEmailProvider implements AuthProvider {
    private _email;
    private _password;
    private _endpoint;
    constructor(_email: string, _password: string, _endpoint: string);
    authenticate(httpClient: HttpClient): Promise<AuthProviderResult>;
}

declare class AuthVerifyProvider implements AuthProvider {
    private _code;
    private _verifyToken;
    private _endpoint;
    constructor(_code: string, _verifyToken: string, _endpoint: string);
    authenticate(httpClient: HttpClient): Promise<AuthProviderResult>;
}

declare class Acting {
    private readonly _auth;
    private _userId$;
    readonly info$: Observable<{
        active?: boolean;
        user?: any;
    }>;
    start(userId: number): Promise<void>;
    stop(): Promise<void>;
    getCurrent(): number;
    private fetchUserDetails;
    private getInfo;
    static ɵfac: i0.ɵɵFactoryDeclaration<Acting, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Acting>;
}

declare class ActingInterceptor implements HttpInterceptor {
    private readonly _acting;
    private readonly _headerString;
    intercept(request: HttpRequest<unknown>, next: HttpHandler): rxjs.Observable<_angular_common_http.HttpEvent<any>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ActingInterceptor, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ActingInterceptor>;
}

declare class AuthSession {
    private readonly _jwt;
    private readonly _storage;
    private readonly _accessTokenStorageKey;
    private readonly _refreshTokenStorageKey;
    private readonly _authenticatedStorageKey;
    private readonly _strategy;
    private _authenticated;
    private _accessTokenString;
    private _refreshTokenString;
    private _accessTokenPayload;
    private _refreshTokenPayload;
    private _user$;
    user: rxjs.Observable<any>;
    constructor(options?: {
        id?: string;
        storage?: StorageStrategy;
        strategy?: AuthStrategy;
    });
    get snapshot(): {
        user: any;
        accessToken?: undefined;
        refreshToken?: undefined;
    } | {
        user: any;
        accessToken: string;
        refreshToken: string;
    };
    get accessToken(): string;
    get refreshToken(): string;
    get accessTokenPayload(): AuthToken;
    get refreshTokenPayload(): AuthToken;
    authenticated(): boolean;
    setTokens(accessToken: string | null, refreshToken: string | null, persist?: boolean): void;
    setUser(user: unknown, persist?: boolean): void;
    clear(): void;
    private restoreFromStorage;
    private persistTokensInStorage;
    private persistAuthenticatedInStorage;
    private setAuthenticated;
    private cacheAccessToken;
    private cacheRefreshToken;
    private cacheAuthenticated;
    private generateKey;
    private isTokenValid;
    private getNextYearDate;
}

declare class Auth {
    private readonly _storage;
    private readonly _injector;
    private readonly _platform;
    private readonly _httpClient;
    private readonly _state?;
    private readonly _config?;
    private readonly _httpConfig?;
    private readonly _handler?;
    private readonly _authStateKey;
    private readonly _httpAlias;
    readonly session: AuthSession;
    readonly user: Observable<any | null>;
    private _refreshHandler;
    constructor();
    initialize(): Promise<void>;
    me<T = any>(): Observable<T>;
    signIn<T = any>(provider: AuthProvider, verify?: (user: T) => void): Promise<AuthSignInResponse>;
    signInWithEmail<T = any>(email: string, password: string, verify?: (user: T) => void): Promise<AuthSignInResponse>;
    signInWithVerifyCode(code: string, verifyToken: string): Promise<AuthSignInResponse>;
    resendVerifyCode(verifyToken: string): Promise<Object>;
    register<T = any>(data: any, options?: {
        headers?: HttpHeaders | {
            [header: string]: string | string[];
        };
        params?: HttpParams | {
            [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
        };
    }): Promise<T>;
    logout(): void;
    refresh(): Observable<string>;
    requestPassword(email: string, extraParams?: {
        [key: string]: any;
    }): Promise<Object>;
    resetPassword(token: string, newPassword: string, extraParams?: {
        [key: string]: any;
    }): Promise<Object>;
    clearAndRedirect(): void;
    private setTokens;
    private handleAutoRefreshing;
    private autoRefresh;
    private get router();
    private getUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<Auth, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<Auth>;
}

declare function provideAuthConfig(config?: AuthConfig): EnvironmentProviders;

declare class AuthModule {
    static forRoot(config: AuthConfig): ModuleWithProviders<AuthModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AuthModule, never, [typeof BbAuthenticated], [typeof BbAuthenticated]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AuthModule>;
}

export { AUTH_CONFIG, AUTH_REDIRECT_HANDLER, Acting, ActingInterceptor, Auth, AuthEmailProvider, AuthModule, AuthSession, AuthVerifyProvider, BbAnonymous, BbAuthenticated, JwtHelper, USE_AUTHORIZATION, bbAnonymousGuard, bbAuthenticatedGuard, provideAuthConfig };
export type { AuthConfig, AuthProvider, AuthProviderResponse, AuthProviderResult, AuthRedirectHandler, AuthSignInResponse, AuthStrategy, AuthToken };