/**
 * ServiceWorker Mock System Type Definitions
 */
interface SwMockConfig {
    enabled: boolean;
    debug: boolean;
    defaultDelay: number;
    interceptPatterns: string[];
    excludePatterns: string[];
    endpoints: Record<string, MockEndpointConfig>;
    globalDelay: number | null;
    errorRate: number;
    networkFailure: NetworkFailureConfig;
    mockDataPath: string;
    includeInterceptPrefix: boolean;
}
interface NetworkFailureConfig {
    enabled: boolean;
    scenarios: {
        httpErrors: HttpErrorScenario;
        timeout: TimeoutScenario;
        connectionFailure: ConnectionFailureScenario;
        responseDelay: ResponseDelayScenario;
        intermittentFailure: IntermittentFailureScenario;
    };
}
interface HttpErrorScenario {
    enabled: boolean;
    statusCodes: number[];
    rate: number;
    distribution: 'random' | 'sequential' | 'weighted';
}
interface TimeoutScenario {
    enabled: boolean;
    duration: number;
    rate: number;
}
interface ConnectionFailureScenario {
    enabled: boolean;
    rate: number;
}
interface ResponseDelayScenario {
    enabled: boolean;
    minDelay: number;
    maxDelay: number;
    rate: number;
}
interface IntermittentFailureScenario {
    enabled: boolean;
    failureDuration: number;
    recoveryDuration: number;
    rate: number;
}
interface MockEndpointConfig {
    delay?: number;
    status?: number;
    errorRate?: number;
    errorStatus?: number;
    data?: any;
    headers?: Record<string, string>;
}
interface SwMockInitOptions extends Partial<SwMockConfig> {
    workerUrl?: string;
    mockDataPath?: string;
    autoRegister?: boolean;
    scope?: string;
}
interface SwMockStatus {
    enabled: boolean;
    debug: boolean;
    defaultDelay: number;
    globalDelay: number | null;
    interceptPatterns: string[];
    excludePatterns: string[];
    endpointsCount: number;
    serviceWorkerReady: boolean;
    mockDataPath: string;
    scope: string;
    networkFailure: {
        enabled: boolean;
        httpErrors: boolean;
        timeout: boolean;
        connectionFailure: boolean;
        responseDelay: boolean;
        intermittentFailure: boolean;
    };
}
interface CapturedRequest {
    method: string;
    url: string;
    timestamp: string;
    headers: Record<string, string>;
    body?: any;
}
interface MockResponse {
    status: number;
    statusText: string;
    headers: Record<string, string>;
    data: any;
}
interface NetworkFailureInfo {
    type: 'httpError' | 'timeout' | 'connectionFailure' | 'responseDelay';
    statusCode?: number;
    duration?: number;
    delay?: number;
}
interface SwMockPlugin {
    name: string;
    install: (swMock: SwMockInstance) => void;
}
interface SwMockInstance {
    init(options?: SwMockInitOptions): Promise<void>;
    enable(): Promise<void>;
    disable(): Promise<void>;
    toggle(): Promise<boolean>;
    getStatus(): Promise<SwMockStatus>;
    getConfig(): Promise<SwMockConfig>;
    updateConfig(config: Partial<SwMockConfig>): Promise<void>;
    resetConfig(): Promise<void>;
    enableNetworkFailure(): Promise<void>;
    disableNetworkFailure(): Promise<void>;
    configureNetworkFailure(config: Partial<NetworkFailureConfig>): Promise<void>;
    resetNetworkFailureState(): Promise<void>;
    enableHttpErrors(options?: Partial<HttpErrorScenario>): Promise<void>;
    enableTimeouts(options?: Partial<TimeoutScenario>): Promise<void>;
    enableConnectionFailures(options?: Partial<ConnectionFailureScenario>): Promise<void>;
    enableResponseDelays(options?: Partial<ResponseDelayScenario>): Promise<void>;
    enableIntermittentFailures(options?: Partial<IntermittentFailureScenario>): Promise<void>;
    enableDevelopmentMode(): Promise<void>;
    enableTestingMode(): Promise<void>;
    enableStressTestMode(): Promise<void>;
    enableDebug(): Promise<void>;
    disableDebug(): Promise<void>;
    startCapture(): Promise<void>;
    stopCapture(): Promise<CapturedRequest[]>;
    exportCapturedRequests(): void;
    addMockEndpoint(endpoint: string, config: MockEndpointConfig): Promise<void>;
    removeMockEndpoint(endpoint: string): Promise<void>;
    setGlobalDelay(delay: number): Promise<void>;
    addInterceptPattern(pattern: string): Promise<void>;
    removeInterceptPattern(pattern: string): Promise<void>;
    addExcludePattern(pattern: string): Promise<void>;
    removeExcludePattern(pattern: string): Promise<void>;
    clearDatabase(): Promise<void>;
    use(plugin: SwMockPlugin): void;
    on(event: string, callback: Function): void;
    off(event: string, callback: Function): void;
    emit(event: string, ...args: any[]): void;
}
type SwMockEventType = 'init' | 'enable' | 'disable' | 'config-update' | 'network-failure-trigger' | 'request-intercepted' | 'mock-response-sent' | 'error';
interface SwMockEvent {
    type: SwMockEventType;
    timestamp: number;
    data?: any;
}
declare global {
    interface Window {
        SwMock?: SwMockInstance;
        swMock?: SwMockInstance;
        swMockUtils?: SwMockInstance;
    }
}

/**
 * Event Emitter for SwMock
 */
declare class EventEmitter {
    private events;
    /**
     * Add event listener
     */
    on(event: string, callback: Function): void;
    /**
     * Remove event listener
     */
    off(event: string, callback: Function): void;
    /**
     * Add one-time event listener
     */
    once(event: string, callback: Function): void;
    /**
     * Emit event
     */
    emit(event: string, ...args: any[]): void;
    /**
     * Remove all listeners for an event
     */
    removeAllListeners(event?: string): void;
    /**
     * Get all event names
     */
    eventNames(): string[];
    /**
     * Get listener count for an event
     */
    listenerCount(event: string): number;
}

/**
 * Main SwMock Class
 */

declare class SwMock extends EventEmitter implements SwMockInstance {
    private communication;
    private plugins;
    private isInitialized;
    constructor();
    /**
     * Initialize SwMock system
     */
    init(options?: SwMockInitOptions): Promise<void>;
    /**
     * Enable mock functionality
     */
    enable(): Promise<void>;
    /**
     * Disable mock functionality
     */
    disable(): Promise<void>;
    /**
     * Toggle mock functionality
     */
    toggle(): Promise<boolean>;
    /**
     * Get current status
     */
    getStatus(): Promise<SwMockStatus>;
    /**
     * Get current configuration
     */
    getConfig(): Promise<SwMockConfig>;
    /**
     * Update configuration
     */
    updateConfig(config: Partial<SwMockConfig>): Promise<void>;
    /**
     * Reset configuration
     */
    resetConfig(): Promise<void>;
    enableNetworkFailure(): Promise<void>;
    disableNetworkFailure(): Promise<void>;
    configureNetworkFailure(config: Partial<NetworkFailureConfig>): Promise<void>;
    resetNetworkFailureState(): Promise<void>;
    enableHttpErrors(options?: Partial<HttpErrorScenario>): Promise<void>;
    enableTimeouts(options?: Partial<TimeoutScenario>): Promise<void>;
    enableConnectionFailures(options?: Partial<ConnectionFailureScenario>): Promise<void>;
    enableResponseDelays(options?: Partial<ResponseDelayScenario>): Promise<void>;
    enableIntermittentFailures(options?: Partial<IntermittentFailureScenario>): Promise<void>;
    enableDevelopmentMode(): Promise<void>;
    enableTestingMode(): Promise<void>;
    enableStressTestMode(): Promise<void>;
    enableDebug(): Promise<void>;
    disableDebug(): Promise<void>;
    startCapture(): Promise<void>;
    stopCapture(): Promise<CapturedRequest[]>;
    exportCapturedRequests(): void;
    addMockEndpoint(endpoint: string, config: MockEndpointConfig): Promise<void>;
    removeMockEndpoint(endpoint: string): Promise<void>;
    setGlobalDelay(delay: number): Promise<void>;
    addInterceptPattern(pattern: string): Promise<void>;
    removeInterceptPattern(pattern: string): Promise<void>;
    addExcludePattern(pattern: string): Promise<void>;
    removeExcludePattern(pattern: string): Promise<void>;
    clearDatabase(): Promise<void>;
    use(plugin: SwMockPlugin): void;
}

/**
 * Utility Helper Functions
 */

/**
 * Check if ServiceWorker is supported
 */
declare function isServiceWorkerSupported(): boolean;
/**
 * Check if running in secure context (HTTPS or localhost)
 */
declare function isSecureContext(): boolean;
/**
 * Export captured requests as JSON file
 */
declare function exportCapturedRequests(requests: CapturedRequest[]): void;

/**
 * ServiceWorker Mock Configuration Management
 */

declare const DEFAULT_CONFIG: SwMockConfig;
declare const PRESET_CONFIGS: {
    development: Partial<SwMockConfig>;
    testing: Partial<SwMockConfig>;
    stress: Partial<SwMockConfig>;
};

/**
 * Create a new SwMock instance
 */
declare function createSwMock(): SwMock;
/**
 * Get or create global SwMock instance
 */
declare function getSwMock(): SwMock;
/**
 * Initialize SwMock with options (convenience function)
 */
declare function init(options?: SwMockInitOptions): Promise<SwMock>;
/**
 * Quick setup functions
 */
declare const SwMockUtils: {
    /**
     * Quick setup for development environment
     */
    setupDevelopment(options?: SwMockInitOptions): Promise<SwMock>;
    /**
     * Quick setup for testing environment
     */
    setupTesting(options?: SwMockInitOptions): Promise<SwMock>;
    /**
     * Quick setup for stress testing
     */
    setupStressTesting(options?: SwMockInitOptions): Promise<SwMock>;
    /**
     * Disable all mock functionality
     */
    disable(): Promise<void>;
    /**
     * Check system compatibility
     */
    checkCompatibility(): {
        compatible: boolean;
        issues: string[];
    };
    /**
     * Get system information
     */
    getSystemInfo(): {
        serviceWorkerSupported: boolean;
        secureContext: boolean;
        indexedDBSupported: boolean;
        userAgent: string;
        url: string;
        timestamp: string;
    };
};
/**
 * Plugin system
 */
declare const plugins: {
    /**
     * Console logger plugin
     */
    consoleLogger: {
        name: string;
        install(swMock: SwMock): void;
    };
    /**
     * Performance monitor plugin
     */
    performanceMonitor: {
        name: string;
        install(swMock: SwMock): void;
    };
};

export { CapturedRequest, ConnectionFailureScenario, DEFAULT_CONFIG, HttpErrorScenario, IntermittentFailureScenario, MockEndpointConfig, MockResponse, NetworkFailureConfig, NetworkFailureInfo, PRESET_CONFIGS, ResponseDelayScenario, SwMock, SwMockConfig, SwMockEvent, SwMockEventType, SwMockInitOptions, SwMockInstance, SwMockPlugin, SwMockStatus, SwMockUtils, TimeoutScenario, createSwMock, SwMock as default, exportCapturedRequests, getSwMock, init, isSecureContext, isServiceWorkerSupported, plugins };