@hichchi/ngx-auth 0.0.1-alpha.0

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

@@ -0,0 +1,328 @@
+import { HttpClient } from "@angular/common/http";
+import { Observable } from "rxjs";
+import { AccessToken, AuthResponse, RefreshToken, SignInBody, SignUpBody, TokenResponse, User } from "@hichchi/nest-connector/auth";
+import { SuccessResponse } from "@hichchi/nest-connector";
+import { AuthConfig } from "../interfaces";
+import * as i0 from "@angular/core";
+/**
+ * Angular authentication service for client-side authentication operations
+ *
+ * This service provides methods for handling authentication operations in Angular applications,
+ * including user sign-in, sign-up, Google OAuth authentication, token management, and sign-out.
+ * It communicates with the backend authentication API and handles the client-side aspects
+ * of the authentication flow.
+ *
+ * The service is configured through the AuthConfig interface and automatically handles
+ * token expiration date parsing and HTTP request management. It integrates seamlessly
+ * with the @hichchi/nest-auth backend module.
+ *
+ * Key features:
+ * - Local authentication (email/username and password)
+ * - Google OAuth authentication with popup flow
+ * - Token refresh functionality
+ * - User registration
+ * - Automatic token expiration handling
+ * - RESTful API communication
+ *
+ * @example
+ * ```typescript
+ * // In a component
+ * export class LoginComponent {
+ *   constructor(private authService: AuthService) {}
+ *
+ *   async signIn() {
+ *     try {
+ *       const response = await this.authService.signIn({
+ *         email: 'user@example.com',
+ *         password: 'password123'
+ *       }).toPromise();
+ *       console.log('Signed in:', response.user);
+ *     } catch (error) {
+ *       console.error('Sign in failed:', error);
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link AuthConfig} Configuration interface for the authentication service
+ * @see {@link NgxHichchiAuthModule} Module that provides this service
+ * @see {@link AuthState} State management service for authentication
+ * @see {@link AuthResponse} Response interface for authentication operations
+ */
+export declare class AuthService {
+    private readonly http;
+    private readonly config;
+    /**
+     * Creates an instance of AuthService
+     *
+     * @param http - Http client
+     * @param config - The authentication configuration injected from AUTH_CONFIG token
+     *
+     * @see {@link AUTH_CONFIG} Injection token for authentication configuration
+     * @see {@link AuthConfig} Interface defining the configuration structure
+     */
+    constructor(http: HttpClient, config: AuthConfig);
+    /**
+     * Authenticates a user with email/username and password
+     *
+     * This method sends a sign-in request to the backend authentication API with the provided
+     * credentials. It automatically converts the token expiration timestamps from the response
+     * into JavaScript Date objects for easier handling in the client application.
+     *
+     * @param dto - The sign-in data containing user credentials
+     * @returns Observable that emits the authentication response with user data and tokens
+     *
+     * @example
+     * ```typescript
+     * // Sign in with email and password
+     * this.authService.signIn({
+     *   email: 'user@example.com',
+     *   password: 'password123'
+     * }).subscribe({
+     *   next: (response) => {
+     *     console.log('User signed in:', response.user);
+     *     console.log('Access token expires:', response.accessTokenExpiresOn);
+     *   },
+     *   error: (error) => {
+     *     console.error('Sign in failed:', error);
+     *   }
+     * });
+     * ```
+     *
+     * @see {@link SignInBody} Interface for sign-in request data
+     * @see {@link AuthResponse} Interface for authentication response
+     * @see {@link AuthEndpoint.SIGN_IN} Backend endpoint for user authentication
+     */
+    signIn(dto: SignInBody): Observable<AuthResponse>;
+    /**
+     * Initiates Google OAuth authentication using a popup window
+     *
+     * This method opens a popup window that navigates to the Google OAuth authentication
+     * endpoint. It handles the OAuth flow by monitoring the popup window and extracting
+     * the access token from the callback URL when authentication is successful.
+     *
+     * The popup is automatically positioned in the center of the screen and has predefined
+     * dimensions for optimal user experience. The method polls the popup window to detect
+     * when authentication is complete or if the user closes the popup.
+     *
+     * @returns Promise that resolves with the access token when authentication succeeds
+     *
+     * @throws {Error} If authentication fails or the popup is blocked
+     *
+     * @example
+     * ```typescript
+     * // Initiate Google sign-in
+     * try {
+     *   const accessToken = await this.authService.googleSignIn();
+     *   console.log('Google authentication successful:', accessToken);
+     *
+     *   // Use the token to get full auth response
+     *   const authResponse = await this.authService.getAuthResponse(accessToken).toPromise();
+     *   console.log('User data:', authResponse.user);
+     * } catch (error) {
+     *   console.error('Google authentication failed:', error);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // In a component with error handling
+     * async signInWithGoogle() {
+     *   try {
+     *     const token = await this.authService.googleSignIn();
+     *     // Handle successful authentication
+     *     this.router.navigate(['/dashboard']);
+     *   } catch (error) {
+     *     if (error.message.includes('popup')) {
+     *       this.showError('Please allow popups for Google sign-in');
+     *     } else {
+     *       this.showError('Google sign-in failed. Please try again.');
+     *     }
+     *   }
+     * }
+     * ```
+     *
+     * @see {@link getAuthResponse} Method to get full authentication response using the access token
+     * @see {@link AuthEndpoint.GOOGLE_SIGN_IN} Backend endpoint for Google OAuth initiation
+     * @see {@link GOOGLE_AUTH_POPUP_WIDTH} Constant defining popup window width
+     * @see {@link GOOGLE_AUTH_POPUP_HEIGHT} Constant defining popup window height
+     * @see {@link POPUP_POLLING_INTERVAL_MS} Constant defining popup polling interval
+     */
+    googleSignIn(): Promise<AccessToken>;
+    /**
+     * Retrieves the complete authentication response using an access token
+     *
+     * This method exchanges an access token for a complete authentication response
+     * containing user information and token details. It's typically used after
+     * Google OAuth authentication to get the full user profile and session data.
+     *
+     * The method automatically converts token expiration timestamps to JavaScript
+     * Date objects for easier handling in the client application.
+     *
+     * @param accessToken - The access token to exchange for authentication response
+     * @returns Observable that emits the complete authentication response
+     *
+     * @example
+     * ```typescript
+     * // Get auth response after Google sign-in
+     * const accessToken = await this.authService.googleSignIn();
+     * this.authService.getAuthResponse(accessToken).subscribe({
+     *   next: (response) => {
+     *     console.log('User:', response.user);
+     *     console.log('Tokens:', {
+     *       access: response.accessToken,
+     *       refresh: response.refreshToken
+     *     });
+     *   },
+     *   error: (error) => {
+     *     console.error('Failed to get auth response:', error);
+     *   }
+     * });
+     * ```
+     *
+     * @see {@link AccessToken} Type representing access tokens
+     * @see {@link AuthResponse} Interface for complete authentication response
+     * @see {@link AuthEndpoint.GET_AUTH_RESPONSE} Backend endpoint for token exchange
+     * @see {@link googleSignIn} Method that provides access tokens for this operation
+     */
+    getAuthResponse(accessToken: AccessToken): Observable<AuthResponse>;
+    /**
+     * Registers a new user account
+     *
+     * This method sends a registration request to the backend API with the provided
+     * user information. It creates a new user account and returns the user data
+     * upon successful registration.
+     *
+     * Note that this method only creates the user account and does not automatically
+     * sign the user in. After successful registration, you may need to call signIn
+     * or handle email verification depending on your application's configuration.
+     *
+     * @param dto - The sign-up data containing user registration information
+     * @returns Observable that emits the newly created user data
+     *
+     * @example
+     * ```typescript
+     * // Register a new user
+     * this.authService.signUp({
+     *   email: 'newuser@example.com',
+     *   password: 'securePassword123',
+     *   firstName: 'John',
+     *   lastName: 'Doe'
+     * }).subscribe({
+     *   next: (user) => {
+     *     console.log('User registered successfully:', user);
+     *     // Optionally redirect to sign-in or email verification page
+     *     this.router.navigate(['/verify-email']);
+     *   },
+     *   error: (error) => {
+     *     console.error('Registration failed:', error);
+     *     // Handle registration errors (email already exists, etc.)
+     *   }
+     * });
+     * ```
+     *
+     * @see {@link SignUpBody} Interface for user registration data
+     * @see {@link User} Interface for user data returned after registration
+     * @see {@link AuthEndpoint.SIGN_UP} Backend endpoint for user registration
+     * @see {@link signIn} Method to authenticate user after registration
+     */
+    signUp(dto: SignUpBody): Observable<User>;
+    /**
+     * Refreshes an expired access token using a refresh token
+     *
+     * This method exchanges a valid refresh token for a new set of access and refresh tokens.
+     * It's typically used when the current access token has expired but the refresh token
+     * is still valid, allowing the user to maintain their session without re-authenticating.
+     *
+     * The refresh token mechanism provides a secure way to maintain long-lived sessions
+     * while keeping access tokens short-lived for better security.
+     *
+     * @param refreshToken - The refresh token to exchange for new tokens
+     * @returns Observable that emits the new token response
+     *
+     * @example
+     * ```typescript
+     * // Refresh tokens when access token expires
+     * const storedRefreshToken = localStorage.getItem('refreshToken');
+     * if (storedRefreshToken) {
+     *   this.authService.refreshToken(storedRefreshToken).subscribe({
+     *     next: (tokenResponse) => {
+     *       console.log('Tokens refreshed successfully');
+     *       // Store new tokens
+     *       localStorage.setItem('accessToken', tokenResponse.accessToken);
+     *       localStorage.setItem('refreshToken', tokenResponse.refreshToken);
+     *     },
+     *     error: (error) => {
+     *       console.error('Token refresh failed:', error);
+     *       // Redirect to login page
+     *       this.router.navigate(['/login']);
+     *     }
+     *   });
+     * }
+     * ```
+     *
+     * @see {@link RefreshToken} Type representing refresh tokens
+     * @see {@link TokenResponse} Interface for token refresh response
+     * @see {@link AuthEndpoint.REFRESH_TOKEN} Backend endpoint for token refresh
+     * @see {@link signIn} Method to get initial tokens through authentication
+     */
+    refreshToken(refreshToken: RefreshToken): Observable<TokenResponse>;
+    /**
+     * Signs out the current user and invalidates their session
+     *
+     * This method sends a sign-out request to the backend API to invalidate the user's
+     * current session and tokens. It effectively logs the user out of the application
+     * and clears their authentication state on the server.
+     *
+     * After calling this method, you should also clear any client-side authentication
+     * data such as tokens stored in localStorage, sessionStorage, or application state.
+     *
+     * @returns Observable that emits a success response when sign-out is complete
+     *
+     * @example
+     * ```typescript
+     * // Sign out the current user
+     * this.authService.signOut().subscribe({
+     *   next: (response) => {
+     *     console.log('User signed out successfully');
+     *     // Clear client-side authentication data
+     *     localStorage.removeItem('accessToken');
+     *     localStorage.removeItem('refreshToken');
+     *     // Redirect to login page
+     *     this.router.navigate(['/login']);
+     *   },
+     *   error: (error) => {
+     *     console.error('Sign out failed:', error);
+     *     // Even if server sign-out fails, clear local data
+     *     localStorage.clear();
+     *     this.router.navigate(['/login']);
+     *   }
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Sign out with state management
+     * async signOut() {
+     *   try {
+     *     await this.authService.signOut().toPromise();
+     *     // Clear authentication state
+     *     this.authState.clearUser();
+     *     this.notificationService.showSuccess('Signed out successfully');
+     *   } catch (error) {
+     *     console.error('Sign out error:', error);
+     *   } finally {
+     *     // Always redirect to login
+     *     this.router.navigate(['/login']);
+     *   }
+     * }
+     * ```
+     *
+     * @see {@link SuccessResponse} Interface for success response
+     * @see {@link AuthEndpoint.SIGN_OUT} Backend endpoint for user sign-out
+     * @see {@link signIn} Method to authenticate user after sign-out
+     */
+    signOut(): Observable<SuccessResponse | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}

package/lib/services/index.d.ts

@@ -0,0 +1 @@
+export * from "./auth.service";

package/lib/state/auth.state.d.ts

@@ -0,0 +1,155 @@
+import { Observable } from "rxjs";
+import { AccessToken, AuthResponse, RefreshToken, SignInBody, TokenResponse, User } from "@hichchi/nest-connector/auth";
+import { SuccessResponse } from "@hichchi/nest-connector";
+/**
+ * Interface defining the authentication state model
+ *
+ * This interface represents the complete authentication state structure used
+ * throughout the Angular application. It contains user information, authentication
+ * tokens, and session data that persists across browser sessions.
+ *
+ * The state is automatically synchronized with browser storage to maintain
+ * authentication across page refreshes and browser restarts.
+ *
+ * @example
+ * ```typescript
+ * // Accessing state in a component
+ * export class HeaderComponent {
+ *   private authState = inject(AuthState)
+ *
+ *   get isSignedIn() {
+ *     return this.authState.signedIn();
+ *   }
+ *
+ *   get currentUser() {
+ *     return this.authState.user();
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link AuthState} The signal store that manages this state
+ * @see {@link User} Interface for user data
+ * @see {@link AccessToken} Type for access tokens
+ * @see {@link RefreshToken} Type for refresh tokens
+ */
+export interface AuthStateModel {
+    /** Whether the user is currently signed in */
+    signedIn: boolean;
+    /** Unique identifier for the current session */
+    sessionId: string | null;
+    /** Current authenticated user information */
+    user: User | null;
+    /** JWT access token for API authentication */
+    accessToken: AccessToken | null;
+    /** JWT refresh token for obtaining new access tokens */
+    refreshToken: RefreshToken | null;
+    /** Expiration date of the access token */
+    accessTokenExpiresOn: Date | null;
+    /** Expiration date of the refresh token */
+    refreshTokenExpiresOn: Date | null;
+}
+/**
+ * Authentication state management store using NgRx Signals
+ *
+ * This signal store provides centralized state management for authentication in Angular applications.
+ * It manages user authentication state, tokens, and provides methods for authentication operations.
+ * The store automatically persists state to browser storage and provides reactive computed values.
+ *
+ * Key features:
+ * - Automatic state persistence with browser storage sync
+ * - Reactive computed properties for common authentication checks
+ * - Built-in methods for sign-in, sign-out, and token management
+ * - Integration with Angular Router for navigation after authentication
+ * - Type-safe state management with TypeScript
+ *
+ * The store is provided at the root level and can be injected into any component or service.
+ * It uses NgRx Signals for reactive state management and provides a modern alternative
+ * to traditional NgRx store patterns.
+ *
+ * @example
+ * ```typescript
+ * // In a component
+ * export class AppComponent {
+ *   private authState = inject(AuthState)
+ *
+ *   // Access reactive state
+ *   isSignedIn = this.authState.signedIn;
+ *   currentUser = this.authState.user;
+ *   hasAccessToken = this.authState.hasAccessToken;
+ *
+ *   // Sign in user
+ *   async signIn() {
+ *     this.authState.signIn({
+ *       email: 'user@example.com',
+ *       password: 'password123'
+ *     }, '/dashboard').subscribe({
+ *       next: (response) => console.log('Signed in:', response.user),
+ *       error: (error) => console.error('Sign in failed:', error)
+ *     });
+ *   }
+ *
+ *   // Sign out user
+ *   signOut() {
+ *     this.authState.signOut('/login').subscribe();
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // In a guard
+ * export class AuthGuard {
+ *   private authState = inject(AuthState)
+ *
+ *   canActivate(): boolean {
+ *     return this.authState.signedIn() && this.authState.hasAccessToken();
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using computed properties
+ * export class HeaderComponent {
+ *   private authState = inject(AuthState)
+ *
+ *   // Reactive computed values
+ *   userRole = this.authState.role;
+ *   isEmailVerified = this.authState.emailVerified;
+ *   hasValidToken = this.authState.hasAccessToken;
+ * }
+ * ```
+ *
+ * @see {@link AuthStateModel} Interface defining the state structure
+ * @see {@link AuthService} Service used for authentication operations
+ * @see {@link signalStore} NgRx Signals store factory function
+ * @see {@link withStorageSync} Storage synchronization feature
+ */
+export declare const AuthState: import("@angular/core").Type<{
+    signedIn: import("@angular/core").Signal<boolean>;
+    sessionId: import("@angular/core").Signal<string | null>;
+    user: import("@angular/core").Signal<User<string, string> | null>;
+    accessToken: import("@angular/core").Signal<AccessToken | null>;
+    refreshToken: import("@angular/core").Signal<RefreshToken | null>;
+    accessTokenExpiresOn: import("@angular/core").Signal<Date | null>;
+    refreshTokenExpiresOn: import("@angular/core").Signal<Date | null>;
+    hasAccessToken: import("@angular/core").Signal<boolean>;
+    role: import("@angular/core").Signal<string | import("@hichchi/nest-connector/auth").Role<string, string> | null | undefined>;
+    emailVerified: import("@angular/core").Signal<boolean>;
+    clearStorage: () => void;
+    readFromStorage: () => void;
+    writeToStorage: () => void;
+    reset: () => void;
+    setTokens: (tokenResponse: TokenResponse) => void;
+    signIn: (signInBody: SignInBody, redirect?: string | ((res: AuthResponse) => string)) => Observable<AuthResponse>;
+    authenticateWithToken: (accessToken: AccessToken, redirect?: string | ((res: AuthResponse) => string)) => Observable<AuthResponse>;
+    signOut: (redirect?: string) => Observable<SuccessResponse | null>;
+} & import("@ngrx/signals").StateSource<{
+    signedIn: boolean;
+    sessionId: string | null;
+    user: User | null;
+    accessToken: AccessToken | null;
+    refreshToken: RefreshToken | null;
+    accessTokenExpiresOn: Date | null;
+    refreshTokenExpiresOn: Date | null;
+}>>;

package/lib/state/index.d.ts

@@ -0,0 +1 @@
+export * from "./auth.state";

package/lib/tokens.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Injection token for authentication configuration
+ *
+ * This constant defines the injection token used by Angular's dependency injection
+ * system to provide authentication configuration throughout the ngx-auth module.
+ * It allows the AuthConfig interface to be injected into services and components
+ * that need access to authentication settings.
+ *
+ * The token is used internally by the NgxHichchiAuthModule.forRoot() method to
+ * register the authentication configuration as a provider, making it available
+ * for injection in services like AuthService.
+ *
+ * This follows Angular's recommended pattern for providing configuration objects
+ * to libraries and modules, ensuring type safety and proper dependency injection.
+ *
+ * @example
+ * ```typescript
+ * // Used internally by the module to provide configuration
+ * @NgModule({
+ *   providers: [
+ *     { provide: AUTH_CONFIG, useValue: config },
+ *     AuthService
+ *   ]
+ * })
+ * export class NgxHichchiAuthModule {
+ *   static forRoot(config: AuthConfig): ModuleWithProviders<NgxHichchiAuthModule> {
+ *     return {
+ *       ngModule: NgxHichchiAuthModule,
+ *       providers: [
+ *         { provide: AUTH_CONFIG, useValue: config },
+ *         provideHttpClient(),
+ *         AuthService
+ *       ]
+ *     };
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Injecting the configuration in a service
+ * @Injectable()
+ * export class AuthService {
+ *   constructor(
+ *     @Inject(AUTH_CONFIG) private readonly config: AuthConfig
+ *   ) {
+ *     console.log('API Base URL:', this.config.apiBaseURL);
+ *     console.log('Auth Field:', this.config.authField);
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using in a component (though typically not recommended)
+ * @Component({
+ *   selector: 'app-auth-info',
+ *   template: `<p>API URL: {{ apiUrl }}</p>`
+ * })
+ * export class AuthInfoComponent {
+ *   apiUrl: string;
+ *
+ *   constructor(@Inject(AUTH_CONFIG) private config: AuthConfig) {
+ *     this.apiUrl = config.apiBaseURL;
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link AuthConfig} Interface that defines the structure of the configuration object
+ * @see {@link NgxHichchiAuthModule} Module that uses this token to provide configuration
+ * @see {@link AuthService} Service that injects this configuration
+ */
+export declare const AUTH_CONFIG = "AUTH_CONFIG";

package/lib/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./route.utils";

package/lib/utils/route.utils.d.ts

@@ -0,0 +1,100 @@
+import { ActivatedRouteSnapshot } from "@angular/router";
+import { AuthGuardOption } from "../interfaces";
+/**
+ * Retrieves all authentication guard options from a route and its parent routes
+ *
+ * This utility function extracts authentication guard options from the current route
+ * and recursively collects options from parent routes in the route hierarchy. It handles
+ * the inheritance and merging of guard options, ensuring that parent route guards are
+ * applied alongside child route guards.
+ *
+ * The function implements a hierarchical guard system where:
+ * - Child route options take precedence over parent options for the same condition
+ * - Parent options are inherited when no conflicting child option exists
+ * - Options are collected recursively up the route tree
+ * - The final array contains all applicable guard options for the route
+ *
+ * This enables complex authentication scenarios where different route levels can
+ * specify different authentication requirements, with child routes able to override
+ * or supplement parent route authentication rules.
+ *
+ * @param currentRoute - The activated route snapshot to extract guard options from
+ * @returns Array of authentication guard options applicable to the route
+ *
+ * @example
+ * ```typescript
+ * // Route configuration with nested guards
+ * const routes: Routes = [
+ *   {
+ *     path: 'admin',
+ *     component: AdminLayoutComponent,
+ *     canActivate: [authGuard(AuthGuardCondition.SIGNED_IN, true, '/login')],
+ *     children: [
+ *       {
+ *         path: 'users',
+ *         component: UsersComponent,
+ *         canActivate: [authGuard(AuthGuardCondition.HAS_TOKEN, true, '/unauthorized')]
+ *       }
+ *     ]
+ *   }
+ * ];
+ *
+ * // In the guard, get all applicable options
+ * const allOptions = getAllAuthGuardOptions(route);
+ * // Result: [
+ * //   { condition: 'signed-in', state: true, redirect: '/login' },
+ * //   { condition: 'has-token', state: true, redirect: '/unauthorized' }
+ * // ]
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using in a custom guard implementation
+ * export const customAuthGuard: CanActivateFn = (route, state) => {
+ *   const authState = inject(AuthState);
+ *   const router = inject(Router);
+ *
+ *   const guardOptions = getAllAuthGuardOptions(route);
+ *
+ *   for (const option of guardOptions) {
+ *     const conditionMet = checkAuthCondition(option.condition, authState);
+ *     if (option.state !== conditionMet) {
+ *       router.navigateByUrl(option.redirect);
+ *       return false;
+ *     }
+ *   }
+ *
+ *   return true;
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Route hierarchy with inherited guards
+ * const routes: Routes = [
+ *   {
+ *     path: 'app',
+ *     data: { [AUTH_GUARD_OPTIONS_KEY]: [
+ *       { condition: AuthGuardCondition.SIGNED_IN, state: true, redirect: '/login' }
+ *     ]},
+ *     children: [
+ *       {
+ *         path: 'profile',
+ *         component: ProfileComponent,
+ *         data: { [AUTH_GUARD_OPTIONS_KEY]: [
+ *           { condition: AuthGuardCondition.HAS_TOKEN, state: true, redirect: '/expired' }
+ *         ]}
+ *       }
+ *     ]
+ *   }
+ * ];
+ *
+ * // When accessing /app/profile, both parent and child guards apply
+ * ```
+ *
+ * @see {@link AuthGuardOption} Interface defining the structure of guard options
+ * @see {@link AUTH_GUARD_OPTIONS_KEY} Constant for the route data key
+ * @see {@link authGuard} Function that uses this utility to process guard options
+ * @see {@link ActivatedRouteSnapshot} Angular router interface for route snapshots
+ */
+export declare const getAllAuthGuardOptions: (currentRoute: ActivatedRouteSnapshot) => AuthGuardOption[];