import { EventEmitter, QueryList, ElementRef, AfterViewInit, AfterViewChecked, OnDestroy, OnChanges, SimpleChanges, ChangeDetectorRef } from '@angular/core';
import { DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
import * as i0 from "@angular/core";
export interface FastForwardConfig {
    fromStep: number;
    toStep: number;
    currentStep: number;
    totalSteps: number;
    targetStepNumber: string;
    targetStepLabel: string;
}
export interface StepMarker {
    cumulativeDuration: number;
    result: 'SUCCESS' | 'FAILURE' | 'ABORTED' | 'SKIPPED';
    testStepId?: number;
    level?: number;
    childSteps?: StepMarker[];
    title?: string;
}
export declare type SegmentType = 'screenshots' | 'video' | 'trace';
declare type SegmentOption = {
    label: string;
    value: string;
    icon?: string;
};
export declare class SimulatorComponent implements AfterViewInit, AfterViewChecked, OnDestroy, OnChanges {
    private sanitizer;
    private cdr;
    videoUrl: string;
    videoUrls: string[];
    videoCurrentDuration: number;
    stepMarkers: StepMarker[];
    screenShotUrl: string;
    traceViewUrl: string;
    platformName: string;
    platformType: 'browser' | 'device';
    platform: string;
    deviceName: string | null;
    isLive: boolean;
    liveStatus: 'In Progress' | 'Paused' | 'Aborted' | 'Failed' | 'Passed' | 'Execution';
    liveLoadingLabel: string;
    isContentVideoLoading: boolean;
    failedStatusMessage: string;
    isVNCSessionIntruppted: boolean;
    vncSessionIntupptedMessage: string;
    selectedView: SegmentType;
    hideVideoTab: boolean;
    browserViewPort: {
        width: number;
        height: number;
    } | null;
    browserDevice: string;
    isFastForwarding: boolean;
    fastForwardConfig: FastForwardConfig | null;
    showVideoLibrary: boolean;
    showCaptureVideo: boolean;
    isCapturingVideo: boolean;
    liveSessionView: 'live' | 'captured';
    get fastForwardProgressPercent(): number;
    videoTimeUpdate: EventEmitter<number>;
    videoPlay: EventEmitter<void>;
    videoPause: EventEmitter<void>;
    markerHit: EventEmitter<StepMarker>;
    isVideoPlayingChange: EventEmitter<boolean>;
    captureVideoRequested: EventEmitter<void>;
    liveSessionViewChange: EventEmitter<"live" | "captured">;
    private _vplayer?;
    set vplayerRef(ref: ElementRef<HTMLVideoElement> | undefined);
    get vplayer(): ElementRef<HTMLVideoElement> | undefined;
    private _timelineBar?;
    set timelineBarRef(ref: ElementRef<HTMLDivElement> | undefined);
    get timelineBar(): ElementRef<HTMLDivElement> | undefined;
    private _speedControlContainer?;
    set speedControlContainerRef(ref: ElementRef<HTMLDivElement> | undefined);
    get speedControlContainer(): ElementRef<HTMLDivElement> | undefined;
    progress: number;
    dragging: boolean;
    isPlaying: boolean;
    showPlayPauseOverlay: boolean;
    /**
     * Icon shown by the play/pause overlay during its 500ms lifetime. Pinned at click time
     * so the icon doesn't flicker as `isPlaying` flips async between
     * `<video>.play()` invocation and its promise resolving. Mirrors the YouTube-style
     * convention: show the action just taken (▶ after play, ∥ after pause).
     */
    overlayShowsPlayingIcon: boolean;
    private playPauseOverlayTimer;
    isFullScreen: boolean;
    currentView: string;
    currentVideoIndex: number;
    currentSpeed: string;
    isSpeedControlOpen: boolean;
    private detectedVideoDurations;
    private wasPlayingBeforeDrag;
    private playPromise;
    private hitMarkers;
    private playerState;
    private operationQueue;
    isVideoLibraryCollapsed: boolean;
    newVideoIndexes: Set<number>;
    libraryVideoDurations: Map<number, number>;
    downloadingIndexes: Set<number>;
    downloadProgress: Map<number, number>;
    clipVideos?: QueryList<ElementRef<HTMLVideoElement>>;
    clipsScrollerRef?: ElementRef<HTMLElement>;
    private lastLibrarySyncKey;
    private lastScrolledClipIndex;
    videoRefreshing: boolean;
    private pendingRecoverySeekSec;
    private pendingRecoveryPlay;
    private recoveryAttempts;
    private recoveryAttemptWindowStart;
    private readonly MAX_RECOVERY_ATTEMPTS;
    private readonly RECOVERY_WINDOW_MS;
    isVideoFullMode: boolean;
    globalDragProgress: number;
    private clipsDragState;
    clipsDragActive: boolean;
    get effectivePlatformType(): 'browser' | 'device';
    get hasDeviceFrame(): boolean;
    get isPlayerSwitching(): boolean;
    get isAspectRatioMatched(): boolean;
    get liveContentContainerStyle(): {
        [key: string]: string;
    };
    segments: SegmentOption[];
    speedSegments: SegmentOption[];
    liveSessionSegments: SegmentOption[];
    onLiveSessionViewChange(next: string): void;
    /** Reset the video player to a clean slate whenever the Live/Captured view toggles
     *  during an active debug session. Pauses playback, exits Full Video mode, rewinds
     *  to clip 0, and clears drag/scroll/marker state.
     *
     *  Applied synchronously (no operationQueue) because the toggle usually also
     *  unmounts/remounts the <video> element — any in-flight operation on the old
     *  element is already dead, and a fresh element naturally mounts with
     *  `src = videoUrls[0]` from `currentVideoUrl`. Enqueueing here would race with
     *  the element lifecycle and either get discarded or block the queue. */
    private resetLiveSessionPlaybackState;
    private videoEventListenerCleanup;
    private lastSetDuration;
    private dragMouseMoveHandler;
    private dragMouseUpHandler;
    private speedControlClickOutsideHandler;
    private preloadVideoElement;
    private preloadAllVideoElement;
    safeTraceUrl: SafeResourceUrl;
    traceViewerLoading: boolean;
    traceViewerError: boolean;
    isCorrectDeviceFrameAvailable: boolean;
    private readonly emptyStateConfig;
    readonly deviceErrorEmptyStateConfig: {
        title: string;
        description: string;
        actions: any[];
        imageUrl: string;
    };
    get effectiveBrowserViewPort(): {
        width: number;
        height: number;
    };
    private readonly MOBILE_BROWSER_DEVICE_MAP;
    private resolveMobileBrowserDevice;
    private readonly deviceFrameConfigs;
    constructor(sanitizer: DomSanitizer, cdr: ChangeDetectorRef);
    onWindowResize(): void;
    private get deviceFrameConfig();
    get deviceMockupImage(): string;
    get deviceScreenStyle(): {
        [key: string]: string;
    };
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    private syncLibraryClipPlayback;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    /**
     * Seek video - public method (enqueues operation)
     */
    seekToTime(milliseconds: number): void;
    /**
     * Seek video internal implementation (no enqueue - called from queue)
     * This prevents pipeline read errors during rapid seek operations
     */
    private seekToTimeInternal;
    onVideoKeydown(event: KeyboardEvent): void;
    /**
     * Toggle play/pause.
     *
     * Decision is based on the video element's native `paused` property (ground truth)
     * rather than on `playerState`, which lags during async play() / pause() transitions.
     * The previous implementation would, on a rapid second click during the ~50-200ms
     * `video.play()` await window, see `playerState === 'loading'` and queue another
     * `playVideo()` instead of the intended `pauseVideo()` — so the second click
     * silently "did nothing" while the video kept playing. Reading `video.paused`
     * directly makes the toggle correct regardless of what stage the state machine
     * happens to be in.
     */
    togglePlay(): void;
    onVideoFrameClick(): void;
    /**
     * Play video - public method (enqueues operation)
     */
    private playVideo;
    /**
     * Play video internal implementation (no enqueue - called from queue)
     * This eliminates FFmpegDemuxer errors and play promise interruptions
     */
    private playVideoInternal;
    /**
     * Pause video - public method (enqueues operation)
     */
    private pauseVideo;
    /**
     * Pause video internal implementation (no enqueue - called from queue)
     */
    private pauseVideoInternal;
    /**
     * Enqueue media operation to prevent race conditions
     * This is the CRITICAL fix for FFmpegDemuxer errors and play promise interruptions
     * All media operations (play, pause, seek, switch) go through this queue
     */
    private enqueueOperation;
    get hasMultipleVideos(): boolean;
    /** Cumulative duration boundaries [ms]. segmentBoundaries[i] = sum of durations [0..i] */
    get segmentBoundaries(): number[];
    /** Total duration across all segments in ms */
    get totalDuration(): number;
    /** Video durations in ms (detected or from single video element).
     *
     *  Merges two independent probes: `detectedVideoDurations` (off-DOM temp videos)
     *  and `libraryVideoDurations` (the rendered library thumbnails). Either can
     *  resolve first depending on browser quirks with WebM/Infinity-duration clips;
     *  we take the first finite value per index. */
    private get videoDurations();
    get currentVideoMarkers(): StepMarker[];
    private adjustChildStepsDuration;
    getStepLeftPosition(step: StepMarker): number;
    /** Full-video markers: every marker, flattened, laid out on the global timeline.
     * `stepMarkers` is already in global coordinates — `currentVideoMarkers` does the
     * inverse (filters + adjusts per-clip); here we just flatten the original list. */
    get fullVideoMarkers(): StepMarker[];
    getGlobalFullStepLeftPosition(step: StepMarker): number;
    /** Cumulative elapsed ms on the global timeline (prior clip durations + current local time). */
    get globalCurrentTimeMs(): number;
    /** 0-100 position on the global timeline, driven by timeupdate. */
    get globalProgress(): number;
    /** While dragging in full mode, the scrubber reads the override; otherwise globalProgress. */
    get globalScrubberPercent(): number;
    getStepColor(step: StepMarker): string;
    getStepResultColor(step: StepMarker): string;
    getGlobalMarkerColor(level?: number): string;
    getGlobalMarkerResultColor(result: StepMarker['result']): string;
    onMarkerClick(event: MouseEvent, marker: StepMarker): void;
    get currentVideoUrl(): string;
    /**
     * Reset video state - public method (enqueues operation)
     */
    private resetVideoState;
    /**
     * Reset video state internal implementation (no enqueue - called from queue)
     */
    private resetVideoStateInternal;
    prevVideo(): void;
    nextVideo(): void;
    onTimelineClick(event: MouseEvent): void;
    startDrag(event: MouseEvent): void;
    onDrag(event: MouseEvent): void;
    stopDrag(): void;
    private addDragListeners;
    private removeDragListeners;
    onVideoMetadataLoaded(): void;
    onVideoCanPlay(): void;
    /** Native error-event handler for the main <video> element. The Chrome media
     * stack occasionally throws "PipelineStatus::PIPELINE_ERROR_READ: FFmpegDemuxer:
     * data source error" during playback after a brief network blip or a burst of
     * fast user actions; once that happens the element becomes unresponsive to
     * play/pause/seek. We recover by unmounting+remounting the <video> via *ngIf
     * — the same mechanism that makes the Screenshots↔Video tab-switch workaround
     * work today — then restore the pre-error playhead and resume playback. */
    onVideoError(): void;
    onVideoEnded(): void;
    private attachVideoListeners;
    private schedulePreloadAllSegments;
    private cancelPreloadAllSegments;
    /**
     * Preload all video URLs in sequence (first, then second, ...) so they are cached.
     * When user jumps to any segment, that video is likely already loaded.
     */
    private preloadAllSegments;
    /** Preload next segment when ~5-10 seconds from ending to minimize switching delay */
    private maybePreloadNextSegment;
    private preloadNextSegment;
    /**
     * Detect actual video durations by loading video metadata.
     *
     * Browser-recorded WebM clips frequently report `duration === Infinity` on the first
     * `loadedmetadata` firing; the real duration only resolves after seeking past the end
     * (same trick `onLibraryClipMetadataLoaded` uses for the library thumbnails). We mirror
     * that probe here so `detectedVideoDurations` ends up dense and `totalDuration` is
     * correct in Full Video mode.
     *
     * Preserves previously-detected entries on re-invocation (append-only videoUrls
     * changes shouldn't wipe finished detections from earlier clips).
     */
    private detectVideoDurations;
    /**
     * Get cumulative duration boundaries for each video
     * Returns an array where each element is [startDuration, endDuration] for that video
     * Uses detected video durations if available, otherwise falls back to videoDurations input
     */
    private getVideoDurationBoundaries;
    /**
     * Flatten all markers recursively including childSteps
     */
    private flattenMarkers;
    private checkMarkerHit;
    toggleFullScreen(): void;
    onSegmentChange(value: string): void;
    formatTime(seconds: number): string;
    captureVideo(): void;
    onClipsMouseDown(event: MouseEvent, scroller: HTMLElement): void;
    onClipsMouseMove(event: MouseEvent, scroller: HTMLElement): void;
    onClipsMouseUp(_event: MouseEvent): void;
    onClipsMouseLeave(event: MouseEvent): void;
    /** Click handler on a Video Library card — switches the main player to that clip and auto-plays.
     * Selecting a *different* clip also collapses the library so the newly-playing video is unobstructed;
     * re-clicking the active clip just toggles play/pause and keeps the drawer state.
     * Ignored when the click originated from a horizontal drag-scroll. */
    selectLibraryClip(index: number): void;
    /** Per-card metadata handler — caches duration so the `0:42` thumbnail label can render.
     * Bound to BOTH `loadedmetadata` and `durationchange`:
     *   - Some MP4s (esp. short clips with moov at the end) report a wrong/partial duration
     *     on `loadedmetadata`; Chrome later corrects it via `durationchange`. Listening to
     *     both + keeping the max-so-far avoids stale wrong values like "00:01" for a 5s clip.
     *   - For streamed MP4s that report `Infinity`, seek to the end once so Chrome fetches
     *     the cues/trailer and fires a corrected `durationchange`. */
    onLibraryClipMetadataLoaded(index: number, videoEl: HTMLVideoElement): void;
    trackLibraryClipByIndex(index: number, url: string): string;
    /** Download the clip at `index`. Streams the bytes with fetch so we can show progress,
     * then saves via a temporary blob URL so the file comes down on the same page
     * (no new tab / window). Falls back to a direct anchor click if fetch is unavailable or fails. */
    downloadClip(index: number): Promise<void>;
    private deriveClipFilename;
    private saveBlobAsDownload;
    /** Circumference of the 6-radius progress ring (see clip-download-btn__ring in template). */
    readonly downloadRingCircumference: number;
    /** stroke-dashoffset for the progress ring of clip `index`; 0 = full, circumference = empty. */
    downloadRingDashoffset(index: number): number;
    private triggerDirectDownload;
    onShowFullVideo(): void;
    onExitFullVideo(): void;
    /** Horizontally scrolls the `.clips-row` so the currently-playing clip card is
     * in the visible strip. No-op if the card is already on screen. Caller guards
     * on `isPlaying` so the user can freely scroll the row while paused. */
    private scrollCurrentClipIntoView;
    toggleVideoLibraryCollapsed(): void;
    getStatusBadgeClass(): string;
    getStatusTextClass(): string;
    get processedTraceUrl(): string;
    private updateSafeTraceUrl;
    onTraceViewerLoad(): void;
    onTraceViewerError(): void;
    onSpeedChange(value: string): void;
    toggleSpeedControl(): void;
    private addSpeedControlClickOutsideListener;
    private removeSpeedControlClickOutsideListener;
    private updateSegments;
    private onVideoElementReady;
    private applyCurrentPlaybackRate;
    private findVideoIndexForTimestamp;
    private switchToVideoAndResetInternal;
    private switchToVideoAndSeek;
    private switchToVideoAndSeekInternal;
    static ɵfac: i0.ɵɵFactoryDeclaration<SimulatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SimulatorComponent, "cqa-simulator", never, { "videoUrl": "videoUrl"; "videoUrls": "videoUrls"; "videoCurrentDuration": "videoCurrentDuration"; "stepMarkers": "stepMarkers"; "screenShotUrl": "screenShotUrl"; "traceViewUrl": "traceViewUrl"; "platformName": "platformName"; "platformType": "platformType"; "platform": "platform"; "deviceName": "deviceName"; "isLive": "isLive"; "liveStatus": "liveStatus"; "liveLoadingLabel": "liveLoadingLabel"; "isContentVideoLoading": "isContentVideoLoading"; "failedStatusMessage": "failedStatusMessage"; "isVNCSessionIntruppted": "isVNCSessionIntruppted"; "vncSessionIntupptedMessage": "vncSessionIntupptedMessage"; "selectedView": "selectedView"; "hideVideoTab": "hideVideoTab"; "browserViewPort": "browserViewPort"; "browserDevice": "browserDevice"; "isFastForwarding": "isFastForwarding"; "fastForwardConfig": "fastForwardConfig"; "showVideoLibrary": "showVideoLibrary"; "showCaptureVideo": "showCaptureVideo"; "isCapturingVideo": "isCapturingVideo"; "liveSessionView": "liveSessionView"; }, { "videoTimeUpdate": "videoTimeUpdate"; "videoPlay": "videoPlay"; "videoPause": "videoPause"; "markerHit": "markerHit"; "isVideoPlayingChange": "isVideoPlayingChange"; "captureVideoRequested": "captureVideoRequested"; "liveSessionViewChange": "liveSessionViewChange"; }, never, ["*"]>;
}
export {};