@nebular/auth
Version:
@nebular/auth
1,105 lines (1,064 loc) • 38.1 kB
TypeScript
import * as i0 from '@angular/core';
import { InjectionToken, OnDestroy, ChangeDetectorRef, OnInit, Injector, ModuleWithProviders } from '@angular/core';
import { HttpHeaders, HttpResponse, HttpRequest, HttpInterceptor, HttpHandler, HttpEvent, HttpClient } from '@angular/common/http';
import { Observable, BehaviorSubject } from 'rxjs';
import * as i8 from '@angular/common';
import { Location } from '@angular/common';
import * as i10 from '@angular/router';
import { Router, Routes, ActivatedRoute } from '@angular/router';
import * as i9 from '@nebular/theme';
import * as i11 from '@angular/forms';
declare abstract class NbAuthToken {
protected payload: any;
abstract getValue(): string;
abstract isValid(): boolean;
abstract getOwnerStrategyName(): string;
abstract getCreatedAt(): Date;
abstract toString(): string;
getName(): string;
getPayload(): any;
}
declare class NbAuthTokenNotFoundError extends Error {
constructor(message: string);
}
declare class NbAuthIllegalTokenError extends Error {
constructor(message: string);
}
declare class NbAuthEmptyTokenError extends NbAuthIllegalTokenError {
constructor(message: string);
}
declare class NbAuthIllegalJWTTokenError extends NbAuthIllegalTokenError {
constructor(message: string);
}
interface NbAuthRefreshableToken {
getRefreshToken(): string;
setRefreshToken(refreshToken: string): any;
}
interface NbAuthTokenClass<T = NbAuthToken> {
NAME: string;
new (raw: any, strategyName: string, expDate?: Date): T;
}
declare function nbAuthCreateToken<T extends NbAuthToken>(tokenClass: NbAuthTokenClass<T>, token: any, ownerStrategyName: string, createdAt?: Date): T;
declare function decodeJwtPayload(payload: string): any;
/**
* Wrapper for simple (text) token
*/
declare class NbAuthSimpleToken extends NbAuthToken {
protected readonly token: any;
protected readonly ownerStrategyName: string;
protected createdAt?: Date;
static NAME: string;
constructor(token: any, ownerStrategyName: string, createdAt?: Date);
protected parsePayload(): any;
protected prepareCreatedAt(date: Date): Date;
/**
* Returns the token's creation date
* @returns {Date}
*/
getCreatedAt(): Date;
/**
* Returns the token value
* @returns string
*/
getValue(): string;
getOwnerStrategyName(): string;
/**
* Is non empty and valid
* @returns {boolean}
*/
isValid(): boolean;
/**
* Validate value and convert to string, if value is not valid return empty string
* @returns {string}
*/
toString(): string;
}
/**
* Wrapper for JWT token with additional methods.
*/
declare class NbAuthJWTToken extends NbAuthSimpleToken {
static NAME: string;
/**
* for JWT token, the iat (issued at) field of the token payload contains the creation Date
*/
protected prepareCreatedAt(date: Date): Date;
/**
* Returns payload object
* @returns any
*/
protected parsePayload(): void;
/**
* Returns expiration date
* @returns Date
*/
getTokenExpDate(): Date;
/**
* Is data expired
* @returns {boolean}
*/
isValid(): boolean;
}
/**
* Wrapper for OAuth2 token whose access_token is a JWT Token
*/
declare class NbAuthOAuth2Token extends NbAuthSimpleToken {
static NAME: string;
constructor(data: {
[key: string]: string | number;
} | string, ownerStrategyName: string, createdAt?: Date);
/**
* Returns the token value
* @returns string
*/
getValue(): string;
/**
* Returns the refresh token
* @returns string
*/
getRefreshToken(): string;
/**
* put refreshToken in the token payload
* @param refreshToken
*/
setRefreshToken(refreshToken: string): void;
/**
* Parses token payload
* @returns any
*/
protected parsePayload(): void;
/**
* Returns the token type
* @returns string
*/
getType(): string;
/**
* Is data expired
* @returns {boolean}
*/
isValid(): boolean;
/**
* Returns expiration date
* @returns Date
*/
getTokenExpDate(): Date;
/**
* Convert to string
* @returns {string}
*/
toString(): string;
}
/**
* Wrapper for OAuth2 token embedding JWT tokens
*/
declare class NbAuthOAuth2JWTToken extends NbAuthOAuth2Token {
static NAME: string;
protected accessTokenPayload: any;
protected parsePayload(): void;
protected parseAccessTokenPayload(): any;
/**
* Returns access token payload
* @returns any
*/
getAccessTokenPayload(): any;
/**
* for Oauth2 JWT token, the iat (issued at) field of the access_token payload
*/
protected prepareCreatedAt(date: Date): Date;
/**
* Is token valid
* @returns {boolean}
*/
isValid(): boolean;
/**
* Returns expiration date :
* - exp if set,
* - super.getExpDate() otherwise
* @returns Date
*/
getTokenExpDate(): Date;
}
declare class NbAuthResult {
protected success: boolean;
protected response?: any;
protected redirect?: any;
protected token: NbAuthToken;
protected errors: string[];
protected messages: string[];
constructor(success: boolean, response?: any, redirect?: any, errors?: any, messages?: any, token?: NbAuthToken);
getResponse(): any;
getToken(): NbAuthToken;
getRedirect(): string;
getErrors(): string[];
getMessages(): string[];
isSuccess(): boolean;
isFailure(): boolean;
}
/**
* @license
* Copyright Akveo. All Rights Reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*/
interface NbStrategyToken {
class?: NbAuthTokenClass;
[key: string]: any;
}
declare class NbAuthStrategyOptions {
name: string;
token?: NbStrategyToken;
headers?: HttpHeaders | {
[header: string]: string | string[];
};
}
declare abstract class NbAuthStrategy {
protected defaultOptions: NbAuthStrategyOptions;
protected options: NbAuthStrategyOptions;
setOptions(options: any): void;
getOption(key: string): any;
createToken<T extends NbAuthToken>(value: any, failWhenInvalidToken?: boolean): T;
getName(): string;
abstract authenticate(data?: any): Observable<NbAuthResult>;
abstract register(data?: any): Observable<NbAuthResult>;
abstract requestPassword(data?: any): Observable<NbAuthResult>;
abstract resetPassword(data?: any): Observable<NbAuthResult>;
abstract logout(): Observable<NbAuthResult>;
abstract refreshToken(data?: any): Observable<NbAuthResult>;
protected createFailResponse(data?: any): HttpResponse<Object>;
protected createSuccessResponse(data?: any): HttpResponse<Object>;
protected getActionEndpoint(action: string): string;
protected getHeaders(): HttpHeaders;
}
type NbAuthStrategyClass = new (...params: any[]) => NbAuthStrategy;
type NbAuthStrategies = [NbAuthStrategyClass, NbAuthStrategyOptions][];
interface NbAuthOptions {
forms?: any;
strategies?: NbAuthStrategies;
}
interface NbAuthSocialLink {
link?: string;
url?: string;
target?: string;
title?: string;
icon?: string;
}
declare const defaultAuthOptions: any;
declare const NB_AUTH_OPTIONS: InjectionToken<NbAuthOptions>;
declare const NB_AUTH_USER_OPTIONS: InjectionToken<NbAuthOptions>;
declare const NB_AUTH_STRATEGIES: InjectionToken<NbAuthStrategies>;
declare const NB_AUTH_TOKENS: InjectionToken<NbAuthTokenClass<NbAuthToken>[]>;
declare const NB_AUTH_INTERCEPTOR_HEADER: InjectionToken<string>;
declare const NB_AUTH_TOKEN_INTERCEPTOR_FILTER: InjectionToken<(req: HttpRequest<any>) => boolean>;
interface NbTokenPack {
name: string;
ownerStrategyName: string;
createdAt: Number;
value: string;
}
declare const NB_AUTH_FALLBACK_TOKEN: InjectionToken<NbAuthTokenClass<NbAuthToken>>;
/**
* Creates a token parcel which could be stored/restored
*/
declare class NbAuthTokenParceler {
private fallbackClass;
private tokenClasses;
constructor(fallbackClass: NbAuthTokenClass, tokenClasses: NbAuthTokenClass[]);
wrap(token: NbAuthToken): string;
unwrap(value: string): NbAuthToken;
protected getClassByName(name: any): NbAuthTokenClass;
protected parseTokenPack(value: any): NbTokenPack;
static ɵfac: i0.ɵɵFactoryDeclaration<NbAuthTokenParceler, never>;
static ɵprov: i0.ɵɵInjectableDeclaration<NbAuthTokenParceler>;
}
declare abstract class NbTokenStorage {
abstract get(): NbAuthToken;
abstract set(token: NbAuthToken): any;
abstract clear(): any;
}
/**
* Service that uses browser localStorage as a storage.
*
* The token storage is provided into auth module the following way:
* ```ts
* { provide: NbTokenStorage, useClass: NbTokenLocalStorage },
* ```
*
* If you need to change the storage behaviour or provide your own - just extend your class from basic `NbTokenStorage`
* or `NbTokenLocalStorage` and provide in your `app.module`:
* ```ts
* { provide: NbTokenStorage, useClass: NbTokenCustomStorage },
* ```
*
*/
declare class NbTokenLocalStorage extends NbTokenStorage {
private parceler;
protected key: string;
constructor(parceler: NbAuthTokenParceler);
/**
* Returns token from localStorage
* @returns {NbAuthToken}
*/
get(): NbAuthToken;
/**
* Sets token to localStorage
* @param {NbAuthToken} token
*/
set(token: NbAuthToken): void;
/**
* Clears token from localStorage
*/
clear(): void;
static ɵfac: i0.ɵɵFactoryDeclaration<NbTokenLocalStorage, never>;
static ɵprov: i0.ɵɵInjectableDeclaration<NbTokenLocalStorage>;
}
/**
* Service that allows you to manage authentication token - get, set, clear and also listen to token changes over time.
*/
declare class NbTokenService {
protected tokenStorage: NbTokenStorage;
protected token$: BehaviorSubject<NbAuthToken>;
constructor(tokenStorage: NbTokenStorage);
/**
* Publishes token when it changes.
* @returns {Observable<NbAuthToken>}
*/
tokenChange(): Observable<NbAuthToken>;
/**
* Sets a token into the storage. This method is used by the NbAuthService automatically.
*
* @param {NbAuthToken} token
* @returns {Observable<any>}
*/
set(token: NbAuthToken): Observable<null>;
/**
* Returns observable of current token
* @returns {Observable<NbAuthToken>}
*/
get(): Observable<NbAuthToken>;
/**
* Removes the token and published token value
*
* @returns {Observable<any>}
*/
clear(): Observable<null>;
protected publishStoredToken(): void;
static ɵfac: i0.ɵɵFactoryDeclaration<NbTokenService, never>;
static ɵprov: i0.ɵɵInjectableDeclaration<NbTokenService>;
}
/**
* Common authentication service.
* Should be used to as an interlayer between UI Components and Auth Strategy.
*/
declare class NbAuthService {
protected tokenService: NbTokenService;
protected strategies: any;
constructor(tokenService: NbTokenService, strategies: any);
/**
* Retrieves current authenticated token stored
* @returns {Observable<any>}
*/
getToken(): Observable<NbAuthToken>;
/**
* Returns true if auth token is present in the token storage
* @returns {Observable<boolean>}
*/
isAuthenticated(): Observable<boolean>;
/**
* Returns true if valid auth token is present in the token storage.
* If not, calls the strategy refreshToken, and returns isAuthenticated() if success, false otherwise
* @returns {Observable<boolean>}
*/
isAuthenticatedOrRefresh(): Observable<boolean>;
/**
* Returns tokens stream
* @returns {Observable<NbAuthSimpleToken>}
*/
onTokenChange(): Observable<NbAuthToken>;
/**
* Returns authentication status stream
* @returns {Observable<boolean>}
*/
onAuthenticationChange(): Observable<boolean>;
/**
* Authenticates with the selected strategy
* Stores received token in the token storage
*
* Example:
* authenticate('email', {email: 'email@example.com', password: 'test'})
*
* @param strategyName
* @param data
* @returns {Observable<NbAuthResult>}
*/
authenticate(strategyName: string, data?: any): Observable<NbAuthResult>;
/**
* Registers with the selected strategy
* Stores received token in the token storage
*
* Example:
* register('email', {email: 'email@example.com', name: 'Some Name', password: 'test'})
*
* @param strategyName
* @param data
* @returns {Observable<NbAuthResult>}
*/
register(strategyName: string, data?: any): Observable<NbAuthResult>;
/**
* Sign outs with the selected strategy
* Removes token from the token storage
*
* Example:
* logout('email')
*
* @param strategyName
* @returns {Observable<NbAuthResult>}
*/
logout(strategyName: string): Observable<NbAuthResult>;
/**
* Sends forgot password request to the selected strategy
*
* Example:
* requestPassword('email', {email: 'email@example.com'})
*
* @param strategyName
* @param data
* @returns {Observable<NbAuthResult>}
*/
requestPassword(strategyName: string, data?: any): Observable<NbAuthResult>;
/**
* Tries to reset password with the selected strategy
*
* Example:
* resetPassword('email', {newPassword: 'test'})
*
* @param strategyName
* @param data
* @returns {Observable<NbAuthResult>}
*/
resetPassword(strategyName: string, data?: any): Observable<NbAuthResult>;
/**
* Sends a refresh token request
* Stores received token in the token storage
*
* Example:
* refreshToken('email', {token: token})
*
* @param {string} strategyName
* @param data
* @returns {Observable<NbAuthResult>}
*/
refreshToken(strategyName: string, data?: any): Observable<NbAuthResult>;
/**
* Get registered strategy by name
*
* Example:
* getStrategy('email')
*
* @param {string} provider
* @returns {NbAbstractAuthProvider}
*/
protected getStrategy(strategyName: string): NbAuthStrategy;
private processResultToken;
static ɵfac: i0.ɵɵFactoryDeclaration<NbAuthService, never>;
static ɵprov: i0.ɵɵInjectableDeclaration<NbAuthService>;
}
/**
* @license
* Copyright Akveo. All Rights Reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*/
declare class NbAuthComponent implements OnDestroy {
protected auth: NbAuthService;
protected location: Location;
private destroy$;
subscription: any;
authenticated: boolean;
token: string;
constructor(auth: NbAuthService, location: Location);
back(): boolean;
ngOnDestroy(): void;
static ɵfac: i0.ɵɵFactoryDeclaration<NbAuthComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<NbAuthComponent, "nb-auth", never, {}, {}, never, never, false, never>;
}
declare class NbAuthBlockComponent {
static ɵfac: i0.ɵɵFactoryDeclaration<NbAuthBlockComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<NbAuthBlockComponent, "nb-auth-block", never, {}, {}, never, ["*"], false, never>;
}
/**
* @license
* Copyright Akveo. All Rights Reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*/
declare class NbLoginComponent {
protected service: NbAuthService;
protected options: {};
protected cd: ChangeDetectorRef;
protected router: Router;
redirectDelay: number;
showMessages: any;
strategy: string;
errors: string[];
messages: string[];
user: any;
submitted: boolean;
socialLinks: NbAuthSocialLink[];
rememberMe: boolean;
constructor(service: NbAuthService, options: {}, cd: ChangeDetectorRef, router: Router);
login(): void;
getConfigValue(key: string): any;
static ɵfac: i0.ɵɵFactoryDeclaration<NbLoginComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<NbLoginComponent, "nb-login", never, {}, {}, never, never, false, never>;
}
/**
* @license
* Copyright Akveo. All Rights Reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*/
declare class NbRegisterComponent {
protected service: NbAuthService;
protected options: {};
protected cd: ChangeDetectorRef;
protected router: Router;
redirectDelay: number;
showMessages: any;
strategy: string;
submitted: boolean;
errors: string[];
messages: string[];
user: any;
socialLinks: NbAuthSocialLink[];
constructor(service: NbAuthService, options: {}, cd: ChangeDetectorRef, router: Router);
register(): void;
getConfigValue(key: string): any;
static ɵfac: i0.ɵɵFactoryDeclaration<NbRegisterComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<NbRegisterComponent, "nb-register", never, {}, {}, never, never, false, never>;
}
/**
* @license
* Copyright Akveo. All Rights Reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*/
declare class NbRequestPasswordComponent {
protected service: NbAuthService;
protected options: {};
protected cd: ChangeDetectorRef;
protected router: Router;
redirectDelay: number;
showMessages: any;
strategy: string;
submitted: boolean;
errors: string[];
messages: string[];
user: any;
constructor(service: NbAuthService, options: {}, cd: ChangeDetectorRef, router: Router);
requestPass(): void;
getConfigValue(key: string): any;
static ɵfac: i0.ɵɵFactoryDeclaration<NbRequestPasswordComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<NbRequestPasswordComponent, "nb-request-password-page", never, {}, {}, never, never, false, never>;
}
/**
* @license
* Copyright Akveo. All Rights Reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*/
declare class NbResetPasswordComponent {
protected service: NbAuthService;
protected options: {};
protected cd: ChangeDetectorRef;
protected router: Router;
redirectDelay: number;
showMessages: any;
strategy: string;
submitted: boolean;
errors: string[];
messages: string[];
user: any;
constructor(service: NbAuthService, options: {}, cd: ChangeDetectorRef, router: Router);
resetPass(): void;
getConfigValue(key: string): any;
static ɵfac: i0.ɵɵFactoryDeclaration<NbResetPasswordComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<NbResetPasswordComponent, "nb-reset-password-page", never, {}, {}, never, never, false, never>;
}
/**
* @license
* Copyright Akveo. All Rights Reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*/
declare class NbLogoutComponent implements OnInit {
protected service: NbAuthService;
protected options: {};
protected router: Router;
redirectDelay: number;
strategy: string;
constructor(service: NbAuthService, options: {}, router: Router);
ngOnInit(): void;
logout(strategy: string): void;
getConfigValue(key: string): any;
static ɵfac: i0.ɵɵFactoryDeclaration<NbLogoutComponent, never>;
static ɵcmp: i0.ɵɵComponentDeclaration<NbLogoutComponent, "nb-logout", never, {}, {}, never, never, false, never>;
}
declare function nbStrategiesFactory(options: NbAuthOptions, injector: Injector): NbAuthStrategy[];
declare function nbTokensFactory(strategies: NbAuthStrategy[]): NbAuthTokenClass[];
declare function nbOptionsFactory(options: any): any;
declare function nbNoOpInterceptorFilter(req: HttpRequest<any>): boolean;
declare class NbAuthModule {
static forRoot(nbAuthOptions?: NbAuthOptions): ModuleWithProviders<NbAuthModule>;
static ɵfac: i0.ɵɵFactoryDeclaration<NbAuthModule, never>;
static ɵmod: i0.ɵɵNgModuleDeclaration<NbAuthModule, [typeof NbAuthComponent, typeof NbAuthBlockComponent, typeof NbLoginComponent, typeof NbRegisterComponent, typeof NbRequestPasswordComponent, typeof NbResetPasswordComponent, typeof NbLogoutComponent], [typeof i8.CommonModule, typeof i9.NbLayoutModule, typeof i9.NbCardModule, typeof i9.NbCheckboxModule, typeof i9.NbAlertModule, typeof i9.NbInputModule, typeof i9.NbButtonModule, typeof i10.RouterModule, typeof i11.FormsModule, typeof i9.NbIconModule], [typeof NbAuthComponent, typeof NbAuthBlockComponent, typeof NbLoginComponent, typeof NbRegisterComponent, typeof NbRequestPasswordComponent, typeof NbResetPasswordComponent, typeof NbLogoutComponent]>;
static ɵinj: i0.ɵɵInjectorDeclaration<NbAuthModule>;
}
/**
* @license
* Copyright Akveo. All Rights Reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*/
declare const routes: Routes;
declare class NbAuthJWTInterceptor implements HttpInterceptor {
private injector;
protected filter: any;
constructor(injector: Injector, filter: any);
intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
protected get authService(): NbAuthService;
static ɵfac: i0.ɵɵFactoryDeclaration<NbAuthJWTInterceptor, never>;
static ɵprov: i0.ɵɵInjectableDeclaration<NbAuthJWTInterceptor>;
}
declare class NbAuthSimpleInterceptor implements HttpInterceptor {
private injector;
protected headerName: string;
constructor(injector: Injector, headerName?: string);
intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
protected get authService(): NbAuthService;
static ɵfac: i0.ɵɵFactoryDeclaration<NbAuthSimpleInterceptor, never>;
static ɵprov: i0.ɵɵInjectableDeclaration<NbAuthSimpleInterceptor>;
}
/**
* @license
* Copyright Akveo. All Rights Reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*/
declare class NbDummyAuthStrategyOptions extends NbAuthStrategyOptions {
token?: NbStrategyToken;
delay?: number;
alwaysFail?: boolean;
}
declare const dummyStrategyOptions: NbDummyAuthStrategyOptions;
/**
* Dummy auth strategy. Could be useful for auth setup when backend is not available yet.
*
*
* Strategy settings.
*
* ```ts
* export class NbDummyAuthStrategyOptions extends NbAuthStrategyOptions {
* name = 'dummy';
* token = {
* class: NbAuthSimpleToken,
* };
* delay? = 1000;
* alwaysFail? = false;
* }
* ```
*/
declare class NbDummyAuthStrategy extends NbAuthStrategy {
protected defaultOptions: NbDummyAuthStrategyOptions;
static setup(options: NbDummyAuthStrategyOptions): [NbAuthStrategyClass, NbDummyAuthStrategyOptions];
authenticate(data?: any): Observable<NbAuthResult>;
register(data?: any): Observable<NbAuthResult>;
requestPassword(data?: any): Observable<NbAuthResult>;
resetPassword(data?: any): Observable<NbAuthResult>;
logout(data?: any): Observable<NbAuthResult>;
refreshToken(data?: any): Observable<NbAuthResult>;
protected createDummyResult(data?: any): NbAuthResult;
static ɵfac: i0.ɵɵFactoryDeclaration<NbDummyAuthStrategy, never>;
static ɵprov: i0.ɵɵInjectableDeclaration<NbDummyAuthStrategy>;
}
/**
* @license
* Copyright Akveo. All Rights Reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*/
interface NbPasswordStrategyModule {
alwaysFail?: boolean;
endpoint?: string;
method?: string;
redirect?: {
success?: string | null;
failure?: string | null;
};
requireValidToken?: boolean;
defaultErrors?: string[];
defaultMessages?: string[];
}
interface NbPasswordStrategyReset extends NbPasswordStrategyModule {
resetPasswordTokenKey?: string;
}
interface NbPasswordStrategyToken {
class?: NbAuthTokenClass;
key?: string;
getter?: Function;
}
interface NbPasswordStrategyMessage {
key?: string;
getter?: Function;
}
declare class NbPasswordAuthStrategyOptions extends NbAuthStrategyOptions {
baseEndpoint?: string;
login?: boolean | NbPasswordStrategyModule;
register?: boolean | NbPasswordStrategyModule;
requestPass?: boolean | NbPasswordStrategyModule;
resetPass?: boolean | NbPasswordStrategyReset;
logout?: boolean | NbPasswordStrategyReset;
refreshToken?: boolean | NbPasswordStrategyModule;
token?: NbPasswordStrategyToken;
errors?: NbPasswordStrategyMessage;
messages?: NbPasswordStrategyMessage;
validation?: {
password?: {
required?: boolean;
minLength?: number | null;
maxLength?: number | null;
regexp?: string | null;
};
email?: {
required?: boolean;
regexp?: string | null;
};
fullName?: {
required?: boolean;
minLength?: number | null;
maxLength?: number | null;
regexp?: string | null;
};
};
}
declare const passwordStrategyOptions: NbPasswordAuthStrategyOptions;
/**
* The most common authentication provider for email/password strategy.
*
* Strategy settings. Note, there is no need to copy over the whole object to change the settings you need.
* Also, this.getOption call won't work outside of the default options declaration
* (which is inside of the `NbPasswordAuthStrategy` class), so you have to replace it with a custom helper function
* if you need it.
*
* ```ts
*export class NbPasswordAuthStrategyOptions extends NbAuthStrategyOptions {
* name: string;
* baseEndpoint? = '/api/auth/';
* login?: boolean | NbPasswordStrategyModule = {
* alwaysFail: false,
* endpoint: 'login',
* method: 'post',
* requireValidToken: true,
* redirect: {
* success: '/',
* failure: null,
* },
* defaultErrors: ['Login/Email combination is not correct, please try again.'],
* defaultMessages: ['You have been successfully logged in.'],
* };
* register?: boolean | NbPasswordStrategyModule = {
* alwaysFail: false,
* endpoint: 'register',
* method: 'post',
* requireValidToken: true,
* redirect: {
* success: '/',
* failure: null,
* },
* defaultErrors: ['Something went wrong, please try again.'],
* defaultMessages: ['You have been successfully registered.'],
* };
* requestPass?: boolean | NbPasswordStrategyModule = {
* endpoint: 'request-pass',
* method: 'post',
* redirect: {
* success: '/',
* failure: null,
* },
* defaultErrors: ['Something went wrong, please try again.'],
* defaultMessages: ['Reset password instructions have been sent to your email.'],
* };
* resetPass?: boolean | NbPasswordStrategyReset = {
* endpoint: 'reset-pass',
* method: 'put',
* redirect: {
* success: '/',
* failure: null,
* },
* resetPasswordTokenKey: 'reset_password_token',
* defaultErrors: ['Something went wrong, please try again.'],
* defaultMessages: ['Your password has been successfully changed.'],
* };
* logout?: boolean | NbPasswordStrategyReset = {
* alwaysFail: false,
* endpoint: 'logout',
* method: 'delete',
* redirect: {
* success: '/',
* failure: null,
* },
* defaultErrors: ['Something went wrong, please try again.'],
* defaultMessages: ['You have been successfully logged out.'],
* };
* refreshToken?: boolean | NbPasswordStrategyModule = {
* endpoint: 'refresh-token',
* method: 'post',
* requireValidToken: true,
* redirect: {
* success: null,
* failure: null,
* },
* defaultErrors: ['Something went wrong, please try again.'],
* defaultMessages: ['Your token has been successfully refreshed.'],
* };
* token?: NbPasswordStrategyToken = {
* class: NbAuthSimpleToken,
* key: 'data.token',
* getter: (module: string, res: HttpResponse<Object>, options: NbPasswordAuthStrategyOptions) => getDeepFromObject(
* res.body,
* options.token.key,
* ),
* };
* errors?: NbPasswordStrategyMessage = {
* key: 'data.errors',
* getter: (module: string, res: HttpErrorResponse, options: NbPasswordAuthStrategyOptions) => getDeepFromObject(
* res.error,
* options.errors.key,
* options[module].defaultErrors,
* ),
* };
* messages?: NbPasswordStrategyMessage = {
* key: 'data.messages',
* getter: (module: string, res: HttpResponse<Object>, options: NbPasswordAuthStrategyOptions) => getDeepFromObject(
* res.body,
* options.messages.key,
* options[module].defaultMessages,
* ),
* };
* validation?: {
* password?: {
* required?: boolean;
* minLength?: number | null;
* maxLength?: number | null;
* regexp?: string | null;
* };
* email?: {
* required?: boolean;
* regexp?: string | null;
* };
* fullName?: {
* required?: boolean;
* minLength?: number | null;
* maxLength?: number | null;
* regexp?: string | null;
* };
* };
*}
* ```
*/
declare class NbPasswordAuthStrategy extends NbAuthStrategy {
protected http: HttpClient;
private route;
protected defaultOptions: NbPasswordAuthStrategyOptions;
static setup(options: NbPasswordAuthStrategyOptions): [NbAuthStrategyClass, NbPasswordAuthStrategyOptions];
constructor(http: HttpClient, route: ActivatedRoute);
authenticate(data?: any): Observable<NbAuthResult>;
register(data?: any): Observable<NbAuthResult>;
requestPassword(data?: any): Observable<NbAuthResult>;
resetPassword(data?: any): Observable<NbAuthResult>;
logout(): Observable<NbAuthResult>;
refreshToken(data?: any): Observable<NbAuthResult>;
protected handleResponseError(res: any, module: string): Observable<NbAuthResult>;
static ɵfac: i0.ɵɵFactoryDeclaration<NbPasswordAuthStrategy, never>;
static ɵprov: i0.ɵɵInjectableDeclaration<NbPasswordAuthStrategy>;
}
/**
* @license
* Copyright Akveo. All Rights Reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*/
declare enum NbOAuth2ResponseType {
CODE = "code",
TOKEN = "token"
}
declare enum NbOAuth2GrantType {
AUTHORIZATION_CODE = "authorization_code",
PASSWORD = "password",
REFRESH_TOKEN = "refresh_token"
}
declare enum NbOAuth2ClientAuthMethod {
NONE = "none",
BASIC = "basic",
REQUEST_BODY = "request-body"
}
declare class NbOAuth2AuthStrategyOptions extends NbAuthStrategyOptions {
baseEndpoint?: string;
clientId: string;
clientSecret?: string;
clientAuthMethod?: string;
redirect?: {
success?: string;
failure?: string;
};
defaultErrors?: any[];
defaultMessages?: any[];
authorize?: {
endpoint?: string;
redirectUri?: string;
responseType?: string;
requireValidToken?: boolean;
scope?: string;
state?: string;
params?: {
[key: string]: string;
};
};
token?: {
endpoint?: string;
grantType?: string;
redirectUri?: string;
scope?: string;
requireValidToken?: boolean;
class: NbAuthTokenClass;
};
refresh?: {
endpoint?: string;
grantType?: string;
scope?: string;
requireValidToken?: boolean;
};
}
declare const auth2StrategyOptions: NbOAuth2AuthStrategyOptions;
/**
* OAuth2 authentication strategy.
*
* Strategy settings:
*
* ```ts
* export enum NbOAuth2ResponseType {
* CODE = 'code',
* TOKEN = 'token',
* }
*
* export enum NbOAuth2GrantType {
* AUTHORIZATION_CODE = 'authorization_code',
* PASSWORD = 'password',
* REFRESH_TOKEN = 'refresh_token',
* }
*
* export class NbOAuth2AuthStrategyOptions {
* name: string;
* baseEndpoint?: string = '';
* clientId: string = '';
* clientSecret: string = '';
* clientAuthMethod: string = NbOAuth2ClientAuthMethod.NONE;
* redirect?: { success?: string; failure?: string } = {
* success: '/',
* failure: null,
* };
* defaultErrors?: any[] = ['Something went wrong, please try again.'];
* defaultMessages?: any[] = ['You have been successfully authenticated.'];
* authorize?: {
* endpoint?: string;
* redirectUri?: string;
* responseType?: string;
* requireValidToken: true,
* scope?: string;
* state?: string;
* params?: { [key: string]: string };
* } = {
* endpoint: 'authorize',
* responseType: NbOAuth2ResponseType.CODE,
* };
* token?: {
* endpoint?: string;
* grantType?: string;
* requireValidToken: true,
* redirectUri?: string;
* scope?: string;
* class: NbAuthTokenClass,
* } = {
* endpoint: 'token',
* grantType: NbOAuth2GrantType.AUTHORIZATION_CODE,
* class: NbAuthOAuth2Token,
* };
* refresh?: {
* endpoint?: string;
* grantType?: string;
* scope?: string;
* requireValidToken: true,
* } = {
* endpoint: 'token',
* grantType: NbOAuth2GrantType.REFRESH_TOKEN,
* };
* }
* ```
*
*/
declare class NbOAuth2AuthStrategy extends NbAuthStrategy {
protected http: HttpClient;
protected route: ActivatedRoute;
protected window: any;
static setup(options: NbOAuth2AuthStrategyOptions): [NbAuthStrategyClass, NbOAuth2AuthStrategyOptions];
get responseType(): any;
get clientAuthMethod(): any;
protected redirectResultHandlers: {
[key: string]: Function;
};
protected redirectResults: {
[key: string]: Function;
};
protected defaultOptions: NbOAuth2AuthStrategyOptions;
constructor(http: HttpClient, route: ActivatedRoute, window: any);
authenticate(data?: any): Observable<NbAuthResult>;
getAuthorizationResult(): Observable<any>;
refreshToken(token: NbAuthRefreshableToken): Observable<NbAuthResult>;
passwordToken(username: string, password: string): Observable<NbAuthResult>;
protected authorizeRedirect(): void;
protected isRedirectResult(): Observable<boolean>;
protected requestToken(code: string): Observable<NbAuthResult>;
protected buildCodeRequestData(code: string): any;
protected buildRefreshRequestData(token: NbAuthRefreshableToken): any;
protected buildPasswordRequestData(username: string, password: string): string;
protected buildAuthHeader(): HttpHeaders | undefined;
protected getHeaders(): HttpHeaders;
protected cleanParams(params: any): any;
protected addCredentialsToParams(params: any): any;
protected handleResponseError(res: any): Observable<NbAuthResult>;
protected buildRedirectUrl(): string;
protected parseHashAsQueryParams(hash: string): {
[key: string]: string;
};
protected urlEncodeParameters(params: any): string;
protected createRefreshedToken(res: any, existingToken: NbAuthRefreshableToken, requireValidToken: boolean): NbAuthToken;
register(data?: any): Observable<NbAuthResult>;
requestPassword(data?: any): Observable<NbAuthResult>;
resetPassword(data?: any): Observable<NbAuthResult>;
logout(): Observable<NbAuthResult>;
static ɵfac: i0.ɵɵFactoryDeclaration<NbOAuth2AuthStrategy, never>;
static ɵprov: i0.ɵɵInjectableDeclaration<NbOAuth2AuthStrategy>;
}
declare class NbUser {
id?: number;
email?: string;
password?: string;
rememberMe?: boolean;
terms?: boolean;
confirmPassword?: string;
fullName?: string;
constructor(id?: number, email?: string, password?: string, rememberMe?: boolean, terms?: boolean, confirmPassword?: string, fullName?: string);
}
/**
* Extending object that entered in first argument.
*
* Returns extended object or false if have no target object or incorrect type.
*
* If you wish to clone source object (without modify it), just use empty new
* object as first argument, like this:
* deepExtend({}, yourObj_1, [yourObj_N]);
*/
declare const deepExtend: (...objects: any[]) => any;
declare function getDeepFromObject(object: {}, name: string, defaultValue?: any): any;
declare function urlBase64Decode(str: string): string;
declare function b64decode(str: string): string;
declare function b64DecodeUnicode(str: any): string;
export { NB_AUTH_FALLBACK_TOKEN, NB_AUTH_INTERCEPTOR_HEADER, NB_AUTH_OPTIONS, NB_AUTH_STRATEGIES, NB_AUTH_TOKENS, NB_AUTH_TOKEN_INTERCEPTOR_FILTER, NB_AUTH_USER_OPTIONS, NbAuthBlockComponent, NbAuthComponent, NbAuthEmptyTokenError, NbAuthIllegalJWTTokenError, NbAuthIllegalTokenError, NbAuthJWTInterceptor, NbAuthJWTToken, NbAuthModule, NbAuthOAuth2JWTToken, NbAuthOAuth2Token, NbAuthResult, NbAuthService, NbAuthSimpleInterceptor, NbAuthSimpleToken, NbAuthStrategy, NbAuthStrategyOptions, NbAuthToken, NbAuthTokenNotFoundError, NbAuthTokenParceler, NbDummyAuthStrategy, NbDummyAuthStrategyOptions, NbLoginComponent, NbLogoutComponent, NbOAuth2AuthStrategy, NbOAuth2AuthStrategyOptions, NbOAuth2ClientAuthMethod, NbOAuth2GrantType, NbOAuth2ResponseType, NbPasswordAuthStrategy, NbPasswordAuthStrategyOptions, NbRegisterComponent, NbRequestPasswordComponent, NbResetPasswordComponent, NbTokenLocalStorage, NbTokenService, NbTokenStorage, NbUser, auth2StrategyOptions, b64DecodeUnicode, b64decode, decodeJwtPayload, deepExtend, defaultAuthOptions, dummyStrategyOptions, getDeepFromObject, nbAuthCreateToken, nbNoOpInterceptorFilter, nbOptionsFactory, nbStrategiesFactory, nbTokensFactory, passwordStrategyOptions, routes, urlBase64Decode };
export type { NbAuthOptions, NbAuthRefreshableToken, NbAuthSocialLink, NbAuthStrategies, NbAuthStrategyClass, NbAuthTokenClass, NbPasswordStrategyMessage, NbPasswordStrategyModule, NbPasswordStrategyReset, NbPasswordStrategyToken, NbStrategyToken, NbTokenPack };