mocha-multiple-sessions-detailed-runner/dist/impl/use-cases/runner-use-cases.d.ts

High-level API for multi-session Mocha tests with detailed reporting

import type { IInitializeRunnerUseCase, IDefineSessionUseCase, IRunSingleSessionUseCase, IRunAllSessionsUseCase, IClearAllSessionsUseCase, IDestroyRunnerUseCase } from '../../interfaces/use-cases/runner-use-cases';
import type { MultiSessionConfig, SessionResult } from '../../interfaces/core/types';
import type { BatchExecutionOptions } from '../../interfaces/core/batch-execution';
import type { ISessionMetaRepository } from '../../interfaces/repositories/session-meta-repository';
import type { IReportRepository } from '../../interfaces/repositories/report-repository';
import type { IUnifiedEventBus } from '../../interfaces/events/unified-event-bus';
import type { IMochaIntegration } from '../../interfaces/infrastructure/mocha-integration';
declare global {
    interface Window {
        MochaMultipleSessions?: {
            testSessionSetup: (config: any) => void;
            onAnySessionEvent: (callback: (event: any) => void) => () => void;
            testSession: (label: string, setupFn: () => void, options?: any) => Promise<string>;
            runSession: (label: string) => Promise<any>;
            runAllSessions: () => Promise<any[]>;
        };
    }
}
export declare class InitializeRunnerUseCase implements IInitializeRunnerUseCase {
    private mochaIntegration;
    private eventBus;
    constructor(mochaIntegration: IMochaIntegration, eventBus: IUnifiedEventBus);
    execute(config?: Partial<MultiSessionConfig>): void;
}
export declare class DefineSessionUseCase implements IDefineSessionUseCase {
    private sessionRepository;
    private reportRepository;
    private eventBus;
    constructor(sessionRepository: ISessionMetaRepository, reportRepository: IReportRepository, eventBus: IUnifiedEventBus);
    execute(label: string, setupFn: () => void): void;
}
export declare class RunSingleSessionUseCase implements IRunSingleSessionUseCase {
    private sessionRepository;
    private reportRepository;
    private eventBus;
    constructor(sessionRepository: ISessionMetaRepository, reportRepository: IReportRepository, eventBus: IUnifiedEventBus);
    execute(label: string): Promise<SessionResult>;
}
export declare class RunAllSessionsUseCase implements IRunAllSessionsUseCase {
    private sessionRepository;
    private runSingleSessionUseCase;
    private eventBus;
    constructor(sessionRepository: ISessionMetaRepository, runSingleSessionUseCase: IRunSingleSessionUseCase, eventBus: IUnifiedEventBus);
    execute(options?: BatchExecutionOptions): Promise<Record<string, SessionResult>>;
}
export declare class ClearAllSessionsUseCase implements IClearAllSessionsUseCase {
    private sessionRepository;
    private reportRepository;
    private eventBus;
    constructor(sessionRepository: ISessionMetaRepository, reportRepository: IReportRepository, eventBus: IUnifiedEventBus);
    execute(): Promise<void>;
}
export declare class DestroyRunnerUseCase implements IDestroyRunnerUseCase {
    private clearAllSessionsUseCase;
    private eventBus;
    constructor(clearAllSessionsUseCase: IClearAllSessionsUseCase, eventBus: IUnifiedEventBus);
    execute(): Promise<void>;
}
//# sourceMappingURL=runner-use-cases.d.ts.map