import type { LayerIdentity } from './layers.js';
import type { SourceIdentity } from './sources.js';
import { type SceneIdentity, type SceneStatus } from './scenes.js';
export interface PlaybackIdentity {
    readonly id: string;
    readonly playbackInstanceId: string;
}
export type PlaybackState = 'ready' | 'playing' | 'paused' | 'stopped' | 'completed' | 'failed';
export interface PlaybackSnapshotBase extends PlaybackIdentity {
    readonly owner: SceneIdentity;
    readonly ownerState: SceneStatus;
    readonly source: SourceIdentity;
    readonly sourceRevision: string;
    readonly state: PlaybackState;
    readonly epoch: string;
    readonly elapsedMs: number;
    readonly positionMs: number;
    readonly durationMs: number;
    readonly loop: boolean;
    readonly delayRemainingMs: number;
    readonly error: {
        readonly code: string;
        readonly message: string;
    } | null;
}
export interface RoutePlaybackSnapshot extends PlaybackSnapshotBase {
    readonly kind: 'route';
    readonly target: SourceIdentity;
    readonly targetRevision: string;
    readonly position: readonly [number, number];
    readonly headingRadians: number;
}
export interface LineFrameSnapshot {
    readonly phase: number;
    readonly reveal: number;
    readonly opacity: number;
    readonly widthScale: number;
    readonly color: readonly [number, number, number, number];
}
export interface LinePlaybackSnapshot extends PlaybackSnapshotBase {
    readonly kind: 'line';
    readonly layer: LayerIdentity;
    readonly sourceStateRevision: string;
    readonly frame: LineFrameSnapshot;
    readonly visibleEffect: boolean;
    readonly pattern?: {
        readonly id: string;
        readonly imageInstanceId: string;
        readonly revision: string;
    };
}
export type PlaybackSnapshot = RoutePlaybackSnapshot | LinePlaybackSnapshot;
export interface RoutePlaybackOptions {
    id: string;
    source: SourceIdentity;
    target: SourceIdentity;
    duration?: number;
    offsets?: readonly number[];
    loop?: boolean;
    delay?: number;
}
export type LineUnit = 'progress' | 'pixels';
export type LineEffect = {
    type: 'flow';
    id?: string;
    unit?: LineUnit;
    spacing?: number;
    trailLength?: number;
    fade?: 'linear' | 'none';
    phase?: number;
} | {
    type: 'dash';
    id?: string;
    unit?: LineUnit;
    on: number;
    gap: number;
} | {
    type: 'reveal';
    id?: string;
    start?: number;
    end?: number;
} | {
    type: 'arrows';
    id?: string;
    unit?: LineUnit;
    spacing?: number;
    length?: number;
} | {
    type: 'glow';
    id?: string;
    radius?: number;
    intensity?: number;
} | {
    type: 'pattern';
    id?: string;
    image: string;
    unit?: LineUnit;
    spacing?: number;
};
export interface LineKeyframe<T> {
    offset: number;
    value: T;
}
export interface LineTracks {
    color?: readonly LineKeyframe<string>[];
    opacity?: readonly LineKeyframe<number>[];
    widthScale?: readonly LineKeyframe<number>[];
}
export interface LineTiming {
    duration: number;
    delay?: number;
    loop?: boolean;
    direction?: 'forward' | 'reverse' | 'alternate';
    easing?: 'linear' | 'ease-in-out';
    fill?: 'forwards' | 'none';
}
export interface LinePlaybackOptions {
    id: string;
    layer: string | LayerIdentity;
    timing: LineTiming;
    effects: readonly LineEffect[];
    tracks?: LineTracks;
    stagger?: boolean;
    cap?: 'butt' | 'round';
    phaseField?: string;
    speedField?: string;
}
export interface Playback<T extends PlaybackSnapshot = PlaybackSnapshot> extends PlaybackIdentity {
    getState(): Promise<T>;
    play(): Promise<void>;
    pause(): Promise<void>;
    stop(): Promise<void>;
    seek(timeMs: number): Promise<void>;
    finished(): Promise<T>;
}
export interface PlaybacksAPI {
    get(id: string): Promise<Playback | undefined>;
    list(): Promise<readonly PlaybackSnapshot[]>;
    remove(playback: PlaybackIdentity): Promise<void>;
}
export interface AnimationsAPI {
    route(options: RoutePlaybackOptions, owner: {
        owner: SceneIdentity;
    }): Promise<Playback<RoutePlaybackSnapshot>>;
    line(options: LinePlaybackOptions, owner: {
        owner: SceneIdentity;
    }): Promise<Playback<LinePlaybackSnapshot>>;
}
export interface PlaybackChangeEvent {
    readonly type: 'sqs.playbackchange';
    readonly reason: string;
    readonly playback: PlaybackSnapshot;
}
export declare function playbackIdentity(value: PlaybackIdentity): PlaybackIdentity;
export declare function immutablePlayback<T extends PlaybackSnapshot>(value: T): T;
export declare function immutablePlaybackEvent(value: PlaybackChangeEvent): PlaybackChangeEvent;
interface Host {
    read<T>(method: string, args: unknown[]): Promise<T>;
    write<T>(method: string, args: unknown[]): Promise<T>;
    sourceIdentity(value: SourceIdentity): SourceIdentity;
    layers?(): Promise<readonly LayerIdentity[]>;
    subscribe?(callback: (event: PlaybackChangeEvent) => void): () => void;
}
export declare function playbackAPIs(host: Host): {
    animations: AnimationsAPI;
    playbacks: PlaybacksAPI;
    close(): void;
};
export {};