Interface Api

interface Api {
    $container: any;
    BasicWidget: typeof BasicWidget;
    bindGlobalShortcut: (
        keyboardShortcut: string,
        handler: Handler,
        namespace?: string,
    ) => void;
    createLink: (notePath: string, options?: CreateLinkOptions) => Promise<any>;
    createNoteLink: (
        notePath: string,
        options?: CreateLinkOptions,
    ) => Promise<any>;
    currentNote: FNote;
    dayjs: __module;
    formatDateISO: (date: Date) => string;
    formatNoteSize: (size: number, decimals?: number) => string;
    formatSize: (size: number, decimals?: number) => string;
    getDayNote: (date: string, calendarRootId?: string) => Promise<FNote>;
    getMonthNote: (month: string) => Promise<FNote>;
    getQuarterNote: (quarter: string) => Promise<FNote>;
    getTodayNote: () => Promise<FNote>;
    getWeekFirstDayNote: (date: string) => Promise<FNote>;
    getWeekNote: (week: string) => Promise<FNote>;
    getYearNote: (year: string) => Promise<FNote>;
    logMessages: Record<string, string[]>;
    logSpacedUpdates: Record<string, default>;
    NoteContextAwareWidget: typeof NoteContextAwareWidget;
    originEntity: unknown;
    parseDate: (str: string) => Date;
    preact: Readonly<
        {
            ActionButton: (__namedParameters: ActionButtonProps) => Element;
            Admonition: (__namedParameters: AdmonitionProps) => Element;
            Button: (__namedParameters: ButtonProps) => Element;
            Calendar: (__namedParameters: CalendarProps) => Element;
            CKEditor: (__namedParameters: CKEditorOpts) => Element;
            Collapsible: (__namedParameters: CollapsibleProps) => Element;
            ColorPicker: (__namedParameters: ColorPickerProps) => Element;
            createContext: <T>(defaultValue: T) => Context<T>;
            Dropdown: (__namedParameters: DropdownProps) => Element;
            ExternallyControlledCollapsible: (
                __namedParameters: Omit<CollapsibleProps, "initiallyExpanded"> & {
                    expanded: boolean;
                    setExpanded: (expanded: boolean) => void;
                },
            ) => Element;
            FormCheckbox: (__namedParameters: FormCheckboxProps) => Element;
            FormDropdownDivider: () => Element;
            FormDropdownList: <T>(__namedParameters: FormDropdownList<T>) => Element;
            FormDropdownSubmenu: (
                __namedParameters: {
                    children: ComponentChildren;
                    dropStart?: boolean;
                    icon: string;
                    onDropdownToggleClicked?: () => void;
                    title: ComponentChildren;
                },
            ) => Element;
            FormFileUploadActionButton: (
                param: Omit<ActionButtonProps, "onClick"> & Pick<
                    FormFileUploadProps,
                    "onChange",
                >,
            ) => Element;
            FormFileUploadButton: (
                param: Omit<ButtonProps, "onClick"> & Pick<
                    FormFileUploadProps,
                    "onChange",
                >,
            ) => Element;
            FormGroup: (__namedParameters: FormGroupProps) => Element;
            FormListItem: (__namedParameters: FormListItemOpts) => Element;
            FormRadioGroup: (__namedParameters: FormRadioProps) => Element;
            FormText: (__namedParameters: { children: ComponentChildren }) => Element;
            FormTextArea: (__namedParameters: FormTextAreaProps) => Element;
            FormTextBox: (__namedParameters: FormTextBoxProps) => Element;
            FormToggle: (__namedParameters: FormToggleProps) => Element;
            Fragment: FunctionComponent<{}>;
            h: typeof h;
            Icon: (__namedParameters: IconProps) => Element;
            LinkButton: (__namedParameters: LinkButtonProps) => Element;
            LoadingSpinner: () => Element;
            Modal: (__namedParameters: ModalProps) => Element;
            NoteAutocomplete: (__namedParameters: NoteAutocompleteProps) => Element;
            NoteColorPicker: (props: NoteColorPickerProps) => Element;
            NoteLink: (__namedParameters: NoteLinkOpts) => Element;
            RawHtml: (
                __namedParameters: RawHtmlProps & {
                    containerRef?: RefObject<HTMLSpanElement>;
                },
            ) => Element;
            RightPanelWidget: (__namedParameters: RightPanelWidgetProps) => Element;
            Slider: (__namedParameters: SliderProps) => Element;
            Table: <T extends {}>(__namedParameters: TableProps<T>) => Element;
            defineLauncherWidget(
                definition: Omit<LauncherWidgetDefinitionWithType, "type">,
            ): { render: () => VNode; type: string };
            defineWidget(
                definition: WidgetDefinition,
            ): {
                parent:
                    | "left-pane"
                    | "center-pane"
                    | "note-detail-pane"
                    | "right-pane";
                position?: number;
                render: () => VNode;
                type: string;
            };
            useActiveNoteContext(): {
                componentId: string;
                hoistedNoteId: string;
                isReadOnlyTemporarilyDisabled: boolean;
                note: FNote;
                noteContext: NoteContext;
                noteId: string;
                notePath: string;
                ntxId: string;
                parentComponent: ReactWrappedWidget;
                viewScope: ViewScope;
            };
            useBlobEditorSpacedUpdate(
                __namedParameters: {
                    dataSaved?: (savedData: Blob) => void;
                    getData: () => Blob | Promise<Blob>;
                    note: FNote;
                    noteContext: NoteContext;
                    noteType:
                        | "search"
                        | "file"
                        | "image"
                        | "noteMap"
                        | "launcher"
                        | "doc"
                        | "contentWidget"
                        | "text"
                        | "relationMap"
                        | "render"
                        | "canvas"
                        | "mermaid"
                        | "book"
                        | "webView"
                        | "code"
                        | "mindMap"
                        | "spreadsheet"
                        | "llmChat";
                    onContentChange: (newBlob: default) => void;
                    replaceWithoutRevision?: boolean;
                    updateInterval?: number;
                },
            ): default<Blob>;
            useCallback<T extends Function>(callback: T, inputs: Inputs): T;
            useChildNotes(parentNoteId: string): FNote[];
            useCollectionTreeDrag(
                containerRef: MutableRef<HTMLElement>,
                __namedParameters: {
                    callback: (
                        data: DragData[],
                        e: DragEvent,
                    ) => string[] | Promise<string[]>;
                    dragEnabled: boolean;
                    includeArchived: boolean;
                },
            ): void;
            useColorScheme(): "dark" | "light";
            useContainedLinkNavigation(
                containerRef: RefObject<HTMLElement>,
                onNavigate: (notePath: string, viewScope: ViewScope) => void,
            ): void;
            useContentElement(noteContext: NoteContext): HTMLElement;
            useContext<T>(context: PreactContext<T>): T;
            useContextualShortcutHints(
                hints: ShortcutHintDefinition | (() => ShortcutHintDefinition),
            ): void;
            useDebouncedValue<T>(value: T, delay: number): T;
            useDebugValue<T>(value: T, formatter?: (value: T) => any): void;
            useDelayedVisibility(
                active: boolean,
                __namedParameters?: DelayedVisibilityOpts,
            ): DelayedVisibilityPhase;
            useEditorSpacedUpdate(
                __namedParameters: {
                    dataSaved?: (savedData: SavedData) => void;
                    getData: () => SavedData | Promise<SavedData>;
                    note: FNote;
                    noteContext: NoteContext;
                    noteType:
                        | "search"
                        | "file"
                        | "image"
                        | "noteMap"
                        | "launcher"
                        | "doc"
                        | "contentWidget"
                        | "text"
                        | "relationMap"
                        | "render"
                        | "canvas"
                        | "mermaid"
                        | "book"
                        | "webView"
                        | "code"
                        | "mindMap"
                        | "spreadsheet"
                        | "llmChat";
                    onContentChange: (newContent: string) => void;
                    updateInterval?: number;
                },
            ): default<SavedData>;
            useEffect(effect: EffectCallback, inputs?: Inputs): void;
            useEffectiveReadOnly(note: FNote, noteContext: NoteContext): boolean;
            useElementSize(ref: RefObject<HTMLElement>): DOMRect;
            useErrorBoundary(
                callback?: (error: any, errorInfo: ErrorInfo) => void | Promise<void>,
            ): [any, () => void];
            useFullscreen(
                element: HTMLElement,
                onChange?: () => void,
            ): [boolean, () => Promise<boolean>];
            useGetContextData<K extends keyof NoteContextDataMap>(
                key: K,
            ): NoteContextDataMap[K];
            useGetContextDataFrom<K extends keyof NoteContextDataMap>(
                noteContext: NoteContext,
                key: K,
            ): NoteContextDataMap[K];
            useGlobalShortcut(keyboardShortcut: string, handler: Handler): void;
            useId(): string;
            useImperativeHandle<T, R>(
                ref: Ref<T>,
                create: () => R,
                inputs?: Inputs,
            ): void;
            useImperativeSearchHighlighlighting(
                highlightedTokens: string[],
            ): (el: HTMLElement) => void;
            useIsNoteReadOnly(
                note: FNote,
                noteContext: NoteContext,
            ): {
                enableEditing: (enabled?: boolean) => void;
                isReadOnly: boolean;
                temporarilyEditable: boolean;
            };
            useKeyboardShortcuts(
                scope: "code-detail" | "text-detail",
                containerRef: RefObject<HTMLElement>,
                parentComponent: Component,
                ntxId: string,
            ): void;
            useLauncherVisibility(launchNoteId: string): boolean;
            useLayoutEffect(effect: EffectCallback, inputs?: Inputs): void;
            useLegacyComponentElement(elRef: RefObject<HTMLElement>): void;
            useLegacyImperativeHandlers(handlers: Record<string, Function>): void;
            useLegacyWidget<T extends BasicWidget>(
                widgetFactory: () => T,
                __namedParameters?: {
                    containerClassName?: string;
                    containerStyle?: CSSProperties;
                    noteContext?: NoteContext;
                },
            ): [VNode<{}>, T];
            useLongPressContextMenu(
                handler: (e: MouseEvent) => void,
                holdMs?: number,
            ): {
                onContextMenu: (e: MouseEvent) => void;
                onTouchCancel: () => void;
                onTouchEnd: (e: TouchEvent) => void;
                onTouchMove: () => void;
                onTouchStart: (e: TouchEvent) => void;
            };
            useMathRendering(
                containerRef: RefObject<HTMLElement>,
                deps: unknown[],
            ): void;
            useMemo<T>(factory: () => T, inputs: Inputs): T;
            useNote(noteId: string, silentNotFoundError?: boolean): FNote;
            useNoteBlob(
                note: FNote,
                componentId?: string,
                opts?: {
                    isVisible?: boolean;
                    refreshOnShow?: boolean;
                    reportLoadStateTo?: NoteContext;
                },
            ): default;
            useNoteColorClass(note: FNote): string;
            useNoteContext(): {
                componentId: string;
                hoistedNoteId: string;
                isReadOnlyTemporarilyDisabled: boolean;
                note: FNote;
                noteContext: NoteContext;
                noteId: string;
                notePath: string;
                ntxId: string;
                parentComponent: ReactWrappedWidget;
                viewScope: ViewScope;
            };
            useNoteIcon(note: FNote): string;
            useNoteLabel(
                note: FNote,
                labelName: FilterLabelsByType<string>,
            ): [string, (newValue: string) => void];
            useNoteLabelBoolean(
                note: FNote,
                labelName: FilterLabelsByType<boolean>,
            ): [boolean, (newValue: boolean) => void];
            useNoteLabelByName(
                note: FNote,
                labelName: string,
            ): [string, (newValue: string) => void];
            useNoteLabelInt(
                note: FNote,
                labelName: FilterLabelsByType<number>,
            ): [number, (newValue: number) => void];
            useNoteLabelOptionalBool(
                note: FNote,
                labelName: FilterLabelsByType<boolean>,
            ): [boolean, (newValue: boolean) => void];
            useNoteLabelWithDefault(
                note: FNote,
                labelName: FilterLabelsByType<string>,
                defaultValue: string,
            ): [string, (newValue: string) => void];
            useNoteProperty<T extends keyof FNote>(
                note: FNote,
                property: T,
                componentId?: string,
            ): FNote[T];
            useNoteRelation(
                note: FNote,
                relationName: RelationNames,
            ): [string, (newValue: string) => void];
            useNoteRelationTarget(
                note: FNote,
                relationName: RelationNames,
            ): readonly [FNote];
            useNoteSavedData(noteId: string): string;
            useNoteTitle(noteId: string, parentNoteId: string): string;
            useNoteTreeDrag(
                containerRef: MutableRef<HTMLElement>,
                __namedParameters: {
                    callback: (data: DragData[], e: DragEvent) => void;
                    dragEnabled: boolean;
                    dragNotEnabledMessage: Omit<ToastOptions, "id">;
                },
            ): void;
            useReducer<S, A>(
                reducer: Reducer<S, A>,
                initialState: S,
            ): [S, Dispatch<A>];
            useReducer<S, A, I>(
                reducer: Reducer<S, A>,
                initialArg: I,
                init: (arg: I) => S,
            ): [S, Dispatch<A>];
            useRef<T>(initialValue: T): MutableRef<T>;
            useRef<T>(initialValue: T): RefObject<T>;
            useRef<T = undefined>(): MutableRef<T>;
            useResizeObserver(
                ref: RefObject<HTMLElement>,
                callback: () => void,
            ): void;
            useSetContextData<K extends keyof NoteContextDataMap>(
                noteContext: NoteContext,
                key: K,
                value: NoteContextDataMap[K],
            ): void;
            useSpacedUpdate(
                callback: () => void | Promise<void>,
                interval?: number,
                stateCallback?: StateCallback,
            ): default<void>;
            useState<S>(initialState: S | (() => S)): [S, Dispatch<StateUpdater<S>>];
            useState<S = undefined>(): [S, Dispatch<StateUpdater<S>>];
            useStaticTooltip(
                elRef: RefObject<Element>,
                config?: Partial<Options>,
            ): void;
            useStaticTooltipWithKeyboardShortcut(
                elRef: RefObject<Element>,
                title: string,
                actionName:
                    | "backInNoteHistory"
                    | "forwardInNoteHistory"
                    | "jumpToNote"
                    | "commandPalette"
                    | "scrollToActiveNote"
                    | "quickSearch"
                    | "searchInSubtree"
                    | "expandSubtree"
                    | "collapseTree"
                    | "collapseSubtree"
                    | "sortChildNotes"
                    | "toggleArchivedNotes"
                    | "createNoteAfter"
                    | "createNoteInto"
                    | "createNoteIntoInbox"
                    | "deleteNotes"
                    | "moveNoteUp"
                    | "moveNoteDown"
                    | "moveNoteUpInHierarchy"
                    | "moveNoteDownInHierarchy"
                    | "editNoteTitle"
                    | "editBranchPrefix"
                    | "cloneNotesTo"
                    | "moveNotesTo"
                    | "copyNotesToClipboard"
                    | "pasteNotesFromClipboard"
                    | "cutNotesToClipboard"
                    | "selectAllNotesInParent"
                    | "addNoteAboveToSelection"
                    | "addNoteBelowToSelection"
                    | "duplicateSubtree"
                    | "openNewTab"
                    | "closeActiveTab"
                    | "reopenLastTab"
                    | "activateNextTab"
                    | "activatePreviousTab"
                    | "openNewWindow"
                    | "openTodayNote"
                    | "toggleTray"
                    | "toggleZenMode"
                    | "firstTab"
                    | "secondTab"
                    | "thirdTab"
                    | "fourthTab"
                    | "fifthTab"
                    | "sixthTab"
                    | "seventhTab"
                    | "eigthTab"
                    | "ninthTab"
                    | "lastTab"
                    | "openNewNoteSplit"
                    | "closeActiveNoteSplit"
                    | "moveActiveNoteSplitLeft"
                    | "moveActiveNoteSplitRight"
                    | "focusNoteSplitLeft"
                    | "focusNoteSplitRight"
                    | "showNoteSource"
                    | "showOptions"
                    | "showRevisions"
                    | "showRecentChanges"
                    | "showDeletedNotes"
                    | "showSQLConsole"
                    | "showBackendLog"
                    | "showSpaceUsage"
                    | "showCheatsheet"
                    | "showShortcutHints"
                    | "showHelp"
                    | "addLinkToText"
                    | "followLinkUnderCursor"
                    | "insertDateTimeToText"
                    | "pasteMarkdownIntoText"
                    | "cutIntoNote"
                    | "addIncludeNoteToText"
                    | "editReadOnlyNote"
                    | "addNewLabel"
                    | "addNewRelation"
                    | "toggleRibbonTabClassicEditor"
                    | "toggleRibbonTabBasicProperties"
                    | "toggleRibbonTabBookProperties"
                    | "toggleRibbonTabFileProperties"
                    | "toggleRibbonTabImageProperties"
                    | "toggleRibbonTabOwnedAttributes"
                    | "toggleRibbonTabInheritedAttributes"
                    | "toggleRibbonTabPromotedAttributes"
                    | "toggleRibbonTabNoteMap"
                    | "toggleRibbonTabNoteInfo"
                    | "toggleRibbonTabNotePaths"
                    | "toggleRibbonTabSimilarNotes"
                    | "toggleRightPane"
                    | "peekRightPane"
                    | "printActiveNote"
                    | "exportAsPdf"
                    | "openNoteExternally"
                    | "renderActiveNote"
                    | "runActiveNote"
                    | "toggleNoteHoisting"
                    | "unhoist"
                    | "reloadFrontendApp"
                    | "openDevTools"
                    | "findInText"
                    | "toggleLeftPane"
                    | "toggleFullscreen"
                    | "zoomOut"
                    | "zoomIn"
                    | "zoomReset"
                    | "copyWithoutFormatting"
                    | "forceSaveRevision"
                    | "saveNamedRevision",
                opts?: Omit<Partial<Options>, "title">,
            ): void;
            useSyncedRef<T>(externalRef?: Ref<T>, initialValue?: T): RefObject<T>;
            useTextEditor(noteContext: NoteContext): CKTextEditor;
            useTooltip(
                elRef: RefObject<HTMLElement>,
                config: Partial<Options>,
                enabled?: boolean,
            ): { hideTooltip: () => void; showTooltip: () => void };
            useTriliumEvent<T extends EventNames>(
                eventName: T,
                handler: (data: EventData<T>) => void,
            ): void;
            useTriliumEvents<T extends EventNames>(
                eventNames: T[],
                handler: (data: EventData<T>, eventName: T) => void,
            ): void;
            useTriliumOption(
                name: keyof OptionDefinitions,
                needsRefresh?: boolean,
            ): [string, (newValue: OptionValue) => Promise<void>];
            useTriliumOptionBool(
                name: keyof OptionDefinitions,
                needsRefresh?: boolean,
            ): [boolean, (newValue: boolean) => Promise<void>];
            useTriliumOptionInt(
                name: keyof OptionDefinitions,
            ): [number, (newValue: number) => Promise<void>];
            useTriliumOptionJson<T>(
                name: keyof OptionDefinitions,
                needsRefresh?: boolean,
            ): [T, (newValue: T) => Promise<void>];
            useTriliumOptions<T extends keyof OptionDefinitions>(
                ...names: T[],
            ): readonly [
                Record<T, string>,
                <T_1 extends keyof OptionDefinitions>(
                    newValues: Record<T_1, OptionValue>,
                ) => Promise<void>,
            ];
            useUniqueName(prefix?: string): string;
            useWindowSize(): { windowHeight: number; windowWidth: number };
        },
    >;
    protectNote: (
        noteId: string,
        protect: boolean,
        includingSubtree: boolean,
    ) => Promise<void>;
    protectSubTree: (
        noteId: string,
        protect: boolean,
        includingSubtree: boolean,
    ) => Promise<void>;
    randomString: (len?: number) => string;
    RightPanelWidget: typeof RightPanelWidget;
    setupElementTooltip: ($el: any) => void;
    showConfirmDialog: (message: any) => Promise<boolean>;
    showError: (message: string, timeout?: number) => void;
    showInfoDialog: (
        message: any,
        extraProps?: InfoExtraProps,
    ) => Promise<unknown>;
    showMessage: (message: string, timeout?: number, icon?: string) => void;
    showPromptDialog: (props: PromptDialogOptions) => Promise<string>;
    startNote: FNote;
    triggerCommand: <K extends keyof CommandMappings>(
        name: K,
        _data?: CommandMappings[K],
    ) => Promise<unknown>;
    triggerEvent: <K extends EventNames>(
        name: K,
        data: EventData<K>,
    ) => Promise<unknown>;
    waitUntilSynced: () => Promise<void>;
    activateNewNote(notePath: string): Promise<void>;
    activateNote(notePath: string): Promise<void>;
    addButtonToToolbar(opts: AddToToolbarOpts): void;
    addTextToActiveContextEditor(text: string): void;
    createNote(
        parentNotePath: string,
        opts?: CreateNoteOpts,
    ): Promise<{ branch: FBranch; note: FNote }>;
    getActiveContext(): NoteContext;
    getActiveContextCodeEditor(): Promise<unknown>;
    getActiveContextNote(): FNote;
    getActiveContextNotePath(): string;
    getActiveContextTextEditor(): Promise<unknown>;
    getActiveMainContext(): NoteContext;
    getActiveNoteDetailWidget(): Promise<ReactWrappedWidget>;
    getComponentByEl(el: HTMLElement): Component;
    getInstanceName(): string;
    getMainNoteContexts(): NoteContext[];
    getNote(noteId: string): Promise<FNote>;
    getNoteContexts(): NoteContext[];
    getNotes(
        noteIds: string[],
        silentNotFoundError?: boolean,
    ): Promise<FNote[]>;
    htmlToMarkdown(html: string): Promise<string>;
    isBackendScriptingEnabled(): boolean;
    isSqlConsoleEnabled(): boolean;
    log(...args: unknown[]): void;
    markdownToHtml(markdown: string): Promise<string>;
    openSplitWithNote(notePath: string, activate: boolean): Promise<void>;
    openTabWithNote(notePath: string, activate: boolean): Promise<void>;
    refreshIncludedNote(includedNoteId: string): void;
    reloadNotes(noteIds: string[]): Promise<void>;
    runAsyncOnBackendWithManualTransactionHandling(
        func: Func,
        params: unknown[],
    ): unknown;
    runOnBackend(func: Func, params: unknown[]): unknown;
    searchForNote(searchString: string): Promise<FNote>;
    searchForNotes(searchString: string): Promise<FNote[]>;
    setHoistedNoteId(noteId: string): void;
}