import { P as PlaybackEngine, a as PlaybackEngineOptions, b as PlaybackEngineFactory } from './types-B1786Fvo.js';
import { M as Ms, P as Project, T as Track, C as Clip, a as MediaSource, b as Theme, A as AspectRatio, K as KeyframeProp, E as EasingKind } from './types-BTUuytwo.js';
export { c as Keyframe, d as ProjectOutput } from './types-BTUuytwo.js';
import { L as Locale } from './i18n-DUwTFylQ.js';
export { f as formatLabel, l as localeEn, a as localeZh, m as mergeLocale } from './i18n-DUwTFylQ.js';

declare class HtmlVideoEngine implements PlaybackEngine {
    private host;
    private mount;
    private sources;
    private project;
    /** trackId → currently-active clipId on that track. PiP off keeps
     *  only the first entry; PiP on holds one per video track. */
    private activeByTrack;
    private playing;
    private timeMs;
    private rafHandle;
    private lastFrameTs;
    /** Permanent rAF that positions the active wrappers at the output
     *  rect + pushes keyframe transforms onto the inner videos via CSS. */
    private transformRaf;
    private pictureInPictureEnabled;
    /** Public event hooks — set by Editor. */
    onTimeUpdate?: (ms: Ms) => void;
    onEnded?: () => void;
    onError?: (err: Error) => void;
    onReady?: () => void;
    onSourceMetadata?: (sourceId: string, durationMs: Ms) => void;
    constructor(opts: PlaybackEngineOptions);
    setProject(next: Project): void;
    setPictureInPictureEnabled(enabled: boolean): void;
    play(): void;
    pause(): void;
    isPlaying(): boolean;
    getTime(): Ms;
    seek(timeMs: Ms): void;
    /**
     * The OUTPUT frame — the fixed stage the rendered video is clipped
     * to. Independent of the keyframe transform. Used by the overlay to
     * draw the dashed border at a stable position.
     */
    getOutputFrameRect(_clipId?: string): {
        x: number;
        y: number;
        w: number;
        h: number;
    } | null;
    /**
     * The CONTENT frame — where the transformed video pixels actually
     * land. Equal to the output frame when transform is identity; may
     * extend outside (zoom in) or fit inside (zoom out) when not.
     *
     * `clipId` (PiP): the overlay passes the selected clip so the
     * dashed border + corner handles latch onto a picture-in-picture
     * overlay instead of always tracking the primary. When omitted,
     * defaults to the primary (= bottom track) clip.
     */
    getFrameRect(clipId?: string): {
        x: number;
        y: number;
        w: number;
        h: number;
    } | null;
    /**
     * Untransformed output-canvas rect.
     *
     * Source of truth: `Project.aspect` when the user picked a ratio
     * via the built-in picker. When it's null we fall back to a
     * STABLE reference — the first clip in the first video track,
     * regardless of playhead — so the canvas stays anchored as
     * playback crosses clip boundaries. Picks up the active primary
     * clip's dims as a last resort when the reference video hasn't
     * loaded metadata yet.
     *
     * Mirrors CapCut: "Original" means "lock to the first clip's
     * aspect", not "follow whatever's playing right now". Without
     * this, the canvas would visibly jump every time the playhead
     * crossed from track-0's clip 1 to clip 2.
     */
    private baseFrameRect;
    /**
     * Dims of the canvas-anchor clip — the first clip (by start time)
     * on the first video track. Stable across playback so the canvas
     * doesn't resize at clip boundaries. Returns null when nothing's
     * decoded yet.
     */
    getCanvasReferenceDims(): [number, number] | null;
    private canvasReferenceDims;
    /**
     * Permanent rAF that (a) sizes + positions every active wrapper to
     * the output frame, and (b) writes the keyframe transform onto each
     * inner video. Negligible cost — a handful of style writes per
     * frame even with PiP on.
     */
    private startTransformLoop;
    private applyTransforms;
    destroy(): void;
    private syncSources;
    /**
     * Resolve the active clip per track for the current playhead and
     * reconcile wrapper visibility, audio policy, and per-source
     * playback state. Called on `seek` / `setProject` / `setPiP` and
     * whenever a tick advances past a clip boundary.
     */
    private refreshActive;
    private computeActiveClips;
    /** First track-in-order with an active clip — the "primary" =
     *  canvas reference + audio source. Track `0` wins when it has
     *  content; otherwise the next video track with a clip. */
    private primaryActiveClip;
    private playAllActive;
    private pauseAllActive;
    private seekVideoToClipOffset;
    private clipById;
    /** Earliest clip starting at-or-after `timeMs` across all video tracks. */
    private nextClipAfterTime;
    /** Max clip end across all video tracks. */
    private totalDuration;
    private startTickLoop;
    private stopTickLoop;
    private advance;
}
/** Factory shorthand for `Editor.create({ playbackEngine })`. */
declare const htmlVideoEngineFactory: PlaybackEngineFactory;

interface CanvasCompositorEngineOptions extends PlaybackEngineOptions {
    /**
     * Show the corner HUD ("engine: canvas compositor • t=… • frames
     * painted: …"). Off by default — production hosts get a clean canvas
     * with no chrome painted on top. Turn on in development / demos to
     * see who's drawing and what the current state is.
     */
    debug?: boolean;
}
/**
 * Reference second engine — demonstrates that the `PlaybackEngine`
 * surface really is engine-agnostic. Same `<video>`-based decode as
 * `HtmlVideoEngine` (so it works in every browser, no WebCodecs gate),
 * but rendering happens via `ctx.drawImage(video, …)` on a single
 * canvas instead of the browser painting the video element itself.
 *
 * Why ship it: it's tangible proof that a host can swap the rendering
 * surface for compositing / shaders / overlays / capture-to-canvas
 * without touching Editor internals. It's also the natural stepping
 * stone toward a WebGL or WebCodecs path (those replace the decoder
 * but keep the canvas-blit pattern).
 *
 * Multi-track / PiP: `setPictureInPictureEnabled(true)` flips the
 * paint loop into multi-clip composite mode — every video track's
 * currently-active clip draws in reverse track order so track 0 ends
 * up on top. Audio: track 0 stays unmuted, lower tracks mute.
 *
 * Limits: same-source same-time tie still goes to a single decoder
 * (one `<video>` per source). Seek snaps to the browser's keyframe
 * pipeline. No transitions / shaders / filters — the canvas blit
 * pattern is the foundation those would build on, not the feature.
 */
declare class CanvasCompositorEngine implements PlaybackEngine {
    private host;
    private mount;
    private canvas;
    private ctx;
    /** Only created when constructed with `debug: true`. */
    private badge;
    private videos;
    private project;
    /** trackId → active clipId on that track. Top track's clip is the
     *  "primary" — drives output canvas + audio + overlay rects. */
    private activeByTrack;
    private playing;
    private timeMs;
    private rafHandle;
    private lastFrameTs;
    private paintedFrames;
    private pictureInPictureEnabled;
    /** Output canvas rect (no transform) — same for every clip on
     *  the same paint pass. */
    private lastOutputRect;
    /** Post-transform content rect, keyed by clipId. With PiP on a
     *  paint pass records one entry per painted clip; the overlay can
     *  ask for any specific one (the SELECTED clip when PiP is on,
     *  the primary clip otherwise). */
    private frameRectsByClip;
    /** Primary (top-track) clip id from the last paint — used as the
     *  fallback for `getFrameRect()` when no clipId is passed. */
    private primaryClipIdLastPaint;
    onTimeUpdate?: (ms: Ms) => void;
    onEnded?: () => void;
    onError?: (err: Error) => void;
    onReady?: () => void;
    onSourceMetadata?: (sourceId: string, durationMs: Ms) => void;
    constructor(opts: CanvasCompositorEngineOptions);
    setProject(next: Project): void;
    setPictureInPictureEnabled(enabled: boolean): void;
    play(): void;
    pause(): void;
    isPlaying(): boolean;
    getTime(): Ms;
    seek(timeMs: Ms): void;
    destroy(): void;
    private syncSources;
    /**
     * Resolve the active clip per track for the current playhead and
     * reconcile per-source playback / audio policy. PiP off = only the
     * top track contributes; PiP on = every video track.
     */
    private refreshActive;
    private computeActiveClips;
    /**
     * The "primary" clip = the bottom-most active clip = the main
     * canvas reference + audio source. It's track `0` when track `0`
     * has content; if that track is empty at the playhead, fall
     * through to the next video track with a clip. (Without that
     * fall-through, dragging the only track-0 clip out of the
     * playhead range blanked the preview even though a lower-track
     * clip was still active.)
     */
    /**
     * Dims of the canvas-anchor clip — the first clip (by start time)
     * on the first video track. Stable across playback so the canvas
     * doesn't resize at clip boundaries. Returns null when nothing's
     * decoded yet.
     */
    getCanvasReferenceDims(): [number, number] | null;
    private canvasReferenceDims;
    private primaryActiveClip;
    private playAllActive;
    private pauseAllActive;
    private seekVideoToClipOffset;
    private clipById;
    private clipAtTime;
    private nextClipAfterTime;
    private totalDuration;
    private resizeCanvas;
    private startTickLoop;
    private stopTickLoop;
    private advance;
    /**
     * One paint per rAF — clears the canvas, composites every active
     * track's clip in reverse track order (so track 0 ends up on top),
     * then refreshes the HUD. Done unconditionally (not just on
     * `playing`) so the HUD frame counter and the seek preview both
     * update when paused.
     *
     * Canvas dims (`dw, dh`) are computed once from the PRIMARY clip's
     * source video — every lower-track clip then letterboxes inside
     * the same canvas via its own contain-fit math. The output rect +
     * content rect for the overlay both reflect the primary clip too
     * (keyframe handles on PiP-overlaid clips are a v2 concern).
     */
    private paint;
    getOutputFrameRect(_clipId?: string): {
        x: number;
        y: number;
        w: number;
        h: number;
    } | null;
    getFrameRect(clipId?: string): {
        x: number;
        y: number;
        w: number;
        h: number;
    } | null;
    /**
     * Compute a clip's content rect (CSS px in host coords) from the
     * LIVE project state — no paint cache involvement. Mirrors the
     * math in `paint()` so visible canvas pixels and overlay handles
     * agree to within float precision.
     */
    private computeFrameRect;
    private updateBadge;
}
/** Factory shorthand for `Editor.create({ playbackEngine })`. */
declare const canvasCompositorEngineFactory: PlaybackEngineFactory;

/**
 * State-only knobs that ALL editor entry points accept — used by the
 * headless (`createHeadless`) path AND the mounted `create` path.
 * Split from `EditorOptions` so React's `<EditorProvider>` and Vue's
 * `useAicutEditor()` can spin up an Editor without a mount container
 * and each primitive component (`<Preview>`, `<Timeline>`, buttons,
 * …) mounts its own DOM independently.
 */
interface HeadlessEditorOptions {
    /** Initial project state. Falls back to an empty single-track project. */
    project?: Project;
    /** CSS variable overrides — applied by `editor.applyThemeTo(el)`. */
    theme?: Theme;
    /** Initial playhead position (ms). */
    initialTime?: Ms;
    /** Initial timeline zoom (pixels per second). Defaults to 80. */
    initialScale?: number;
    /** Initial snap toggle. Defaults to true. */
    initialSnap?: boolean;
    /**
     * UI string overrides. Falls back to English (`localeEn`) for any
     * keys not provided. Use `localeZh` as the value for full Chinese.
     */
    locale?: Partial<Locale>;
    /**
     * Optional factory for a custom playback engine. Receives the
     * preview host element + the initial project, returns anything
     * satisfying `PlaybackEngine`. Defaults to the built-in
     * `HtmlVideoEngine`. The engine is created LAZILY on
     * `editor.attachPreview(host)` — headless editors have no engine
     * until a Preview primitive mounts.
     */
    playbackEngine?: PlaybackEngineFactory;
    /** See `EditorOptions`. */
    trackHeight?: number;
    rulerHeight?: number;
    timelineHeight?: number;
    rulerMinTickPx?: number;
    keyframes?: {
        enabled?: boolean;
    };
    clipEdgeNav?: {
        enabled?: boolean;
    };
    previewFrame?: {
        enabled?: boolean;
    };
    pictureInPicture?: {
        enabled?: boolean;
        toolbarAdd?: boolean;
    };
    aspect?: {
        enabled?: boolean;
    };
    previewLayout?: PreviewLayout;
}
interface EditorOptions extends HeadlessEditorOptions {
    /** Host element to mount the editor into. Will be wiped on init. */
    container: HTMLElement;
    /** Initial project state. Falls back to an empty single-track project. */
    project?: Project;
    /** CSS variable overrides. */
    theme?: Theme;
    /** Initial playhead position (ms). */
    initialTime?: Ms;
    /** Initial timeline zoom (pixels per second). Defaults to 80. */
    initialScale?: number;
    /** Initial snap toggle. Defaults to true. */
    initialSnap?: boolean;
    /**
     * UI string overrides. Falls back to English (`localeEn`) for any
     * keys not provided. Use `localeZh` as the value for full Chinese.
     * Call `editor.setLocale(...)` to switch at runtime.
     */
    locale?: Partial<Locale>;
    /**
     * Optional factory for a custom playback engine. Receives the
     * editor's preview host element + the initial project, returns
     * anything satisfying `PlaybackEngine`. Defaults to the built-in
     * `HtmlVideoEngine` (one hidden `<video>` per source, swap on
     * boundaries). Hosts that need frame-accurate editing, multi-track
     * compositing, transitions, etc. pass a `WebCodecsEngine` factory
     * (v0.6+) or their own.
     */
    playbackEngine?: PlaybackEngineFactory;
    /**
     * Pixel height of each track row in the timeline (default 56). Lower
     * values (~32–40) shrink the timeline footprint for small viewports
     * where the default crowds out the preview. Reasonable range:
     * [28, 96]. Applied process-wide via `setTimelineMetrics` — multi-
     * editor mounts share the value.
     */
    trackHeight?: number;
    /**
     * Pixel height of the timeline ruler / time-label strip (default 24).
     * Pair with `trackHeight` to compact the whole timeline. Reasonable
     * range: [18, 36].
     */
    rulerHeight?: number;
    /**
     * Pixel height of the whole bottom timeline area (default 240). The
     * canvas inside fills 100% of this and shows a vertical scrollbar
     * when there are more tracks than fit. Lower this (~120–180) on
     * small viewports so the preview takes more of the editor's height.
     * Reasonable range: [120, 480].
     */
    timelineHeight?: number;
    /**
     * Minimum pixel gap between ruler major ticks. The library picks the
     * "nicest" interval (1s, 0.5s, 0.2s, …) that keeps majors at least
     * this far apart for the current zoom. Default 80; lower (~50) packs
     * labels denser, higher (~140) spaces them out. Reactive via
     * `editor.setRulerMinTickPx(...)`.
     */
    rulerMinTickPx?: number;
    /**
     * Per-clip keyframe animation (X / Y / Scale). Off by default; flip
     * `enabled: true` to surface keyframe markers on the timeline and
     * route the canvas / WebCodecs engines through `getEffectiveTransform`
     * when painting. Data is preserved either way — disabling just hides
     * the editing UI and renders identity transforms.
     *
     * HtmlVideoEngine cannot apply per-frame transforms (it shows a raw
     * `<video>`), so keyframes are silently ignored on that engine
     * regardless of this flag. Swap to `CanvasCompositorEngine` or
     * `WebCodecsEngine` for live preview.
     */
    keyframes?: {
        enabled?: boolean;
    };
    /**
     * Show the |◀ / ▶| "jump to clip start / end" toolbar buttons and
     * bind the I / O keyboard shortcuts. Off by default — hosts opt in
     * the same way they do for keyframes. When off the buttons are
     * completely hidden (display: none) so they don't take up toolbar
     * space, and the I / O keys fall through to the page.
     */
    clipEdgeNav?: {
        enabled?: boolean;
    };
    /**
     * Dashed output-frame outline on top of the preview. Independent
     * of keyframes mode — the frame is purely visual (it shows the
     * fixed output canvas where the video lands after transforms), so
     * it's useful even when keyframe editing is off (e.g. to visualize
     * the current aspect-ratio choice). On by default; pass
     * `{ enabled: false }` to hide it entirely. When keyframes mode is
     * also on, the frame body becomes draggable (pan) and grows corner
     * scale handles — both are gated by `keyframes.enabled` regardless
     * of this flag.
     */
    previewFrame?: {
        enabled?: boolean;
    };
    /**
     * Built-in aspect-ratio picker (CapCut-style "比例" dropdown).
     * Off by default — hosts who want to provide their own picker keep
     * today's behaviour by leaving this off and rendering a control
     * into `editor.toolbarLeft`. When `enabled: true`, the editor
     * renders the picker before the left-hand button cluster and emits
     * `aspectChange` whenever the user picks. The selected value is
     * persisted on `Project.aspect`.
     *
     * Hosts wire `onAspectChange` to update their preview letterbox /
     * export defaults — the library does not letterbox the preview by
     * itself (different engines have different paint pipelines).
     */
    aspect?: {
        enabled?: boolean;
    };
    /**
     * Multi-track picture-in-picture compositing in the preview. Off by
     * default so today's single-clip behaviour is unchanged. When on,
     * every video track's currently-active clip paints at the playhead
     * with track `0` on top — matching the timeline's visual order.
     *
     * Audio policy: only the top track's clip stays unmuted; lower
     * tracks mute to avoid stacking audio playback. Hosts wanting
     * per-track audio control should disable PiP and roll their own
     * mixer.
     *
     * Same-source caveat: a single `<video>` / decoder can only be at
     * one `currentTime`, so a clip dropped on two tracks at different
     * timeline positions visually appears in both, but plays from
     * whichever position was activated last. The fix is to upload the
     * source twice (separate `MediaSource.id`s).
     *
     * `HtmlVideoEngine`, `CanvasCompositorEngine` both implement PiP
     * via `PlaybackEngine.setPictureInPictureEnabled`. Other engines
     * fall back to single-clip.
     *
     * `toolbarAdd: true` surfaces a built-in "+ PiP overlay" icon
     * button in the toolbar (next to the keyframe button). Clicking
     * it emits the `requestPictureInPictureAdd` event — the LIBRARY
     * doesn't run an upload itself. Hosts wire this to their existing
     * file-picker / upload pipeline and then create the new clip
     * wherever makes sense for their data model. Defaults to false
     * so the chrome stays unchanged for hosts that roll their own UI.
     *
     * `enabled` controls whether multi-track composition actually
     * happens. It's intentionally orthogonal to the toolbar button:
     * the toolbar is "add a PiP", the enable flag is "show the
     * compositor". Hosts typically wire a sidebar checkbox or
     * settings menu to it.
     */
    pictureInPicture?: {
        enabled?: boolean;
        toolbarAdd?: boolean;
    };
    /**
     * High-level editor layout.
     *
     * - `"centered"` (default): three-column grid — host content on
     *   the left, preview locked to the centre 1/3, host content on
     *   the right. CapCut-desktop convention.
     * - `"fullWidth"`: preview spans the editor's full width with no
     *   side columns — useful for embeds where the host doesn't want
     *   to render any panels.
     *   The preview's aspect frame sizes its height from that 1/3
     *   width and the video letterboxes inside. Playback chrome
     *   (time / play / duration / fullscreen) renders as an overlay
     *   inside the preview, CapCut-desktop style, so the top toolbar
     *   collapses to edit + viewport clusters only.
     *
     * Hosts wire `panelLeft` / `panelRight` slots via the React /
     * Vue wrappers to fill the side columns. Reactive — flip via
     * `editor.setPreviewLayout(...)`.
     */
    previewLayout?: PreviewLayout;
}
type PreviewLayout = "fullWidth" | "centered";
interface EditorEventMap {
    /** Emitted whenever the project mutates. */
    change: {
        project: Project;
    };
    /** Playhead position update — driven by the playback tick loop. */
    time: {
        timeMs: Ms;
    };
    play: void;
    pause: void;
    /** A source's metadata finished loading (duration etc). */
    ready: {
        sourceId: string | null;
    };
    /** User clicked the Export button. Host decides what to do with the JSON. */
    export: {
        project: Project;
    };
    error: {
        error: Error;
    };
    /** Currently selected clip id, or null. */
    selectionChange: {
        clipId: string | null;
    };
    /** Currently selected keyframe (parent clip + keyframe id), or null.
     *  Selecting a keyframe also selects its parent clip — listeners
     *  watching `selectionChange` get notified independently. */
    keyframeSelectionChange: {
        target: {
            clipId: string;
            keyframeId: string;
        } | null;
    };
    /** Keyframe-mode toggle changed (Editor.setKeyframesEnabled). */
    keyframesEnabledChange: {
        enabled: boolean;
    };
    /** Jump-to-clip-edge nav toggle changed (Editor.setClipEdgeNavEnabled). */
    clipEdgeNavEnabledChange: {
        enabled: boolean;
    };
    /** Output-frame outline visibility flipped (Editor.setPreviewFrameEnabled). */
    previewFrameEnabledChange: {
        enabled: boolean;
    };
    /** Multi-track preview compositing toggle changed
     *  (Editor.setPictureInPictureEnabled). */
    pictureInPictureEnabledChange: {
        enabled: boolean;
    };
    /** Layout flipped between fullWidth and centered. */
    previewLayoutChange: {
        layout: PreviewLayout;
    };
    /**
     * User clicked the built-in "+ PiP overlay" toolbar button. Host
     * is expected to surface its own file-picker / upload affordance
     * and append the resulting clip somewhere appropriate (typically
     * a new video track). The library doesn't ship an upload UI on
     * purpose — different hosts have very different upload pipelines.
     */
    requestPictureInPictureAdd: void;
    /**
     * Aspect-ratio picker toggle changed (Editor.setAspectEnabled). Only
     * fires when the host-facing visibility flips — picking a new ratio
     * fires `aspectChange` instead.
     */
    aspectEnabledChange: {
        enabled: boolean;
    };
    /**
     * User (or programmatic call) chose a different output aspect ratio.
     * `aspect` is null when cleared back to "Original" (use the source
     * clip's intrinsic aspect). Persisted on `Project.aspect`.
     */
    aspectChange: {
        aspect: AspectRatio | null;
    };
    /** Zoom (px/sec) changed. */
    scaleChange: {
        pxPerSec: number;
    };
    /** Snap toggle changed. */
    snapChange: {
        snap: boolean;
    };
    /** Undo/redo stack states changed (button enablement). */
    historyChange: {
        canUndo: boolean;
        canRedo: boolean;
    };
    /** Theme tokens changed via `editor.setTheme(...)`. Subscribers (e.g.
     *  the standalone `<TimelinePrimitive>`) use this to force a canvas
     *  re-paint since CSS custom properties don't invalidate the canvas
     *  on their own. */
    themeChange: {
        theme: Theme;
    };
    /** Locale tokens changed via `editor.setLocale(...)`. */
    localeChange: {
        locale: Locale;
    };
}
type EditorEventName = keyof EditorEventMap;
interface EditorApi {
    play(): void;
    pause(): void;
    togglePlay(): void;
    seek(timeMs: Ms): void;
    getTime(): Ms;
    getDuration(): Ms;
    isPlaying(): boolean;
    enterFullscreen(): Promise<void>;
    exitFullscreen(): Promise<void>;
    isFullscreen(): boolean;
    split(timeMs?: Ms): string[] | null;
    /** Alias of split, kept for back-compat. */
    cut(timeMs?: Ms): string[] | null;
    /** Trim the selected clip's left edge to the given time (or playhead). */
    trimLeft(timeMs?: Ms): boolean;
    /** Trim the selected clip's right edge to the given time (or playhead). */
    trimRight(timeMs?: Ms): boolean;
    removeClip(clipId: string): boolean;
    setClipSpeed(clipId: string, speed: number): boolean;
    previewMoveTarget(clipId: string, start: Ms, intendedTrackId?: string): {
        trackIndex: number;
        trackId: string;
        wouldCreateNew: boolean;
    } | null;
    addTrack(kind: Track["kind"]): Track;
    removeTrack(trackId: string): boolean;
    moveClip(clipId: string, opts: {
        start?: Ms;
        trackId?: string;
        newTrack?: boolean;
    }): boolean;
    resizeClip(clipId: string, edits: Partial<Pick<Clip, "in" | "out" | "start">>): boolean;
    addSource(source: MediaSource, opts?: {
        appendClip?: boolean;
    }): MediaSource;
    setProject(project: Project): void;
    getProject(): Project;
    /** Replace the project with a brand-new empty one. */
    reset(): void;
    setTheme(theme: Theme): void;
    /**
     * Swap the UI locale at runtime. Partial overrides merge with the
     * English default. Triggers a re-render so the toolbar tooltips
     * and timeline canvas labels pick up the new strings immediately.
     */
    setLocale(locale: Partial<Locale>): void;
    /** Currently resolved `Locale` object (merged with `localeEn` for
     *  any keys the host didn't override). Emits `localeChange` on
     *  update — used by the React `useLocale()` hook. */
    getLocale(): Locale;
    /**
     * Fire the `export` event with the current project JSON. Hosts call
     * this from their own export button (built into their toolbarRight
     * slot, a keyboard shortcut, a menu item, etc.) to surface project
     * data to whatever pipeline they own. The library never invokes
     * this on its own — it has no UI for export.
     */
    requestExport(): void;
    getScale(): number;
    setScale(pxPerSec: number): void;
    getSnap(): boolean;
    setSnap(snap: boolean): void;
    /** Read current ruler tick min-pixel-gap (see `rulerMinTickPx` option). */
    getRulerMinTickPx(): number;
    /** Update the ruler tick density at runtime. */
    setRulerMinTickPx(px: number): void;
    getSelection(): string | null;
    setSelection(clipId: string | null): void;
    isKeyframesEnabled(): boolean;
    setKeyframesEnabled(enabled: boolean): void;
    isClipEdgeNavEnabled(): boolean;
    setClipEdgeNavEnabled(enabled: boolean): void;
    /** Dashed output-frame outline visibility. Defaults to true. */
    isPreviewFrameEnabled(): boolean;
    setPreviewFrameEnabled(enabled: boolean): void;
    /** Multi-track preview compositing (picture-in-picture). Defaults
     *  to false. Flipping triggers an engine-side re-composite. */
    isPictureInPictureEnabled(): boolean;
    setPictureInPictureEnabled(enabled: boolean): void;
    /** Current high-level editor layout. Defaults to "centered". */
    getPreviewLayout(): PreviewLayout;
    setPreviewLayout(layout: PreviewLayout): void;
    /** Built-in aspect picker visibility (CapCut-style 比例 dropdown). */
    isAspectEnabled(): boolean;
    setAspectEnabled(enabled: boolean): void;
    /** Current output aspect ratio, or null when "Original" (follow source). */
    getAspect(): AspectRatio | null;
    /**
     * Set the output aspect ratio. Pass `null` to clear back to
     * "Original". Persists on `Project.aspect`, also writes the matching
     * 1080p-tier dims into `Project.output`, emits `aspectChange`, and
     * pushes a history entry so the change participates in undo. No-op
     * when the value didn't change.
     */
    setAspect(aspect: AspectRatio | null): void;
    /**
     * Output canvas dims in pixels. THIS is the reference coordinate
     * system every spatial value in the project lives in — keyframe
     * panX/panY, the canvas guide rect, the export resolution. Falls
     * back to `aspect`-derived dims, then to the first clip's intrinsic
     * source size, when nothing's been set on the project explicitly.
     */
    getOutput(): {
        width: number;
        height: number;
        fps?: number;
    };
    /**
     * Write output canvas dims into `Project.output`. Even-snaps both
     * axes (H.264 requirement) and pushes history. Pan / scale already
     * stored against the previous canvas are NOT rescaled — same as
     * how Premiere handles a sequence-settings change. Hosts who want
     * value preservation should normalize keyframes themselves.
     */
    setOutput(output: {
        width: number;
        height: number;
        fps?: number;
    }): void;
    /** Screen-space CSS-pixel rect of the active rendered frame, post
     *  transform, relative to the editor preview. Null when none. */
    getActiveFrameRect(): {
        x: number;
        y: number;
        w: number;
        h: number;
    } | null;
    /** Same as `getActiveFrameRect` but for an arbitrary clipId. Used
     *  by the overlay's hit-testing to figure out which PiP clip a
     *  click in the preview lands on. Null when the clip isn't
     *  currently being painted. */
    getClipFrameRect(clipId: string): {
        x: number;
        y: number;
        w: number;
        h: number;
    } | null;
    /** Output frame rect (fixed bounds, no transform). The overlay
     *  draws the dashed border here. */
    getActiveOutputFrameRect(): {
        x: number;
        y: number;
        w: number;
        h: number;
    } | null;
    /**
     * Upsert a per-property keyframe at the given clip-local time. If a
     * keyframe for the same `prop` already exists within ~1 frame of
     * `time` it gets its value updated; else a new one is appended.
     * Returns the keyframe's id, or null when the clip can't be found.
     *
     * Defaults: `time` = playhead in clip-local coords; `value` = the
     * currently interpolated value for that prop (so adding doesn't
     * cause a visible jump).
     */
    addKeyframe(clipId: string, prop: KeyframeProp, opts?: {
        time?: Ms;
        value?: number;
    }): string | null;
    removeKeyframe(clipId: string, keyframeId: string): boolean;
    moveKeyframe(clipId: string, keyframeId: string, timeMs: Ms): boolean;
    /** Change one keyframe's value (single number, since each kf is
     *  per-property). */
    setKeyframeValue(clipId: string, keyframeId: string, value: number): boolean;
    /**
     * Change one keyframe's outgoing easing curve. Shapes only the
     * segment from this kf to the NEXT kf in time on the same prop.
     * The kf's value is untouched.
     */
    setKeyframeEasing(clipId: string, keyframeId: string, easing: EasingKind): boolean;
    /**
     * Batch-set the outgoing easing on every kf at one moment in time
     * (within the 16ms tolerance that the rest of the API uses) on a
     * single clip. Mirrors the panel's "one dropdown for the moment"
     * UX so all three props (panX / panY / scale) at the selected
     * moment animate with the same curve. Single history entry.
     */
    setKeyframesEasingAtTime(clipId: string, timeMs: Ms, easing: EasingKind): boolean;
    /**
     * CapCut-style auto-record: write `value` for `prop` at the playhead.
     * - If the prop already has keyframes → upsert a keyframe at the
     *   playhead with this value.
     * - If the prop has no keyframes → just update the static base
     *   (panX / panY / scale on the clip) so the visual changes
     *   without committing the user to an animation track yet.
     * Returns true if the project changed.
     */
    setValueAtPlayhead(clipId: string, prop: KeyframeProp, value: number): boolean;
    getSelectedKeyframe(): {
        clipId: string;
        keyframeId: string;
    } | null;
    setSelectedKeyframe(target: {
        clipId: string;
        keyframeId: string;
    } | null): void;
    /**
     * Toolbar-style toggle. If ANY keyframe exists at the playhead time
     * on the selected clip, remove every keyframe at that time (all
     * props). Otherwise, capture one keyframe per prop (panX, panY,
     * scale) at the playhead with the currently interpolated values.
     * Returns true when the project changed.
     */
    toggleKeyframeAtPlayhead(): boolean;
    /**
     * Clear every keyframe AND every static transform value on a clip,
     * restoring the identity pose (panX=0, panY=0, scale=1). Single
     * history entry. */
    resetClipTransform(clipId: string): boolean;
    /**
     * Pin all three transform props (panX, panY, scale) to identity
     * (0, 0, 1) at one specific clip-local time. Upserts on each prop —
     * keyframes that already exist at that time get their values
     * overwritten; props with no kf there get one added. Single history
     * entry. Used by the panel's Reset button when a keyframe is selected.
     */
    resetKeyframesAtTime(clipId: string, timeMs: Ms): boolean;
    /**
     * Move the playhead to a clip edge. "end" intentionally lands 1ms
     * INSIDE the clip (clipEnd - 1) so the playhead remains inside the
     * clip — that lets the user immediately press the keyframe button
     * (or the I/O shortcut) and have it find the right clip + drop a
     * keyframe at clip-local time `duration - 1ms`. Without the -1ms
     * offset the playhead lands on the seam and `toggleKeyframeAtPlayhead`
     * picks the next clip (or none at all).
     * Returns true when the seek actually moved.
     */
    seekToClipEdge(clipId: string, edge: "start" | "end"): boolean;
    /** Convenience for the toolbar: act on the currently-selected clip. */
    seekToSelectedClipEdge(edge: "start" | "end"): boolean;
    canUndo(): boolean;
    canRedo(): boolean;
    undo(): boolean;
    redo(): boolean;
    /**
     * Open a "drag session". While open, every internal `pushHistory`
     * call captures the pre-session snapshot ONCE — subsequent calls
     * during the same session are no-ops. The session commits a single
     * history entry on `endInteraction()` (or is dropped entirely if
     * the project ended up unchanged). Nestable: nested begin/end pairs
     * count by depth and only the outermost commits.
     *
     * Hosts call this around continuous gestures (drag the preview
     * overlay, scrub a numeric slider, wheel-zoom) so a single user
     * gesture becomes ONE undo entry instead of 30-100. Without this,
     * each pointermove of an overlay drag pushes its own history entry
     * and the user has to mash Cmd+Z that many times to fully undo.
     */
    beginInteraction(): void;
    endInteraction(): void;
    /**
     * Bookend slot at the very left of the top toolbar — host appends
     * its own controls (e.g. an aspect-ratio dropdown). Empty by default
     * and renders no separator until populated.
     */
    /**
     * Preview host element the playback engine paints into. React /
     * Vue `<Preview>` primitives teleport this into their own slots via
     * `appendChild`. Available in both mounted mode (returns the built-in
     * UI's preview host) and headless mode (returns the detached
     * `.aicut-preview-host` div created in the constructor).
     */
    readonly previewHost: HTMLElement;
    readonly toolbarLeft: HTMLElement;
    /** Right-side bookend slot — conventionally export / save / share. */
    readonly toolbarRight: HTMLElement;
    /**
     * Optional editor header above the preview. Host appends branding,
     * project name, file menu, etc. on the left and Share / Export /
     * profile / settings on the right. Layout is identical to today's
     * editor when both slots are empty — CSS collapses the bar.
     */
    readonly headerLeft: HTMLElement;
    /** Right-side header slot — conventionally Share / Export / etc. */
    readonly headerRight: HTMLElement;
    /**
     * Side panel slot, rendered only when `previewLayout === "centered"`.
     * Sits to the LEFT of the preview at 1/3 of the editor's width.
     * Conventionally a media library / asset browser. Empty when the
     * layout is `"fullWidth"` — the editor's overall grid still
     * reserves the slot but CSS collapses it.
     */
    readonly panelLeft: HTMLElement;
    /** Right side panel slot — conventionally an inspector / clip
     *  properties panel. See `panelLeft`. */
    readonly panelRight: HTMLElement;
    on<K extends EditorEventName>(event: K, handler: (payload: EditorEventMap[K]) => void): () => void;
    off<K extends EditorEventName>(event: K, handler: (payload: EditorEventMap[K]) => void): void;
    destroy(): void;
}
/**
 * Top-level editor instance — the only stateful object a host app
 * interacts with. Owns the project, the playback engine, the vanilla
 * DOM UI, plus viewport (zoom/snap), selection, and history state.
 *
 * Framework wrappers (`@aicut/react`, `@aicut/vue`) should mount a
 * container, instantiate this once, mirror prop changes (`theme`)
 * into it, and forward events as framework-native callbacks.
 */
declare class Editor implements EditorApi {
    private container;
    /** Only populated in headless mode — the offscreen `.aicut-preview-host`
     *  the engine paints into until a `<Preview>` primitive teleports it
     *  into the visible tree. */
    private detachedPreviewHost;
    private project;
    private engine;
    private ui;
    private bus;
    private history;
    private selectedClipId;
    private selectedKeyframe;
    private keyframesEnabled;
    private clipEdgeNavEnabled;
    private aspectEnabled;
    private previewFrameEnabled;
    private pictureInPictureEnabled;
    private previewLayout;
    private pictureInPictureToolbarAddEnabled;
    /** Drag-session bookkeeping for ripple-merge undo. See
     *  beginInteraction / endInteraction docs on EditorApi. */
    private interactionDepth;
    private interactionStartSnapshot;
    private pxPerSec;
    private snap;
    private locale;
    private rulerMinTickPx;
    private destroyed;
    constructor(opts: EditorOptions | (HeadlessEditorOptions & {
        container?: undefined | null;
    }));
    private createDetachedPreviewHost;
    /**
     * Preview host element the engine paints into. React / Vue primitives
     * grab this to teleport it into their own slots via `appendChild`.
     * In built-in mode this is the EditorUI's preview-host div; in
     * headless mode it's the detached div created at construction.
     */
    get previewHost(): HTMLElement;
    /**
     * Apply the editor's theme tokens to any host container. Primitives
     * use this on their root divs so custom compositions inherit the
     * same CSS variable set as the built-in shell.
     */
    applyThemeTo(el: HTMLElement, theme?: Theme): void;
    /**
     * Headless entry point — creates an Editor with state + engine but
     * no built-in DOM. React `<EditorProvider>` and Vue `useAicutEditor`
     * use this so hosts can compose their own layout out of the exposed
     * primitives (`<Preview>`, `<Timeline>`, `<PlayButton>`, …).
     */
    static createHeadless(opts?: HeadlessEditorOptions): Editor;
    static create(opts: EditorOptions): Editor;
    get toolbarLeft(): HTMLElement;
    get toolbarRight(): HTMLElement;
    get headerLeft(): HTMLElement;
    get headerRight(): HTMLElement;
    get panelLeft(): HTMLElement;
    get panelRight(): HTMLElement;
    /** Slot-getter guard — the built-in slots only exist when EditorUI
     *  was mounted. Headless callers should compose their own layout via
     *  primitives instead of reaching for these DOM handles. */
    private requireUi;
    play(): void;
    pause(): void;
    togglePlay(): void;
    seek(timeMs: Ms): void;
    getTime(): Ms;
    getDuration(): Ms;
    isPlaying(): boolean;
    /**
     * In-tab "fullscreen" — covers the browser viewport via fixed
     * positioning, NOT the OS Fullscreen API. This is what the reference
     * UI calls "全屏预览": the user stays in their tab, no browser
     * permission prompt, ESC exits. Browser fullscreen would also work
     * but is heavier UX and gets blocked in iframes.
     */
    enterFullscreen(): Promise<void>;
    exitFullscreen(): Promise<void>;
    isFullscreen(): boolean;
    /**
     * Split the clip at `timeMs` (or playhead). Returns the two new clip ids
     * or null if there's no clip to split at that time.
     */
    split(timeMs?: Ms): string[] | null;
    cut(timeMs?: Ms): string[] | null;
    trimLeft(timeMs?: Ms): boolean;
    trimRight(timeMs?: Ms): boolean;
    removeClip(clipId: string): boolean;
    setClipSpeed(clipId: string, speed: number): boolean;
    addTrack(kind: Track["kind"]): Track;
    removeTrack(trackId: string): boolean;
    /**
     * Pure prediction of where a `moveClip(...)` would land — same smart
     * routing as the real move (intended → source → other → new track),
     * just no mutation, no history. Lets the Timeline preview the
     * ACTUAL outcome of a drop so the ghost stops lying about new
     * tracks that won't get created.
     */
    previewMoveTarget(clipId: string, start: Ms, intendedTrackId?: string): {
        trackIndex: number;
        trackId: string;
        wouldCreateNew: boolean;
    } | null;
    moveClip(clipId: string, opts: {
        start?: Ms;
        trackId?: string;
        newTrack?: boolean;
    }): boolean;
    resizeClip(clipId: string, edits: Partial<Pick<Clip, "in" | "out" | "start">>): boolean;
    addSource(source: MediaSource, opts?: {
        appendClip?: boolean;
    }): MediaSource;
    setProject(project: Project): void;
    getProject(): Project;
    /**
     * Restore the "fresh import" state: same media library, single
     * default video track, one full-length clip per video source laid
     * end-to-end. This mirrors the initial layout a host would get
     * after dropping their videos in, so "reset" feels like "start
     * over without re-importing" rather than "wipe everything".
     *
     * Goes through the regular history stack — ⌘Z brings the previous
     * edit back. Sources without a known duration are skipped (they'd
     * render as zero-width clips, which is worse than absent).
     */
    reset(): void;
    setTheme(theme: Theme): void;
    setLocale(locale: Partial<Locale>): void;
    /** Internal — UI reads the resolved locale here on each render. */
    getLocale(): Locale;
    requestExport(): void;
    getScale(): number;
    setScale(pxPerSec: number): void;
    getSnap(): boolean;
    setSnap(snap: boolean): void;
    getRulerMinTickPx(): number;
    setRulerMinTickPx(px: number): void;
    /** Snap a candidate ms to the nearest snappable surface within SNAP_PX. */
    snapMs(timeMs: Ms, ignoreClipId?: string | null): Ms;
    getSelection(): string | null;
    setSelection(clipId: string | null): void;
    isKeyframesEnabled(): boolean;
    /**
     * Screen-space CSS-pixel rect of the actively painted frame
     * (post-transform), relative to the editor's preview element.
     * Null when no clip is active, the engine doesn't expose
     * `getFrameRect`, or the rect isn't computed yet. Used by the
     * library's keyframe-editing overlay.
     *
     * When PiP is on and a non-primary clip is selected, returns
     * THAT clip's rect — that's how the overlay's dashed border +
     * corner handles latch onto a picture-in-picture overlay. With
     * PiP off (or nothing selected) falls back to the primary clip.
     */
    getActiveFrameRect(): {
        x: number;
        y: number;
        w: number;
        h: number;
    } | null;
    getClipFrameRect(clipId: string): {
        x: number;
        y: number;
        w: number;
        h: number;
    } | null;
    /**
     * Screen-space CSS-pixel rect of the OUTPUT FRAME (the fixed
     * stage that clips the rendered video). Different from
     * `getActiveFrameRect` which includes the keyframe transform —
     * this one stays put as the user drags / scales the content.
     * Used by the overlay to anchor the dashed border + drag body.
     */
    getActiveOutputFrameRect(): {
        x: number;
        y: number;
        w: number;
        h: number;
    } | null;
    setKeyframesEnabled(enabled: boolean): void;
    isClipEdgeNavEnabled(): boolean;
    setClipEdgeNavEnabled(enabled: boolean): void;
    isPreviewFrameEnabled(): boolean;
    setPreviewFrameEnabled(enabled: boolean): void;
    isPictureInPictureEnabled(): boolean;
    /** Whether the built-in "+ PiP overlay" toolbar button is rendered. */
    isPictureInPictureToolbarAddEnabled(): boolean;
    setPictureInPictureEnabled(enabled: boolean): void;
    getPreviewLayout(): PreviewLayout;
    setPreviewLayout(layout: PreviewLayout): void;
    isAspectEnabled(): boolean;
    setAspectEnabled(enabled: boolean): void;
    getAspect(): AspectRatio | null;
    setAspect(aspect: AspectRatio | null): void;
    getOutput(): {
        width: number;
        height: number;
        fps?: number;
    };
    setOutput(output: {
        width: number;
        height: number;
        fps?: number;
    }): void;
    addKeyframe(clipId: string, prop: KeyframeProp, opts?: {
        time?: Ms;
        value?: number;
    }): string | null;
    removeKeyframe(clipId: string, keyframeId: string): boolean;
    moveKeyframe(clipId: string, keyframeId: string, timeMs: Ms): boolean;
    setKeyframeValue(clipId: string, keyframeId: string, value: number): boolean;
    setKeyframeEasing(clipId: string, keyframeId: string, easing: EasingKind): boolean;
    setKeyframesEasingAtTime(clipId: string, timeMs: Ms, easing: EasingKind): boolean;
    setValueAtPlayhead(clipId: string, prop: KeyframeProp, value: number): boolean;
    getSelectedKeyframe(): {
        clipId: string;
        keyframeId: string;
    } | null;
    resetClipTransform(clipId: string): boolean;
    resetKeyframesAtTime(clipId: string, timeMs: Ms): boolean;
    seekToClipEdge(clipId: string, edge: "start" | "end"): boolean;
    seekToSelectedClipEdge(edge: "start" | "end"): boolean;
    toggleKeyframeAtPlayhead(): boolean;
    setSelectedKeyframe(target: {
        clipId: string;
        keyframeId: string;
    } | null): void;
    canUndo(): boolean;
    canRedo(): boolean;
    undo(): boolean;
    redo(): boolean;
    beginInteraction(): void;
    endInteraction(): void;
    /**
     * Selections (clipId + selectedKeyframe) live OUTSIDE the project
     * snapshot, so undo / redo can leave them pointing at ids that no
     * longer exist. Defend against dangling refs by clearing anything
     * the restored project doesn't actually contain — and emit the
     * paired change events so panels / overlays hide cleanly instead
     * of holding zombie references.
     */
    private reconcileSelectionsWithProject;
    on<K extends EditorEventName>(event: K, handler: (payload: EditorEventMap[K]) => void): () => void;
    off<K extends EditorEventName>(event: K, handler: (payload: EditorEventMap[K]) => void): void;
    destroy(): void;
    private appendTrack;
    private resolveTrimTarget;
    private pushHistory;
    private emitHistory;
    private afterMutation;
    private handleSourceMetadata;
}

/**
 * Inline SVG icon set. Strings, not JSX, since core has no framework.
 * Each icon is 14×14 paint-area inside a 16×16 viewbox; `currentColor`
 * so toolbar buttons can recolor by `color`.
 */
declare const ICONS: {
    undo: string;
    redo: string;
    split: string;
    trimLeft: string;
    trimRight: string;
    speed: string;
    play: string;
    pause: string;
    fullscreen: string;
    snap: string;
    zoomOut: string;
    zoomIn: string;
    export: string;
    addTrack: string;
    trash: string;
    /** "Skip to start" — vertical bar + left-pointing triangle. Sits to
     *  the left of the keyframe diamond so the clip-edge nav cluster
     *  reads as [|◀ ◇ ▶|] = "go to clip start / add kf / go to clip end". */
    seekClipStart: string;
    /** "Skip to end" — mirror of seekClipStart. */
    seekClipEnd: string;
    /** Outlined diamond (rotated square) — "add keyframe" affordance. */
    keyframeOutline: string;
    /** Filled diamond — shown when a keyframe already exists at playhead. */
    keyframeFilled: string;
    /** Aspect-ratio picker — outlined rounded rectangle (landscape
     *  proportions) with a portrait rectangle nested inside it. Matches
     *  CapCut's "比例" affordance: a frame-within-frame conveying
     *  "choose which output canvas to crop into". */
    aspect: string;
    /** Picture-in-picture frame outline + smaller inset frame at the
     *  top-right corner. Outlined when PiP is off. */
    pipOutline: string;
    /** Filled inset frame — PiP is on. */
    pipFilled: string;
    /** Counter-clockwise circular arrow — "reset to initial layout". */
    reset: string;
};
type IconName = keyof typeof ICONS;

/**
 * Default 1080p-tier output dimensions per aspect ratio — the canvas
 * the editor renders into when the user picks an aspect from the
 * built-in chip. 1080p is the lowest-common-denominator distribution
 * target (web, mobile, most SaaS encoders) and matches CapCut's
 * "Standard 1080p" default. Hosts can override by writing directly
 * into `project.output` via `editor.setOutput(...)`.
 */
declare const DEFAULT_OUTPUT_DIMS: Record<AspectRatio, {
    width: number;
    height: number;
}>;
/** Pick canvas dims for a chosen aspect, snapping to even pixels. */
declare function defaultOutputForAspect(aspect: AspectRatio): {
    width: number;
    height: number;
};
declare function createEmptyProject(): Project;
/**
 * Defensive normalization — ensures clips on each track are sorted by
 * `start`, IDs exist, and trivially-empty clips (out <= in) are dropped.
 * Called from `Editor.setProject` so consumers can hand us loosely-formed
 * JSON without risking inconsistent internal state.
 */
declare function normalizeProject(project: Project): Project;

/**
 * The transform a clip's content is rendered with at a given moment.
 * Engines apply this INSIDE a fixed output frame: `panX` / `panY`
 * translate the content (in CSS px), `scale` resizes it around the
 * output frame's center. Anything pushed outside the frame is
 * clipped. Identity = `{ panX: 0, panY: 0, scale: 1 }`.
 */
interface EffectiveTransform {
    panX: number;
    panY: number;
    scale: number;
}
/** Identity transform — no pan, no scaling (content fills the output frame). */
declare const IDENTITY_TRANSFORM: EffectiveTransform;
/** True when a transform is effectively identity (within FP slop). */
declare function isIdentityTransform(t: EffectiveTransform): boolean;

/**
 * Effective transform = all three properties evaluated together. The
 * engine applies this to the content inside the fixed output frame:
 * scale around frame center, then translate by (panX, panY).
 */
declare function getEffectiveTransform(clip: Clip, localMs: Ms): EffectiveTransform;
/** Same as `getEffectiveTransform` but takes timeline-absolute time. */
declare function getTransformAtTimelineTime(clip: Clip, timelineMs: Ms): EffectiveTransform;

/**
 * Short, stable, URL-safe ID. Not cryptographic — fine for client IDs
 * that get persisted in the project JSON.
 */
declare function createId(prefix?: string): string;

/** Visual constants — kept here so draw + hit-test share one source of truth.
 *  The two row-height values are `let` rather than `const` so hosts can
 *  shrink the timeline footprint for small screens via
 *  `setTimelineMetrics(...)`. ES module live bindings mean every importer
 *  sees the updated value automatically. */
declare let TRACK_HEIGHT: number;
declare let RULER_HEIGHT: number;
declare const HEADER_WIDTH = 96;
/**
 * Override the default timeline row + ruler heights. Process-wide — call
 * before / during editor construction. Useful when the editor is mounted
 * in a small viewport (e.g. side-by-side panel on a laptop) and the
 * default 56px tracks crowd out the preview.
 *
 * Reasonable ranges: trackHeight ∈ [28, 96], rulerHeight ∈ [18, 36].
 * Anything smaller leaves no room for the clip label or the time ticks.
 *
 * Multi-editor mounts share these values. If you have two editors with
 * different needs, agree on the smaller one or remount on switch.
 */
declare function setTimelineMetrics(opts: {
    trackHeight?: number;
    rulerHeight?: number;
}): void;

/**
 * Public options for the standalone `Timeline` component. The class
 * is framework-agnostic — `@aicut/react` and `@aicut/vue` wrap it,
 * and the built-in `Editor` composes one internally for its timeline
 * panel. Reuse the same instance for a "frame-picker" use case by
 * loading a project with a single video clip and `readOnly: true`.
 */
interface TimelineOptions {
    /** Host element. Will be wiped on init. */
    container: HTMLElement;
    project: Project;
    /** Pixels per second. Defaults to 80; auto-fits on mount when possible. */
    pxPerSec?: number;
    /** Initial playhead position. */
    time?: Ms;
    /** Initially selected clip. */
    selectedClipId?: string | null;
    /** Show the track-name header column (left). Default true. */
    showHeader?: boolean;
    /**
     * Minimum pixel gap between ruler major ticks. Drives the auto
     * picker via `niceTickSeconds(minPx / pxPerSec)` — smaller values
     * pack more labels per zoom level, larger values space them out.
     * Default 80; sensible range ~40–160.
     */
    rulerMinTickPx?: number;
    /** Disable interactions — useful for read-only preview / frame picker. */
    readOnly?: boolean;
    /** Snap to clip edges + playhead when dragging. Default true. */
    snap?: boolean;
    /** Compute and apply fit-to-window on first project change. Default true. */
    autoFit?: boolean;
    /** UI string overrides (English defaults). Use `localeZh` for Chinese. */
    locale?: Partial<Locale>;
    /**
     * Theme tokens — applied as `--aicut-*` CSS variables on the host
     * container. Same shape as the video Editor's `theme` option, so a
     * host can pass the SAME object to both an Editor and a standalone
     * Timeline. Reactive via `setTheme(...)`. */
    theme?: Theme;
    /**
     * Render an empty 36px toolbar strip at the top of the host element
     * with `toolbarLeft` / `toolbarRight` flex slots. The library paints
     * NOTHING into either slot — hosts append their own controls (an
     * export button, a size/aspect dropdown, etc.). Default false; the
     * canvas takes the full host height when the toolbar is off, so
     * adopting the slot later is a non-breaking opt-in.
     */
    toolbar?: boolean;
    onSeek?: (timeMs: Ms) => void;
    onSelectClip?: (clipId: string | null) => void;
    onScaleChange?: (pxPerSec: number) => void;
    onDeleteTrack?: (trackId: string) => void;
    onMoveClip?: (clipId: string, opts: {
        start?: Ms;
        trackId?: string;
        newTrack?: boolean;
    }) => void;
    onResizeClip?: (clipId: string, edits: Partial<Pick<Clip, "in" | "out" | "start">>) => void;
    onChange?: (project: Project) => void;
    /**
     * Hosts wire these to forward keyframe edits to the Editor. The
     * Timeline only paints + hit-tests; mutation goes through these
     * callbacks so the Editor can push history + emit events.
     */
    onSelectKeyframe?: (target: {
        clipId: string;
        keyframeId: string;
    } | null) => void;
    onMoveKeyframe?: (clipId: string, keyframeId: string, timeMs: Ms) => void;
    /** Host-driven state mirror — Editor passes these on every render
     *  via `Timeline.setKeyframeState`. */
    keyframesEnabled?: boolean;
    selectedKeyframe?: {
        clipId: string;
        keyframeId: string;
    } | null;
    /**
     * Lets the host predict where a drop will actually land — used to
     * keep the drag-ghost visual honest. The Editor wires this to its
     * smart routing (intended → source → other → new track), so the
     * ghost shows the real outcome rather than just the user's hover.
     *
     * Return `{ trackIndex }` for an existing track, or
     * `{ wouldCreateNew: true }` for the auto-split case.
     */
    resolveDrop?: (clipId: string, intent: {
        start: Ms;
        intendedTrackIndex: number;
    }) => {
        trackIndex: number;
        wouldCreateNew: boolean;
    };
}
/**
 * Canvas-rendered, framework-free timeline. Owns ruler, multi-track
 * layout, headers, frame-thumbnails, playhead, snap, and all pointer
 * gestures. No DOM children for clips/ticks/etc — every pixel is
 * painted via 2D canvas, so even hundreds of clips render in <2ms.
 */
declare class Timeline {
    private root;
    private opts;
    private canvas;
    private ctx;
    private thumbs;
    private hiddenHost;
    private toolbarEl;
    /**
     * Public flex slot at the left of the top toolbar. `null` when
     * `toolbar` is disabled. Hosts append their own elements (e.g. a
     * size/aspect dropdown). React/Vue wrappers portal children here.
     */
    readonly toolbarLeft: HTMLDivElement | null;
    /** Right-side counterpart — conventionally used for export/save. */
    readonly toolbarRight: HTMLDivElement | null;
    private project;
    private pxPerSec;
    private timeMs;
    private selectedClipId;
    private snapEnabled;
    private showHeader;
    private readOnly;
    private autoFitEnabled;
    private locale;
    private rulerMinTickPx;
    private keyframesEnabled;
    private selectedKeyframe;
    private scrollLeft;
    private scrollTop;
    private viewportWidth;
    private viewportHeight;
    /**
     * `Date.now()` of the last interaction with each scrollbar (scroll
     * change OR hover OR drag). Drives the macOS-style fade — bars are
     * fully opaque for SCROLLBAR_FADE_HOLD_MS after activity, then ease
     * out over the next SCROLLBAR_FADE_OUT_MS.
     */
    private lastScrollInteractY;
    private lastScrollInteractX;
    private hoverScrollbarY;
    private hoverScrollbarX;
    /** When set, pointer is dragging a scrollbar thumb. */
    private scrollbarDrag;
    private hoveredClipId;
    private hoveredTrackIndex;
    private hoveredKeyframe;
    private hoverCursor;
    private dropTargetTrackIndex;
    private snapX;
    private drag;
    /**
     * In-flight ghost of the clip being dragged. Decoupled from the
     * project data so the data stays clean and undo-able only commits
     * on release. Has both the proposed `start` (X) and `trackIndex`
     * (Y), so the rendered ghost follows the cursor across tracks.
     */
    private dragGhost;
    /**
     * Most recent local pointer coords during a move drag — used by the
     * edge-autoscroll loop to re-run drop-target resolution between
     * pointermove events while scrollTop ticks under a stationary cursor.
     */
    private lastDragPointerX;
    private lastDragPointerY;
    private dragScrollRafPending;
    private rafPending;
    private hasAutoFitted;
    private resizeObs;
    private destroyed;
    static create(opts: TimelineOptions): Timeline;
    constructor(opts: TimelineOptions);
    /**
     * Sync the project data. Does NOT reset the auto-fit latch — that's
     * what caused the editor-side zoom feedback loop: every Editor
     * mutation called `ui.render() → timeline.setProject()` which used
     * to reset auto-fit, refit on the next frame, emit a new scale,
     * which re-rendered… and round we went. Callers that genuinely
     * want a re-fit (e.g. when the host swaps to a brand-new project)
     * should call `refit()` explicitly.
     */
    setProject(p: Project): void;
    /** Force a re-fit on the next render. */
    refit(): void;
    getProject(): Project;
    setTime(timeMs: Ms): void;
    getTime(): Ms;
    setScale(pxPerSec: number): void;
    getScale(): number;
    setSelection(id: string | null): void;
    getSelection(): string | null;
    setSnap(snap: boolean): void;
    getSnap(): boolean;
    setLocale(locale: Partial<Locale>): void;
    setRulerMinTickPx(px: number): void;
    /** Swap the theme tokens at runtime. Same Theme shape as the video
     *  Editor's `setTheme`. */
    setTheme(theme: Theme): void;
    /** Fit the project's full duration into the current viewport width. */
    fitToWindow(): void;
    /**
     * Test/debug introspection — pixel coordinates of every visible clip,
     * the playhead, and the headers. Because clips are canvas-painted
     * there are no DOM nodes to query in e2e; tests use this instead.
     * Exposed publicly so React/Vue wrappers can forward it to a ref.
     */
    getDebugInfo(): {
        pxPerSec: number;
        scrollLeft: number;
        viewportWidth: number;
        viewportHeight: number;
        playheadX: number;
        clips: Array<{
            id: string;
            trackIndex: number;
            x: number;
            width: number;
            y: number;
            height: number;
        }>;
    };
    destroy(): void;
    private resizeCanvas;
    private computeFitScale;
    private maxScrollLeft;
    private maxScrollTop;
    private clampScroll;
    /**
     * Scrollbar opacity = full for SCROLLBAR_FADE_HOLD_MS after last
     * interaction, then linearly fades to 0 over SCROLLBAR_FADE_OUT_MS.
     * Hovering or actively dragging the bar pins opacity at 1. Returns
     * 0 if the bar isn't needed (content fits).
     */
    private scrollbarOpacity;
    /** Mark a scrollbar axis as just-touched so its fade timer restarts. */
    private touchScrollbar;
    private scheduleRender;
    /**
     * Keep the raf loop alive while a scrollbar is still in its HOLD or
     * fade-out window. Without this, opacity is sampled once and the
     * bar would freeze at whatever value it had at the last input event
     * instead of smoothly fading out. Skipped when a bar is pinned
     * (hover or active drag) since opacity is constant there.
     */
    private maybeContinueFade;
    private maybeAutoFit;
    private buildDrawState;
    /** Host-pushed state — Editor calls this when its keyframe mode
     *  changes or when a keyframe is selected/deselected externally. */
    setKeyframeState(state: {
        enabled?: boolean;
        selected?: {
            clipId: string;
            keyframeId: string;
        } | null;
    }): void;
    private readStyle;
    private attachPointer;
    private onPointerDown;
    private onPointerMove;
    /**
     * Update dragGhost + dropTargetTrackIndex for the in-flight move
     * drag, given the current viewport pointer position. Pulled out of
     * onPointerMove so the edge-autoscroll loop can re-run it on each
     * tick — autoscroll moves scrollTop under a stationary cursor, and
     * the ghost must follow the new row under that cursor.
     */
    private processMoveDrag;
    /**
     * Px-per-frame scroll speed when the pointer is in a vertical edge
     * zone of the track region. Returns 0 outside the zone. Speed ramps
     * linearly from 0 at the zone's inner edge to ~16 px/frame at the
     * outer edge, so brushing the edge gives a gentle nudge and parking
     * deep at it gives a brisk auto-scroll.
     */
    private dragScrollSpeedY;
    /**
     * Drive vertical auto-scroll while the user holds a clip near the
     * top/bottom edge of the track area. Self-stopping — exits the loop
     * once the pointer leaves the zone, the drag ends, or scroll bottoms
     * out at the clamp.
     */
    private maybeStartDragAutoScroll;
    private onPointerUp;
    private attachKeyboard;
    private attachWheel;
    private attachResize;
    private localCoords;
    private hitTarget;
    private trackIndexAtY;
    private applySnap;
}

export { AspectRatio, CanvasCompositorEngine, type CanvasCompositorEngineOptions, Clip, DEFAULT_OUTPUT_DIMS, EasingKind, Editor, type EditorApi, type EditorEventMap, type EditorEventName, type EditorOptions, type EffectiveTransform, HEADER_WIDTH, type HeadlessEditorOptions, HtmlVideoEngine, ICONS, IDENTITY_TRANSFORM, type IconName, KeyframeProp, Locale, MediaSource, Ms, PlaybackEngine, PlaybackEngineFactory, PlaybackEngineOptions, type PreviewLayout, Project, RULER_HEIGHT, TRACK_HEIGHT, Theme, Timeline, type TimelineOptions, Track, canvasCompositorEngineFactory, createEmptyProject, createId, defaultOutputForAspect, getEffectiveTransform, getTransformAtTimelineTime, htmlVideoEngineFactory, isIdentityTransform, normalizeProject, setTimelineMetrics };