Variable timelineHookMocksConst

Type declaration

• useClips: Mock<
      () => {
          applyEffect: Mock<(_clipId: string, _effect: any) => void>;
          clips: TimelineClip[];
          getClipById: Mock<(_clipId: string) => any>;
          getClipsInRange: Mock<(_startTime: number, _endTime: number) => any[]>;
          getClipsOnTrack: Mock<(_trackId: string) => any[]>;
          removeEffect: Mock<(_clipId: string, _effectId: string) => void>;
          splitClip: Mock<(_clipId: string, _time: number) => void>;
          trimClip: Mock<(_clipId: string, _start: number, _end: number) => void>;
      },
  >

• useDragDropTimeline: Mock<
      () => {
          dragState: {
              draggedItem: any;
              dragOverTrack: any;
              dropPosition: any;
              isDragging: boolean;
          };
          handleDragEnd: Mock<Procedure>;
          handleDragOver: Mock<Procedure>;
          handleDragStart: Mock<Procedure>;
          isValidDropTarget: Mock<() => boolean>;
          isValidDropTargetForNewTrack: Mock<() => boolean>;
      },
  >

• useTimeline: Mock<
      () => {
          addClip: Mock<
              (trackId: string, mediaFile: any, position?: number) => TimelineClip,
          >;
          addSection: Mock<
              (name: string, startTime: number, duration: number) => TimelineSection,
          >;
          addTrack: Mock<
              (
                  type: "audio" | "video",
                  sectionId?: string,
                  index?: number,
              ) => TimelineTrack,
          >;
          createNewProject: Mock<(name?: string) => TimelineProject>;
          error: any;
          loading: boolean;
          loadProject: Mock<(path: string) => Promise<TimelineProject>>;
          moveClip: Mock<
              (trackId: string, clipId: string, newStartTime: number) => boolean,
          >;
          project: TimelineProject;
          removeClip: Mock<(trackId: string, clipId: string) => boolean>;
          removeTrack: Mock<(trackId: string) => boolean>;
          saveProject: Mock<(project: TimelineProject) => Promise<void>>;
      },
  >

• useTimelinePlayback: Mock<
      () => {
          currentTime: number;
          duration: number;
          frameRate: number;
          isPlaying: boolean;
          nextFrame: Mock<Procedure>;
          pause: Mock<Procedure>;
          play: Mock<Procedure>;
          previousFrame: Mock<Procedure>;
          seek: Mock<(_time: number) => void>;
      },
  >

• useTimelineSelection: Mock<
      () => {
          clearSelection: Mock<Procedure>;
          isClipSelected: Mock<(_clipId: string) => boolean>;
          isTrackSelected: Mock<(_trackId: string) => boolean>;
          selectClip: Mock<(_clipId: string, _multi?: boolean) => void>;
          selectedClips: string[];
          selectedTracks: string[];
          selectTrack: Mock<(_trackId: string, _multi?: boolean) => void>;
      },
  >

• useTimelineUndo: Mock<
      () => {
          canRedo: boolean;
          canUndo: boolean;
          history: any[];
          historyIndex: number;
          redo: Mock<Procedure>;
          undo: Mock<Procedure>;
      },
  >

• useTimelineZoom: Mock<
      () => {
          maxScale: number;
          minScale: number;
          scale: number;
          setScale: Mock<(_scale: number) => void>;
          zoomIn: Mock<Procedure>;
          zoomOut: Mock<Procedure>;
          zoomToFit: Mock<Procedure>;
      },
  >

• useTracks: Mock<
      () => {
          getTrackById: Mock<(trackId: string) => TimelineTrack>;
          getTracksByType: Mock<(type: "audio" | "video") => TimelineTrack[]>;
          reorderTracks: Mock<(_fromIndex: number, _toIndex: number) => void>;
          setTrackHeight: Mock<(_trackId: string, _height: number) => void>;
          toggleTrackLock: Mock<(_trackId: string) => void>;
          toggleTrackMute: Mock<(_trackId: string) => void>;
          tracks: TimelineTrack[];
      },
  >