@opensourcekd/ng-common-libs 1.2.3 → 1.2.5

package/dist/angular/index.d.ts

@@ -1,691 +1,349 @@
-import { Observable } from 'rxjs';
-import { CanActivateFn } from '@angular/router';
-import { HttpInterceptorFn, HttpErrorResponse } from '@angular/common/http';
+import { HttpClient } from '@angular/common/http';
+import { ReplaySubject, Observable } from 'rxjs';
+import { EventType } from 'mitt';
 
 /**
- * Event payload interface
- */
-interface EventPayload<T = any> {
-    type: string;
-    data: T;
-    timestamp?: number;
-}
-/**
- * EventBus - A centralized event bus for application-wide communication
- * Framework-agnostic implementation using only RxJS
+ * EventBusService - Angular service for cross-application event communication
+ * Uses mitt library for efficient event handling and RxJS ReplaySubject for observable stream
  *
- * @example
- * ```typescript
- * // Create an instance
- * const eventBus = new EventBus();
- *
- * // Emit an event
- * eventBus.emit('user:login', { userId: '123', username: 'john' });
- *
- * // Subscribe to an event
- * eventBus.on('user:login').subscribe(data => {
- *   console.log('User logged in:', data);
- * });
- * ```
- */
-declare class EventBus {
-    private eventSubject;
-    /**
-     * Emit an event with optional data
-     * @param eventType - The type/name of the event
-     * @param data - Optional data to send with the event
-     */
-    emit<T = any>(eventType: string, data?: T): void;
-    /**
-     * Subscribe to a specific event type
-     * @param eventType - The type/name of the event to listen for
-     * @returns Observable that emits the event data
-     */
-    on<T = any>(eventType: string): Observable<T>;
-    /**
-     * Subscribe to multiple event types
-     * @param eventTypes - Array of event types to listen for
-     * @returns Observable that emits the full event payload
-     */
-    onMultiple(eventTypes: string[]): Observable<EventPayload>;
-    /**
-     * Subscribe to all events
-     * @returns Observable that emits all event payloads
-     */
-    onAll(): Observable<EventPayload>;
-}
-
-/**
- * NgEventEmitter - Angular service wrapper for EventBus
- * Provides Angular dependency injection support for the framework-agnostic EventBus
+ * This service is designed for MicroFrontend architectures where different apps need to communicate
+ * The ReplaySubject keeps last 100 events in memory for late subscribers
  *
  * @example
  * ```typescript
- * import { Component, inject } from '@angular/core';
- * import { NgEventEmitter } from 'common-libs';
+ * import { Component, inject, OnInit } from '@angular/core';
+ * import { EventBusService } from '@opensourcekd/ng-common-libs';
  *
  * @Component({
  *   selector: 'app-example',
  *   template: '...'
  * })
- * export class ExampleComponent {
- *   private eventEmitter = inject(NgEventEmitter);
+ * export class ExampleComponent implements OnInit {
+ *   private eventBus = inject(EventBusService);
  *
  *   ngOnInit() {
- *     this.eventEmitter.on('user:login').subscribe(data => {
- *       console.log('User logged in:', data);
+ *     // Subscribe to all events
+ *     this.eventBus.onePlusNEvents.subscribe(event => {
+ *       console.log('Event received:', event);
  *     });
  *   }
  *
- *   login() {
- *     this.eventEmitter.emit('user:login', { userId: '123' });
- *   }
- * }
- * ```
- */
-declare class NgEventEmitter extends EventBus {
-    constructor();
-}
-
-/**
- * Token configuration interface
- */
-interface TokenConfig {
-    tokenKey?: string;
-    refreshTokenKey?: string;
-    useSessionStorage?: boolean;
-}
-/**
- * TokenManager - Manages authentication tokens
- * Framework-agnostic implementation using browser storage APIs
- * Handles storage, retrieval, and validation of JWT tokens
- *
- * @example
- * ```typescript
- * const tokenManager = new TokenManager();
- *
- * // Store a token
- * tokenManager.setToken('your-jwt-token');
- *
- * // Check if authenticated
- * if (tokenManager.isAuthenticated()) {
- *   const userData = tokenManager.getUserFromToken();
- * }
- * ```
- */
-declare class TokenManager {
-    private TOKEN_KEY;
-    private REFRESH_TOKEN_KEY;
-    private useSessionStorage;
-    /**
-     * Configure token manager
-     */
-    configure(config: TokenConfig): void;
-    /**
-     * Get the storage mechanism based on configuration
-     */
-    private getStorage;
-    /**
-     * Set authentication token
-     */
-    setToken(token: string): void;
-    /**
-     * Get authentication token
-     */
-    getToken(): string | null;
-    /**
-     * Remove authentication token
-     */
-    removeToken(): void;
-    /**
-     * Set refresh token
-     */
-    setRefreshToken(token: string): void;
-    /**
-     * Get refresh token
-     */
-    getRefreshToken(): string | null;
-    /**
-     * Remove refresh token
-     */
-    removeRefreshToken(): void;
-    /**
-     * Clear all tokens
-     */
-    clearTokens(): void;
-    /**
-     * Check if token exists
-     */
-    hasToken(): boolean;
-    /**
-     * Decode JWT token (without verification)
-     * @param token - JWT token to decode
-     * @returns Decoded token payload or null if invalid
-     */
-    decodeToken(token?: string): any;
-    /**
-     * Check if token is expired
-     * @param token - Optional token to check (defaults to stored token)
-     * @returns true if token is expired or invalid
-     */
-    isTokenExpired(token?: string): boolean;
-    /**
-     * Check if user is authenticated (has valid, non-expired token)
-     */
-    isAuthenticated(): boolean;
-    /**
-     * Get token expiration date
-     */
-    getTokenExpirationDate(token?: string): Date | null;
-    /**
-     * Get user data from token
-     */
-    getUserFromToken(token?: string): any;
-}
-
-/**
- * TokenService - Angular service wrapper for TokenManager
- * Provides Angular dependency injection support for the framework-agnostic TokenManager
- *
- * @example
- * ```typescript
- * import { Component, inject } from '@angular/core';
- * import { TokenService } from 'common-libs';
- *
- * export class AuthService {
- *   private tokenService = inject(TokenService);
- *
- *   login(token: string) {
- *     this.tokenService.setToken(token);
- *   }
+ *   sendCustomEvent() {
+ *     // Send a custom event
+ *     this.eventBus.sendEvent('user:action');
  *
- *   isAuthenticated(): boolean {
- *     return this.tokenService.isAuthenticated();
+ *     // Or send structured event with data
+ *     this.eventBus.sendEvent(JSON.stringify({
+ *       type: 'user:login',
+ *       payload: { userId: '123' },
+ *       timestamp: new Date().toISOString()
+ *     }));
  *   }
  * }
  * ```
  */
-declare class TokenService extends TokenManager {
-    constructor();
-}
-
-/**
- * StorageManager - Type-safe wrapper for browser storage
- * Framework-agnostic implementation using browser storage APIs
- * Provides JSON serialization/deserialization and error handling
- *
- * @example
- * ```typescript
- * const storage = new StorageManager();
- *
- * // Store data
- * storage.setLocal('user-prefs', { theme: 'dark', lang: 'en' });
- *
- * // Retrieve data
- * const prefs = storage.getLocal('user-prefs');
- *
- * // With expiration
- * storage.setWithExpiration('temp-data', someData, 3600000); // 1 hour
- * ```
- */
-declare class StorageManager {
-    /**
-     * Set item in localStorage with JSON serialization
-     */
-    setLocal<T>(key: string, value: T): boolean;
-    /**
-     * Get item from localStorage with JSON deserialization
-     */
-    getLocal<T>(key: string, defaultValue?: T): T | null;
-    /**
-     * Remove item from localStorage
-     */
-    removeLocal(key: string): void;
-    /**
-     * Clear all localStorage items
-     */
-    clearLocal(): void;
-    /**
-     * Check if key exists in localStorage
-     */
-    hasLocal(key: string): boolean;
-    /**
-     * Get all localStorage keys
-     */
-    getLocalKeys(): string[];
-    /**
-     * Set item in sessionStorage with JSON serialization
-     */
-    setSession<T>(key: string, value: T): boolean;
-    /**
-     * Get item from sessionStorage with JSON deserialization
-     */
-    getSession<T>(key: string, defaultValue?: T): T | null;
-    /**
-     * Remove item from sessionStorage
-     */
-    removeSession(key: string): void;
-    /**
-     * Clear all sessionStorage items
-     */
-    clearSession(): void;
-    /**
-     * Check if key exists in sessionStorage
-     */
-    hasSession(key: string): boolean;
-    /**
-     * Get all sessionStorage keys
-     */
-    getSessionKeys(): string[];
+declare class EventBusService {
     /**
-     * Set item with expiration time
-     * @param key - Storage key
-     * @param value - Value to store
-     * @param expirationMs - Expiration time in milliseconds
-     * @param useSession - Use sessionStorage instead of localStorage
+     * ReplaySubject that buffers the last 100 events for late subscribers
+     * Subscribe to this observable to receive all events
      */
-    setWithExpiration<T>(key: string, value: T, expirationMs: number, useSession?: boolean): boolean;
+    onePlusNEvents: ReplaySubject<EventType>;
     /**
-     * Get item with expiration check
-     * Returns null if item is expired
+     * mitt event emitter instance
+     * Lightweight event emitter library
      */
-    getWithExpiration<T>(key: string, useSession?: boolean): T | null;
-}
-
-/**
- * StorageService - Angular service wrapper for StorageManager
- * Provides Angular dependency injection support for the framework-agnostic StorageManager
- *
- * @example
- * ```typescript
- * import { Component, inject } from '@angular/core';
- * import { StorageService } from 'common-libs';
- *
- * export class UserPreferencesService {
- *   private storage = inject(StorageService);
- *
- *   savePreferences(prefs: any) {
- *     this.storage.setLocal('user-prefs', prefs);
- *   }
- *
- *   getPreferences() {
- *     return this.storage.getLocal('user-prefs');
- *   }
- * }
- * ```
- */
-declare class StorageService extends StorageManager {
+    private emitter;
     constructor();
+    /**
+     * Send an event through the event bus
+     * The event will be forwarded to all subscribers via the ReplaySubject
+     *
+     * @param s - Event string, can be a simple event name or JSON stringified structured data
+     *
+     * @example
+     * ```typescript
+     * // Simple event
+     * eventBus.sendEvent('user:logout');
+     *
+     * // Structured event
+     * eventBus.sendEvent(JSON.stringify({
+     *   type: 'auth:token_updated',
+     *   payload: { token: 'abc123' },
+     *   timestamp: new Date().toISOString()
+     * }));
+     * ```
+     */
+    sendEvent(s: string): void;
 }
 
 /**
- * Log level enum
- */
-declare enum LogLevel {
-    DEBUG = 0,
-    INFO = 1,
-    WARN = 2,
-    ERROR = 3,
-    NONE = 4
+ * User information from ID token
+ * Standard OIDC claims compatible with Auth0
+ */
+interface UserInfo {
+    sub: string;
+    name?: string;
+    email?: string;
+    email_verified?: boolean;
+    preferred_username?: string;
+    given_name?: string;
+    family_name?: string;
+    nickname?: string;
+    locale?: string;
+    picture?: string;
+    phone?: string;
+    phone_verified?: boolean;
+    updated_at?: string;
+    role?: string;
+    org?: string;
+    organization?: string;
+    [key: string]: any;
 }
 /**
- * Logger configuration
+ * Simplified user data extracted from token
  */
-interface LoggerConfig {
-    level?: LogLevel;
-    enableTimestamp?: boolean;
-    enableStackTrace?: boolean;
-    prefix?: string;
+interface UserData {
+    id: string;
+    name: string;
+    email: string;
+    role: string;
+    org: string;
 }
 /**
- * Logger - Centralized logging utility
- * Framework-agnostic implementation using browser console APIs
- * Supports different log levels and can be configured globally
- *
- * @example
- * ```typescript
- * const logger = new Logger();
+ * Authentication service for Auth0 integration
+ * Handles login, logout, token management, and user session
+ * Uses sessionStorage for sensitive data and emits authentication events for MicroApps
  *
- * // Configure
- * logger.configure({
- *   level: LogLevel.DEBUG,
- *   enableTimestamp: true,
- *   prefix: 'MyApp'
- * });
+ * Configuration is centralized in config/auth.config.ts for easy management
  *
- * // Use
- * logger.info('User logged in', { userId: '123' });
- * logger.error('Failed to load data', error);
- * ```
+ * NOTE: All navigation logic using setTimeout is commented out as per requirements.
+ * To enable navigation after auth operations, uncomment the marked sections in consuming components.
  */
-declare class Logger {
-    private config;
+declare class AuthService {
+    private http;
+    private eventBus;
+    id: string;
+    private readonly STANDARD_JWT_CLAIMS;
+    private auth0Client;
+    private initializationPromise;
+    private userSubject;
+    user$: Observable<UserInfo | null>;
+    constructor(http: HttpClient, eventBus: EventBusService);
     /**
-     * Configure the logger
+     * Initialize Auth0 client
      */
-    configure(config: LoggerConfig): void;
+    private initializeAuth0;
     /**
-     * Set log level
+     * Ensure Auth0 client is initialized before use
      */
-    setLevel(level: LogLevel): void;
+    private ensureInitialized;
     /**
-     * Get current log level
+     * Login with Auth0
+     * Redirects to Auth0 Universal Login
+     * Preserves current URL parameters (like invitation tokens) through the auth flow
+     *
+     * @param user - Optional user identifier for logging
+     * @param options - Optional login options including invitation and organization parameters
      */
-    getLevel(): LogLevel;
+    login(user?: string, options?: {
+        invitation?: string;
+        organization?: string;
+    }): Promise<void>;
     /**
-     * Format log message with timestamp and prefix
+     * Handle OAuth2 callback after successful authorization
+     * Processes the callback and retrieves user info
+     *
+     * NOTE: Navigation after successful/failed authentication should be handled in the calling component
+     * using setTimeout. See commented examples in app.component.ts
+     *
+     * @returns Promise<{ success: boolean, appState?: any }> - Success status and preserved appState
      */
-    private formatMessage;
+    handleCallback(): Promise<{
+        success: boolean;
+        appState?: any;
+    }>;
     /**
-     * Check if log level should be logged
+     * Log all user claims for debugging
+     * @param user - User info from Auth0
      */
-    private shouldLog;
+    private logUserClaims;
     /**
-     * Log debug message
+     * Log standard OIDC claims
+     * @param user - User info from Auth0
      */
-    debug(message: string, ...args: any[]): void;
+    private logStandardClaims;
     /**
-     * Log info message
+     * Log claims with consistent formatting
+     * @param header - Section header to display
+     * @param claims - Array of claim keys to log
+     * @param user - User info object
      */
-    info(message: string, ...args: any[]): void;
+    private logClaims;
     /**
-     * Log warning message
+     * Get custom namespaced claims from user info
+     * @param user - User info object
+     * @returns Array of custom claim keys
      */
-    warn(message: string, ...args: any[]): void;
+    private getCustomClaims;
     /**
-     * Log error message
+     * Get additional non-namespaced claims from user info
+     * @param user - User info object
+     * @returns Array of additional claim keys
      */
-    error(message: string, error?: any, ...args: any[]): void;
+    private getAdditionalClaims;
     /**
-     * Log a group of messages
+     * Check if a claim key is namespaced
+     * @param key - Claim key to check
+     * @returns True if the key starts with http:// or https://
      */
-    group(label: string, callback: () => void): void;
+    private isNamespacedClaim;
     /**
-     * Log a collapsed group of messages
+     * Logout user and clear authentication state
+     * Redirects to Auth0 logout endpoint and clears local state
      */
-    groupCollapsed(label: string, callback: () => void): void;
+    logout(): Promise<void>;
     /**
-     * Log a table (useful for arrays of objects)
+     * Get current access token from storage or Auth0 client
+     * @returns string | null - Access token or null if not authenticated
      */
-    table(data: any, columns?: string[]): void;
+    getToken(): Promise<string | null>;
     /**
-     * Log execution time of a function
+     * Get current access token synchronously from storage only
+     * Use this for synchronous operations like interceptors
+     * @returns string | null - Access token or null if not authenticated
      */
-    time<T>(label: string, fn: () => Promise<T> | T): Promise<T>;
-}
-
-/**
- * LoggerService - Angular service wrapper for Logger
- * Provides Angular dependency injection support for the framework-agnostic Logger
- *
- * @example
- * ```typescript
- * import { Component, inject } from '@angular/core';
- * import { LoggerService, LogLevel } from 'common-libs';
- *
- * export class MyService {
- *   private logger = inject(LoggerService);
- *
- *   constructor() {
- *     this.logger.configure({
- *       level: LogLevel.DEBUG,
- *       prefix: 'MyApp'
- *     });
- *   }
- *
- *   doSomething() {
- *     this.logger.info('Doing something');
- *   }
- * }
- * ```
- */
-declare class LoggerService extends Logger {
-    constructor();
-}
-
-/**
- * PermissionService - Manages user permissions and roles
- */
-declare class PermissionService {
-    private tokenService;
+    getTokenSync(): string | null;
     /**
-     * Check if user has a specific permission
+     * Set access token in storage and emit event for MicroApps
+     * @param token - Access token to store
      */
-    hasPermission(permission: string): boolean;
+    private setToken;
     /**
-     * Check if user has any of the specified permissions
+     * Check if user is authenticated
+     * @returns boolean - True if user has valid token
      */
-    hasAnyPermission(permissions: string[]): boolean;
+    isAuthenticated(): Promise<boolean>;
     /**
-     * Check if user has all of the specified permissions
+     * Check if user is authenticated synchronously
+     * Only checks storage, doesn't verify with Auth0
+     * @returns boolean - True if user has token in storage
      */
-    hasAllPermissions(permissions: string[]): boolean;
+    isAuthenticatedSync(): boolean;
     /**
-     * Check if user has a specific role
+     * Get current user information
+     * @returns UserInfo | null - Current user or null if not authenticated
      */
-    hasRole(role: string): boolean;
+    getUser(): UserInfo | null;
     /**
-     * Check if user has any of the specified roles
+     * Get simplified user data from token
+     * Extracts user details, role, and organization from ID token claims
+     * Checks both top-level claims and namespaced custom claims
+     * @returns UserData | null - Simplified user data or null if not authenticated
      */
-    hasAnyRole(roles: string[]): boolean;
+    getUserData(): UserData | null;
     /**
-     * Check if user has all of the specified roles
+     * Extract claim value from user info, checking both direct properties and namespaced custom claims
+     * @param userInfo - User info object
+     * @param claimNames - Single claim name or array of claim names to search for
+     * @param defaultValue - Default value if claim is not found
+     * @returns Extracted claim value or default value
      */
-    hasAllRoles(roles: string[]): boolean;
+    private extractClaimValue;
     /**
-     * Get all user permissions
+     * Get user information from storage
+     * @returns UserInfo | null - Stored user info or null
      */
-    getPermissions(): string[];
+    private getUserInfoFromStorage;
     /**
-     * Get all user roles
+     * Set user information in storage, update observable and emit event for MicroApps
+     * Logs all Auth0 claims for debugging
+     * @param userInfo - User information to store
      */
-    getRoles(): string[];
+    private setUserInfo;
     /**
-     * Get user ID from token
+     * Emit authentication event for MicroApps to consume
+     * Events are emitted via EventBus for cross-MFE communication
+     * @param eventType - Type of authentication event
+     * @param payload - Event payload
      */
-    getUserId(): string | null;
-    /**
-     * Get username from token
-     */
-    getUsername(): string | null;
-    /**
-     * Get user email from token
-     */
-    getUserEmail(): string | null;
-}
-
-/**
- * Auth guard configuration
- */
-interface AuthGuardConfig {
-    redirectUrl?: string;
-    checkExpiration?: boolean;
-}
-/**
- * Factory function to create an auth guard with configuration
- *
- * @example
- * ```typescript
- * // In routes
- * {
- *   path: 'dashboard',
- *   component: DashboardComponent,
- *   canActivate: [createAuthGuard({ redirectUrl: '/login' })]
- * }
- * ```
- */
-declare function createAuthGuard(config?: AuthGuardConfig): CanActivateFn;
-/**
- * Default auth guard - redirects to '/login' if not authenticated
- */
-declare const authGuard: CanActivateFn;
-/**
- * Permission-based guard factory
- * Checks if user has required permissions from token
- *
- * @example
- * ```typescript
- * {
- *   path: 'admin',
- *   component: AdminComponent,
- *   canActivate: [createPermissionGuard(['admin', 'editor'])]
- * }
- * ```
- */
-declare function createPermissionGuard(requiredPermissions: string[], config?: AuthGuardConfig): CanActivateFn;
-/**
- * Role-based guard factory
- * Checks if user has required role from token
- *
- * @example
- * ```typescript
- * {
- *   path: 'admin',
- *   component: AdminComponent,
- *   canActivate: [createRoleGuard(['admin'])]
- * }
- * ```
- */
-declare function createRoleGuard(requiredRoles: string[], config?: AuthGuardConfig): CanActivateFn;
-
-/**
- * Auth interceptor configuration
- */
-interface AuthInterceptorConfig {
-    headerName?: string;
-    tokenPrefix?: string;
-    excludedUrls?: string[];
+    private emitAuthEvent;
 }
-/**
- * Configure the auth interceptor
- */
-declare function configureAuthInterceptor(config: AuthInterceptorConfig): void;
-/**
- * Auth Interceptor - Automatically adds authentication token to HTTP requests
- *
- * @example
- * ```typescript
- * // In app.config.ts
- * export const appConfig: ApplicationConfig = {
- *   providers: [
- *     provideHttpClient(
- *       withInterceptors([authInterceptor])
- *     )
- *   ]
- * };
- * ```
- */
-declare const authInterceptor: HttpInterceptorFn;
 
 /**
- * Error handling configuration
- */
-interface ErrorHandlingConfig {
-    enableLogging?: boolean;
-    retryAttempts?: number;
-    retryDelay?: number;
-    retryStatusCodes?: number[];
-    excludedUrls?: string[];
-}
-/**
- * Configure the error handling interceptor
- */
-declare function configureErrorHandling(config: ErrorHandlingConfig): void;
-/**
- * Error handling interceptor - Handles HTTP errors and retries
- *
- * @example
- * ```typescript
- * // In app.config.ts
- * export const appConfig: ApplicationConfig = {
- *   providers: [
- *     provideHttpClient(
- *       withInterceptors([errorHandlingInterceptor])
- *     )
- *   ]
- * };
+ * Auth0 Configuration
+ * Centralized configuration for Auth0 integration
  *
- * // Configure retry behavior
- * configureErrorHandling({
- *   retryAttempts: 3,
- *   retryDelay: 2000,
- *   retryStatusCodes: [500, 502, 503]
- * });
- * ```
+ * Environment variables are typically set in consuming applications
+ * Default values are provided for development/testing
  */
-declare const errorHandlingInterceptor: HttpInterceptorFn;
 /**
- * HTTP Error class with additional context
+ * Auth0 client configuration
+ * Override these values in your consuming application by setting them before importing AuthService
  */
-declare class HttpError extends Error {
-    status: number;
-    statusText: string;
-    url: string;
-    originalError: HttpErrorResponse;
-    constructor(status: number, statusText: string, url: string, originalError: HttpErrorResponse);
-}
+declare const AUTH0_CONFIG: {
+    domain: string;
+    clientId: string;
+    redirectUri: string;
+    logoutUri: string;
+    audience: string;
+    scope: string;
+    connection: string | undefined;
+};
 /**
- * Parse HTTP error and return user-friendly message
+ * Storage configuration
+ * Controls where sensitive data is stored
  */
-declare function parseHttpError(error: HttpErrorResponse): string;
+declare const STORAGE_CONFIG: {
+    TOKEN_STORAGE: "localStorage" | "sessionStorage";
+    USER_INFO_STORAGE: "localStorage" | "sessionStorage";
+};
 /**
- * Check if error is a network error
+ * Storage keys for auth data
  */
-declare function isNetworkError(error: HttpErrorResponse): boolean;
+declare const STORAGE_KEYS: {
+    ACCESS_TOKEN: string;
+    USER_INFO: string;
+};
 /**
- * Check if error is a server error (5xx)
+ * Helper functions for storage operations
+ * These work with both localStorage and sessionStorage
  */
-declare function isServerError(error: HttpErrorResponse): boolean;
-/**
- * Check if error is a client error (4xx)
- */
-declare function isClientError(error: HttpErrorResponse): boolean;
-
-/**
- * Cache configuration
- */
-interface CacheConfig {
-    enabled?: boolean;
-    maxAge?: number;
-    excludedUrls?: string[];
-    cacheableUrls?: string[];
-    cacheMethods?: string[];
-}
 /**
- * Configure the caching interceptor
+ * Get item from storage
+ * @param key - Storage key
+ * @param storageType - Type of storage to use
+ * @returns Stored value or null
  */
-declare function configureCaching(config: CacheConfig): void;
+declare function getStorageItem(key: string, storageType?: 'localStorage' | 'sessionStorage'): string | null;
 /**
- * Clear all cached entries
+ * Set item in storage
+ * @param key - Storage key
+ * @param value - Value to store
+ * @param storageType - Type of storage to use
  */
-declare function clearCache(): void;
+declare function setStorageItem(key: string, value: string, storageType?: 'localStorage' | 'sessionStorage'): void;
 /**
- * Clear cache entry for specific URL
+ * Remove item from storage
+ * @param key - Storage key
+ * @param storageType - Type of storage to use
  */
-declare function clearCacheEntry(url: string): void;
+declare function removeStorageItem(key: string, storageType?: 'localStorage' | 'sessionStorage'): void;
 /**
- * Caching interceptor - Caches HTTP GET requests
+ * Configure Auth0 settings
+ * Call this function in your consuming application before using AuthService
  *
  * @example
  * ```typescript
- * // In app.config.ts
- * export const appConfig: ApplicationConfig = {
- *   providers: [
- *     provideHttpClient(
- *       withInterceptors([cachingInterceptor])
- *     )
- *   ]
- * };
+ * import { configureAuth0 } from '@opensourcekd/ng-common-libs';
  *
- * // Configure caching
- * configureCaching({
- *   enabled: true,
- *   maxAge: 300000, // 5 minutes
- *   cacheableUrls: ['/api/users', '/api/products']
+ * configureAuth0({
+ *   domain: 'your-domain.auth0.com',
+ *   clientId: 'your-client-id',
+ *   audience: 'https://your-api.com'
  * });
  * ```
  */
-declare const cachingInterceptor: HttpInterceptorFn;
+declare function configureAuth0(config: Partial<typeof AUTH0_CONFIG>): void;
 
-export { HttpError, LogLevel, LoggerService, NgEventEmitter, PermissionService, StorageService, TokenService, authGuard, authInterceptor, cachingInterceptor, clearCache, clearCacheEntry, configureAuthInterceptor, configureCaching, configureErrorHandling, createAuthGuard, createPermissionGuard, createRoleGuard, errorHandlingInterceptor, isClientError, isNetworkError, isServerError, parseHttpError };
-export type { AuthGuardConfig, AuthInterceptorConfig, CacheConfig, ErrorHandlingConfig, LoggerConfig, TokenConfig };
+export { AUTH0_CONFIG, AuthService, EventBusService, STORAGE_CONFIG, STORAGE_KEYS, configureAuth0, getStorageItem, removeStorageItem, setStorageItem };
+export type { UserData, UserInfo };