debug-time-machine-core/dist/index.d.ts

🕰️ Debug Time Machine Core - 시간여행 엔진과 네트워크 인터셉터

interface ITimeSnapshot {
    id: string;
    timestamp: number;
    state: Record<string, unknown>;
    actionType: string;
    description?: string;
}
interface ITimeTravelEngine {
    createSnapshot: (state: Record<string, unknown>, actionType: string) => ITimeSnapshot;
    restoreSnapshot: (snapshotId: string) => boolean;
    getAllSnapshots: () => ITimeSnapshot[];
    clearSnapshots: () => void;
}
type TTimeTravelAction = 'CREATE_SNAPSHOT' | 'RESTORE_SNAPSHOT' | 'CLEAR_SNAPSHOTS';
interface INetworkRequest {
    id: string;
    url: string;
    method: string;
    headers: Record<string, string>;
    body?: string;
    timestamp: number;
}
interface INetworkResponse {
    id: string;
    requestId: string;
    status: number;
    statusText: string;
    headers: Record<string, string>;
    body?: string;
    timestamp: number;
}
interface INetworkInterceptor {
    startIntercepting: () => void;
    stopIntercepting: () => void;
    getRequestHistory: () => INetworkRequest[];
    getResponseHistory: () => INetworkResponse[];
    clearHistory: () => void;
}
type TNetworkMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
type TNetworkPriority = 'high' | 'medium' | 'low';
type TCacheStatus = 'hit' | 'miss' | 'stale' | 'none';
interface IWebSocketMessage {
    type: string;
    payload: unknown;
    timestamp: number;
}
type TWebSocketEvent = 'connection' | 'message' | 'close' | 'error';
interface IDebugEvent {
    id: string;
    type: string;
    data: unknown;
    timestamp: number;
    source: string;
}
type TDebugEventType = 'state_change' | 'network_request' | 'network_response' | 'error' | 'warning' | 'info';
interface IErrorContext {
    url: string;
    userAgent: string;
    timestamp: number;
    userId?: string;
    sessionId?: string;
    reactState?: Record<string, unknown>;
    reactProps?: Record<string, unknown>;
    domSnapshot?: string;
    breadcrumbs?: IBreadcrumb[];
    originalError?: Error | string;
}
interface IBreadcrumb {
    id: string;
    type: 'navigation' | 'user_action' | 'http' | 'console' | 'state_change';
    message: string;
    data?: Record<string, unknown>;
    timestamp: number;
    level: 'info' | 'warning' | 'error';
}

interface IMemoryConfig {
    maxTotalMemoryMB: number;
    maxSnapshotSizeMB: number;
    compressionEnabled: boolean;
    circularRefHandling: boolean;
    autoCleanupThreshold: number;
    memoryCheckInterval: number;
}
interface IMemoryUsage {
    totalUsageMB: number;
    snapshotCount: number;
    averageSnapshotSizeMB: number;
    largestSnapshotMB: number;
    compressionRatio: number;
}
interface IMemoryAlert {
    type: 'warning' | 'critical';
    message: string;
    currentUsageMB: number;
    recommendedAction: string;
    timestamp: number;
}
/**
 * MemoryManager - 스냅샷 메모리 사용량을 관리하고 최적화하는 클래스
 */
declare class MemoryManager {
    private _config;
    private _snapshotSizes;
    private _currentMemoryUsage;
    private _memoryCheckTimer;
    private _onMemoryAlert?;
    constructor(config?: Partial<IMemoryConfig>);
    /**
     * 스냅샷의 메모리 사용량을 계산합니다
     */
    calculateSnapshotSize(snapshot: ITimeSnapshot): number;
    /**
     * 스냅샷 압축을 수행합니다
     */
    compressSnapshot(state: Record<string, unknown>): Record<string, unknown>;
    /**
     * 메모리 정리를 수행합니다
     */
    cleanup(snapshots: Map<string, ITimeSnapshot>): string[];
    /**
     * 스냅샷 제거시 메모리 사용량 업데이트
     */
    removeSnapshot(snapshotId: string): void;
    /**
     * 현재 메모리 사용량 정보를 반환합니다
     */
    getMemoryUsage(): IMemoryUsage;
    /**
     * 메모리 알림 콜백을 설정합니다
     */
    onMemoryAlert(callback: (alert: IMemoryAlert) => void): void;
    /**
     * 메모리 관리자를 정리합니다
     */
    destroy(): void;
    /**
     * Circular reference를 처리하여 직렬화합니다
     */
    private _serializeWithCircularRefHandling;
    /**
     * 깊은 복사를 수행합니다
     */
    private _deepClone;
    /**
     * 압축 전략들을 적용합니다
     */
    private _applyCompressionStrategies;
    /**
     * 긴 문자열을 압축합니다
     */
    private _compressLongStrings;
    /**
     * 중복 객체를 제거합니다
     */
    private _deduplicateObjects;
    /**
     * 불필요한 속성들을 제거합니다
     */
    private _removeUnnecessaryProps;
    /**
     * 압축률을 계산합니다
     */
    private _calculateCompressionRatio;
    /**
     * 메모리 사용량을 업데이트합니다
     */
    private _updateMemoryUsage;
    /**
     * 메모리 모니터링을 시작합니다
     */
    private _startMemoryMonitoring;
    /**
     * 메모리 알림을 발생시킵니다
     */
    private _emitMemoryAlert;
}

interface ITimeTravelEngineConfig {
    maxSnapshots?: number;
    memoryConfig?: Partial<IMemoryConfig>;
    enableAutoCleanup?: boolean;
    compressionEnabled?: boolean;
    enableLogging?: boolean;
}
/**
 * Enhanced TimeTravelEngine - 메모리 관리가 강화된 시간여행 디버깅 엔진
 */
declare class TimeTravelEngine implements ITimeTravelEngine {
    private _snapshots;
    private _maxSnapshots;
    private _memoryManager;
    private _config;
    private _onMemoryAlert?;
    constructor(config?: ITimeTravelEngineConfig);
    /**
     * 현재 상태의 스냅샷을 생성합니다 (오버로드)
     */
    createSnapshot(): ITimeSnapshot;
    createSnapshot(state: Record<string, unknown>, actionType: string): ITimeSnapshot;
    /**
     * 상태와 함께 스냅샷 생성 (내부 구현)
     */
    private _createSnapshotWithState;
    /**
     * 스냅샷을 복원합니다
     */
    restoreSnapshot(snapshotId: string): boolean;
    /**
     * 모든 스냅샷을 가져옵니다
     */
    getAllSnapshots(): ITimeSnapshot[];
    /**
     * 모든 스냅샷을 삭제합니다
     */
    clearSnapshots(): void;
    /**
     * 특정 스냅샷을 삭제합니다
     */
    deleteSnapshot(snapshotId: string): boolean;
    /**
     * 메모리 사용량 정보를 가져옵니다
     */
    getMemoryUsage(): IMemoryUsage;
    /**
     * 메모리 알림 콜백을 설정합니다
     */
    onMemoryAlert(callback: (alert: IMemoryAlert) => void): void;
    /**
     * 시간 범위 기반 스냅샷 정리
     */
    cleanupByTimeRange(olderThanMs: number): number;
    /**
     * 패턴 기반 스냅샷 정리 (중복 제거)
     */
    cleanupDuplicates(): number;
    /**
     * 시간여행 엔진을 시작합니다
     */
    start(): void;
    /**
     * 시간여행 엔진을 중지합니다
     */
    stop(): void;
    /**
     * 특정 시점으로 시간여행
     */
    travelToTime(timestamp: number): void;
    /**
     * 이전 이벤트로 이동
     */
    travelToPreviousEvent(): void;
    /**
     * 다음 이벤트로 이동
     */
    travelToNextEvent(): void;
    /**
     * 현재 상태 가져오기
     */
    getState(): {
        snapshotCount: number;
        maxSnapshots: number;
        memoryUsage: IMemoryUsage;
        config: Required<ITimeTravelEngineConfig>;
    };
    /**
     * 히스토리 초기화 (clearSnapshots와 동일)
     */
    clearHistory(): void;
    /**
     * 엔진을 정리합니다
     */
    destroy(): void;
    /**
     * 자동 정리를 수행합니다
     */
    private _performAutomaticCleanup;
    /**
     * 스냅샷 개수를 제한합니다
     */
    private _enforceMaxSnapshots;
    /**
     * 복원 이벤트를 발생시킵니다
     */
    private _emitRestoreEvent;
    /**
     * 메모리 알림을 처리합니다
     */
    private _handleMemoryAlert;
    /**
     * 상태 압축을 해제합니다
     */
    private _decompressState;
    /**
     * 두 상태가 동일한지 비교합니다
     */
    private _areStatesEqual;
}

/**
 * 네트워크 인터셉터 전용 타입 정의
 */
/**
 * 네트워크 요청 타이밍 정보
 */
interface INetworkTiming {
    startTime: number;
    requestStart: number;
    responseStart: number;
    responseEnd: number;
    duration: number;
    dnsLookup?: number;
    tcpConnect?: number;
    sslHandshake?: number;
    firstByte?: number;
}
/**
 * GraphQL 쿼리 정보
 */
interface IGraphQLInfo {
    operationType: 'query' | 'mutation' | 'subscription';
    operationName?: string;
    variables?: Record<string, unknown>;
    extensions?: Record<string, unknown>;
}
/**
 * 확장된 네트워크 요청 인터페이스
 */
interface IEnhancedNetworkRequest extends INetworkRequest {
    timing: INetworkTiming;
    size: {
        requestHeaders: number;
        requestBody: number;
        total: number;
    };
    graphql?: IGraphQLInfo;
    retryAttempt?: number;
    cacheStatus?: 'hit' | 'miss' | 'stale' | 'none';
    priority?: 'high' | 'medium' | 'low';
}
/**
 * 확장된 네트워크 응답 인터페이스
 */
interface IEnhancedNetworkResponse extends INetworkResponse {
    timing: INetworkTiming;
    size: {
        responseHeaders: number;
        responseBody: number;
        total: number;
    };
    compression?: {
        type: string;
        ratio: number;
    };
    graphql?: {
        errors?: unknown[];
        data?: unknown;
        extensions?: Record<string, unknown>;
    };
}
/**
 * 네트워크 인터셉터 설정
 */
interface INetworkInterceptorConfig {
    maxHistorySize?: number;
    captureRequestBody?: boolean;
    captureResponseBody?: boolean;
    enableTiming?: boolean;
    enableGraphQLParsing?: boolean;
    enableAxiosInterception?: boolean;
    maxBodySize?: number;
    excludePatterns?: RegExp[];
    includePatterns?: RegExp[];
    onRequest?: (request: IEnhancedNetworkRequest) => void;
    onResponse?: (response: IEnhancedNetworkResponse) => void;
    onError?: (error: Error, request: IEnhancedNetworkRequest) => void;
}

interface IStateChange {
    id: string;
    timestamp: number;
    statePath: string;
    oldValue: unknown;
    newValue: unknown;
    source: 'api' | 'user' | 'system' | 'unknown';
    trigger?: {
        type: 'api_request' | 'api_response' | 'user_action' | 'timer' | 'unknown';
        id?: string;
        details?: Record<string, unknown>;
    };
}
interface IAPIStateMapping {
    id: string;
    apiRequestId: string;
    apiResponseId?: string;
    url: string;
    method: string;
    stateChanges: IStateChange[];
    timing: {
        apiStart: number;
        apiEnd?: number;
        firstStateChange?: number;
        lastStateChange?: number;
        totalDuration?: number;
    };
    confidence: number;
    metadata: {
        dataFlowType: 'direct' | 'indirect' | 'batched' | 'unknown';
        affectedComponents: string[];
        stateChangeCount: number;
    };
}
interface IAPIStateMapperConfig {
    enableAutoMapping?: boolean;
    stateChangeWindow?: number;
    confidenceThreshold?: number;
    maxMappingHistory?: number;
    enablePatternLearning?: boolean;
    excludeStatePatterns?: RegExp[];
    onMappingCreated?: (mapping: IAPIStateMapping) => void;
    onStateChange?: (stateChange: IStateChange) => void;
}
/**
 * API-상태 매핑 시스템
 *
 * API 호출과 상태 변경 간의 연관성을 자동으로 분석하고 추적합니다.
 */
declare class APIStateMapper {
    private _config;
    private _isActive;
    private _pendingRequests;
    private _recentStateChanges;
    private _mappings;
    private _stateObservers;
    private _patterns;
    constructor(config?: IAPIStateMapperConfig);
    /**
     * 매핑 시작
     */
    start(): void;
    /**
     * 매핑 중지
     */
    stop(): void;
    /**
     * API 요청 추적 시작
     */
    trackAPIRequest(request: IEnhancedNetworkRequest): void;
    /**
     * API 응답 추적
     */
    trackAPIResponse(response: IEnhancedNetworkResponse): void;
    /**
     * 상태 변경 수동 추가
     */
    addStateChange(stateChange: Omit<IStateChange, 'id' | 'timestamp'>): void;
    /**
     * 매핑 목록 가져오기
     */
    getMappings(): IAPIStateMapping[];
    /**
     * 특정 API 패턴의 매핑 가져오기
     */
    getMappingsByURL(urlPattern: string | RegExp): IAPIStateMapping[];
    /**
     * 상태 변경 히스토리
     */
    getStateChangeHistory(): IStateChange[];
    /**
     * 패턴 학습 결과
     */
    getLearnedPatterns(): Map<string, number>;
    /**
     * 통계 정보
     */
    getStats(): {
        isActive: boolean;
        totalMappings: number;
        pendingRequests: number;
        recentStateChanges: number;
        learnedPatterns: number;
        averageConfidence: number;
        config: {
            enableAutoMapping: boolean;
            stateChangeWindow: number;
            confidenceThreshold: number;
            maxMappingHistory: number;
            enablePatternLearning: boolean;
            excludeStatePatterns: RegExp[];
            onMappingCreated?: (mapping: IAPIStateMapping) => void;
            onStateChange?: (stateChange: IStateChange) => void;
        };
    };
    /**
     * 상태 변경 감지 창 시작
     */
    private _startStateChangeWindow;
    /**
     * API-상태 매핑 생성
     */
    private _createMapping;
    /**
     * 신뢰도 계산
     */
    private _calculateConfidence;
    /**
     * 데이터 플로우 타입 분석
     */
    private _analyzeDataFlowType;
    /**
     * 영향받은 컴포넌트 추출
     */
    private _extractAffectedComponents;
    /**
     * URL 패턴 추출
     */
    private _extractURLPattern;
    /**
     * 패턴 학습
     */
    private _learnPattern;
    /**
     * 자동 매핑 시도
     */
    private _attemptAutoMapping;
    /**
     * 상태 관찰자 설정
     */
    private _setupStateObservers;
    /**
     * Redux 상태 관찰자 설정
     */
    private _setupReduxObserver;
    /**
     * MobX 상태 관찰자 설정
     */
    private _setupMobXObserver;
    /**
     * Zustand 상태 관찰자 설정
     */
    private _setupZustandObserver;
    /**
     * 상태 변경 감지
     */
    private _detectStateChanges;
    /**
     * 상태 diff 계산
     */
    private _diffStates;
    /**
     * 상태 변경 제외 여부 확인
     */
    private _shouldExcludeStateChange;
    /**
     * 상태 관찰자들 정리
     */
    private _cleanupStateObservers;
    /**
     * 정리
     */
    destroy(): void;
}
/**
 * 전역 API 상태 매퍼 가져오기/생성
 */
declare function getGlobalAPIStateMapper(config?: IAPIStateMapperConfig): APIStateMapper;
/**
 * 전역 API 상태 매퍼 정리
 */
declare function destroyGlobalAPIStateMapper(): void;

/**
 * 에러 감지 시스템의 설정 인터페이스
 */
interface IErrorDetectorConfig {
    captureConsole?: boolean;
    captureUnhandledErrors?: boolean;
    captureUnhandledRejections?: boolean;
    captureReactErrors?: boolean;
    includeSourceMap?: boolean;
    maxStackFrames?: number;
    excludePatterns?: RegExp[];
    onError?: (event: IDebugEvent) => void;
}
/**
 * 에러 컨텍스트 정보
 */
interface IErrorContextLocal {
    url: string;
    userAgent: string;
    timestamp: number;
    userId?: string;
    sessionId?: string;
    reactState?: Record<string, unknown>;
    reactProps?: Record<string, unknown>;
    domSnapshot?: string;
    breadcrumbs?: IBreadcrumbLocal[];
    originalError?: Error | string;
    performance?: any;
    network?: any;
    stateSnapshot?: any;
}
/**
 * 브레드크럼 (사용자 행동 추적)
 */
interface IBreadcrumbLocal {
    id: string;
    type: 'navigation' | 'user_action' | 'http' | 'console' | 'state_change';
    message: string;
    data?: Record<string, unknown>;
    timestamp: number;
    level: 'info' | 'warning' | 'error';
}
/**
 * 에러 상세 정보
 */
interface IErrorDetails {
    id: string;
    type: TDebugEventType;
    message: string;
    stack?: string;
    filename?: string;
    lineNumber?: number;
    columnNumber?: number;
    source?: 'javascript' | 'promise' | 'console' | 'react' | 'manual';
    level: 'info' | 'warning' | 'error' | 'critical';
    context: IErrorContextLocal;
    originalError?: Error | string;
}
/**
 * 완전한 에러 감지 시스템
 *
 * JavaScript 에러, Promise rejection, console 메시지, React 에러 등을
 * 포괄적으로 감지하고 컨텍스트 정보와 함께 수집합니다.
 */
declare class ErrorDetector {
    private _config;
    private _isActive;
    private _breadcrumbs;
    private _maxBreadcrumbs;
    private _originalConsole;
    private _originalOnError;
    private _originalOnUnhandledRejection;
    private _reactErrorHandler?;
    constructor(config?: Partial<IErrorDetectorConfig>);
    /**
     * 에러 감지 시작
     */
    start(): void;
    /**
     * 에러 감지 중단
     */
    stop(): void;
    /**
     * 브레드크럼 추가
     */
    addBreadcrumb(breadcrumb: Omit<IBreadcrumbLocal, 'id' | 'timestamp'>): void;
    /**
     * React Error Handler 설정
     */
    setReactErrorHandler(handler: (error: Error, errorInfo: any) => void): void;
    /**
     * 현재 컨텍스트 정보 수집
     */
    getCurrentContext(): IErrorContextLocal;
    /**
     * 글로벌 JavaScript 에러 핸들러 설정
     */
    private _setupGlobalErrorHandler;
    /**
     * Unhandled Promise Rejection 핸들러 설정
     */
    private _setupUnhandledRejectionHandler;
    /**
     * Console 메서드 오버라이드
     */
    private _setupConsoleOverride;
    /**
     * React Error Handler 설정
     */
    private _setupReactErrorHandler;
    /**
     * React 에러 처리
     */
    private _handleReactError;
    /**
     * 에러 제외 여부 확인
     */
    private _shouldExcludeError;
    /**
     * 컨텍스트 정보 강화
     */
    private _enhanceContext;
    /**
     * DOM 스냅샷 캡처 (간단한 버전)
     */
    private _captureDOMSnapshot;
    /**
     * 에러 이벤트 처리
     */
    private _handleError;
    /**
     * 현재 상태 가져오기
     */
    getState(): {
        isActive: boolean;
        breadcrumbsCount: number;
        config: Required<Omit<IErrorDetectorConfig, 'onError'>> & {
            onError?: (event: IDebugEvent) => void;
        };
    };
    /**
     * 설정 업데이트
     */
    updateConfig(newConfig: Partial<IErrorDetectorConfig>): void;
}
/**
 * 글로벌 ErrorDetector 가져오기/생성
 */
declare function getGlobalErrorDetector(config?: Partial<IErrorDetectorConfig>): ErrorDetector;
/**
 * React Error Boundary HOC
 */
declare function createReactErrorBoundary(errorDetector: ErrorDetector): {
    new (props: any): {
        [x: string]: any;
        componentDidCatch(error: Error, errorInfo: any): void;
        render(): any;
    };
    [x: string]: any;
    getDerivedStateFromError(error: Error): {
        hasError: boolean;
        error: Error;
    };
} | null;

/**
 * 사용자 액션 감지 설정
 */
interface IUserActionDetectorConfig {
    captureLevel: 'minimal' | 'normal' | 'verbose';
    debounceMs: number;
    includeHoverEvents: boolean;
    includeScrollEvents: boolean;
    includeKeyboardEvents: boolean;
    maxActionsPerSecond: number;
    excludeSelectors: string[];
    prioritySelectors: string[];
    onAction?: (action: IUserActionEvent) => void;
}
/**
 * 사용자 액션 이벤트
 */
interface IUserActionEvent {
    id: string;
    type: string;
    timestamp: number;
    element: {
        tagName: string;
        id?: string;
        className?: string;
        textContent?: string;
        attributes?: Record<string, string>;
    };
    coordinates?: {
        x: number;
        y: number;
        pageX: number;
        pageY: number;
    };
    value?: string;
    target: {
        selector: string;
        xpath: string;
    };
    priority: 'low' | 'medium' | 'high' | 'critical';
    metadata: {
        url: string;
        viewport: {
            width: number;
            height: number;
        };
        sessionId?: string;
        userId?: string;
    };
}
/**
 * 스마트 사용자 액션 감지 시스템
 *
 * 의미있는 사용자 액션만 선별적으로 캐치하고,
 * 노이즈를 제거하며, 우선순위에 따라 분류합니다.
 */
declare class UserActionDetector {
    private _config;
    private _isActive;
    private _actionQueue;
    private _debouncedActions;
    private _actionCount;
    private _lastSecond;
    private readonly _priorityRules;
    constructor(config?: Partial<IUserActionDetectorConfig>);
    /**
     * 사용자 액션 감지 시작
     */
    start(): void;
    /**
     * 사용자 액션 감지 중단
     */
    stop(): void;
    /**
     * 설정에 따른 캡처할 이벤트 타입들 가져오기
     */
    private _getEventTypesToCapture;
    /**
     * 이벤트 핸들러
     */
    private _handleEvent;
    /**
     * 이벤트 캡처 여부 결정
     */
    private _shouldCaptureEvent;
    /**
     * Rate limiting 체크
     */
    private _checkRateLimit;
    /**
     * 액션 우선순위 계산
     */
    private _calculatePriority;
    /**
     * 규칙 매칭 확인
     */
    private _matchesRule;
    /**
     * 액션 디바운싱
     */
    private _debounceAction;
    /**
     * 액션 처리
     */
    private _processAction;
    /**
     * 중요한 속성들 가져오기
     */
    private _getImportantAttributes;
    /**
     * 마우스 좌표 가져오기
     */
    private _getCoordinates;
    /**
     * 입력 값 가져오기
     */
    private _getValue;
    /**
     * CSS 셀렉터 생성
     */
    private _getElementSelector;
    /**
     * XPath 생성
     */
    private _getElementXPath;
    /**
     * 액션 큐 가져오기
     */
    getActionQueue(): IUserActionEvent[];
    /**
     * 액션 큐 초기화
     */
    clearActionQueue(): void;
    /**
     * 현재 상태 가져오기
     */
    getState(): {
        isActive: boolean;
        queueLength: number;
        config: Required<Omit<IUserActionDetectorConfig, 'onAction'>> & {
            onAction?: (action: IUserActionEvent) => void;
        };
    };
    /**
     * 설정 업데이트
     */
    updateConfig(newConfig: Partial<IUserActionDetectorConfig>): void;
}

interface IRealTimeErrorReporterConfig extends Partial<IErrorDetectorConfig> {
    websocket?: {
        url: string;
        reconnectInterval?: number;
        maxReconnectAttempts?: number;
        enableHeartbeat?: boolean;
        heartbeatInterval?: number;
    };
    enableStateSnapshot?: boolean;
    enableConsoleContext?: boolean;
    enableNetworkContext?: boolean;
    enablePerformanceContext?: boolean;
    autoConnect?: boolean;
    bufferErrors?: boolean;
    maxErrorBuffer?: number;
    enableLogging?: boolean;
    onError?: (event: IDebugEvent) => void;
}
/**
 * 실시간 에러 리포터 - 에러를 감지하고 즉시 WebSocket으로 전송
 */
declare class RealTimeErrorReporter {
    private _config;
    private _errorDetector;
    private _webSocketConnector;
    private _isActive;
    private _errorBuffer;
    private _stats;
    constructor(config?: IRealTimeErrorReporterConfig);
    /**
     * 실시간 에러 리포팅 시작
     */
    start(): Promise<void>;
    /**
     * 실시간 에러 리포팅 중지
     */
    stop(): Promise<void>;
    /**
     * WebSocket 수동 연결
     */
    connectWebSocket(): Promise<void>;
    /**
     * WebSocket 연결 해제
     */
    disconnectWebSocket(): void;
    /**
     * 에러 수동 리포트
     */
    reportError(error: Error, context?: Record<string, unknown>): void;
    /**
     * 브레드크럼 추가
     */
    addBreadcrumb(breadcrumb: {
        type: 'navigation' | 'user_action' | 'http' | 'console' | 'state_change';
        message: string;
        data?: Record<string, unknown>;
        level?: 'info' | 'warning' | 'error';
    }): void;
    /**
     * 통계 정보 가져오기
     */
    getStats(): {
        uptime: number;
        isActive: boolean;
        webSocketConnected: boolean;
        errorDetectorState: {
            isActive: boolean;
            breadcrumbsCount: number;
            config: Required<Omit<IErrorDetectorConfig, "onError">> & {
                onError?: (event: IDebugEvent) => void;
            };
        };
        totalErrors: number;
        sentErrors: number;
        bufferedErrors: number;
        startTime: number;
    };
    /**
     * 현재 상태 정보
     */
    getState(): {
        isActive: boolean;
        config: {
            excludePatterns: RegExp[];
            websocket: {
                url: string;
                reconnectInterval?: number;
                maxReconnectAttempts?: number;
                enableHeartbeat?: boolean;
                heartbeatInterval?: number;
            };
            autoConnect: boolean;
            enableLogging: boolean;
            captureConsole: boolean;
            captureUnhandledErrors: boolean;
            captureUnhandledRejections: boolean;
            captureReactErrors: boolean;
            includeSourceMap: boolean;
            maxStackFrames: number;
            enableStateSnapshot: boolean;
            enableConsoleContext: boolean;
            enableNetworkContext: boolean;
            enablePerformanceContext: boolean;
            bufferErrors: boolean;
            maxErrorBuffer: number;
            onError?: (event: IDebugEvent) => void;
        };
        stats: {
            uptime: number;
            isActive: boolean;
            webSocketConnected: boolean;
            errorDetectorState: {
                isActive: boolean;
                breadcrumbsCount: number;
                config: Required<Omit<IErrorDetectorConfig, "onError">> & {
                    onError?: (event: IDebugEvent) => void;
                };
            };
            totalErrors: number;
            sentErrors: number;
            bufferedErrors: number;
            startTime: number;
        };
        errorDetector: {
            isActive: boolean;
            breadcrumbsCount: number;
            config: Required<Omit<IErrorDetectorConfig, "onError">> & {
                onError?: (event: IDebugEvent) => void;
            };
        };
        webSocketConnector: {
            isConnected: boolean;
            sessionId: string;
            queueSize: number;
            reconnectAttempts: number;
            websocketState: number | undefined;
        } | undefined;
        errorBufferSize: number;
    };
    /**
     * 에러 이벤트 처리
     */
    private _handleError;
    /**
     * 에러 이벤트 강화 (추가 컨텍스트 수집)
     */
    private _enhanceErrorEvent;
    /**
     * 성능 컨텍스트 수집
     */
    private _collectPerformanceContext;
    /**
     * 네트워크 컨텍스트 수집
     */
    private _collectNetworkContext;
    /**
     * 상태 스냅샷 수집 (간단한 버전)
     */
    private _collectStateSnapshot;
    /**
     * LocalStorage 스냅샷 (키만)
     */
    private _getLocalStorageSnapshot;
    /**
     * SessionStorage 스냅샷 (키만)
     */
    private _getSessionStorageSnapshot;
    /**
     * 에러 이벤트 전송
     */
    private _sendErrorEvent;
    /**
     * 에러 이벤트 버퍼링
     */
    private _bufferErrorEvent;
    /**
     * 에러 버퍼 전송
     */
    private _flushErrorBuffer;
    /**
     * 시작 이벤트 전송
     */
    private _sendStartEvent;
    /**
     * 종료 이벤트 전송
     */
    private _sendStopEvent;
    /**
     * 로깅 헬퍼
     */
    private _log;
    /**
     * 정리
     */
    destroy(): Promise<void>;
}
/**
 * 전역 에러 리포터 생성/가져오기
 */
declare function getGlobalErrorReporter(config?: IRealTimeErrorReporterConfig): RealTimeErrorReporter;
/**
 * 전역 에러 리포터 정리
 */
declare function destroyGlobalErrorReporter(): Promise<void>;
/**
 * React Error Boundary 컴포넌트 생성 헬퍼
 */
declare function createErrorBoundaryWithReporter(errorReporter: RealTimeErrorReporter): {
    new (props: any): {
        [x: string]: any;
        componentDidCatch(error: Error, errorInfo: any): void;
        render(): any;
    };
    [x: string]: any;
    getDerivedStateFromError(error: Error): {
        hasError: boolean;
        error: Error;
    };
} | null;

/**
 * 고급 네트워크 인터셉터
 *
 * Fetch, XHR을 지원하며 다음 기능을 제공합니다:
 * - 상세한 타이밍 정보 수집
 * - GraphQL 쿼리 감지 및 파싱
 * - 요청/응답 크기 측정
 * - 네트워크 에러 추적
 */
declare class NetworkInterceptor implements INetworkInterceptor {
    private _config;
    private _isIntercepting;
    private _requestHistory;
    private _responseHistory;
    private _originalFetch;
    private _originalXMLHttpRequest;
    constructor(config?: Partial<INetworkInterceptorConfig>);
    /**
     * 네트워크 요청 가로채기 시작
     */
    startIntercepting(): void;
    /**
     * 네트워크 요청 가로채기 중단
     */
    stopIntercepting(): void;
    /**
     * 요청 히스토리 가져오기
     */
    getRequestHistory(): IEnhancedNetworkRequest[];
    /**
     * 응답 히스토리 가져오기
     */
    getResponseHistory(): IEnhancedNetworkResponse[];
    /**
     * 히스토리 초기화
     */
    clearHistory(): void;
    /**
     * 네트워크 성능 매트릭 가져오기
     */
    getNetworkMetrics(): {
        totalRequests: number;
        successRate: number;
        averageResponseTime: number;
        totalDataTransferred: number;
        errorCount: number;
        slowRequestsCount: number;
        completedRequests?: undefined;
        graphqlRequestsCount?: undefined;
    } | {
        totalRequests: number;
        completedRequests: number;
        successRate: number;
        averageResponseTime: number;
        totalDataTransferred: number;
        errorCount: number;
        slowRequestsCount: number;
        graphqlRequestsCount: number;
    };
    /**
     * Fetch API 가로채기
     */
    private _interceptFetch;
    /**
     * XMLHttpRequest 가로채기
     */
    private _interceptXMLHttpRequest;
    /**
     * 요청 URL이 제외 패턴에 매치되는지 확인
     */
    private _shouldExcludeRequest;
    /**
     * GraphQL 쿼리 파싱
     */
    private _parseGraphQL;
    /**
     * GraphQL 오퍼레이션 타입 감지
     */
    private _detectGraphQLOperationType;
    /**
     * GraphQL 오퍼레이션 이름 추출
     */
    private _extractGraphQLOperationName;
    /**
     * 요청 우선순위 계산
     */
    private _calculateRequestPriority;
    /**
     * Fetch 응답 처리
     */
    private _handleFetchResponse;
    /**
     * Fetch 에러 처리
     */
    private _handleFetchError;
    /**
     * XHR 응답 처리
     */
    private _handleXHRResponse;
    /**
     * GraphQL 응답 파싱
     */
    private _parseGraphQLResponse;
    /**
     * 헤더 크기 계산
     */
    private _calculateHeadersSize;
    /**
     * 요청 헤더 추출
     */
    private _extractHeaders;
    /**
     * 응답 헤더 추출
     */
    private _extractResponseHeaders;
    /**
     * 현재 상태 가져오기
     */
    getState(): {
        isIntercepting: boolean;
        requestCount: number;
        responseCount: number;
        config: {
            maxHistorySize: number;
            captureRequestBody: boolean;
            captureResponseBody: boolean;
            enableTiming: boolean;
            enableGraphQLParsing: boolean;
            enableAxiosInterception: boolean;
            maxBodySize: number;
            excludePatterns: RegExp[];
            includePatterns: RegExp[];
            onRequest?: (request: IEnhancedNetworkRequest) => void;
            onResponse?: (response: IEnhancedNetworkResponse) => void;
            onError?: (error: Error, request: IEnhancedNetworkRequest) => void;
        };
        metrics: {
            totalRequests: number;
            successRate: number;
            averageResponseTime: number;
            totalDataTransferred: number;
            errorCount: number;
            slowRequestsCount: number;
            completedRequests?: undefined;
            graphqlRequestsCount?: undefined;
        } | {
            totalRequests: number;
            completedRequests: number;
            successRate: number;
            averageResponseTime: number;
            totalDataTransferred: number;
            errorCount: number;
            slowRequestsCount: number;
            graphqlRequestsCount: number;
        };
    };
    /**
     * 정리
     */
    destroy(): void;
}

interface IRealTimeAPIInterceptorConfig extends Partial<INetworkInterceptorConfig> {
    websocket?: {
        url: string;
        reconnectInterval?: number;
        maxReconnectAttempts?: number;
        enableHeartbeat?: boolean;
        heartbeatInterval?: number;
    };
    enableAxiosInterception?: boolean;
    autoConnect?: boolean;
    enableLogging?: boolean;
}
/**
 * 실시간 API 인터셉터 - 모든 네트워크 요청을 실시간으로 캡처하고 WebSocket으로 전송
 */
declare class RealTimeAPIInterceptor {
    private _config;
    private _networkInterceptor;
    private _axiosInterceptor;
    private _webSocketConnector;
    private _isActive;
    private _stats;
    constructor(config?: IRealTimeAPIInterceptorConfig);
    /**
     * 실시간 API 인터셉션 시작
     */
    start(): Promise<void>;
    /**
     * 실시간 API 인터셉션 중지
     */
    stop(): Promise<void>;
    /**
     * WebSocket 수동 연결
     */
    connectWebSocket(): Promise<void>;
    /**
     * WebSocket 연결 해제
     */
    disconnectWebSocket(): void;
    /**
     * 요청 히스토리 가져오기
     */
    getRequestHistory(): IEnhancedNetworkRequest[];
    /**
     * 응답 히스토리 가져오기
     */
    getResponseHistory(): IEnhancedNetworkResponse[];
    /**
     * 히스토리 초기화
     */
    clearHistory(): void;
    /**
     * 통계 정보 가져오기
     */
    getStats(): {
        uptime: number;
        networkMetrics: {
            totalRequests: number;
            successRate: number;
            averageResponseTime: number;
            totalDataTransferred: number;
            errorCount: number;
            slowRequestsCount: number;
            completedRequests?: undefined;
            graphqlRequestsCount?: undefined;
        } | {
            totalRequests: number;
            completedRequests: number;
            successRate: number;
            averageResponseTime: number;
            totalDataTransferred: number;
            errorCount: number;
            slowRequestsCount: number;
            graphqlRequestsCount: number;
        };
        isActive: boolean;
        webSocketConnected: boolean;
        webSocketQueueSize: number;
        axiosIntercepting: boolean;
        totalRequests: number;
        totalResponses: number;
        totalErrors: number;
        startTime: number;
    };
    /**
     * 현재 상태 정보
     */
    getState(): {
        isActive: boolean;
        config: {
            maxHistorySize: number;
            captureRequestBody: boolean;
            captureResponseBody: boolean;
            enableTiming: boolean;
            enableGraphQLParsing: boolean;
            enableAxiosInterception: boolean;
            maxBodySize: number;
            excludePatterns: RegExp[];
            includePatterns: RegExp[];
            websocket: {
                url: string;
                reconnectInterval?: number;
                maxReconnectAttempts?: number;
                enableHeartbeat?: boolean;
                heartbeatInterval?: number;
            };
            autoConnect: boolean;
            enableLogging: boolean;
            onRequest?: (request: IEnhancedNetworkRequest) => void;
            onResponse?: (response: IEnhancedNetworkResponse) => void;
            onError?: (error: Error, request: IEnhancedNetworkRequest) => void;
        };
        stats: {
            uptime: number;
            networkMetrics: {
                totalRequests: number;
                successRate: number;
                averageResponseTime: number;
                totalDataTransferred: number;
                errorCount: number;
                slowRequestsCount: number;
                completedRequests?: undefined;
                graphqlRequestsCount?: undefined;
            } | {
                totalRequests: number;
                completedRequests: number;
                successRate: number;
                averageResponseTime: number;
                totalDataTransferred: number;
                errorCount: number;
                slowRequestsCount: number;
                graphqlRequestsCount: number;
            };
            isActive: boolean;
            webSocketConnected: boolean;
            webSocketQueueSize: number;
            axiosIntercepting: boolean;
            totalRequests: number;
            totalResponses: number;
            totalErrors: number;
            startTime: number;
        };
        networkInterceptor: {
            isIntercepting: boolean;
            requestCount: number;
            responseCount: number;
            config: {
                maxHistorySize: number;
                captureRequestBody: boolean;
                captureResponseBody: boolean;
                enableTiming: boolean;
                enableGraphQLParsing: boolean;
                enableAxiosInterception: boolean;
                maxBodySize: number;
                excludePatterns: RegExp[];
                includePatterns: RegExp[];
                onRequest?: (request: IEnhancedNetworkRequest) => void;
                onResponse?: (response: IEnhancedNetworkResponse) => void;
                onError?: (error: Error, request: IEnhancedNetworkRequest) => void;
            };
            metrics: {
                totalRequests: number;
                successRate: number;
                averageResponseTime: number;
                totalDataTransferred: number;
                errorCount: number;
                slowRequestsCount: number;
                completedRequests?: undefined;
                graphqlRequestsCount?: undefined;
            } | {
                totalRequests: number;
                completedRequests: number;
                successRate: number;
                averageResponseTime: number;
                totalDataTransferred: number;
                errorCount: number;
                slowRequestsCount: number;
                graphqlRequestsCount: number;
            };
        };
        axiosInterceptor: {
            isIntercepting: boolean;
            hasRequestInterceptor: boolean;
            hasResponseInterceptor: boolean;
            axiosAvailable: boolean;
        } | undefined;
        webSocketConnector: {
            isConnected: boolean;
            sessionId: string;
            queueSize: number;
            reconnectAttempts: number;
            websocketState: number | undefined;
        } | undefined;
    };
    /**
     * 네트워크 요청 처리
     */
    private _handleNetworkRequest;
    /**
     * 네트워크 응답 처리
     */
    private _handleNetworkResponse;
    /**
     * 네트워크 에러 처리
     */
    private _handleNetworkError;
    /**
     * 시작 이벤트 전송
     */
    private _sendStartEvent;
    /**
     * 종료 이벤트 전송
     */
    private _sendStopEvent;
    /**
     * 로깅 헬퍼
     */
    private _log;
    /**
     * 정리
     */
    destroy(): Promise<void>;
}
/**
 * 전역 API 인터셉터 생성/가져오기
 */
declare function getGlobalAPIInterceptor(config?: IRealTimeAPIInterceptorConfig): RealTimeAPIInterceptor;
/**
 * 전역 API 인터셉터 정리
 */
declare function destroyGlobalAPIInterceptor(): Promise<void>;

/**
 * Axios 인터셉터 - axios 라이브러리와의 통합
 */
declare class AxiosInterceptor {
    private _isIntercepting;
    private _requestInterceptorId;
    private _responseInterceptorId;
    private _onRequest?;
    private _onResponse?;
    private _onError?;
    constructor(callbacks?: {
        onRequest?: (request: IEnhancedNetworkRequest) => void;
        onResponse?: (response: IEnhancedNetworkResponse) => void;
        onError?: (error: Error, request: IEnhancedNetworkRequest) => void;
    });
    /**
     * Axios 인터셉션 시작
     */
    startIntercepting(): void;
    /**
     * Axios 인터셉션 중지
     */
    stopIntercepting(): void;
    /**
     * 전역 axios 인스턴스 탐지
     */
    private _getAxiosInstance;
    /**
     * Axios 요청 인터셉터
     */
    private _handleAxiosRequest;
    /**
     * Axios 요청 에러 인터셉터
     */
    private _handleAxiosRequestError;
    /**
     * Axios 응답 인터셉터
     */
    private _handleAxiosResponse;
    /**
     * Axios 응답 에러 인터셉터
     */
    private _handleAxiosResponseError;
    /**
     * 전체 URL 구성
     */
    private _buildFullUrl;
    /**
     * 헤더 정규화
     */
    private _normalizeHeaders;
    /**
     * 헤더 크기 계산
     */
    private _calculateHeadersSize;
    /**
     * GraphQL 감지
     */
    private _detectGraphQL;
    /**
     * GraphQL 오퍼레이션 타입 감지
     */
    private _detectGraphQLOperationType;
    /**
     * GraphQL 오퍼레이션 이름 추출
     */
    private _extractGraphQLOperationName;
    /**
     * GraphQL 응답 파싱
     */
    private _parseGraphQLResponse;
    /**
     * 요청 우선순위 계산
     */
    private _calculatePriority;
    /**
     * 현재 상태 확인
     */
    get isIntercepting(): boolean;
    /**
     * 상태 정보 가져오기
     */
    getState(): {
        isIntercepting: boolean;
        hasRequestInterceptor: boolean;
        hasResponseInterceptor: boolean;
        axiosAvailable: boolean;
    };
    /**
     * 정리
     */
    destroy(): void;
}

interface IDebugTimeMachineConfig {
    websocket?: {
        url: string;
        reconnectInterval?: number;
        maxReconnectAttempts?: number;
        enableHeartbeat?: boolean;
        heartbeatInterval?: number;
    };
    networkInterception?: Partial<IRealTimeAPIInterceptorConfig>;
    errorReporting?: Partial<IRealTimeErrorReporterConfig>;
    stateMapping?: Partial<IAPIStateMapperConfig>;
    enableNetworkInterception?: boolean;
    enableErrorReporting?: boolean;
    enableStateMapping?: boolean;
    autoStart?: boolean;
    enableLogging?: boolean;
    sessionId?: string;
}
interface IDebugTimeMachineStats {
    uptime: number;
    sessionId: string;
    isActive: boolean;
    network: {
        totalRequests: number;
        totalResponses: number;
        totalErrors: number;
        webSocketConnected: boolean;
    };
    errors: {
        totalErrors: number;
        sentErrors: number;
        bufferedErrors: number;
    };
    stateMapping: {
        totalMappings: number;
        averageConfidence: number;
        learnedPatterns: number;
    };
}
/**
 * Debug Time Machine 통합 엔진
 *
 * 모든 핵심 기능들을 통합하고 관리하는 메인 클래스입니다.
 */
declare class DebugTimeMachineEngine {
    private _config;
    private _isActive;
    private _sessionId;
    private _startTime;
    private _apiInterceptor;
    private _errorReporter;
    private _stateMapper;
    private _timeTravelEngine;
    constructor(config?: IDebugTimeMachineConfig);
    /**
     * Debug Time Machine 시작
     */
    start(): Promise<void>;
    /**
     * Debug Time Machine 중지
     */
    stop(): Promise<void>;
    /**
     * WebSocket 수동 연결
     */
    connectWebSocket(): Promise<void>;
    /**
     * WebSocket 연결 해제
     */
    disconnectWebSocket(): void;
    /**
     * 에러 수동 리포트
     */
    reportError(error: Error, context?: Record<string, unknown>): void;
    /**
     * 브레드크럼 추가
     */
    addBreadcrumb(breadcrumb: {
        type: 'navigation' | 'user_action' | 'http' | 'console' | 'state_change';
        message: string;
        data?: Record<string, unknown>;
        level?: 'info' | 'warning' | 'error';
    }): void;
    /**
     * 상태 변경 수동 추가
     */
    addStateChange(stateChange: {
        statePath: string;
        oldValue: unknown;
        newValue: unknown;
        source?: 'api' | 'user' | 'system' | 'unknown';
    }): void;
    /**
     * 시간여행 - 특정 시점으로 이동
     */
    travelToTime(timestamp: number): void;
    /**
     * 시간여행 - 이전 이벤트로 이동
     */
    travelToPreviousEvent(): void;
    /**
     * 시간여행 - 다음 이벤트로 이동
     */
    travelToNextEvent(): void;
    /**
     * 현재 상태 스냅샷 생성
     */
    createSnapshot(): void;
    /**
     * 히스토리 초기화
     */
    clearHistory(): void;
    /**
     * 통계 정보 가져오기
     */
    getStats(): IDebugTimeMachineStats;
    /**
     * 상세 상태 정보
     */
    getDetailedState(): {
        engine: {
            isActive: boolean;
            sessionId: string;
            uptime: number;
            config: {
                websocket: {
                    url: string;
                    reconnectInterval?: number;
                    maxReconnectAttempts?: number;
                    enableHeartbeat?: boolean;
                    heartbeatInterval?: number;
                };
                networkInterception: Partial<IRealTimeAPIInterceptorConfig>;
                errorReporting: Partial<IRealTimeErrorReporterConfig>;
                stateMapping: Partial<IAPIStateMapperConfig>;
                enableNetworkInterception: boolean;
                enableErrorReporting: boolean;
                enableStateMapping: boolean;
                autoStart: boolean;
                enableLogging: boolean;
                sessionId: string;
            };
        };
        apiInterceptor: {
            isActive: boolean;
            config: {
                maxHistorySize: number;
                captureRequestBody: boolean;
                captureResponseBody: boolean;
                enableTiming: boolean;
                enableGraphQLParsing: boolean;
                enableAxiosInterception: boolean;
                maxBodySize: number;
                excludePatterns: RegExp[];
                includePatterns: RegExp[];
                websocket: {
                    url: string;
                    reconnectInterval?: number;
                    maxReconnectAttempts?: number;
                    enableHeartbeat?: boolean;
                    heartbeatInterval?: number;
                };
                autoConnect: boolean;
                enableLogging: boolean;
                onRequest?: (request: IEnhancedNetworkRequest) => void;
                onResponse?: (response: IEnhancedNetworkResponse) => void;
                onError?: (error: Error, request: IEnhancedNetworkRequest) => void;
            };
            stats: {
                uptime: number;
                networkMetrics: {
                    totalRequests: number;
                    successRate: number;
                    averageResponseTime: number;
                    totalDataTransferred: number;
                    errorCount: number;
                    slowRequestsCount: number;
                    completedRequests?: undefined;
                    graphqlRequestsCount?: undefined;
                } | {
                    totalRequests: number;
                    completedRequests: number;
                    successRate: number;
                    averageResponseTime: number;
                    totalDataTransferred: number;
                    errorCount: number;
                    slowRequestsCount: number;
                    graphqlRequestsCount: number;
                };
                isActive: boolean;
                webSocketConnected: boolean;
                webSocketQueueSize: number;
                axiosIntercepting: boolean;
                totalRequests: number;
                totalResponses: number;
                totalErrors: number;
                startTime: number;
            };
            networkInterceptor: {
                isIntercepting: boolean;
                requestCount: number;
                responseCount: number;
                config: {
                    maxHistorySize: number;
                    captureRequestBody: boolean;
                    captureResponseBody: boolean;
                    enableTiming: boolean;
                    enableGraphQLParsing: boolean;
                    enableAxiosInterception: boolean;
                    maxBodySize: number;
                    excludePatterns: RegExp[];
                    includePatterns: RegExp[];
                    onRequest?: (request: IEnhancedNetworkRequest) => void;
                    onResponse?: (response: IEnhancedNetworkResponse) => void;
                    onError?: (error: Error, request: IEnhancedNetworkRequest) => void;
                };
                metrics: {
                    totalRequests: number;
                    successRate: number;
                    averageResponseTime: number;
                    totalDataTransferred: number;
                    errorCount: number;
                    slowRequestsCount: number;
                    completedRequests?: undefined;
                    graphqlRequestsCount?: undefined;
                } | {
                    totalRequests: number;
                    completedRequests: number;
                    successRate: number;
                    averageResponseTime: number;
                    totalDataTransferred: number;
                    errorCount: number;
                    slowRequestsCount: number;
                    graphqlRequestsCount: number;
                };
            };
            axiosInterceptor: {
                isIntercepting: boolean;
                hasRequestInterceptor: boolean;
                hasResponseInterceptor: boolean;
                axiosAvailable: boolean;
            } | undefined;
            webSocketConnector: {
                isConnected: boolean;
                sessionId: string;
                queueSize: number;
                reconnectAttempts: number;
                websocketState: number | undefined;
            } | undefined;
        } | undefined;
        errorReporter: {
            isActive: boolean;
            config: {
                excludePatterns: RegExp[];
                websocket: {
                    url: string;
                    reconnectInterval?: number;
                    maxReconnectAttempts?: number;
                    enableHeartbeat?: boolean;
                    heartbeatInterval?: number;
                };
                autoConnect: boolean;
                enableLogging: boolean;
                captureConsole: boolean;
                captureUnhandledErrors: boolean;
                captureUnhandledRejections: boolean;
                captureReactErrors: boolean;
                includeSourceMap: boolean;
                maxStackFrames: number;
                enableStateSnapshot: boolean;
                enableConsoleContext: boolean;
                enableNetworkContext: boolean;
                enablePerformanceContext: boolean;
                bufferErrors: boolean;
                maxErrorBuffer: number;
                onError?: (event: IDebugEvent) => void;
            };
            stats: {
                uptime: number;
                isActive: boolean;
                webSocketConnected: boolean;
                errorDetectorState: {
                    isActive: boolean;
                    breadcrumbsCount: number;
                    config: Required<Omit<IErrorDetectorConfig, "onError">> & {
                        onError?: (event: IDebugEvent) => void;
                    };
                };
                totalErrors: number;
                sentErrors: number;
                bufferedErrors: number;
                startTime: number;
            };
            errorDetector: {
                isActive: boolean;
                breadcrumbsCount: number;
                config: Required<Omit<IErrorDetectorConfig, "onError">> & {
                    onError?: (event: IDebugEvent) => void;
                };
            };
            webSocketConnector: {
                isConnected: boolean;
                sessionId: string;
                queueSize: number;
                reconnectAttempts: number;
                websocketState: number | undefined;
            } | undefined;
            errorBufferSize: number;
        } | undefined;
        stateMapper: {
            isActive: boolean;
            totalMappings: number;
            pendingRequests: number;
            recentStateChanges: number;
            learnedPatterns: number;
            averageConfidence: number;
            config: {
                enableAutoMapping: boolean;
                stateChangeWindow: number;
                confidenceThreshold: number;
                maxMappingHistory: number;
                enablePatternLearning: boolean;
                excludeStatePatterns: RegExp[];
                onMappingCreated?: (mapping: IAPIStateMapping) => void;
                onStateChange?: (stateChange: IStateChange) => void;
            };
        } | undefined;
        timeTravelEngine: {
            snapshotCount: number;
            maxSnapshots: number;
            memoryUsage: IMemoryUsage;
            config: Required<ITimeTravelEngineConfig>;
        } | undefined;
    };
    /**
     * API 매핑 정보 가져오기
     */
    getAPIMappings(): IAPIStateMapping[];
    /**
     * 네트워크 요청 히스토리
     */
    getNetworkHistory():