/**
 * @file Enterprise Logging Extension
 * @description Comprehensive logging system for React applications with enterprise-grade features
 *
 * @version 2.0.0
 * @author Enzyme Team
 * @license MIT
 *
 * ## Features
 *
 * 1. **Structured Logging** - Six log levels (trace, debug, info, warn, error, fatal)
 * 2. **Operation Tracking** - Track React lifecycle, API calls, state changes
 * 3. **Context Injection** - Automatic correlationId, userId, sessionId, requestId
 * 4. **Log Formatters** - JSON, human-readable, browser console with colors
 * 5. **Transport System** - Console, localStorage, remote endpoint, custom transports
 * 6. **Log Buffering** - Batch logs for performance with configurable flush intervals
 * 7. **Log Filtering** - Filter by level, category, pattern, or custom predicate
 * 8. **Performance Metrics** - Automatic timing of operations with thresholds
 * 9. **Breadcrumbs** - Track user actions for debugging (last N actions)
 * 10. **Sensitive Data Masking** - Automatic PII masking for compliance
 *
 * @example Basic Usage
 * ```typescript
 * import { loggingExtension } from '@defendr/enzyme/extensions/built-in';
 *
 * // In your app initialization
 * const logger = loggingExtension.initialize({
 *   level: 'info',
 *   enableBreadcrumbs: true,
 *   bufferSize: 100,
 *   flushInterval: 5000,
 * });
 *
 * // Use client methods
 * logger.$log('info', 'User logged in', { userId: '123' });
 * logger.$startOperation('fetchUserData');
 * // ... async operation
 * logger.$endOperation('fetchUserData');
 * logger.$addBreadcrumb({ type: 'navigation', message: 'User navigated to /dashboard' });
 * ```
 *
 * @example With React
 * ```typescript
 * import { useLogger } from '@defendr/enzyme/extensions/built-in';
 *
 * function MyComponent() {
 *   const logger = useLogger();
 *
 *   useEffect(() => {
 *     const op = logger.$startOperation('componentMount');
 *     // ... initialization
 *     logger.$endOperation(op);
 *   }, []);
 *
 *   return <div>My Component</div>;
 * }
 * ```
 *
 * @example Remote Logging
 * ```typescript
 * logger.addTransport({
 *   name: 'remote',
 *   async write(entries) {
 *     await fetch('/api/logs', {
 *       method: 'POST',
 *       headers: { 'Content-Type': 'application/json' },
 *       body: JSON.stringify(entries),
 *     });
 *   },
 * });
 * ```
 */
/**
 * Log levels in order of severity
 */
export declare enum LogLevel {
    TRACE = 0,
    DEBUG = 1,
    INFO = 2,
    WARN = 3,
    ERROR = 4,
    FATAL = 5
}
/**
 * Log level names for human readability
 */
export type LogLevelName = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
/**
 * Map log level names to enum values
 */
export declare const LOG_LEVEL_MAP: Record<LogLevelName, LogLevel>;
/**
 * Operation category for tracking
 */
export type OperationCategory = 'lifecycle' | 'api' | 'state' | 'navigation' | 'user-action' | 'render' | 'custom';
/**
 * Breadcrumb type for user action tracking
 */
export interface Breadcrumb {
    /** Timestamp when breadcrumb was created */
    timestamp: number;
    /** Type of action */
    type: 'navigation' | 'user-action' | 'api' | 'state-change' | 'error' | 'custom';
    /** Human-readable message */
    message: string;
    /** Additional metadata */
    data?: Record<string, unknown>;
    /** Severity level */
    level?: LogLevelName;
}
/**
 * Log context for correlation and debugging
 */
export interface LogContext {
    /** Correlation ID for tracking requests across services */
    correlationId?: string;
    /** User ID for user-specific logs */
    userId?: string;
    /** Session ID for session tracking */
    sessionId?: string;
    /** Request ID for tracking individual requests */
    requestId?: string;
    /** Component name for React component logs */
    component?: string;
    /** Additional custom context */
    [key: string]: unknown;
}
/**
 * Log entry structure
 */
export interface LogEntry {
    /** Unique log entry ID */
    id: string;
    /** Timestamp in milliseconds */
    timestamp: number;
    /** ISO 8601 timestamp string */
    timestampISO: string;
    /** Log level */
    level: LogLevel;
    /** Log level name */
    levelName: LogLevelName;
    /** Log message */
    message: string;
    /** Log context */
    context: LogContext;
    /** Additional metadata */
    metadata?: Record<string, unknown>;
    /** Error object if applicable */
    error?: Error;
    /** Stack trace if error */
    stack?: string;
    /** Operation name if tracking operation */
    operation?: string;
    /** Operation category */
    category?: OperationCategory;
    /** Operation duration in ms */
    duration?: number;
}
/**
 * Operation tracking info
 */
export interface OperationInfo {
    /** Operation name */
    name: string;
    /** Operation category */
    category: OperationCategory;
    /** Start time */
    startTime: number;
    /** Context at operation start */
    context: LogContext;
    /** Additional metadata */
    metadata?: Record<string, unknown>;
}
/**
 * Log formatter function
 */
export type LogFormatter = (entry: LogEntry) => string;
/**
 * Log transport for sending logs to different destinations
 */
export interface LogTransport {
    /** Transport name */
    name: string;
    /** Minimum log level for this transport */
    level?: LogLevel;
    /** Write log entries */
    write: (entries: LogEntry[]) => Promise<void> | void;
    /** Flush any buffered logs */
    flush?: () => Promise<void> | void;
    /** Transport-specific formatter */
    formatter?: LogFormatter;
}
/**
 * Log filter predicate
 */
export type LogFilter = (entry: LogEntry) => boolean;
/**
 * Logger configuration
 */
export interface LoggerConfig {
    /** Minimum log level to capture */
    level?: LogLevelName;
    /** Enable breadcrumb tracking */
    enableBreadcrumbs?: boolean;
    /** Maximum breadcrumbs to keep */
    maxBreadcrumbs?: number;
    /** Buffer size before auto-flush */
    bufferSize?: number;
    /** Auto-flush interval in milliseconds */
    flushInterval?: number;
    /** Enable sensitive data masking */
    enableMasking?: boolean;
    /** Custom masking patterns */
    maskPatterns?: RegExp[];
    /** Global log context */
    context?: LogContext;
    /** Custom log formatters */
    formatters?: Record<string, LogFormatter>;
    /** Initial transports */
    transports?: LogTransport[];
    /** Custom filters */
    filters?: LogFilter[];
    /** Enable performance tracking */
    enablePerformanceTracking?: boolean;
    /** Slow operation threshold in ms */
    slowOperationThreshold?: number;
}
/**
 * Performance metrics
 */
export interface PerformanceMetrics {
    /** Total operations tracked */
    totalOperations: number;
    /** Average operation duration */
    averageDuration: number;
    /** Slowest operations */
    slowestOperations: Array<{
        name: string;
        duration: number;
        timestamp: number;
    }>;
    /** Operations by category */
    operationsByCategory: Record<OperationCategory, number>;
}
/**
 * Logger instance interface
 */
export interface Logger {
    /** Log a message at specified level */
    $log(level: LogLevelName, message: string, context?: Record<string, unknown>): void;
    /** Log trace message */
    $trace(message: string, context?: Record<string, unknown>): void;
    /** Log debug message */
    $debug(message: string, context?: Record<string, unknown>): void;
    /** Log info message */
    $info(message: string, context?: Record<string, unknown>): void;
    /** Log warning message */
    $warn(message: string, context?: Record<string, unknown>): void;
    /** Log error message */
    $error(message: string, error?: Error, context?: Record<string, unknown>): void;
    /** Log fatal message */
    $fatal(message: string, error?: Error, context?: Record<string, unknown>): void;
    /** Start tracking an operation */
    $startOperation(name: string, category?: OperationCategory, metadata?: Record<string, unknown>): string;
    /** End tracking an operation */
    $endOperation(operationId: string): void;
    /** Add a breadcrumb */
    $addBreadcrumb(breadcrumb: Omit<Breadcrumb, 'timestamp'>): void;
    /** Get breadcrumb history */
    $getBreadcrumbs(): Breadcrumb[];
    /** Get log history */
    $getLogHistory(options?: {
        level?: LogLevelName;
        limit?: number;
        offset?: number;
        category?: OperationCategory;
    }): LogEntry[];
    /** Set log level dynamically */
    $setLogLevel(level: LogLevelName): void;
    /** Flush buffered logs */
    $flushLogs(): Promise<void>;
    /** Add a transport */
    $addTransport(transport: LogTransport): void;
    /** Remove a transport */
    $removeTransport(name: string): boolean;
    /** Add a filter */
    $addFilter(filter: LogFilter): void;
    /** Clear filters */
    $clearFilters(): void;
    /** Update global context */
    $updateContext(context: Partial<LogContext>): void;
    /** Get performance metrics */
    $getMetrics(): PerformanceMetrics;
    /** Clear all logs and metrics */
    $clear(): void;
}
/**
 * Generate correlation ID
 */
declare function generateCorrelationId(): string;
/**
 * Mask sensitive data in a string
 */
declare function maskSensitiveData(text: string, patterns?: RegExp[]): string;
/**
 * Deep mask sensitive data in objects
 */
declare function maskObject(obj: unknown, patterns?: RegExp[]): unknown;
/**
 * JSON formatter for structured logging
 */
export declare const jsonFormatter: LogFormatter;
/**
 * Human-readable formatter
 */
export declare const humanFormatter: LogFormatter;
/**
 * Browser console formatter with colors
 */
export declare const consoleFormatter: LogFormatter;
/**
 * Compact formatter for production
 */
export declare const compactFormatter: LogFormatter;
/**
 * Console transport with color support
 */
export declare const consoleTransport: LogTransport;
/**
 * LocalStorage transport for persistence
 */
export declare const localStorageTransport: LogTransport;
/**
 * Remote transport for sending logs to a server
 */
export declare function createRemoteTransport(endpoint: string, options?: {
    headers?: Record<string, string>;
    batchSize?: number;
}): LogTransport;
/**
 * Create a logger instance
 */
export declare function createLogger(config?: LoggerConfig): Logger;
/**
 * Initialize global logger
 *
 * @example
 * ```typescript
 * import { initializeLogger } from '@defendr/enzyme/extensions/built-in';
 *
 * initializeLogger({
 *   level: 'info',
 *   enableBreadcrumbs: true,
 *   transports: [consoleTransport, localStorageTransport],
 * });
 * ```
 */
export declare function initializeLogger(config?: LoggerConfig): Logger;
/**
 * Get global logger instance
 *
 * @example
 * ```typescript
 * import { getLogger } from '@defendr/enzyme/extensions/built-in';
 *
 * const logger = getLogger();
 * logger.$info('Application started');
 * ```
 */
export declare function getLogger(): Logger;
/**
 * React hook for using logger
 *
 * @example
 * ```typescript
 * import { useLogger } from '@defendr/enzyme/extensions/built-in';
 *
 * function MyComponent() {
 *   const logger = useLogger();
 *
 *   useEffect(() => {
 *     logger.$info('Component mounted');
 *     return () => logger.$info('Component unmounted');
 *   }, []);
 *
 *   return <div>My Component</div>;
 * }
 * ```
 */
export declare function useLogger(): Logger;
/**
 * Enzyme logging extension
 *
 * This extension provides comprehensive logging capabilities for React applications.
 *
 * @example
 * ```typescript
 * import { loggingExtension } from '@defendr/enzyme/extensions/built-in';
 * import { Enzyme } from '@defendr/enzyme/cli';
 *
 * const enzyme = new Enzyme().$extends(loggingExtension);
 * ```
 */
export declare const loggingExtension: {
    name: string;
    version: string;
    description: string;
    /**
     * Initialize the extension
     */
    initialize(config?: LoggerConfig): Logger;
    /**
     * Get logger instance
     */
    getLogger: typeof getLogger;
    /**
     * Create a new logger instance
     */
    createLogger: typeof createLogger;
    /**
     * React hook
     */
    useLogger: typeof useLogger;
    /**
     * Formatters
     */
    formatters: {
        json: LogFormatter;
        human: LogFormatter;
        console: LogFormatter;
        compact: LogFormatter;
    };
    /**
     * Transports
     */
    transports: {
        console: LogTransport;
        localStorage: LogTransport;
        createRemote: typeof createRemoteTransport;
    };
    /**
     * Utilities
     */
    utils: {
        maskSensitiveData: typeof maskSensitiveData;
        maskObject: typeof maskObject;
        generateCorrelationId: typeof generateCorrelationId;
    };
};
export default loggingExtension;