/**
 * Timeline -- quantizer over time with play/pause/seek/scrub/reverse.
 *
 * A Timeline wraps a BoundaryDef and drives it from a time-based signal,
 * producing discrete state transitions as the elapsed time crosses thresholds.
 *
 * @module
 */
import type { Stream, Scope } from 'effect';
import { Effect } from 'effect';
import type { Millis } from './brands.js';
import { Boundary } from './boundary.js';
import type { StateUnion } from './type-utils.js';
import type { Scheduler } from './scheduler.js';
interface TimelineShape<B extends Boundary.Shape = Boundary.Shape> {
    readonly boundary: B;
    readonly state: Effect.Effect<StateUnion<B>>;
    readonly progress: Effect.Effect<number>;
    readonly elapsed: Effect.Effect<Millis>;
    readonly changes: Stream.Stream<StateUnion<B>>;
    play(): Effect.Effect<void>;
    pause(): Effect.Effect<void>;
    reverse(): Effect.Effect<void>;
    seek(ms: Millis): Effect.Effect<void>;
    scrub(progress: number): Effect.Effect<void>;
}
interface TimelineFactory {
    from<B extends Boundary.Shape>(boundary: B, config?: {
        duration?: Millis;
        loop?: boolean;
        scheduler?: Scheduler.Shape;
    }): Effect.Effect<TimelineShape<B>, never, Scope.Scope>;
}
/**
 * Timeline — scheduler-driven advancement over a {@link Boundary}.
 * Produces a scoped reactive timeline that seeks or plays between boundary
 * states; pluggable clock via {@link Scheduler}.
 */
export declare const Timeline: TimelineFactory;
export declare namespace Timeline {
    /** Structural shape of a timeline instance for a given {@link Boundary}. */
    type Shape<B extends Boundary.Shape = Boundary.Shape> = TimelineShape<B>;
}
export {};
//# sourceMappingURL=timeline.d.ts.map