@abp/ng.oauth 9.3.0-rc.2 → 9.3.0-rc.4

package/index.d.ts

@@ -1,5 +1,342 @@
+import * as i0 from '@angular/core';
+import { ModuleWithProviders, Injector, Provider } from '@angular/core';
+import * as angular_oauth2_oidc from 'angular-oauth2-oidc';
+import { OAuthStorage, OAuthErrorEvent, OAuthService, AuthConfig } from 'angular-oauth2-oidc';
+import * as _abp_ng_core from '@abp/ng.core';
+import { PipeToLoginFn, CheckAuthenticationStateFn, IAuthService, LoginParams, AbpAuthResponse, AbstractAuthErrorFilter, AuthErrorFilter, AbpLocalStorageService, HttpErrorReporterService, EnvironmentService, ConfigStateService, SessionStateService, AbpWindowService, ABP, IApiInterceptor, HttpWaitService, IAbpGuard, AuthService } from '@abp/ng.core';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { Params, Router, ActivatedRouteSnapshot, RouterStateSnapshot, UrlTree, CanActivateFn } from '@angular/router';
+import { HttpHeaders, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+
 /**
- * Generated bundle index. Do not edit.
+ * @deprecated AbpOAuthModule is deprecated use `provideAbpOAuth` *function* instead.
  */
-/// <amd-module name="@abp/ng.oauth" />
-export * from './public-api';
+declare class AbpOAuthModule {
+    static forRoot(): ModuleWithProviders<AbpOAuthModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbpOAuthModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AbpOAuthModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AbpOAuthModule>;
+}
+
+declare const oAuthStorage: Storage;
+
+declare function storageFactory(): OAuthStorage;
+
+declare const pipeToLogin: PipeToLoginFn;
+declare function isTokenExpired(expireDate: number): boolean;
+
+declare function clearOAuthStorage(storage?: OAuthStorage): void;
+
+declare const checkAccessToken: CheckAuthenticationStateFn;
+
+declare class AbpOAuthService implements IAuthService {
+    protected injector: Injector;
+    private strategy;
+    private readonly oAuthService;
+    get oidc(): boolean;
+    set oidc(value: boolean);
+    get isInternalAuth(): boolean;
+    constructor(injector: Injector);
+    init(): Promise<any>;
+    logout(queryParams?: Params): Observable<any>;
+    navigateToLogin(queryParams?: Params): void;
+    login(params: LoginParams): Observable<any>;
+    get isAuthenticated(): boolean;
+    loginUsingGrant(grantType: string, parameters: object, headers?: HttpHeaders): Promise<AbpAuthResponse>;
+    getRefreshToken(): string;
+    getAccessToken(): string;
+    refreshToken(): Promise<AbpAuthResponse>;
+    getAccessTokenExpiration(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbpOAuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AbpOAuthService>;
+}
+
+declare class OAuthErrorFilterService extends AbstractAuthErrorFilter<AuthErrorFilter<OAuthErrorEvent>, OAuthErrorEvent> {
+    protected readonly _filters: i0.WritableSignal<AuthErrorFilter<OAuthErrorEvent>[]>;
+    readonly filters: i0.Signal<AuthErrorFilter<OAuthErrorEvent>[]>;
+    get(id: string): AuthErrorFilter<OAuthErrorEvent>;
+    add(filter: AuthErrorFilter<OAuthErrorEvent>): void;
+    patch(item: Partial<AuthErrorFilter<OAuthErrorEvent>>): void;
+    remove(id: string): void;
+    run(event: OAuthErrorEvent): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OAuthErrorFilterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OAuthErrorFilterService>;
+}
+
+declare class RememberMeService {
+    #private;
+    protected readonly localStorageService: AbpLocalStorageService;
+    set(remember: boolean): void;
+    remove(): void;
+    get(): boolean;
+    getFromToken(accessToken: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RememberMeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RememberMeService>;
+}
+
+declare abstract class AuthFlowStrategy {
+    protected injector: Injector;
+    abstract readonly isInternalAuth: boolean;
+    protected httpErrorReporter: HttpErrorReporterService;
+    protected environment: EnvironmentService;
+    protected configState: ConfigStateService;
+    protected oAuthService: OAuthService;
+    protected oAuthConfig: AuthConfig;
+    protected sessionState: SessionStateService;
+    protected localStorageService: AbpLocalStorageService;
+    protected rememberMeService: RememberMeService;
+    protected windowService: AbpWindowService;
+    protected tenantKey: string;
+    protected router: Router;
+    protected readonly oAuthErrorFilterService: OAuthErrorFilterService;
+    abstract checkIfInternalAuth(queryParams?: Params): boolean;
+    abstract navigateToLogin(queryParams?: Params): void;
+    abstract logout(queryParams?: Params): Observable<any>;
+    abstract login(params?: LoginParams | Params): Observable<any>;
+    private catchError;
+    constructor(injector: Injector);
+    init(): Promise<any>;
+    protected navigateToPreviousUrl(): void;
+    protected refreshToken(): Promise<void | angular_oauth2_oidc.TokenResponse>;
+    protected listenToOauthErrors(): void;
+}
+
+declare class AuthCodeFlowStrategy extends AuthFlowStrategy {
+    readonly isInternalAuth = false;
+    init(): Promise<void>;
+    private checkRememberMeOption;
+    private getCultureParams;
+    protected setUICulture(): void;
+    protected replaceURLParams(): void;
+    protected listenToTokenReceived(): void;
+    navigateToLogin(queryParams?: Params): void;
+    checkIfInternalAuth(queryParams?: Params): boolean;
+    logout(queryParams?: Params): rxjs.Observable<any>;
+    login(queryParams?: Params): rxjs.Observable<null>;
+}
+
+declare class AuthPasswordFlowStrategy extends AuthFlowStrategy {
+    readonly isInternalAuth = true;
+    private listenToTokenExpiration;
+    init(): Promise<void>;
+    private checkRememberMeOption;
+    navigateToLogin(queryParams?: Params): Promise<boolean>;
+    checkIfInternalAuth(): boolean;
+    login(params: LoginParams): Observable<any>;
+    logout(): Observable<{
+        localization?: {
+            values?: {
+                [x: string]: {
+                    [x: string]: string;
+                };
+            };
+            resources?: {
+                [x: string]: {
+                    texts?: {
+                        [x: string]: string;
+                    };
+                    baseResources?: string[];
+                };
+            };
+            languages?: _abp_ng_core.LanguageInfo[];
+            currentCulture?: {
+                displayName?: string;
+                englishName?: string;
+                threeLetterIsoLanguageName?: string;
+                twoLetterIsoLanguageName?: string;
+                isRightToLeft?: boolean;
+                cultureName?: string;
+                name?: string;
+                nativeName?: string;
+                dateTimeFormat?: {
+                    calendarAlgorithmType?: string;
+                    dateTimeFormatLong?: string;
+                    shortDatePattern?: string;
+                    fullDateTimePattern?: string;
+                    dateSeparator?: string;
+                    shortTimePattern?: string;
+                    longTimePattern?: string;
+                };
+            };
+            defaultResourceName?: string;
+            languagesMap?: {
+                [x: string]: _abp_ng_core.NameValue<string>[];
+            };
+            languageFilesMap?: {
+                [x: string]: _abp_ng_core.NameValue<string>[];
+            };
+        };
+        auth?: {
+            grantedPolicies?: {
+                [x: string]: boolean;
+            };
+        };
+        setting?: {
+            values?: {
+                [x: string]: string;
+            };
+        };
+        currentUser?: {
+            isAuthenticated?: boolean;
+            id?: string;
+            tenantId?: string;
+            impersonatorUserId?: string;
+            impersonatorTenantId?: string;
+            impersonatorUserName?: string;
+            impersonatorTenantName?: string;
+            userName?: string;
+            name?: string;
+            surName?: string;
+            email?: string;
+            emailVerified?: boolean;
+            phoneNumber?: string;
+            phoneNumberVerified?: boolean;
+            roles?: string[];
+        };
+        features?: {
+            values?: {
+                [x: string]: string;
+            };
+        };
+        globalFeatures?: {
+            enabledFeatures?: string[];
+        };
+        multiTenancy?: {
+            isEnabled?: boolean;
+        };
+        currentTenant?: {
+            id?: string;
+            name?: string;
+            isAvailable?: boolean;
+        };
+        timing?: {
+            timeZone?: {
+                iana?: {
+                    timeZoneName?: string;
+                };
+                windows?: {
+                    timeZoneId?: string;
+                };
+            };
+        };
+        clock?: {
+            kind?: string;
+        };
+        objectExtensions?: {
+            modules?: {
+                [x: string]: {
+                    entities?: {
+                        [x: string]: {
+                            properties?: {
+                                [x: string]: {
+                                    type?: string;
+                                    typeSimple?: string;
+                                    displayName?: {
+                                        name?: string;
+                                        resource?: string;
+                                    };
+                                    api?: {
+                                        onGet?: {
+                                            isAvailable?: boolean;
+                                        };
+                                        onCreate?: {
+                                            isAvailable?: boolean;
+                                        };
+                                        onUpdate?: {
+                                            isAvailable?: boolean;
+                                        };
+                                    };
+                                    ui?: {
+                                        onTable?: {
+                                            isVisible?: boolean;
+                                        };
+                                        onCreateForm?: {
+                                            isVisible?: boolean;
+                                        };
+                                        onEditForm?: {
+                                            isVisible?: boolean;
+                                        };
+                                        lookup?: {
+                                            url?: string;
+                                            resultListPropertyName?: string;
+                                            displayPropertyName?: string;
+                                            valuePropertyName?: string;
+                                            filterParamName?: string;
+                                        };
+                                    };
+                                    attributes?: _abp_ng_core.ExtensionPropertyAttributeDto[];
+                                    configuration?: {
+                                        [x: string]: object;
+                                    };
+                                    defaultValue?: object;
+                                };
+                            };
+                            configuration?: {
+                                [x: string]: object;
+                            };
+                        };
+                    };
+                    configuration?: {
+                        [x: string]: object;
+                    };
+                };
+            };
+            enums?: {
+                [x: string]: {
+                    fields?: _abp_ng_core.ExtensionEnumFieldDto[];
+                    localizationResource?: string;
+                };
+            };
+        };
+        extraProperties?: {
+            [x: string]: object;
+        };
+    }>;
+    protected refreshToken(): Promise<void | angular_oauth2_oidc.TokenResponse>;
+}
+
+declare const AUTH_FLOW_STRATEGY: {
+    Code(injector: Injector): AuthCodeFlowStrategy;
+    Password(injector: Injector): AuthPasswordFlowStrategy;
+};
+
+declare class OAuthConfigurationHandler {
+    private oAuthService;
+    private environmentService;
+    private options;
+    constructor(oAuthService: OAuthService, environmentService: EnvironmentService, options: ABP.Root);
+    private listenToSetEnvironment;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OAuthConfigurationHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OAuthConfigurationHandler>;
+}
+
+declare class OAuthApiInterceptor implements IApiInterceptor {
+    private oAuthService;
+    private sessionState;
+    private httpWaitService;
+    private tenantKey;
+    constructor(oAuthService: OAuthService, sessionState: SessionStateService, httpWaitService: HttpWaitService, tenantKey: string);
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    getAdditionalHeaders(existingHeaders?: HttpHeaders): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OAuthApiInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OAuthApiInterceptor>;
+}
+
+/**
+ * @deprecated Use `abpOAuthGuard` *function* instead.
+ */
+declare class AbpOAuthGuard implements IAbpGuard {
+    protected readonly oAuthService: OAuthService;
+    protected readonly authService: AuthService;
+    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | boolean | UrlTree;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbpOAuthGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AbpOAuthGuard>;
+}
+declare const abpOAuthGuard: CanActivateFn;
+
+declare const NavigateToManageProfileProvider: Provider;
+
+declare function provideAbpOAuth(): i0.EnvironmentProviders;
+
+export { AUTH_FLOW_STRATEGY, AbpOAuthGuard, AbpOAuthModule, AbpOAuthService, AuthCodeFlowStrategy, AuthFlowStrategy, AuthPasswordFlowStrategy, NavigateToManageProfileProvider, OAuthApiInterceptor, OAuthConfigurationHandler, OAuthErrorFilterService, RememberMeService, abpOAuthGuard, checkAccessToken, clearOAuthStorage, isTokenExpired, oAuthStorage, pipeToLogin, provideAbpOAuth, storageFactory };

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@abp/ng.oauth",
-  "version": "9.3.0-rc.2",
+  "version": "9.3.0-rc.4",
   "homepage": "https://abp.io",
   "repository": {
     "type": "git",
     "url": "https://github.com/abpframework/abp.git"
   },
   "dependencies": {
-    "@abp/ng.core": "~9.3.0-rc.2",
-    "@abp/utils": "~9.3.0-rc.2",
-    "angular-oauth2-oidc": "^17.0.0",
+    "@abp/ng.core": "~9.3.0-rc.4",
+    "@abp/utils": "~9.3.0-rc.4",
+    "angular-oauth2-oidc": "^20.0.0",
     "just-clone": "^6.0.0",
     "just-compare": "^2.0.0",
     "tslib": "^2.0.0"

package/lib/guards/index.d.ts

@@ -1 +0,0 @@
-export * from './oauth.guard';

package/lib/guards/oauth.guard.d.ts

@@ -1,16 +0,0 @@
-import { UrlTree, ActivatedRouteSnapshot, RouterStateSnapshot, CanActivateFn } from '@angular/router';
-import { Observable } from 'rxjs';
-import { OAuthService } from 'angular-oauth2-oidc';
-import { AuthService, IAbpGuard } from '@abp/ng.core';
-import * as i0 from "@angular/core";
-/**
- * @deprecated Use `abpOAuthGuard` *function* instead.
- */
-export declare class AbpOAuthGuard implements IAbpGuard {
-    protected readonly oAuthService: OAuthService;
-    protected readonly authService: AuthService;
-    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | boolean | UrlTree;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AbpOAuthGuard, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AbpOAuthGuard>;
-}
-export declare const abpOAuthGuard: CanActivateFn;

package/lib/handlers/index.d.ts

@@ -1 +0,0 @@
-export * from './oauth-configuration.handler';

package/lib/handlers/oauth-configuration.handler.d.ts

@@ -1,12 +0,0 @@
-import { OAuthService } from "angular-oauth2-oidc";
-import { ABP, EnvironmentService } from '@abp/ng.core';
-import * as i0 from "@angular/core";
-export declare class OAuthConfigurationHandler {
-    private oAuthService;
-    private environmentService;
-    private options;
-    constructor(oAuthService: OAuthService, environmentService: EnvironmentService, options: ABP.Root);
-    private listenToSetEnvironment;
-    static ɵfac: i0.ɵɵFactoryDeclaration<OAuthConfigurationHandler, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<OAuthConfigurationHandler>;
-}

package/lib/interceptors/api.interceptor.d.ts

@@ -1,15 +0,0 @@
-import { HttpHandler, HttpHeaders, HttpRequest } from '@angular/common/http';
-import { OAuthService } from 'angular-oauth2-oidc';
-import { HttpWaitService, IApiInterceptor, SessionStateService } from '@abp/ng.core';
-import * as i0 from "@angular/core";
-export declare class OAuthApiInterceptor implements IApiInterceptor {
-    private oAuthService;
-    private sessionState;
-    private httpWaitService;
-    private tenantKey;
-    constructor(oAuthService: OAuthService, sessionState: SessionStateService, httpWaitService: HttpWaitService, tenantKey: string);
-    intercept(request: HttpRequest<any>, next: HttpHandler): import("rxjs").Observable<import("@angular/common/http").HttpEvent<any>>;
-    getAdditionalHeaders(existingHeaders?: HttpHeaders): any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<OAuthApiInterceptor, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<OAuthApiInterceptor>;
-}

package/lib/interceptors/index.d.ts

@@ -1 +0,0 @@
-export * from './api.interceptor';

package/lib/oauth.module.d.ts

@@ -1,11 +0,0 @@
-import { ModuleWithProviders } from '@angular/core';
-import * as i0 from "@angular/core";
-/**
- * @deprecated AbpOAuthModule is deprecated use `provideAbpOAuth` *function* instead.
- */
-export declare class AbpOAuthModule {
-    static forRoot(): ModuleWithProviders<AbpOAuthModule>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AbpOAuthModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<AbpOAuthModule, never, never, never>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<AbpOAuthModule>;
-}

package/lib/providers/index.d.ts

@@ -1,2 +0,0 @@
-export * from './navigate-to-manage-profile.provider';
-export * from './oauth-module-config.provider';

package/lib/providers/navigate-to-manage-profile.provider.d.ts

@@ -1,2 +0,0 @@
-import { Provider } from '@angular/core';
-export declare const NavigateToManageProfileProvider: Provider;

package/lib/providers/oauth-module-config.provider.d.ts

@@ -1 +0,0 @@
-export declare function provideAbpOAuth(): import("@angular/core").EnvironmentProviders;

package/lib/services/index.d.ts

@@ -1,3 +0,0 @@
-export * from './oauth.service';
-export * from './oauth-error-filter.service';
-export * from './remember-me.service';

package/lib/services/oauth-error-filter.service.d.ts

@@ -1,14 +0,0 @@
-import { OAuthErrorEvent } from 'angular-oauth2-oidc';
-import { AbstractAuthErrorFilter, AuthErrorFilter } from '@abp/ng.core';
-import * as i0 from "@angular/core";
-export declare class OAuthErrorFilterService extends AbstractAuthErrorFilter<AuthErrorFilter<OAuthErrorEvent>, OAuthErrorEvent> {
-    protected readonly _filters: import("@angular/core").WritableSignal<AuthErrorFilter<OAuthErrorEvent>[]>;
-    readonly filters: import("@angular/core").Signal<AuthErrorFilter<OAuthErrorEvent>[]>;
-    get(id: string): AuthErrorFilter<OAuthErrorEvent>;
-    add(filter: AuthErrorFilter<OAuthErrorEvent>): void;
-    patch(item: Partial<AuthErrorFilter<OAuthErrorEvent>>): void;
-    remove(id: string): void;
-    run(event: OAuthErrorEvent): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<OAuthErrorFilterService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<OAuthErrorFilterService>;
-}

package/lib/services/oauth.service.d.ts

@@ -1,27 +0,0 @@
-import { Injector } from '@angular/core';
-import { Params } from '@angular/router';
-import { Observable } from 'rxjs';
-import { AbpAuthResponse, IAuthService, LoginParams } from '@abp/ng.core';
-import { HttpHeaders } from '@angular/common/http';
-import * as i0 from "@angular/core";
-export declare class AbpOAuthService implements IAuthService {
-    protected injector: Injector;
-    private strategy;
-    private readonly oAuthService;
-    get oidc(): boolean;
-    set oidc(value: boolean);
-    get isInternalAuth(): boolean;
-    constructor(injector: Injector);
-    init(): Promise<any>;
-    logout(queryParams?: Params): Observable<any>;
-    navigateToLogin(queryParams?: Params): void;
-    login(params: LoginParams): Observable<any>;
-    get isAuthenticated(): boolean;
-    loginUsingGrant(grantType: string, parameters: object, headers?: HttpHeaders): Promise<AbpAuthResponse>;
-    getRefreshToken(): string;
-    getAccessToken(): string;
-    refreshToken(): Promise<AbpAuthResponse>;
-    getAccessTokenExpiration(): number;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AbpOAuthService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AbpOAuthService>;
-}

package/lib/services/remember-me.service.d.ts

@@ -1,12 +0,0 @@
-import { AbpLocalStorageService } from '@abp/ng.core';
-import * as i0 from "@angular/core";
-export declare class RememberMeService {
-    #private;
-    protected readonly localStorageService: AbpLocalStorageService;
-    set(remember: boolean): void;
-    remove(): void;
-    get(): boolean;
-    getFromToken(accessToken: string): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<RememberMeService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<RememberMeService>;
-}

package/lib/strategies/auth-code-flow-strategy.d.ts

@@ -1,15 +0,0 @@
-import { Params } from '@angular/router';
-import { AuthFlowStrategy } from './auth-flow-strategy';
-export declare class AuthCodeFlowStrategy extends AuthFlowStrategy {
-    readonly isInternalAuth = false;
-    init(): Promise<void>;
-    private checkRememberMeOption;
-    private getCultureParams;
-    protected setUICulture(): void;
-    protected replaceURLParams(): void;
-    protected listenToTokenReceived(): void;
-    navigateToLogin(queryParams?: Params): void;
-    checkIfInternalAuth(queryParams?: Params): boolean;
-    logout(queryParams?: Params): import("rxjs").Observable<any>;
-    login(queryParams?: Params): import("rxjs").Observable<null>;
-}

package/lib/strategies/auth-flow-strategy.d.ts

@@ -1,33 +0,0 @@
-import { Injector } from '@angular/core';
-import { Params, Router } from '@angular/router';
-import { Observable } from 'rxjs';
-import { AuthConfig, OAuthService as OAuthService2 } from 'angular-oauth2-oidc';
-import { AbpLocalStorageService, AbpWindowService, ConfigStateService, EnvironmentService, HttpErrorReporterService, LoginParams, SessionStateService } from '@abp/ng.core';
-import { OAuthErrorFilterService } from '../services';
-import { RememberMeService } from '../services/remember-me.service';
-export declare abstract class AuthFlowStrategy {
-    protected injector: Injector;
-    abstract readonly isInternalAuth: boolean;
-    protected httpErrorReporter: HttpErrorReporterService;
-    protected environment: EnvironmentService;
-    protected configState: ConfigStateService;
-    protected oAuthService: OAuthService2;
-    protected oAuthConfig: AuthConfig;
-    protected sessionState: SessionStateService;
-    protected localStorageService: AbpLocalStorageService;
-    protected rememberMeService: RememberMeService;
-    protected windowService: AbpWindowService;
-    protected tenantKey: string;
-    protected router: Router;
-    protected readonly oAuthErrorFilterService: OAuthErrorFilterService;
-    abstract checkIfInternalAuth(queryParams?: Params): boolean;
-    abstract navigateToLogin(queryParams?: Params): void;
-    abstract logout(queryParams?: Params): Observable<any>;
-    abstract login(params?: LoginParams | Params): Observable<any>;
-    private catchError;
-    constructor(injector: Injector);
-    init(): Promise<any>;
-    protected navigateToPreviousUrl(): void;
-    protected refreshToken(): Promise<void | import("angular-oauth2-oidc").TokenResponse>;
-    protected listenToOauthErrors(): void;
-}