import { ESLIntersectionEvent } from '../../../esl-event-listener/core';
import { ESLCarouselPlugin } from '../esl-carousel.plugin';
import type { ESLCarouselAutoplayBehaviour, ESLCarouselAutoplayReason, ESLCarouselAutoplayState } from './esl-carousel.autoplay.types';
export interface ESLCarouselAutoplayConfig {
    /** Global autoplay duration (ms) or media rule pattern. 0 means "no default cycle"; negative / invalid disables plugin */
    duration: string | number;
    /** Navigation command executed each cycle */
    command: string;
    /** Intersection threshold used to (auto) pause when out of viewport */
    intersection: number;
    /** Enable hover / focus based pausing */
    trackInteraction: boolean;
    /** Scope selector for interaction tracking subscriptions (defaults to host (carousel)) */
    interactionScope?: string;
    /** CSS selector (Element.matches) to exclude items from the effective interaction scope. Does not affect subscriptions */
    interactionScopeExclude?: string;
    /** CSS class applied to the carousel container while autoplay is enabled */
    containerCls?: string;
    /** Behaviour of runtime blockers */
    blockBehaviour: ESLCarouselAutoplayBehaviour;
    /** Selector for items that, when active, should disable autoplay */
    blockerSelector?: string;
    /** Events that should trigger blocking state re-check when fired anywhere in the document */
    watchEvents: string;
}
/**
 * Autoplay plugin mixin for {@link ESLCarousel}.
 * Schedules slide navigation by timeout while allowed by viewport, interaction and config constraints.
 */
export declare class ESLCarouselAutoplayMixin extends ESLCarouselPlugin<ESLCarouselAutoplayConfig> {
    static is: string;
    static DEFAULT_CONFIG: ESLCarouselAutoplayConfig;
    static DEFAULT_CONFIG_KEY: keyof ESLCarouselAutoplayConfig;
    /** Per-slide override attribute name for timeout */
    static SLIDE_DURATION_ATTRIBUTE: string;
    /** Manual stop flag */
    private _stoppedByUser;
    /** Manual pause flag */
    private _pausedByUser;
    /** Last known viewport intersection state */
    private _inViewport;
    /** Active cycle timeout id (null if no cycle scheduled) */
    private _timeout;
    /** Remaining time until the current cycle ends */
    private _remaining;
    /** Current cycle full duration */
    private _cycleDuration;
    /** Current cycle scheduling start timestamp */
    private _cycleStartedAt;
    /** Last dispatch reason */
    private _lastReason;
    /** Last dispatched state snapshot key to suppress duplicate events */
    private _lastDispatchKey;
    /** True when a navigation timeout is currently scheduled */
    get active(): boolean;
    /** True when autoplay is paused explicitly by user action and can potentially be resumed */
    get paused(): boolean;
    /** Exclusive summary state for autoplay runtime */
    get state(): ESLCarouselAutoplayState;
    /** True when autoplay cannot run due to runtime blockers */
    get blocked(): boolean;
    /**
     * Effective enabled state.
     * True when autoplay is not manually stopped and global duration is non-negative / valid.
     */
    get enabled(): boolean;
    /** Backward-compatible manual enable / disable API */
    set enabled(value: boolean);
    /** Global base duration in ms (raw config parsed). Negative / NaN considered as disabled */
    get duration(): number;
    /**
     * Effective current slide duration.
     * Tries active slide attribute; falls back to global duration.
     * Non-positive result pauses cycle for the slide only (unless global invalid disables plugin).
     */
    get effectiveDuration(): number;
    /** Remaining time of the current/paused cycle */
    get remaining(): number;
    /** Interaction scope elements used as event subscription targets (memoized) */
    get $interactionScope(): HTMLElement[];
    /** Effective interaction scope after exclusion rules are applied */
    get $effectiveInteractionScope(): HTMLElement[];
    /** True if active slide contains any blocking items */
    get hasActiveBlockingItems(): boolean;
    /** True if any scope element is hovered */
    get hovered(): boolean;
    /** True if keyboard-visible focus is within scope */
    get focused(): boolean;
    /** Backward-compatible alias for runtime allowance */
    get allowed(): boolean;
    /** Runtime predicate: autoplay may have an active timeout right now */
    get canRun(): boolean;
    /** True if autoplay can be scheduled for the current slide */
    protected get canSchedule(): boolean;
    /** True if autoplay may be re-started automatically by runtime conditions */
    protected get canAutoStart(): boolean;
    /** True if runtime listeners should sync blocking state right now */
    protected get shouldProcessBlockingState(): boolean;
    /** Start autoplay or resume paused cycle */
    start(reason?: ESLCarouselAutoplayReason): void;
    /** Pause autoplay preserving remaining time when possible */
    pause(reason?: ESLCarouselAutoplayReason): void;
    /** Stop autoplay and clear current cycle state */
    stop(reason?: ESLCarouselAutoplayReason): void;
    /** Toggle autoplay state according to the specified control behaviour */
    toggle(behaviour?: ESLCarouselAutoplayBehaviour): void;
    /** Init lifecycle hook */
    protected onInit(): void;
    /** React to config changes (rebuild memoized queries, re-evaluate state) */
    protected onConfigChange(): void;
    /** Suspend & cleanup on disconnect */
    protected disconnectedCallback(): void;
    /** Update classes and listeners and synchronize state markers */
    protected update(): void;
    /** Update UI markers reflecting effective autoplay state */
    protected updateMarkers(): void;
    /** Reset current cycle state completely */
    protected resetCycle(): void;
    /** Clear active timer only */
    protected clearTimer(): void;
    /** Schedule next autoplay cycle */
    protected schedule(duration: number, total?: number, reason?: ESLCarouselAutoplayReason): void;
    /** Sync current state markers and dispatch autoplay event */
    protected syncState(reason?: ESLCarouselAutoplayReason): void;
    /** Apply blocking logic according to configured block behaviour */
    protected syncBlockingState(): void;
    /** Internal cycle handler (execute navigation then schedule next cycle if needed) */
    protected _onCycle(exec?: boolean): Promise<void>;
    /** Viewport intersection listener controlling runtime allowance */
    protected _onIntersection(e: ESLIntersectionEvent): void;
    /** Hover/focus interaction listener toggling pause state */
    protected _onInteract(): void;
    /** Slide change listener (forces cycle restart) */
    protected _onSlideChange(): void;
    /** Subscribe to events that block autoplay */
    protected _onBlockingEvent(): void;
}
declare global {
    export interface ESLCarouselNS {
        Autoplay: typeof ESLCarouselAutoplayMixin;
    }
}