Interface Editor

interface Editor {
    aabbToDrawboardAabb: (aabb: Aabb2D) => Aabb2D;
    activateTool: (tool: string | undefined) => void;
    activeStrategy: ActiveStrategy;
    activeTool: Ref<Tool>;
    addElement: (element: Element, options?: AddElementOptions) => Element2D;
    addElements: (
        element: Element<Meta>[],
        options?: AddElementOptions,
    ) => Element2D[];
    animationPresets: Ref<AnimationPreset[]>;
    applyResizeOverride: (
        element: Element2D,
        context: ResizeOverrideContext,
    ) => boolean;
    assets: Assets;
    camera: Ref<Camera2D>;
    canLoad: (source: any) => Promise<boolean>;
    canRedo: Ref<boolean>;
    canUndo: Ref<boolean>;
    captureElementScreenshot: (
        element: Element<Meta> | Element2D,
    ) => Promise<HTMLCanvasElement>;
    captureFrameScreenshot: (index: number) => void;
    clearDoc: () => void;
    commands: Reactive<Map<string, Command>>;
    contextMenu: ComputedRef<MenuItem[]>;
    copiedData: Ref<any>;
    currentTime: WritableComputedRef<number>;
    docLoading: Ref<boolean>;
    doubleclickStrategy: DoubleclickStrategy;
    drawboardAabb: Ref<Aabb2D>;
    drawboardContextMenuPointer: Ref<Vector2 | undefined>;
    drawboardDom: Ref<HTMLElement | undefined>;
    drawboardEffect: Ref<DrawboardEffect>;
    drawboardPointer: Ref<Vector2 | undefined>;
    drawboardToGlobal: (
        point: { x: number; y: number },
    ) => { x: number; y: number };
    editingStates: Set<string>;
    elementSelection: Ref<Element2D[]>;
    endTime: WritableComputedRef<number>;
    enterHandlers: EnterHandler[];
    exec: <K extends keyof Commands>(
        command: K,
        ...args: Parameters<Commands[K]>,
    ) => ReturnType<Commands[K]>;
    export: <K extends keyof Exporters>(
        name: K,
        options?: ExportOptions,
    ) => Exporters[K];
    exportConfig: () => Blob;
    exporters: Reactive<Map<string, Exporter>>;
    exporting: Ref<boolean>;
    exportProgress: Ref<number>;
    findFrame: (target: "next" | "previous") => Element2D | undefined;
    findSibling: (target: "next" | "previous") => Node | undefined;
    fonts: Fonts;
    fps: Ref<number>;
    frames: ComputedRef<Element2D[]>;
    frameThumbs: Ref<FrameThumb[]>;
    getAabb: (
        node: Node | Node[] | undefined,
        inTarget?: "parent" | "drawboard" | "frame",
    ) => Aabb2D;
    getAncestorFrame: (node?: Node, isTop?: boolean) => Element2D | undefined;
    getAnimationPreset: (id: string) => AnimationPreset | undefined;
    getConfig: (path: string, defaultValue?: any) => any;
    getConfigRef: <T = any>(path: string) => WritableComputedRef<T>;
    getDoc: () => JsonData;
    getGlobalPointer: () => Vector2Like;
    getImagePipeline: (name: string) => ImagePipeline | undefined;
    getKbd: (command: string) => string;
    getNodeById: (id: string) => Node | undefined;
    getObb: (
        node: Node | Node[] | undefined,
        inTarget?: "parent" | "drawboard" | "frame",
    ) => Obb2D;
    getTimeRange: (
        node?: Node | Node[],
    ) => { endTime: number; startTime: number };
    globalToDrawboard: (
        point: { x: number; y: number },
    ) => { x: number; y: number };
    hasTextSelectionRange: Ref<boolean>;
    hotkeys: Reactive<Map<string, Hotkey>>;
    hotkeysData: WritableComputedRef<HotkeyData[]>;
    hoverElement: Ref<Element2D | undefined>;
    hoverStrategy: HoverStrategy;
    http: Http;
    icons: Ref<Record<string, string>>;
    imagePipelines: Ref<ImagePipeline[]>;
    importConfig: () => Promise<Config | undefined>;
    inEditorIs: (node: Node, inEditorIs?: EditorNodeType) => boolean;
    interactionsRev: Ref<number>;
    isContentEditing: () => boolean;
    isElement: (value: any) => value is Element2D;
    isFrameNode: (node: Node, isTop?: boolean) => boolean;
    isLock: (node: Node) => boolean;
    isNode: (value: any) => value is Node;
    isPointerInSelection: ComputedRef<boolean>;
    isRootNode: (node: Node) => boolean;
    isTextAllSelected: Ref<boolean>;
    isUndoRedoing: Ref<boolean>;
    isVisible: (node: Node) => boolean;
    keyframeEditing: Ref<KeyframeEditing | null>;
    load: <T = NormalizedElement<Meta>>(source: any) => Promise<T[]>;
    loadDoc: (source: any) => Promise<Doc>;
    loaders: Reactive<Map<string, Loader>>;
    loadFont: (
        source: FontSource,
        options?: FontLoadOptions,
    ) => Promise<FontLoadedResult>;
    loopMode: Ref<LoopMode>;
    mainMenu: ComputedRef<MenuItem[]>;
    mode: Ref<Mode>;
    modes: Ref<string[]>;
    msPerPx: Ref<number>;
    newDoc: () => void;
    nodeIndexMap: Map<string, number>;
    nodes: Ref<Node[]>;
    obbToDrawboardObb: (aabb: Obb2D) => Obb2D;
    obbToFit: (element: Element2D) => void;
    openDoc: () => Promise<void>;
    openFileDialog: (options?: { multiple?: boolean }) => Promise<File[]>;
    panels: PanelsApi;
    parseAnchor: (anchor: Anchor, isRtl?: boolean) => ParsedAnchor;
    paused: Ref<boolean>;
    playbackRate: Ref<number>;
    previewMode: Ref<boolean>;
    readonly: Ref<boolean>;
    recomputeTimelineEndTime: () => Promise<void>;
    redo: () => void;
    registerAnimationPreset: (preset: AnimationPreset) => void;
    registerCommand: (value: Command | Command[]) => void;
    registerConfig: <T>(
        path: string,
        declaration?: ConfigDeclaration<T>,
    ) => WritableComputedRef<T>;
    registerEditingState: (state: string) => void;
    registerEnterHandler: (fn: EnterHandler) => void;
    registerExporter: (value: Exporter | Exporter[]) => void;
    registerHotkey: (value: Hotkey | Hotkey[]) => void;
    registerIcon: (name: string, path: string) => void;
    registerImagePipeline: (pipeline: ImagePipeline) => void;
    registerLoader: (value: Loader | Loader[]) => void;
    registerMessages: (
        messages: Partial<Record<string, LocaleMessages>>,
    ) => void;
    registerMode: (mode: string) => void;
    registerResizeOverride: (fn: ResizeOverride) => void;
    registerSelectionRedirect: (fn: SelectionRedirect) => void;
    registerSnapper: (key: string, snapper: Snapper) => void;
    registerStatusbarItem: (component: Component) => void;
    registerTool: (tool: Tool | Tool[]) => void;
    registerToolbeltItem: (item: ToolbeltItem) => void;
    registerToolbeltShapeItem: (key: string) => void;
    renderEngine: Ref<Engine>;
    renderFrames: (options: RenderFramesOptions) => Promise<void>;
    resizeElement: (
        element: Element2D,
        newWidth: number,
        newHeight: number,
        options?: ResizeElementOptions,
    ) => void;
    resizeOverrides: ResizeOverride[];
    resizeStrategy?: ResizeStrategy;
    resolveImagePipelines: (
        steps: ImagePipeline[],
        image: PipelineImage,
    ) => Promise<PipelineImage>;
    resolveSelectionRedirect: (
        node: Element2D | undefined,
    ) => Element2D | undefined;
    root: Ref<Doc>;
    rootAabb: ComputedRef<Aabb2D>;
    runExclusiveRender: <T>(fn: () => T | Promise<T>) => Promise<T>;
    save: (reason?: SaveReason) => void;
    saveAsConfig: (filename?: string) => void;
    screenCenter: ComputedRef<{ x: number; y: number }>;
    screenCenterOffset: ComputedRef<Required<ScreenPadding>>;
    screenControlsOffset: ComputedRef<Required<ScreenPadding>>;
    scrollDriven: Ref<boolean>;
    selection: Ref<Node[]>;
    selectionAabb: ComputedRef<Aabb2D>;
    selectionAabbInDrawboard: ComputedRef<Aabb2D>;
    selectionMarquee: Ref<Aabb2D>;
    selectionObb: ComputedRef<Obb2D>;
    selectionObbInDrawboard: ComputedRef<Aabb2D>;
    selectionRedirects: SelectionRedirect[];
    setConfig: (path: string, value: any) => void;
    setCursor: (mode: string | undefined) => void;
    setDefaultFont: (
        source: FontSource,
        options?: FontLoadOptions,
    ) => Promise<void>;
    setDoc: (doc: DocumentSource) => Doc;
    setLock: (node: Node, lock: boolean) => void;
    setUploader: (uploader: Upload) => void;
    setVisible: (node: Node, visible: boolean) => void;
    snap: (
        box: { height: number; left: number; top: number; width: number },
    ) => void;
    snappers: Reactive<Map<string, Snapper>>;
    snapResize: (
        box: { height: number; left: number; top: number; width: number },
        dir: string,
    ) => void;
    snapshot: () => void;
    startTime: WritableComputedRef<number>;
    state: Ref<State>;
    statusbarItems: Ref<Component[]>;
    t: Translation;
    textSelection: Ref<IndexCharacter[] | undefined>;
    timeline: Ref<Timeline>;
    to: <K extends keyof Exporters>(
        name: K,
        options?: ExportOptions,
    ) => Exporters[K];
    toolbeltItems: Ref<ToolbeltItem[]>;
    toolbeltShapeItems: Ref<string[]>;
    tools: Reactive<Map<string, Tool>>;
    undo: () => void;
    unregisterCommand: (command: string) => void;
    unregisterExporter: (name: string) => void;
    unregisterHotkey: (command: string) => void;
    unregisterLoader: (name: string) => void;
    unregisterSnapper: (key: string) => void;
    unregisterTool: (tool: string) => void;
    upload: Upload;
    viewportAabb: ComputedRef<Aabb2D>;
    waitUntilFontLoad: () => Promise<void>;
}