@linker-design-plus/timeline-track 1.0.9 → 1.0.11

package/dist/components/interaction/globalPointerDragSession.d.ts

@@ -0,0 +1,8 @@
+export interface GlobalPointerDragSessionHandlers {
+    onPointerMove: (evt: MouseEvent) => void;
+    onPointerEnd: () => void;
+    onVisibilityChange: () => void;
+    onWindowBlur?: () => void;
+}
+export declare function bindGlobalPointerDragSession(handlers: GlobalPointerDragSessionHandlers): boolean;
+export declare function unbindGlobalPointerDragSession(handlers: GlobalPointerDragSessionHandlers): void;

package/dist/components/panel/ClipConfigPanel.d.ts

@@ -0,0 +1,48 @@
+import { Clip } from '../../core/models';
+export interface ClipConfigPanelTheme {
+    backgroundColor: string;
+    borderColor: string;
+    textColor: string;
+    labelColor: string;
+    inputBackground: string;
+    inputBorder: string;
+    inputFocusBorder: string;
+    buttonBackground: string;
+    buttonBorder: string;
+    buttonActiveBackground: string;
+    buttonActiveBorder: string;
+    buttonActiveText: string;
+}
+export declare const defaultDarkTheme: ClipConfigPanelTheme;
+export interface ClipConfigPanelConfig {
+    container: HTMLElement;
+    theme?: ClipConfigPanelTheme;
+    onClipUpdate?: (clipId: string, updates: Partial<Clip>) => void;
+}
+export declare class ClipConfigPanel {
+    private container;
+    private rootElement;
+    private theme;
+    private onClipUpdate?;
+    private currentClip;
+    private xSlider;
+    private xInput;
+    private ySlider;
+    private yInput;
+    private scaleSlider;
+    private scaleInput;
+    constructor(config: ClipConfigPanelConfig);
+    setClip(clip: Clip | null): void;
+    destroy(): void;
+    private render;
+    private renderEmptyState;
+    private renderConfigPanel;
+    private renderPositionControl;
+    private renderPresetGrid;
+    private renderScaleControl;
+    private clampValue;
+    private updateUIControls;
+    private handleTransformChange;
+    private handleTransformChanges;
+    private applyTheme;
+}

package/dist/components/panel/TrackInfoPanel.d.ts

@@ -0,0 +1,33 @@
+import { Track } from '../../core/models';
+export interface TrackInfoPanelConfig {
+    container: HTMLElement;
+    theme?: {
+        background?: string;
+        border?: string;
+        text?: string;
+        buttonBackground?: string;
+        buttonHover?: string;
+        buttonDanger?: string;
+    };
+    width?: number;
+    timeScaleHeight?: number;
+    includeTimeScaleSpacer?: boolean;
+}
+export declare class TrackInfoPanel {
+    private container;
+    private tracks;
+    private theme;
+    private width;
+    private timeScaleHeight;
+    private includeTimeScaleSpacer;
+    private trackList;
+    private onMuteTrack?;
+    constructor(config: TrackInfoPanelConfig, _onRenameTrack?: (trackId: string, newName: string) => void, _onDeleteTrack?: (trackId: string) => void, onMuteTrack?: (trackId: string, isMuted: boolean) => void);
+    private init;
+    setTracks(tracks: Track[]): void;
+    getTracks(): Track[];
+    render(): void;
+    setScrollTop(scrollTop: number): void;
+    private createTrackItem;
+    destroy(): void;
+}

package/dist/components/scrollbar/KonvaScrollbarView.d.ts

@@ -0,0 +1,58 @@
+import type { Theme } from '../../core/models/types';
+type ScrollbarOrientation = 'horizontal' | 'vertical';
+export interface KonvaScrollbarViewConfig {
+    container: HTMLElement;
+    orientation: ScrollbarOrientation;
+    theme: Theme;
+    onScrollChange: (nextOffset: number) => void;
+    leadingInset?: number;
+    trailingInset?: number;
+}
+export declare class KonvaScrollbarView {
+    private readonly container;
+    private readonly orientation;
+    private readonly theme;
+    private readonly onScrollChange;
+    private readonly leadingInset;
+    private readonly trailingInset;
+    private readonly stage;
+    private readonly layer;
+    private readonly hitAreaRect;
+    private readonly thumbRect;
+    private viewportSize;
+    private contentSize;
+    private scrollOffset;
+    private isDragging;
+    private dragStartClient;
+    private dragStartOffset;
+    private hasBoundGlobalPointerListeners;
+    private readonly handleGlobalPointerMove;
+    private readonly handleGlobalPointerEnd;
+    private readonly handleVisibilityChange;
+    constructor(config: KonvaScrollbarViewConfig);
+    setViewportMetrics(viewportSize: number, contentSize: number): void;
+    setScrollLeft(scrollLeft: number): void;
+    setScrollTop(scrollTop: number): void;
+    resize(): void;
+    destroy(): void;
+    private readonly handleStageMouseDown;
+    private readonly handleStageMouseUp;
+    private readonly handleStageMouseEnter;
+    private readonly handleStageMouseMove;
+    private readonly handleStageMouseLeave;
+    private bindGlobalPointerListeners;
+    private unbindGlobalPointerListeners;
+    private handleDragMove;
+    private jumpToPointer;
+    private emitScrollChange;
+    private render;
+    private getTrackSize;
+    private getAvailableTrackSize;
+    private getMaxScrollOffset;
+    private clampScrollOffset;
+    private shouldHideScrollbar;
+    private updateCursor;
+    private getThumbSize;
+    private getThumbPosition;
+}
+export {};

package/dist/components/timeline/ManagedPlayhead.d.ts

@@ -0,0 +1,29 @@
+import type { TimeMs, Theme } from '../../core/models/types';
+export declare class ManagedPlayhead {
+    private readonly container;
+    private readonly lineElement;
+    private readonly handleElement;
+    private readonly theme;
+    private readonly onTimeChange;
+    private currentTime;
+    private zoom;
+    private scrollLeft;
+    private height;
+    private isDragging;
+    private hasBoundGlobalPointerListeners;
+    private handleGlobalPointerMove;
+    private handleGlobalPointerEnd;
+    private handleVisibilityChange;
+    constructor(container: HTMLElement, initialTime: TimeMs, zoom: number, height: number, theme: Theme, onTimeChange: (time: TimeMs) => void);
+    setCurrentTime(time: TimeMs): void;
+    setTime(time: TimeMs): void;
+    setZoom(zoom: number): void;
+    setScrollLeft(scrollLeft: number): void;
+    setHeight(height: number): void;
+    destroy(): void;
+    private handleMouseDown;
+    private bindGlobalPointerListeners;
+    private unbindGlobalPointerListeners;
+    private updateTimeFromClientX;
+    private render;
+}

package/dist/components/{Playhead.d.ts → timeline/Playhead.d.ts}

@@ -1,5 +1,5 @@
 import Konva from 'konva';
-import { TimeMs, Theme } from '../core/types';
+import { TimeMs, Theme } from '../../core/models';
 export declare class Playhead {
     private layer;
     private playheadGroup;

package/dist/components/{Timeline.d.ts → timeline/Timeline.d.ts}

@@ -1,5 +1,5 @@
 import Konva from 'konva';
-import { TimelineConfig, TimeMs } from '../core/types';
+import { TimelineConfig, TimeMs } from '../../core/models';
 export declare class Timeline {
     private stage;
     private gridLayer;
@@ -13,14 +13,26 @@ export declare class Timeline {
     private onZoomChange;
     private onScrollChange;
     private animationFrameId;
-    private scrollbarHeight;
-    private scrollbarY;
+    private hasBoundGlobalPointerListenersForDrag;
     private isScrollbarDragging;
     private scrollbarDragStartX;
     private scrollbarDragStartScrollLeft;
+    private isPointerInsideTimeline;
+    private lastPointerXInTimeline;
+    private readonly scrollbarHeight;
+    private readonly scrollbarMargin;
+    private handleGlobalPointerMove;
+    private handleGlobalPointerEnd;
+    private handleVisibilityChange;
     private leftPadding;
     constructor(stage: Konva.Stage, gridLayer: Konva.Layer, config: Partial<TimelineConfig>, onTimeChange: (time: TimeMs) => void, onZoomChange: (zoom: number) => void, onScrollChange: (scrollLeft: number) => void);
     private initEventListeners;
+    private updatePointerPosition;
+    private bindGlobalPointerListenersForDrag;
+    private unbindGlobalPointerListenersForDrag;
+    private isPointerSessionActive;
+    private finalizePointerInteraction;
+    private handlePointerMove;
     private handleZoom;
     private animateZoom;
     private animateHorizontalScroll;
@@ -34,14 +46,15 @@ export declare class Timeline {
     setPlayState(playState: 'playing' | 'paused'): void;
     update(): void;
     private render;
-    /**
-     * 绘制滚动条
-     */
     private renderScrollbar;
     private renderTimeTicks;
     getConfig(): TimelineConfig;
     getScrollLeft(): number;
     setScrollLeft(scrollLeft: number): void;
+    private getTotalDurationPixels;
+    private getScrollbarThumbWidth;
+    private getScrollbarThumbX;
+    private jumpScrollbarToPointer;
     /**
      * 滚动到指定时间
      * @param time 目标时间（毫秒）
@@ -63,6 +76,14 @@ export declare class Timeline {
      * 获取网格图层
      */
     getGridLayer(): Konva.Layer;
+    /**
+     * 鼠标当前是否位于时间轴区域内
+     */
+    hasPointerInTimeline(): boolean;
+    /**
+     * 获取时间轴内最近一次鼠标 X 坐标（相对 stage）
+     */
+    getPointerXInTimeline(): number | null;
     /**
      * 调整大小
      */

package/dist/components/timeline/TimelineHeaderView.d.ts

@@ -0,0 +1,45 @@
+import Konva from 'konva';
+import type { TimeMs, TimelineConfig } from '../../core/models/types';
+export declare class TimelineHeaderView {
+    private readonly stage;
+    private readonly layer;
+    private readonly onTimeChange;
+    private readonly onScrollChange;
+    private config;
+    private theme;
+    private scrollLeft;
+    private timeScaleHeight;
+    private isDragging;
+    private dragStartX;
+    private isPointerInsideTimeline;
+    private lastPointerXInTimeline;
+    private hasBoundGlobalPointerListenersForDrag;
+    private handleGlobalPointerMove;
+    private handleGlobalPointerEnd;
+    private handleVisibilityChange;
+    constructor(stage: Konva.Stage, layer: Konva.Layer, config: Partial<TimelineConfig>, onTimeChange: (time: TimeMs) => void, onScrollChange: (scrollLeft: number) => void);
+    setCurrentTime(_time: TimeMs): void;
+    setZoom(zoom: number): void;
+    setDuration(duration: TimeMs): void;
+    setScrollLeft(scrollLeft: number): void;
+    getScrollLeft(): number;
+    scrollToTime(time: TimeMs): void;
+    scrollToClip(clip: {
+        startTime: TimeMs;
+        duration: TimeMs;
+    }): void;
+    resize(width: number): void;
+    hasPointerInTimeline(): boolean;
+    getPointerXInTimeline(): number | null;
+    destroy(): void;
+    private initEventListeners;
+    private updatePointerPosition;
+    private bindGlobalPointerListenersForDrag;
+    private unbindGlobalPointerListenersForDrag;
+    private handlePointerMove;
+    private pixelToTime;
+    private timeToPixel;
+    private render;
+    private renderTimeTicks;
+    private clampScrollLeft;
+}

package/dist/components/track/Clip.d.ts

@@ -0,0 +1,16 @@
+import { Clip as ClipType, Position } from '../../core/models';
+export declare class Clip {
+    private clip;
+    private onUpdate;
+    private onSplit;
+    constructor(clip: ClipType, onUpdate: (clip: ClipType) => void, onSplit: (clip: ClipType, time: number) => void);
+    getClip(): ClipType;
+    applyPreviewState(clip: ClipType): void;
+    setSelected(selected: boolean): void;
+    isPointInResizeHandle(x: number, y: number, zoom: number, trackY: number, trackHeight: number, scrollLeft: number): boolean;
+    startDrag(_pos: Position): void;
+    startResize(_pos: Position): void;
+    endDrag(): void;
+    split(time: number): void;
+    private setResizeHandleState;
+}

package/dist/components/track/Track.d.ts

@@ -0,0 +1,121 @@
+import Konva from 'konva';
+import { Clip as ClipType, ClipStateUpdate, TrackConfig, TimeMs, Theme, TrackType } from '../../core/models';
+export declare class Track {
+    private static readonly DEFAULT_DRAG_ACTIVATION_THRESHOLD;
+    private static readonly DEFAULT_CLIP_SNAP_THRESHOLD;
+    private static readonly AUTO_SCROLL_EDGE_THRESHOLD;
+    private static readonly AUTO_SCROLL_MAX_SPEED;
+    private layer;
+    private trackGroup;
+    private dropPreviewGroup;
+    private config;
+    private theme;
+    private trackType;
+    private clips;
+    private clipGroups;
+    private zoom;
+    private scrollLeft;
+    private trackY;
+    private trackHeight;
+    private selectedClip;
+    private hasSelectedClip;
+    private interactionState;
+    private isVisualUpdate;
+    private onClipUpdate;
+    private onClipAdd;
+    private onClipRemove;
+    private onClipSplit;
+    private onClipSelect;
+    private onTimeJump;
+    private onClipOverlap?;
+    private hasBoundGlobalPointerListenersForDrag;
+    private hasLockedGlobalCursor;
+    private edgeAutoScrollAnimationFrameId;
+    private onHorizontalDragAutoScroll?;
+    private onClipCrossTrackPreview?;
+    private onClipCrossTrack?;
+    private onClearDropPreview?;
+    private onClearSelection?;
+    private onSnapGuideChange?;
+    private resolveSnapTargetClips?;
+    private readonly dragActivationThreshold;
+    private enableClipSnap;
+    private readonly clipSnapThreshold;
+    private handleGlobalPointerMove;
+    private handleGlobalPointerEnd;
+    private handleWindowBlur;
+    constructor(layer: Konva.Layer, config: TrackConfig, trackType: TrackType, zoom: number, trackY: number, trackHeight: number, theme: Theme, onClipUpdate: (clip: ClipType, originalClip?: ClipType, clipUpdates?: ClipStateUpdate[]) => void, onClipAdd: (clip: ClipType) => void, onClipRemove: (clipId: string) => void, onClipSplit: (clip1: ClipType, clip2: ClipType) => void, onClipSelect: (clip: ClipType) => void, onTimeJump: (time: TimeMs) => void, onHorizontalDragAutoScroll?: (nextScrollLeft: number) => number, onClipOverlap?: (clip: ClipType, currentTrackId: string) => void, onClipCrossTrackPreview?: (clip: ClipType, targetTrackY: number, currentTrackId: string) => 'self' | 'external' | 'clear', onClipCrossTrack?: (clip: ClipType, originalClip: ClipType | null, targetTrackY: number, currentTrackId: string) => boolean | void, onClearDropPreview?: () => void, onClearSelection?: () => void, onSnapGuideChange?: (guideTime: TimeMs | null) => void, dragActivationThreshold?: number, enableClipSnap?: boolean, clipSnapThreshold?: number);
+    private initClips;
+    private ensureDropPreviewGroup;
+    private showDropPreview;
+    private hideDropPreview;
+    private initEventListeners;
+    private bindGlobalPointerListenersForDrag;
+    private unbindGlobalPointerListenersForDrag;
+    private handleVisibilityChange;
+    private readonly handleEdgeAutoScrollFrame;
+    private handleTrackBackgroundClick;
+    private createClipGroup;
+    private handleClipClick;
+    private handleClipMouseDown;
+    private handleClipMouseMove;
+    private handleTrackBackgroundMouseMove;
+    private handleClipMouseUp;
+    private finishPointerInteraction;
+    private applyInteractionTransition;
+    private resolveInteractionState;
+    private syncLegacyInteractionMirror;
+    private handleClipMoveEnd;
+    private updateAllClips;
+    private buildAndSendUpdates;
+    private updateHoverCursor;
+    private isDragSessionActive;
+    private handleDragMove;
+    private handleClipMouseLeave;
+    private lockPointerCursor;
+    private releasePointerCursor;
+    private updateClipGroup;
+    private handleClipUpdate;
+    private handleClipSplit;
+    addClip(clip: ClipType): void;
+    removeClip(clipId: string): void;
+    updateClip(clipId: string, updates: Partial<ClipType>): void;
+    setZoom(zoom: number): void;
+    setCurrentTime(_time: TimeMs): void;
+    setScrollLeft(scrollLeft: number): void;
+    private updateClipVisibility;
+    setTrackY(trackY: number): void;
+    getTrackType(): TrackType;
+    render(shouldBatchDraw?: boolean): void;
+    private getTrackBackgroundFill;
+    getClips(): ClipType[];
+    getSelectedClip(): ClipType | null;
+    clearSelection(): void;
+    updateSelectionVisual(selectedClipId: string | null): void;
+    selectClip(clipId: string): void;
+    private applySelectionVisual;
+    splitSelectedClip(time: TimeMs): void;
+    removeClipGaps(): void;
+    getTrackGroup(): Konva.Group;
+    getId(): string;
+    setTrackHeight(height: number): void;
+    showClipDropPreview(clip: ClipType): void;
+    clearClipDropPreview(): void;
+    getRole(): 'primary' | 'normal';
+    setClipSnapEnabled(enabled: boolean): void;
+    setSnapTargetResolver(resolver: (() => ClipType[]) | undefined): void;
+    private updateDraggedClipFromPointer;
+    private buildPreviewClip;
+    private constrainResizePreviewToTrackBounds;
+    private getResizeLeftBoundaryStart;
+    private getResizeRightBoundaryEnd;
+    private buildResizeLeftPreviewClip;
+    private buildResizeRightPreviewClip;
+    private applyClipSnap;
+    private applyPreviewClipState;
+    private updateSnapGuideLine;
+    private updateEdgeAutoScrollState;
+    private calculateHorizontalAutoScrollVelocity;
+    private startEdgeAutoScroll;
+    private stopEdgeAutoScroll;
+}

package/dist/components/track/trackClipLayout.d.ts

@@ -0,0 +1,23 @@
+import { Clip, TimeMs } from '../../core/models';
+export type TrackPointerCursor = 'default' | 'pointer' | 'ew-resize';
+export declare const CLIP_RESIZE_HANDLE_SIZE = 8;
+interface TrackClipMetricsInput {
+    duration: TimeMs;
+    startTime: TimeMs;
+    zoom: number;
+    scrollLeft: number;
+}
+interface ResolveTrackPointerCursorInput {
+    clips: Clip[];
+    zoom: number;
+    scrollLeft: number;
+    trackY: number;
+    trackHeight: number;
+    x: number;
+    y: number;
+}
+export declare function getTrackClipX(startTime: TimeMs, zoom: number, scrollLeft: number): number;
+export declare function getTrackClipRenderWidth(duration: TimeMs, zoom: number): number;
+export declare function isTrackClipVisible(input: TrackClipMetricsInput, viewportWidth: number): boolean;
+export declare function resolveTrackPointerCursor(input: ResolveTrackPointerCursorInput): TrackPointerCursor;
+export {};

package/dist/components/track/trackInteractionState.d.ts

@@ -0,0 +1,79 @@
+import type { Clip as ClipType } from '../../core/models';
+export type TrackPointerOperation = 'move' | 'resize-left' | 'resize-right';
+export interface TrackInteractionContext {
+    clipId: string;
+    originalClipsState: ClipType[];
+    nonDraggedClips: ClipType[];
+    snapCandidateClips: ClipType[];
+    pointerStartClientX: number;
+    pointerStartClientY: number;
+    pointerStartX: number;
+    pointerStartY: number;
+    dragStartScrollLeft: number;
+    lastPointerClientX: number;
+    lastPointerClientY: number;
+    dragTargetTrackY: number;
+    crossTrackDragOffsetY: number;
+}
+export interface IdleTrackInteractionState {
+    kind: 'idle';
+}
+export interface PressedTrackInteractionState {
+    kind: 'pressed';
+    operation: TrackPointerOperation;
+    context: TrackInteractionContext;
+}
+export interface DraggingMoveTrackInteractionState {
+    kind: 'draggingMove';
+    context: TrackInteractionContext;
+}
+export interface DraggingResizeLeftTrackInteractionState {
+    kind: 'draggingResizeLeft';
+    context: TrackInteractionContext;
+}
+export interface DraggingResizeRightTrackInteractionState {
+    kind: 'draggingResizeRight';
+    context: TrackInteractionContext;
+}
+export type TrackInteractionState = IdleTrackInteractionState | PressedTrackInteractionState | DraggingMoveTrackInteractionState | DraggingResizeLeftTrackInteractionState | DraggingResizeRightTrackInteractionState;
+export type TrackInteractionEvent = {
+    type: 'POINTER_DOWN';
+    operation: TrackPointerOperation;
+    clipId: string;
+    originalClipsState: ClipType[];
+    nonDraggedClips: ClipType[];
+    snapCandidateClips: ClipType[];
+    clientX: number;
+    clientY: number;
+    localX: number;
+    localY: number;
+    scrollLeft: number;
+} | {
+    type: 'POINTER_MOVE';
+    clientX: number;
+    clientY: number;
+    localY: number;
+    activationThreshold: number;
+} | {
+    type: 'SCROLL_LEFT_CHANGED';
+} | {
+    type: 'POINTER_UP' | 'VISIBILITY_HIDDEN' | 'WINDOW_BLUR' | 'CANCEL';
+};
+export interface TrackInteractionTransitionEffects {
+    bindGlobalListeners?: boolean;
+    unbindGlobalListeners?: boolean;
+    updatePreview?: boolean;
+    commit?: boolean;
+    cleanup?: boolean;
+}
+export interface TrackInteractionTransitionResult {
+    state: TrackInteractionState;
+    effects: TrackInteractionTransitionEffects;
+}
+export declare function createIdleTrackInteractionState(): TrackInteractionState;
+export declare function isTrackInteractionActive(state: TrackInteractionState | null | undefined): boolean;
+export declare function isTrackInteractionDragging(state: TrackInteractionState | null | undefined): boolean;
+export declare function getTrackInteractionContext(state: TrackInteractionState | null | undefined): TrackInteractionContext | null;
+export declare function getTrackInteractionOperation(state: TrackInteractionState | null | undefined): TrackPointerOperation | null;
+export declare function getTrackInteractionCursor(state: TrackInteractionState | null | undefined): 'ew-resize' | 'grabbing' | null;
+export declare function transitionTrackInteraction(state: TrackInteractionState, event: TrackInteractionEvent): TrackInteractionTransitionResult;

package/dist/core/commands/timelineCommands.d.ts

@@ -0,0 +1,121 @@
+import { TimelineStore } from '../stores/timelineStore';
+import type { Clip, TimeMs, TrackInsertionPlacement, TrackType } from '../models/types';
+export interface ValueChangeCommandResult<T> {
+    previousValue: T;
+    nextValue: T;
+    changed: boolean;
+}
+export interface SelectionCommandResult {
+    previousClipId: string | null;
+    nextClipId: string | null;
+    changed: boolean;
+}
+export interface TimelineTrackView {
+    getId?(): string;
+    id?: string;
+    type?: TrackType;
+    getClips(): Clip[];
+    getTrackType?(): TrackType;
+    addClip?(clip: Clip): void;
+    removeClip?(clipId: string): void;
+    splitSelectedClip?(time: TimeMs): void;
+}
+export interface TimelineTrackLayout {
+    id: string;
+    type: TrackType;
+    role?: 'primary' | 'normal';
+}
+export interface ClipLookupResult {
+    clip: Clip;
+    track: TimelineTrackView;
+    trackId: string | null;
+}
+export interface RemoveClipCommandResult {
+    exists: boolean;
+    clip: Clip | null;
+    trackId: string | null;
+    shouldClearSelection: boolean;
+}
+export type MoveClipToTrackCommandResult = {
+    status: 'ready';
+    clip: Clip;
+    sourceTrack: TimelineTrackView;
+    sourceTrackId: string;
+    targetTrack: TimelineTrackView;
+    targetTrackId: string;
+} | {
+    status: 'noop';
+    clipId: string;
+    sourceTrackId: string;
+    targetTrackId: string;
+} | {
+    status: 'missing_source_track' | 'missing_target_track' | 'track_type_mismatch';
+    clipId: string;
+    targetTrackId: string;
+    sourceTrackId?: string;
+};
+export type TrackPlacementCommandResult = {
+    status: 'use_existing_track';
+    trackId: string;
+} | {
+    status: 'create_track';
+    trackType: TrackType;
+    suggestedTrackName: string;
+};
+export type CrossTrackMoveCommandResult = {
+    status: 'missing_target_track_by_position';
+} | {
+    status: 'same_track';
+    targetTrackId: string;
+} | {
+    status: 'missing_target_track_view';
+    targetTrackId: string;
+} | {
+    status: 'track_type_mismatch';
+    targetTrackId: string;
+    targetTrackType: TrackType | null;
+} | {
+    status: 'move_to_track';
+    targetTrackId: string;
+} | {
+    status: 'create_track';
+    trackType: TrackType;
+    insertionPlacement: TrackInsertionPlacement;
+    referenceTrackId?: string;
+};
+export type CrossTrackPreviewCommandResult = {
+    status: 'existing_track_placeholder';
+    targetTrackId: string;
+} | {
+    status: 'new_track_insertion';
+    trackType: TrackType;
+    insertionPlacement: TrackInsertionPlacement;
+    referenceTrackId?: string;
+} | {
+    status: 'clear';
+};
+export declare class TimelineCommands {
+    private readonly timelineStore;
+    constructor(timelineStore: TimelineStore);
+    selectClip(clipId: string): SelectionCommandResult;
+    clearSelection(): SelectionCommandResult;
+    findClipById(tracks: TimelineTrackView[], clipId: string): ClipLookupResult | null;
+    findClipAtTime(tracks: TimelineTrackView[], time: TimeMs): ClipLookupResult | null;
+    prepareRemoveClip(clipId: string, tracks: TimelineTrackView[]): RemoveClipCommandResult;
+    prepareMoveClipToTrack(clipId: string, targetTrackId: string, tracks: TimelineTrackView[]): MoveClipToTrackCommandResult;
+    planTrackPlacement(clip: Pick<Clip, 'type' | 'startTime' | 'duration'>, tracks: TimelineTrackView[]): TrackPlacementCommandResult;
+    planCrossTrackMove(clip: Pick<Clip, 'id' | 'type' | 'startTime' | 'duration'>, targetTrackY: number, currentTrackId: string, timeScaleHeight: number, layoutTracks: TimelineTrackLayout[], tracks: TimelineTrackView[]): CrossTrackMoveCommandResult;
+    planCrossTrackPreview(clip: Pick<Clip, 'id' | 'type' | 'startTime' | 'duration'>, targetTrackY: number, currentTrackId: string, timeScaleHeight: number, layoutTracks: TimelineTrackLayout[], tracks: TimelineTrackView[]): CrossTrackPreviewCommandResult;
+    setCurrentTime(time: TimeMs): ValueChangeCommandResult<TimeMs>;
+    setZoom(zoom: number): ValueChangeCommandResult<number>;
+    setSpeed(speed: number): ValueChangeCommandResult<number>;
+    private updateSelection;
+    private updateCurrentTime;
+    private updateZoom;
+    private updateSpeed;
+    private resolveTrackId;
+    private resolveTrackType;
+    private resolveTrackTargetByY;
+    private resolvePreferredInsertionPlacement;
+    private hasOverlapOnTrack;
+}