obsidian-sample-plugin-f-sharp/Obsidian.fs

1701 lines
85 KiB
Forth

module rec Obsidian
open System
open Fable.Core
open Fable.Core.JS
open Browser.Types
open System.Drawing
type Array<'T> = System.Collections.Generic.IList<'T>
type Function = System.Action
type RegExp = System.Text.RegularExpressions.Regex
type [<AllowNullLiteral>] IExports =
abstract isBoolean: obj: obj option -> bool
abstract fish: selector: string -> HTMLElement option
abstract fishAll: selector: string -> ResizeArray<HTMLElement>
abstract createDiv: ?o: U2<DomElementInfo, string> * ?callback: (HTMLDivElement -> unit) -> HTMLDivElement
abstract createSpan: ?o: U2<DomElementInfo, string> * ?callback: (HTMLSpanElement -> unit) -> HTMLSpanElement
abstract createFragment: ?callback: (DocumentFragment -> unit) -> DocumentFragment
abstract ajax: options: AjaxOptions -> unit
abstract ajaxPromise: options: AjaxOptions -> Promise<obj option>
abstract ready: fn: (unit -> obj option) -> unit
abstract AbstractTextComponent: AbstractTextComponentStatic
/// <summary>Adds an icon to the library</summary>
/// <param name="iconId">- the icon ID</param>
/// <param name="svgContent">- the content of the SVG, without the <svg>. Must fit viewBox="0 0 100 100".</param>
abstract addIcon: iconId: string * svgContent: string -> unit
abstract App: AppStatic
abstract BaseComponent: BaseComponentStatic
abstract ButtonComponent: ButtonComponentStatic
abstract Component: ComponentStatic
abstract Constructor: ConstructorStatic
/// <summary>A standard debounce function.</summary>
/// <param name="cb">- The function to call.</param>
/// <param name="timeout">- The timeout to wait.</param>
/// <param name="resetTimer">- Whether to reset the timeout when the debouncer is called again.</param>
abstract debounce: cb: (obj -> obj option) * ?timeout: float * ?resetTimer: bool -> Debouncer<'T>
abstract DropdownComponent: DropdownComponentStatic
abstract EditableFileView: EditableFileViewStatic
abstract Editor: EditorStatic
abstract EditorSuggest: EditorSuggestStatic
abstract Events: EventsStatic
abstract ExtraButtonComponent: ExtraButtonComponentStatic
abstract FileManager: FileManagerStatic
abstract FileSystemAdapter: FileSystemAdapterStatic
abstract FileView: FileViewStatic
/// Flush the MathJax stylesheet.
abstract finishRenderMath: unit -> Promise<unit>
abstract fuzzySearch: q: PreparedQuery * text: string -> SearchResult option
abstract FuzzySuggestModal: FuzzySuggestModalStatic
abstract getAllTags: cache: CachedMetadata -> ResizeArray<string> option
abstract getLinkpath: linktext: string -> string
abstract HoverPopover: HoverPopoverStatic
/// Converts HTML to Markdown using Turndown Service.
abstract htmlToMarkdown: html: string -> string
abstract ItemView: ItemViewStatic
/// Iterate links and embeds. If callback returns true, the iteration process will be interrupted.
abstract iterateCacheRefs: cache: CachedMetadata * cb: (ReferenceCache -> U2<bool, unit>) -> bool
abstract iterateRefs: refs: ResizeArray<ReferenceCache> * cb: (ReferenceCache -> U2<bool, unit>) -> bool
abstract Keymap: KeymapStatic
/// Load MathJax.
abstract loadMathJax: unit -> Promise<unit>
/// Load Mermaid and return a promise to the global mermaid object.
/// Can also use `mermaid` after this promise resolves to get the same reference.
abstract loadMermaid: unit -> Promise<obj option>
/// Load PDF.js and return a promise to the global pdfjsLib object.
/// Can also use `window.pdfjsLib` after this promise resolves to get the same reference.
abstract loadPdfJs: unit -> Promise<obj option>
/// Load Prism.js and return a promise to the global Prism object.
/// Can also use `Prism` after this promise resolves to get the same reference.
abstract loadPrism: unit -> Promise<obj option>
abstract MarkdownEditView: MarkdownEditViewStatic
abstract MarkdownPreviewRenderer: MarkdownPreviewRendererStatic
abstract MarkdownPreviewView: MarkdownPreviewViewStatic
abstract MarkdownRenderChild: MarkdownRenderChildStatic
abstract MarkdownRenderer: MarkdownRendererStatic
abstract MarkdownSourceView: MarkdownSourceViewStatic
abstract MarkdownView: MarkdownViewStatic
abstract Menu: MenuStatic
abstract MenuItem: MenuItemStatic
abstract MetadataCache: MetadataCacheStatic
abstract Modal: ModalStatic
abstract MomentFormatComponent: MomentFormatComponentStatic
abstract normalizePath: path: string -> string
abstract Notice: NoticeStatic
abstract parseFrontMatterAliases: frontmatter: obj option option -> ResizeArray<string> option
abstract parseFrontMatterEntry: frontmatter: obj option option * key: U2<string, RegExp> -> obj option option
abstract parseFrontMatterStringArray: frontmatter: obj option option * key: U2<string, RegExp> * ?nospaces: bool -> ResizeArray<string> option
abstract parseFrontMatterTags: frontmatter: obj option option -> ResizeArray<string> option
abstract parseLinktext: linktext: string -> ParseLinktextReturn
abstract parseYaml: yaml: string -> obj option
abstract Plugin: PluginStatic
abstract PluginSettingTab: PluginSettingTabStatic
abstract PopoverSuggest: PopoverSuggestStatic
/// <summary>Construct a fuzzy search callback that runs on a target string.
/// Performance may be an issue if you are running the search for more than a few thousand times.
/// If performance is a problem, consider using `prepareSimpleSearch` instead.</summary>
/// <param name="query">- the fuzzy query.</param>
abstract prepareFuzzySearch: query: string -> (string -> SearchResult option)
abstract prepareQuery: query: string -> PreparedQuery
/// <summary>Construct a simple search callback that runs on a target string.</summary>
/// <param name="query">- the space-separated words</param>
abstract prepareSimpleSearch: query: string -> (string -> SearchResult option)
abstract renderMatches: el: U2<HTMLElement, DocumentFragment> * text: string * matches: SearchMatches option * ?offset: float -> unit
/// Render some LaTeX math using the MathJax engine. Returns an HTMLElement.
/// Requires calling `finishRenderMath` when rendering is all done to flush the MathJax stylesheet.
abstract renderMath: source: string * display: bool -> HTMLElement
abstract renderResults: el: HTMLElement * text: string * result: SearchResult * ?offset: float -> unit
/// Similar to `fetch()`, request a URL using HTTP/HTTPS, without any CORS restrictions.
/// Returns the text value of the response.
abstract request: request: RequestUrlParam -> Promise<string>
/// Similar to `fetch()`, request a URL using HTTP/HTTPS, without any CORS restrictions.
abstract requestUrl: request: RequestUrlParam -> Promise<RequestUrlResponse>
/// Returns true if the API version is equal or higher than the requested version.
/// Use this to limit functionality that require specific API versions to avoid
/// crashing on older Obsidian builds.
abstract requireApiVersion: version: string -> bool
abstract resolveSubpath: cache: CachedMetadata * subpath: string -> U2<HeadingSubpathResult, BlockSubpathResult>
abstract sanitizeHTMLToDom: html: string -> DocumentFragment
abstract Scope: ScopeStatic
abstract SearchComponent: SearchComponentStatic
/// <param name="parent">- the HTML element to insert the icon</param>
/// <param name="iconId">- the icon ID</param>
/// <param name="size">- the pixel size for width and height, defaults to 16</param>
abstract setIcon: parent: HTMLElement * iconId: string * ?size: float -> unit
abstract Setting: SettingStatic
abstract SettingTab: SettingTabStatic
abstract SliderComponent: SliderComponentStatic
abstract sortSearchResults: results: ResizeArray<SearchResultContainer> -> unit
abstract stringifyYaml: obj: obj option -> string
/// This function normalizes headings for link matching by stripping out special characters and shrinking consecutive spaces.
abstract stripHeading: heading: string -> string
abstract SuggestModal: SuggestModalStatic
abstract TAbstractFile: TAbstractFileStatic
abstract Tasks: TasksStatic
abstract TextAreaComponent: TextAreaComponentStatic
abstract TextComponent: TextComponentStatic
abstract TextFileView: TextFileViewStatic
abstract TFile: TFileStatic
abstract TFolder: TFolderStatic
abstract ToggleComponent: ToggleComponentStatic
abstract ValueComponent: ValueComponentStatic
abstract Vault: VaultStatic
abstract View: ViewStatic
abstract Workspace: WorkspaceStatic
abstract WorkspaceItem: WorkspaceItemStatic
abstract WorkspaceLeaf: WorkspaceLeafStatic
abstract WorkspaceMobileDrawer: WorkspaceMobileDrawerStatic
abstract WorkspaceParent: WorkspaceParentStatic
abstract WorkspaceRibbon: WorkspaceRibbonStatic
abstract WorkspaceSidedock: WorkspaceSidedockStatic
abstract WorkspaceSplit: WorkspaceSplitStatic
abstract WorkspaceTabs: WorkspaceTabsStatic
type [<AllowNullLiteral>] ParseLinktextReturn =
abstract path: string with get, set
abstract subpath: string with get, set
type [<AllowNullLiteral>] ObjectConstructor =
abstract each: ``object``: ObjectConstructorEachObject * callback: ('T -> string -> U2<bool, unit>) * ?context: obj -> bool
abstract assign: target: obj option * [<ParamArray>] sources: obj option -> obj option
abstract entries: obj: obj option -> ResizeArray<obj option>
type [<AllowNullLiteral>] ObjectConstructorEachObject =
[<Emit "$0[$1]{{=$2}}">] abstract Item: key: string -> obj with get, set
type [<AllowNullLiteral>] Math =
abstract clamp: value: float * min: float * max: float -> float
abstract square: value: float -> float
type [<AllowNullLiteral>] StringConstructor =
abstract isString: obj: obj option -> bool
type [<AllowNullLiteral>] String =
abstract contains: target: string -> bool
abstract startsWith: searchString: string * ?position: float -> bool
abstract endsWith: target: string * ?length: float -> bool
abstract format: [<ParamArray>] args: ResizeArray<string> -> string
type [<AllowNullLiteral>] NumberConstructor =
abstract isNumber: obj: obj option -> bool
type [<AllowNullLiteral>] Window =
inherit EventTarget
inherit GlobalEventHandlers
inherit WindowLocalStorage
inherit WindowSessionStorage
abstract isBoolean: obj: obj option -> bool
abstract fish: selector: string -> HTMLElement option
abstract fishAll: selector: string -> ResizeArray<HTMLElement>
abstract ElementList: obj option with get, set
type [<AllowNullLiteral>] Element =
inherit Node
abstract getText: unit -> string
abstract setText: ``val``: U2<string, DocumentFragment> -> unit
abstract addClass: [<ParamArray>] classes: ResizeArray<string> -> unit
abstract addClasses: classes: ResizeArray<string> -> unit
abstract removeClass: [<ParamArray>] classes: ResizeArray<string> -> unit
abstract removeClasses: classes: ResizeArray<string> -> unit
abstract toggleClass: classes: U2<string, ResizeArray<string>> * value: bool -> unit
abstract hasClass: cls: string -> bool
abstract setAttr: qualifiedName: string * value: U3<string, float, bool> option -> unit
abstract setAttrs: obj: ElementSetAttrsObj -> unit
abstract getAttr: qualifiedName: string -> string option
abstract matchParent: selector: string * ?lastParent: Element -> Element option
abstract find: selector: string -> Element option
abstract findAll: selector: string -> ResizeArray<HTMLElement>
abstract findAllSelf: selector: string -> ResizeArray<HTMLElement>
type [<AllowNullLiteral>] ElementSetAttrsObj =
[<Emit "$0[$1]{{=$2}}">] abstract Item: key: string -> U3<string, float, bool> option with get, set
type [<AllowNullLiteral>] Node =
abstract detach: unit -> unit
abstract empty: unit -> unit
abstract insertAfter: other: Node -> unit
abstract indexOf: other: Node -> float
abstract setChildrenInPlace: children: ResizeArray<Node> -> unit
abstract appendText: ``val``: string -> unit
/// Create an element and append it to this node.
abstract createEl: tag: 'K * ?o: U2<DomElementInfo, string> * ?callback: (obj -> unit) -> obj
abstract createDiv: ?o: U2<DomElementInfo, string> * ?callback: (HTMLDivElement -> unit) -> HTMLDivElement
abstract createSpan: ?o: U2<DomElementInfo, string> * ?callback: (HTMLSpanElement -> unit) -> HTMLSpanElement
type [<AllowNullLiteral>] HTMLElement =
inherit Element
abstract show: unit -> unit
abstract hide: unit -> unit
abstract toggle: show: bool -> unit
abstract toggleVisibility: visible: bool -> unit
/// Returns whether this element is shown, when the element is attached to the DOM and
/// none of the parent and ancestor elements are hidden with `display: none`.
///
/// Exception: Does not work on <body> and <html>, or on elements with `position: fixed`.
abstract isShown: unit -> bool
abstract find: selector: string -> HTMLElement
abstract findAll: selector: string -> ResizeArray<HTMLElement>
abstract findAllSelf: selector: string -> ResizeArray<HTMLElement>
abstract _EVENTS: obj option with get, set
abstract on: this: HTMLElement * ``type``: 'K * selector: string * listener: (HTMLElement -> obj -> HTMLElement -> obj option) * ?options: U2<bool, AddEventListenerOptions> -> unit
abstract off: this: HTMLElement * ``type``: 'K * selector: string * listener: (HTMLElement -> obj -> HTMLElement -> obj option) * ?options: U2<bool, AddEventListenerOptions> -> unit
abstract onClickEvent: this: HTMLElement * listener: (HTMLElement -> MouseEvent -> obj option) * ?options: U2<bool, AddEventListenerOptions> -> unit
/// <param name="listener">- the callback to call when this node is inserted into the DOM.</param>
/// <param name="once">- if true, this will only fire once and then unhook itself.</param>
abstract onNodeInserted: this: HTMLElement * listener: (unit -> obj option) * ?once: bool -> (unit -> unit)
abstract trigger: eventType: string -> unit
type [<AllowNullLiteral>] DomElementInfo =
/// The class to be assigned. Can be a space-separated string or an array of strings.
abstract cls: U2<string, ResizeArray<string>> option with get, set
/// The textContent to be assigned.
abstract text: U2<string, DocumentFragment> option with get, set
/// HTML attributes to be added.
abstract attr: DomElementInfoAttr option with get, set
/// HTML title (for hover tooltip).
abstract title: string option with get, set
/// The parent element to be assigned to.
abstract parent: Node option with get, set
abstract value: string option with get, set
abstract ``type``: string option with get, set
abstract prepend: bool option with get, set
abstract href: string option with get, set
type [<AllowNullLiteral>] Document =
abstract _EVENTS: obj option with get, set
abstract on: this: Document * ``type``: 'K * selector: string * listener: (Document -> obj -> HTMLElement -> obj option) * ?options: U2<bool, AddEventListenerOptions> -> unit
abstract off: this: Document * ``type``: 'K * selector: string * listener: (Document -> obj -> HTMLElement -> obj option) * ?options: U2<bool, AddEventListenerOptions> -> unit
type [<AllowNullLiteral>] EventListenerInfo =
abstract selector: string with get, set
abstract listener: Function with get, set
abstract options: U2<bool, AddEventListenerOptions> option with get, set
abstract callback: Function with get, set
type [<AllowNullLiteral>] AjaxOptions =
abstract ``method``: AjaxOptionsMethod option with get, set
abstract url: string with get, set
abstract success: (obj option -> XMLHttpRequest -> obj option) option with get, set
abstract error: (obj option -> XMLHttpRequest -> obj option) option with get, set
abstract data: U3<obj, string, ArrayBuffer> option with get, set
abstract headers: obj option with get, set
abstract withCredentials: bool option with get, set
abstract req: XMLHttpRequest option with get, set
type [<AllowNullLiteral>] AbstractTextComponent<'T> =
inherit ValueComponent<string>
abstract inputEl: 'T with get, set
abstract setDisabled: disabled: bool -> AbstractTextComponent<'T>
abstract getValue: unit -> string
abstract setValue: value: string -> AbstractTextComponent<'T>
abstract setPlaceholder: placeholder: string -> AbstractTextComponent<'T>
abstract onChanged: unit -> unit
abstract onChange: callback: (string -> obj option) -> AbstractTextComponent<'T>
type [<AllowNullLiteral>] AbstractTextComponentStatic =
[<Emit "new $0($1...)">] abstract Create: inputEl: 'T -> AbstractTextComponent<'T>
type [<AllowNullLiteral>] App =
abstract keymap: Keymap with get, set
abstract scope: Scope with get, set
abstract workspace: Workspace with get, set
abstract vault: Vault with get, set
abstract metadataCache: MetadataCache with get, set
abstract fileManager: FileManager with get, set
/// The last known user interaction event, to help commands find out what modifier keys are pressed.
abstract lastEvent: UserEvent option with get, set
type [<AllowNullLiteral>] AppStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> App
type [<AllowNullLiteral>] BaseComponent =
abstract disabled: bool with get, set
/// Facilitates chaining
abstract ``then``: cb: (BaseComponent -> obj option) -> BaseComponent
abstract setDisabled: disabled: bool -> BaseComponent
type [<AllowNullLiteral>] BaseComponentStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> BaseComponent
type [<AllowNullLiteral>] BlockCache =
inherit CacheItem
abstract id: string with get, set
type [<AllowNullLiteral>] BlockSubpathResult =
inherit SubpathResult
abstract ``type``: string with get, set
abstract block: BlockCache with get, set
abstract list: ListItemCache option with get, set
type [<AllowNullLiteral>] ButtonComponent =
inherit BaseComponent
abstract buttonEl: HTMLButtonElement with get, set
abstract setDisabled: disabled: bool -> ButtonComponent
abstract setCta: unit -> ButtonComponent
abstract removeCta: unit -> ButtonComponent
abstract setWarning: unit -> ButtonComponent
abstract setTooltip: tooltip: string -> ButtonComponent
abstract setButtonText: name: string -> ButtonComponent
abstract setIcon: icon: string -> ButtonComponent
abstract setClass: cls: string -> ButtonComponent
abstract onClick: callback: (MouseEvent -> obj option) -> ButtonComponent
type [<AllowNullLiteral>] ButtonComponentStatic =
[<Emit "new $0($1...)">] abstract Create: containerEl: HTMLElement -> ButtonComponent
type [<AllowNullLiteral>] CachedMetadata =
abstract links: ResizeArray<LinkCache> option with get, set
abstract embeds: ResizeArray<EmbedCache> option with get, set
abstract tags: ResizeArray<TagCache> option with get, set
abstract headings: ResizeArray<HeadingCache> option with get, set
/// Sections are root level markdown blocks, which can be used to divide the document up.
abstract sections: ResizeArray<SectionCache> option with get, set
abstract listItems: ResizeArray<ListItemCache> option with get, set
abstract frontmatter: FrontMatterCache option with get, set
abstract blocks: obj option with get, set
type [<AllowNullLiteral>] CacheItem =
abstract position: Pos with get, set
type [<AllowNullLiteral>] CloseableComponent =
abstract close: unit -> obj option
type [<AllowNullLiteral>] Command =
/// Globally unique ID to identify this command.
abstract id: string with get, set
/// Human friendly name for searching.
abstract name: string with get, set
/// Icon ID to be used in the toolbar.
abstract icon: string option with get, set
abstract mobileOnly: bool option with get, set
/// Simple callback, triggered globally.
abstract callback: (unit -> obj option) option with get, set
/// Complex callback, overrides the simple callback.
/// Used to "check" whether your command can be performed in the current circumstances.
/// For example, if your command requires the active focused pane to be a MarkdownSourceView, then
/// you should only return true if the condition is satisfied. Returning false or undefined causes
/// the command to be hidden from the command palette.
abstract checkCallback: (bool -> U2<bool, unit>) option with get, set
/// A command callback that is only triggered when the user is in an editor.
/// Overrides `callback` and `checkCallback`
abstract editorCallback: (Editor -> MarkdownView -> obj option) option with get, set
/// A command callback that is only triggered when the user is in an editor.
/// Overrides `editorCallback`, `callback` and `checkCallback`
abstract editorCheckCallback: (bool -> Editor -> MarkdownView -> U2<bool, unit>) option with get, set
/// Sets the default hotkey. It is recommended for plugins to avoid setting default hotkeys if possible,
/// to avoid conflicting hotkeys with one that's set by the user, even though customized hotkeys have higher priority.
abstract hotkeys: ResizeArray<Hotkey> option with get, set
type [<AllowNullLiteral>] Component =
/// Load this component and its children
abstract load: unit -> unit
/// Override this to load your component
abstract onload: unit -> unit
/// Unload this component and its children
abstract unload: unit -> unit
/// Override this to unload your component
abstract onunload: unit -> unit
/// Adds a child component, loading it if this component is loaded
abstract addChild: ``component``: 'T -> 'T
/// Removes a child component, unloading it
abstract removeChild: ``component``: 'T -> 'T
/// Registers a callback to be called when unloading
abstract register: cb: (unit -> obj option) -> unit
/// Registers an event to be detached when unloading
abstract registerEvent: eventRef: EventRef -> unit
/// Registers an DOM event to be detached when unloading
abstract registerDomEvent: el: HTMLElement * ``type``: 'K * callback: (HTMLElement -> obj -> obj option) -> unit
/// Registers an key event to be detached when unloading
abstract registerScopeEvent: keyHandler: KeymapEventHandler -> unit
/// Registers an interval (from setInterval) to be cancelled when unloading
/// Use {@link window.setInterval} instead of {@link setInterval} to avoid TypeScript confusing between NodeJS vs Browser API
abstract registerInterval: id: float -> float
type [<AllowNullLiteral>] ComponentStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> Component
type [<AllowNullLiteral>] Constructor<'T> =
interface end
type [<AllowNullLiteral>] ConstructorStatic =
[<Emit "new $0($1...)">] abstract Create: [<ParamArray>] args: ResizeArray<obj option> -> Constructor<'T>
type [<AllowNullLiteral>] DataAdapter =
abstract getName: unit -> string
abstract exists: normalizedPath: string * ?sensitive: bool -> Promise<bool>
abstract stat: normalizedPath: string -> Promise<Stat option>
abstract list: normalizedPath: string -> Promise<ListedFiles>
abstract read: normalizedPath: string -> Promise<string>
abstract readBinary: normalizedPath: string -> Promise<ArrayBuffer>
abstract write: normalizedPath: string * data: string * ?options: DataWriteOptions -> Promise<unit>
abstract writeBinary: normalizedPath: string * data: ArrayBuffer * ?options: DataWriteOptions -> Promise<unit>
abstract append: normalizedPath: string * data: string * ?options: DataWriteOptions -> Promise<unit>
abstract getResourcePath: normalizedPath: string -> string
abstract mkdir: normalizedPath: string -> Promise<unit>
abstract trashSystem: normalizedPath: string -> Promise<bool>
abstract trashLocal: normalizedPath: string -> Promise<unit>
abstract rmdir: normalizedPath: string * recursive: bool -> Promise<unit>
abstract remove: normalizedPath: string -> Promise<unit>
abstract rename: normalizedPath: string * normalizedNewPath: string -> Promise<unit>
abstract copy: normalizedPath: string * normalizedNewPath: string -> Promise<unit>
type [<AllowNullLiteral>] DataWriteOptions =
abstract ctime: float option with get, set
abstract mtime: float option with get, set
type [<AllowNullLiteral>] Debouncer<'T> =
[<Emit "$0($1...)">] abstract Invoke: [<ParamArray>] args: obj -> unit
abstract cancel: unit -> Debouncer<'T>
type [<AllowNullLiteral>] DropdownComponent =
inherit ValueComponent<string>
abstract selectEl: HTMLSelectElement with get, set
abstract setDisabled: disabled: bool -> DropdownComponent
abstract addOption: value: string * display: string -> DropdownComponent
abstract addOptions: options: obj -> DropdownComponent
abstract getValue: unit -> string
abstract setValue: value: string -> DropdownComponent
abstract onChange: callback: (string -> obj option) -> DropdownComponent
type [<AllowNullLiteral>] DropdownComponentStatic =
[<Emit "new $0($1...)">] abstract Create: containerEl: HTMLElement -> DropdownComponent
type [<AllowNullLiteral>] EditableFileView =
inherit FileView
type [<AllowNullLiteral>] EditableFileViewStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> EditableFileView
/// A common interface that bridges the gap between CodeMirror 5 and CodeMirror 6.
type [<AllowNullLiteral>] Editor =
abstract getDoc: unit -> Editor
abstract refresh: unit -> unit
abstract getValue: unit -> string
abstract setValue: content: string -> unit
/// Get the text at line (0-indexed)
abstract getLine: line: float -> string
abstract setLine: n: float * text: string -> unit
/// Gets the number of lines in the document
abstract lineCount: unit -> float
abstract lastLine: unit -> float
abstract getSelection: unit -> string
abstract somethingSelected: unit -> bool
abstract getRange: from: EditorPosition * ``to``: EditorPosition -> string
abstract replaceSelection: replacement: string * ?origin: string -> unit
abstract replaceRange: replacement: string * from: EditorPosition * ?``to``: EditorPosition * ?origin: string -> unit
abstract getCursor: ?string: EditorGetCursorString -> EditorPosition
abstract listSelections: unit -> ResizeArray<EditorSelection>
abstract setCursor: pos: U2<EditorPosition, float> * ?ch: float -> unit
abstract setSelection: anchor: EditorPosition * ?head: EditorPosition -> unit
abstract setSelections: ranges: ResizeArray<EditorSelectionOrCaret> * ?main: float -> unit
abstract focus: unit -> unit
abstract blur: unit -> unit
abstract hasFocus: unit -> bool
abstract getScrollInfo: unit -> EditorGetScrollInfoReturn
abstract scrollTo: ?x: float * ?y: float -> unit
abstract scrollIntoView: range: EditorRange * ?center: bool -> unit
abstract undo: unit -> unit
abstract redo: unit -> unit
abstract exec: command: EditorCommandName -> unit
abstract transaction: tx: EditorTransaction * ?origin: string -> unit
abstract wordAt: pos: EditorPosition -> EditorRange option
abstract posToOffset: pos: EditorPosition -> float
abstract offsetToPos: offset: float -> EditorPosition
abstract processLines: read: (float -> string -> 'T option) * write: (float -> string -> 'T option -> U2<EditorChange, unit>) * ?ignoreEmpty: bool -> unit
type [<StringEnum>] [<RequireQualifiedAccess>] EditorGetCursorString =
| From
| To
| Head
| Anchor
type [<AllowNullLiteral>] EditorGetScrollInfoReturn =
abstract top: float with get, set
abstract left: float with get, set
/// A common interface that bridges the gap between CodeMirror 5 and CodeMirror 6.
type [<AllowNullLiteral>] EditorStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> Editor
type [<AllowNullLiteral>] EditorChange =
inherit EditorRangeOrCaret
abstract text: string with get, set
type [<StringEnum>] [<RequireQualifiedAccess>] EditorCommandName =
| GoUp
| GoDown
| GoLeft
| GoRight
| GoStart
| GoEnd
| IndentMore
| IndentLess
| NewlineAndIndent
| SwapLineUp
| SwapLineDown
| DeleteLine
| ToggleFold
| FoldAll
| UnfoldAll
type [<AllowNullLiteral>] EditorPosition =
abstract line: float with get, set
abstract ch: float with get, set
type [<AllowNullLiteral>] EditorRange =
abstract from: EditorPosition with get, set
abstract ``to``: EditorPosition with get, set
type [<AllowNullLiteral>] EditorRangeOrCaret =
abstract from: EditorPosition with get, set
abstract ``to``: EditorPosition option with get, set
type [<AllowNullLiteral>] EditorSelection =
abstract anchor: EditorPosition with get, set
abstract head: EditorPosition with get, set
type [<AllowNullLiteral>] EditorSelectionOrCaret =
abstract anchor: EditorPosition with get, set
abstract head: EditorPosition option with get, set
type [<AllowNullLiteral>] EditorSuggest<'T> =
inherit PopoverSuggest<'T>
/// Current suggestion context, containing the result of `onTrigger`.
/// This will be null any time the EditorSuggest is not supposed to run.
abstract context: EditorSuggestContext option with get, set
/// Override this to use a different limit for suggestion items
abstract limit: float with get, set
abstract setInstructions: instructions: ResizeArray<Instruction> -> unit
/// Based on the editor line and cursor position, determine if this EditorSuggest should be triggered at this moment.
/// Typically, you would run a regular expression on the current line text before the cursor.
/// Return null to indicate that this editor suggest is not supposed to be triggered.
///
/// Please be mindful of performance when implementing this function, as it will be triggered very often (on each keypress).
/// Keep it simple, and return null as early as possible if you determine that it is not the right time.
abstract onTrigger: cursor: EditorPosition * editor: Editor * file: TFile -> EditorSuggestTriggerInfo option
/// Generate suggestion items based on this context. Can be async, but preferably sync.
/// When generating async suggestions, you should pass the context along.
abstract getSuggestions: context: EditorSuggestContext -> U2<ResizeArray<'T>, Promise<ResizeArray<'T>>>
type [<AllowNullLiteral>] EditorSuggestStatic =
[<Emit "new $0($1...)">] abstract Create: app: App -> EditorSuggest<'T>
type [<AllowNullLiteral>] EditorSuggestContext =
inherit EditorSuggestTriggerInfo
abstract editor: Editor with get, set
abstract file: TFile with get, set
type [<AllowNullLiteral>] EditorSuggestTriggerInfo =
/// The start position of the triggering text. This is used to position the popover.
abstract start: EditorPosition with get, set
/// The end position of the triggering text. This is used to position the popover.
abstract ``end``: EditorPosition with get, set
/// They query string (usually the text between start and end) that will be used to generate the suggestion content.
abstract query: string with get, set
type [<AllowNullLiteral>] EditorTransaction =
abstract replaceSelection: string option with get, set
abstract changes: ResizeArray<EditorChange> option with get, set
/// Multiple selections, overrides `selection`.
abstract selections: ResizeArray<EditorRangeOrCaret> option with get, set
abstract selection: EditorRangeOrCaret option with get, set
type [<AllowNullLiteral>] EmbedCache =
inherit ReferenceCache
type [<AllowNullLiteral>] EventRef =
interface end
type [<AllowNullLiteral>] Events =
abstract on: name: string * callback: (obj option -> obj option) * ?ctx: obj -> EventRef
abstract off: name: string * callback: (obj option -> obj option) -> unit
abstract offref: ref: EventRef -> unit
abstract trigger: name: string * [<ParamArray>] data: ResizeArray<obj option> -> unit
abstract tryTrigger: evt: EventRef * args: ResizeArray<obj option> -> unit
type [<AllowNullLiteral>] EventsStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> Events
type [<AllowNullLiteral>] ExtraButtonComponent =
inherit BaseComponent
abstract extraSettingsEl: HTMLElement with get, set
abstract setDisabled: disabled: bool -> ExtraButtonComponent
abstract setTooltip: tooltip: string -> ExtraButtonComponent
abstract setIcon: icon: string -> ExtraButtonComponent
abstract onClick: callback: (unit -> obj option) -> ExtraButtonComponent
type [<AllowNullLiteral>] ExtraButtonComponentStatic =
[<Emit "new $0($1...)">] abstract Create: containerEl: HTMLElement -> ExtraButtonComponent
/// Manage the creation, deletion and renaming of files from the UI.
type [<AllowNullLiteral>] FileManager =
/// <summary>Gets the folder that new files should be saved to, given the user's preferences.</summary>
/// <param name="sourcePath">- The path to the current open/focused file,
/// used when the user wants new files to be created "in the same folder".
/// Use an empty string if there is no active file.</param>
abstract getNewFileParent: sourcePath: string -> TFolder
/// <summary>Rename or move a file safely, and update all links to it depending on the user's preferences.</summary>
/// <param name="file">- the file to rename</param>
/// <param name="newPath">- the new path for the file</param>
abstract renameFile: file: TAbstractFile * newPath: string -> Promise<unit>
/// <summary>Generate a markdown link based on the user's preferences.</summary>
/// <param name="file">- the file to link to.</param>
/// <param name="sourcePath">- where the link is stored in, used to compute relative links.</param>
/// <param name="subpath">- A subpath, starting with `#`, used for linking to headings or blocks.</param>
/// <param name="alias">- The display text if it's to be different than the file name. Pass empty string to use file name.</param>
abstract generateMarkdownLink: file: TFile * sourcePath: string * ?subpath: string * ?alias: string -> string
/// Manage the creation, deletion and renaming of files from the UI.
type [<AllowNullLiteral>] FileManagerStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> FileManager
type [<AllowNullLiteral>] FileStats =
abstract ctime: float with get, set
abstract mtime: float with get, set
abstract size: float with get, set
type [<AllowNullLiteral>] FileSystemAdapter =
inherit DataAdapter
abstract getName: unit -> string
abstract getBasePath: unit -> string
abstract mkdir: normalizedPath: string -> Promise<unit>
abstract trashSystem: normalizedPath: string -> Promise<bool>
abstract trashLocal: normalizedPath: string -> Promise<unit>
abstract rmdir: normalizedPath: string * recursive: bool -> Promise<unit>
abstract read: normalizedPath: string -> Promise<string>
abstract readBinary: normalizedPath: string -> Promise<ArrayBuffer>
abstract write: normalizedPath: string * data: string * ?options: DataWriteOptions -> Promise<unit>
abstract writeBinary: normalizedPath: string * data: ArrayBuffer * ?options: DataWriteOptions -> Promise<unit>
abstract append: normalizedPath: string * data: string * ?options: DataWriteOptions -> Promise<unit>
abstract getResourcePath: normalizedPath: string -> string
abstract remove: normalizedPath: string -> Promise<unit>
abstract rename: normalizedPath: string * normalizedNewPath: string -> Promise<unit>
abstract copy: normalizedPath: string * normalizedNewPath: string -> Promise<unit>
abstract exists: normalizedPath: string * ?sensitive: bool -> Promise<bool>
abstract stat: normalizedPath: string -> Promise<Stat option>
abstract list: normalizedPath: string -> Promise<ListedFiles>
abstract getFullPath: normalizedPath: string -> string
type [<AllowNullLiteral>] FileSystemAdapterStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> FileSystemAdapter
abstract readLocalFile: path: string -> Promise<ArrayBuffer>
abstract mkdir: path: string -> Promise<unit>
type [<AllowNullLiteral>] FileView =
inherit ItemView
abstract allowNoFile: bool with get, set
abstract file: TFile with get, set
abstract getDisplayText: unit -> string
/// Override this to load your component
abstract onload: unit -> unit
abstract getState: unit -> obj option
abstract setState: state: obj option * result: ViewStateResult -> Promise<unit>
abstract onLoadFile: file: TFile -> Promise<unit>
abstract onUnloadFile: file: TFile -> Promise<unit>
abstract onMoreOptionsMenu: menu: Menu -> unit
abstract onHeaderMenu: menu: Menu -> unit
abstract canAcceptExtension: extension: string -> bool
type [<AllowNullLiteral>] FileViewStatic =
[<Emit "new $0($1...)">] abstract Create: leaf: WorkspaceLeaf -> FileView
type [<AllowNullLiteral>] FrontMatterCache =
inherit CacheItem
[<Emit "$0[$1]{{=$2}}">] abstract Item: key: string -> obj option with get, set
type [<AllowNullLiteral>] FuzzyMatch<'T> =
abstract item: 'T with get, set
abstract ``match``: SearchResult with get, set
type [<AllowNullLiteral>] FuzzySuggestModal<'T> =
inherit SuggestModal<FuzzyMatch<'T>>
abstract getSuggestions: query: string -> ResizeArray<FuzzyMatch<'T>>
/// Render the suggestion item into DOM.
abstract renderSuggestion: item: FuzzyMatch<'T> * el: HTMLElement -> unit
abstract onChooseSuggestion: item: FuzzyMatch<'T> * evt: U2<MouseEvent, KeyboardEvent> -> unit
abstract getItems: unit -> ResizeArray<'T>
abstract getItemText: item: 'T -> string
abstract onChooseItem: item: 'T * evt: U2<MouseEvent, KeyboardEvent> -> unit
type [<AllowNullLiteral>] FuzzySuggestModalStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> FuzzySuggestModal<'T>
type [<AllowNullLiteral>] HeadingCache =
inherit CacheItem
abstract heading: string with get, set
abstract level: float with get, set
type [<AllowNullLiteral>] HeadingSubpathResult =
inherit SubpathResult
abstract ``type``: string with get, set
abstract current: HeadingCache with get, set
abstract next: HeadingCache with get, set
type [<AllowNullLiteral>] Hotkey =
abstract modifiers: ResizeArray<Modifier> with get, set
abstract key: string with get, set
type [<AllowNullLiteral>] HoverParent =
abstract hoverPopover: HoverPopover option with get, set
type [<AllowNullLiteral>] HoverPopover =
inherit Component
abstract state: obj with get, set
type [<AllowNullLiteral>] HoverPopoverStatic =
[<Emit "new $0($1...)">] abstract Create: parent: HoverParent * targetEl: HTMLElement option * ?waitTime: float -> HoverPopover
type [<AllowNullLiteral>] Instruction =
abstract command: string with get, set
abstract purpose: string with get, set
type [<AllowNullLiteral>] ISuggestOwner<'T> =
/// Render the suggestion item into DOM.
abstract renderSuggestion: value: 'T * el: HTMLElement -> unit
/// Called when the user makes a selection.
abstract selectSuggestion: value: 'T * evt: U2<MouseEvent, KeyboardEvent> -> unit
type [<AllowNullLiteral>] ItemView =
inherit View
abstract contentEl: HTMLElement with get, set
abstract onMoreOptionsMenu: menu: Menu -> unit
abstract addAction: icon: string * title: string * callback: (MouseEvent -> obj option) * ?size: float -> HTMLElement
abstract onHeaderMenu: menu: Menu -> unit
type [<AllowNullLiteral>] ItemViewStatic =
[<Emit "new $0($1...)">] abstract Create: leaf: WorkspaceLeaf -> ItemView
type [<AllowNullLiteral>] Keymap =
abstract pushScope: scope: Scope -> unit
abstract popScope: scope: Scope -> unit
type [<AllowNullLiteral>] KeymapStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> Keymap
/// Checks whether the modifier key is pressed during this event
abstract isModifier: evt: U3<MouseEvent, TouchEvent, KeyboardEvent> * modifier: Modifier -> bool
/// Returns true if the modifier key Cmd/Ctrl is pressed OR if this is a middle-click MouseEvent.
abstract isModEvent: ?evt: UserEvent -> bool
type [<AllowNullLiteral>] KeymapContext =
inherit KeymapInfo
abstract vkey: string with get, set
type [<AllowNullLiteral>] KeymapEventHandler =
inherit KeymapInfo
abstract scope: Scope with get, set
type [<AllowNullLiteral>] KeymapEventListener =
[<Emit "$0($1...)">] abstract Invoke: evt: KeyboardEvent * ctx: KeymapContext -> U2<bool, unit>
type [<AllowNullLiteral>] KeymapInfo =
abstract modifiers: string option with get, set
abstract key: string option with get, set
type [<AllowNullLiteral>] LinkCache =
inherit ReferenceCache
type [<AllowNullLiteral>] ListedFiles =
abstract files: ResizeArray<string> with get, set
abstract folders: ResizeArray<string> with get, set
type [<AllowNullLiteral>] ListItemCache =
inherit CacheItem
/// The block ID of this list item, if defined.
abstract id: string option with get, set
/// A single character indicating the checked status of a task.
/// The space character `' '` is interpreted as an incomplete task.
/// An other character is interpreted as completed task.
/// `undefined` if this item isn't a task.
abstract task: string option with get, set
/// Line number of the parent list item (position.start.line).
/// If this item has no parent (e.g. it's a root level list),
/// then this value is the negative of the line number of the first list item (start of the list).
///
/// Can be used to deduce which list items belongs to the same group (item1.parent === item2.parent).
/// Can be used to reconstruct hierarchy information (parentItem.position.start.line === childItem.parent).
abstract parent: float with get, set
type [<AllowNullLiteral>] Loc =
abstract line: float with get, set
abstract col: float with get, set
abstract offset: float with get, set
/// This is the editor for Obsidian Mobile as well as the upcoming WYSIWYG editor.
type [<AllowNullLiteral>] MarkdownEditView =
inherit MarkdownSubView
inherit HoverParent
abstract hoverPopover: HoverPopover with get, set
abstract clear: unit -> unit
abstract get: unit -> string
abstract set: data: string * clear: bool -> unit
abstract getSelection: unit -> string
abstract getScroll: unit -> float
abstract applyScroll: scroll: float -> unit
/// This is the editor for Obsidian Mobile as well as the upcoming WYSIWYG editor.
type [<AllowNullLiteral>] MarkdownEditViewStatic =
[<Emit "new $0($1...)">] abstract Create: view: MarkdownView -> MarkdownEditView
/// A post processor receives an element which is a section of the preview.
///
/// Post processors can mutate the DOM to render various things, such as mermaid graphs, latex equations, or custom controls.
///
/// If your post processor requires lifecycle management, for example, to clear an interval, kill a subprocess, etc when this element is
/// removed from the app, look into {@link MarkdownPostProcessorContext#addChild}
type [<AllowNullLiteral>] MarkdownPostProcessor =
/// The processor function itself.
[<Emit "$0($1...)">] abstract Invoke: el: HTMLElement * ctx: MarkdownPostProcessorContext -> U2<Promise<obj option>, unit>
/// An optional integer sort order. Defaults to 0. Lower number runs before higher numbers.
abstract sortOrder: float option with get, set
type [<AllowNullLiteral>] MarkdownPostProcessorContext =
abstract docId: string with get, set
abstract sourcePath: string with get, set
abstract frontmatter: obj option option with get, set
/// Adds a child component that will have its lifecycle managed by the renderer.
///
/// Use this to add a dependent child to the renderer such that if the containerEl
/// of the child is ever removed, the component's unload will be called.
abstract addChild: child: MarkdownRenderChild -> unit
/// Gets the section information of this element at this point in time.
/// Only call this function right before you need this information to get the most up-to-date version.
/// This function may also return null in many circumstances; if you use it, you must be prepared to deal with nulls.
abstract getSectionInfo: el: HTMLElement -> MarkdownSectionInformation option
type [<AllowNullLiteral>] MarkdownPreviewEvents =
inherit Component
type [<AllowNullLiteral>] MarkdownPreviewRenderer =
interface end
type [<AllowNullLiteral>] MarkdownPreviewRendererStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> MarkdownPreviewRenderer
abstract registerPostProcessor: postProcessor: MarkdownPostProcessor * ?sortOrder: float -> unit
abstract unregisterPostProcessor: postProcessor: MarkdownPostProcessor -> unit
abstract createCodeBlockPostProcessor: language: string * handler: (string -> HTMLElement -> MarkdownPostProcessorContext -> U2<Promise<obj option>, unit>) -> (HTMLElement -> MarkdownPostProcessorContext -> unit)
type [<AllowNullLiteral>] MarkdownPreviewView =
inherit MarkdownRenderer
inherit MarkdownSubView
inherit MarkdownPreviewEvents
abstract containerEl: HTMLElement with get, set
abstract get: unit -> string
abstract set: data: string * clear: bool -> unit
abstract clear: unit -> unit
abstract rerender: ?full: bool -> unit
abstract getScroll: unit -> float
abstract applyScroll: scroll: float -> unit
type [<AllowNullLiteral>] MarkdownPreviewViewStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> MarkdownPreviewView
type [<AllowNullLiteral>] MarkdownRenderChild =
inherit Component
abstract containerEl: HTMLElement with get, set
type [<AllowNullLiteral>] MarkdownRenderChildStatic =
/// <param name="containerEl">- This HTMLElement will be used to test whether this component is still alive.
/// It should be a child of the markdown preview sections, and when it's no longer attached
/// (for example, when it is replaced with a new version because the user edited the markdown source code),
/// this component will be unloaded.</param>
[<Emit "new $0($1...)">] abstract Create: containerEl: HTMLElement -> MarkdownRenderChild
type [<AllowNullLiteral>] MarkdownRenderer =
inherit MarkdownRenderChild
inherit MarkdownPreviewEvents
inherit HoverParent
abstract hoverPopover: HoverPopover with get, set
type [<AllowNullLiteral>] MarkdownRendererStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> MarkdownRenderer
/// <summary>Renders markdown string to an HTML element.</summary>
/// <param name="markdown">- The markdown source code</param>
/// <param name="el">- The element to append to</param>
/// <param name="sourcePath">- The normalized path of this markdown file, used to resolve relative internal links</param>
/// <param name="component">- A parent component to manage the lifecycle of the rendered child components, if any</param>
abstract renderMarkdown: markdown: string * el: HTMLElement * sourcePath: string * ``component``: Component -> Promise<unit>
type [<AllowNullLiteral>] MarkdownSectionInformation =
abstract text: string with get, set
abstract lineStart: float with get, set
abstract lineEnd: float with get, set
type [<AllowNullLiteral>] MarkdownSourceView =
inherit MarkdownSubView
inherit HoverParent
abstract cmEditor: obj with get, set
abstract hoverPopover: HoverPopover with get, set
abstract clear: unit -> unit
abstract get: unit -> string
abstract set: data: string * clear: bool -> unit
abstract getSelection: unit -> string
abstract getScroll: unit -> float
abstract applyScroll: scroll: float -> unit
type [<AllowNullLiteral>] MarkdownSourceViewStatic =
[<Emit "new $0($1...)">] abstract Create: view: MarkdownView -> MarkdownSourceView
type [<AllowNullLiteral>] MarkdownSubView =
abstract getScroll: unit -> float
abstract applyScroll: scroll: float -> unit
abstract get: unit -> string
abstract set: data: string * clear: bool -> unit
type [<AllowNullLiteral>] MarkdownView =
inherit TextFileView
abstract editor: Editor with get, set
abstract previewMode: MarkdownPreviewView with get, set
abstract currentMode: MarkdownSubView with get, set
abstract getViewType: unit -> string
abstract getMode: unit -> MarkdownViewModeType
/// Gets the data from the editor. This will be called to save the editor contents to the file.
abstract getViewData: unit -> string
/// Clear the editor. This is usually called when we're about to open a completely
/// different file, so it's best to clear any editor states like undo-redo history,
/// and any caches/indexes associated with the previous file contents.
abstract clear: unit -> unit
/// Set the data to the editor. This is used to load the file contents.
///
/// If clear is set, then it means we're opening a completely different file.
/// In that case, you should call clear(), or implement a slightly more efficient
/// clearing mechanism given the new data to be set.
abstract setViewData: data: string * clear: bool -> unit
abstract showSearch: ?replace: bool -> unit
type [<AllowNullLiteral>] MarkdownViewStatic =
[<Emit "new $0($1...)">] abstract Create: leaf: WorkspaceLeaf -> MarkdownView
type [<StringEnum>] [<RequireQualifiedAccess>] MarkdownViewModeType =
| Source
| Preview
type [<AllowNullLiteral>] Menu =
inherit Component
abstract setNoIcon: unit -> Menu
abstract addItem: cb: (MenuItem -> obj option) -> Menu
abstract addSeparator: unit -> Menu
abstract showAtMouseEvent: evt: MouseEvent -> Menu
abstract showAtPosition: position: Point -> Menu
abstract hide: unit -> Menu
abstract onHide: callback: (unit -> obj option) -> unit
type [<AllowNullLiteral>] MenuStatic =
[<Emit "new $0($1...)">] abstract Create: app: App -> Menu
type [<AllowNullLiteral>] MenuItem =
abstract setTitle: title: U2<string, DocumentFragment> -> MenuItem
abstract setIcon: icon: string option * ?size: float -> MenuItem
abstract setActive: active: bool -> MenuItem
abstract setDisabled: disabled: bool -> MenuItem
abstract setIsLabel: isLabel: bool -> MenuItem
abstract onClick: callback: (U2<MouseEvent, KeyboardEvent> -> obj option) -> MenuItem
type [<AllowNullLiteral>] MenuItemStatic =
[<Emit "new $0($1...)">] abstract Create: menu: Menu -> MenuItem
/// Linktext is any internal link that is composed of a path and a subpath, such as "My note#Heading"
/// Linkpath (or path) is the path part of a linktext
/// Subpath is the heading/block ID part of a linktext.
type [<AllowNullLiteral>] MetadataCache =
inherit Events
/// Get the best match for a linkpath.
abstract getFirstLinkpathDest: linkpath: string * sourcePath: string -> TFile option
abstract getFileCache: file: TFile -> CachedMetadata option
abstract getCache: path: string -> CachedMetadata
/// Generates a linktext for a file.
///
/// If file name is unique, use the filename.
/// If not unique, use full path.
abstract fileToLinktext: file: TFile * sourcePath: string * ?omitMdExtension: bool -> string
/// Contains all resolved links. This object maps each source file's path to an object of destination file paths with the link count.
/// Source and destination paths are all vault absolute paths that comes from `TFile.path` and can be used with `Vault.getAbstractFileByPath(path)`.
abstract resolvedLinks: obj with get, set
/// Contains all unresolved links. This object maps each source file to an object of unknown destinations with count.
/// Source paths are all vault absolute paths, similar to `resolvedLinks`.
abstract unresolvedLinks: obj with get, set
/// Called when a file has been indexed, and its (updated) cache is now available.
[<Emit "$0.on('changed',$1,$2)">] abstract on_changed: callback: (TFile -> string -> CachedMetadata -> obj option) * ?ctx: obj -> EventRef
/// Called when a file has been deleted. A best-effort previous version of the cached metadata is presented,
/// but it could be null in case the file was not successfully cached previously.
[<Emit "$0.on('deleted',$1,$2)">] abstract on_deleted: callback: (TFile -> CachedMetadata option -> obj option) * ?ctx: obj -> EventRef
/// Called when a file has been resolved for `resolvedLinks` and `unresolvedLinks`.
/// This happens sometimes after a file has been indexed.
[<Emit "$0.on('resolve',$1,$2)">] abstract on_resolve: callback: (TFile -> obj option) * ?ctx: obj -> EventRef
/// Called when all files has been resolved. This will be fired each time files get modified after the initial load.
[<Emit "$0.on('resolved',$1,$2)">] abstract on_resolved: callback: (unit -> obj option) * ?ctx: obj -> EventRef
/// Linktext is any internal link that is composed of a path and a subpath, such as "My note#Heading"
/// Linkpath (or path) is the path part of a linktext
/// Subpath is the heading/block ID part of a linktext.
type [<AllowNullLiteral>] MetadataCacheStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> MetadataCache
type [<AllowNullLiteral>] Modal =
inherit CloseableComponent
abstract app: App with get, set
abstract scope: Scope with get, set
abstract containerEl: HTMLElement with get, set
abstract modalEl: HTMLElement with get, set
abstract titleEl: HTMLElement with get, set
abstract contentEl: HTMLElement with get, set
abstract shouldRestoreSelection: bool with get, set
abstract ``open``: unit -> unit
abstract close: unit -> unit
abstract onOpen: unit -> unit
abstract onClose: unit -> unit
type [<AllowNullLiteral>] ModalStatic =
[<Emit "new $0($1...)">] abstract Create: app: App -> Modal
type [<StringEnum>] [<RequireQualifiedAccess>] Modifier =
| [<CompiledName "Mod">] Mod
| [<CompiledName "Ctrl">] Ctrl
| [<CompiledName "Meta">] Meta
| [<CompiledName "Shift">] Shift
| [<CompiledName "Alt">] Alt
type [<AllowNullLiteral>] MomentFormatComponent =
inherit TextComponent
abstract sampleEl: HTMLElement with get, set
/// Sets the default format when input is cleared. Also used for placeholder.
abstract setDefaultFormat: defaultFormat: string -> MomentFormatComponent
abstract setSampleEl: sampleEl: HTMLElement -> MomentFormatComponent
abstract setValue: value: string -> MomentFormatComponent
abstract onChanged: unit -> unit
abstract updateSample: unit -> unit
type [<AllowNullLiteral>] MomentFormatComponentStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> MomentFormatComponent
type [<AllowNullLiteral>] Notice =
/// Change the message of this notice.
abstract setMessage: message: U2<string, DocumentFragment> -> Notice
abstract hide: unit -> unit
type [<AllowNullLiteral>] NoticeStatic =
[<Emit "new $0($1...)">] abstract Create: message: U2<string, DocumentFragment> * ?timeout: float -> Notice
type [<AllowNullLiteral>] ObsidianProtocolData =
abstract action: string with get, set
[<Emit "$0[$1]{{=$2}}">] abstract Item: key: string -> string with get, set
type [<AllowNullLiteral>] ObsidianProtocolHandler =
[<Emit "$0($1...)">] abstract Invoke: ``params``: ObsidianProtocolData -> obj option
type [<AllowNullLiteral>] OpenViewState =
interface end
type [<AllowNullLiteral>] Plugin =
inherit Component
abstract app: App with get, set
abstract manifest: PluginManifest with get, set
/// <summary>Adds a ribbon icon to the left bar.</summary>
/// <param name="icon">- The icon name to be used. See {@link addIcon}</param>
/// <param name="title">- The title to be displayed in the tooltip.</param>
/// <param name="callback">- The `click` callback.</param>
abstract addRibbonIcon: icon: string * title: string * callback: (MouseEvent -> obj option) -> HTMLElement
abstract addStatusBarItem: unit -> HTMLElement
/// Register a command globally. The command id and name will be automatically prefixed with this plugin's id and name.
abstract addCommand: command: Command -> Command
abstract addSettingTab: settingTab: PluginSettingTab -> unit
abstract registerView: ``type``: string * viewCreator: ViewCreator -> unit
abstract registerExtensions: extensions: ResizeArray<string> * viewType: string -> unit
abstract registerMarkdownPostProcessor: postProcessor: MarkdownPostProcessor * ?sortOrder: float -> MarkdownPostProcessor
/// Register a special post processor that handles fenced code given a language and a handler.
/// This special post processor takes care of removing the <pre><code> and create a <div> that
/// will be passed to your handler, and is expected to be filled with your custom elements.
abstract registerMarkdownCodeBlockProcessor: language: string * handler: (string -> HTMLElement -> MarkdownPostProcessorContext -> U2<Promise<obj option>, unit>) * ?sortOrder: float -> MarkdownPostProcessor
/// Runs callback on all currently loaded instances of CodeMirror,
/// then registers the callback for all future CodeMirror instances.
abstract registerCodeMirror: callback: (obj -> obj option) -> unit
/// <summary>Registers a CodeMirror 6 extension.
/// To reconfigure cm6 extensions for your plugin on the fly, you can pass an array here and dynamically
/// modify it. Once this array is modified, call `Workspace.updateOptions()` to have the changes applied.</summary>
/// <param name="extension">- must be a CodeMirror 6 `Extension`, or an array of Extensions.</param>
abstract registerEditorExtension: extension: obj -> unit
/// <summary>Register a handler for obsidian:// URLs.</summary>
/// <param name="action">- the action string. For example, "open" corresponds to `obsidian://open`.</param>
/// <param name="handler">- the callback to trigger. You will be passed the key-value pair that is decoded from the query.
/// For example, `obsidian://open?key=value` would generate `{"action": "open", "key": "value"}`.</param>
abstract registerObsidianProtocolHandler: action: string * handler: ObsidianProtocolHandler -> unit
/// Register an EditorSuggest which can provide live suggestions while the user is typing.
abstract registerEditorSuggest: editorSuggest: EditorSuggest<obj option> -> unit
abstract loadData: unit -> Promise<obj option>
abstract saveData: data: obj option -> Promise<unit>
type [<AllowNullLiteral>] PluginStatic =
[<Emit "new $0($1...)">] abstract Create: app: App * manifest: PluginManifest -> Plugin
type [<AllowNullLiteral>] PluginManifest =
abstract dir: string option with get, set
abstract id: string with get, set
abstract name: string with get, set
abstract author: string with get, set
abstract version: string with get, set
abstract minAppVersion: string with get, set
abstract description: string with get, set
abstract authorUrl: string option with get, set
abstract isDesktopOnly: bool option with get, set
type [<AllowNullLiteral>] PluginSettingTab =
inherit SettingTab
type [<AllowNullLiteral>] PluginSettingTabStatic =
[<Emit "new $0($1...)">] abstract Create: app: App * plugin: Plugin -> PluginSettingTab
type [<AllowNullLiteral>] Point =
abstract x: float with get, set
abstract y: float with get, set
type [<AllowNullLiteral>] PopoverSuggest<'T> =
inherit ISuggestOwner<'T>
inherit CloseableComponent
abstract ``open``: unit -> unit
abstract close: unit -> unit
/// Render the suggestion item into DOM.
abstract renderSuggestion: value: 'T * el: HTMLElement -> unit
/// Called when the user makes a selection.
abstract selectSuggestion: value: 'T * evt: U2<MouseEvent, KeyboardEvent> -> unit
type [<AllowNullLiteral>] PopoverSuggestStatic =
[<Emit "new $0($1...)">] abstract Create: app: App * ?scope: Scope -> PopoverSuggest<'T>
type [<AllowNullLiteral>] Pos =
abstract start: Loc with get, set
abstract ``end``: Loc with get, set
type [<AllowNullLiteral>] PreparedQuery =
abstract query: string with get, set
abstract tokens: ResizeArray<string> with get, set
abstract fuzzy: ResizeArray<string> with get, set
type [<AllowNullLiteral>] Rect_2 =
abstract x: float with get, set
abstract y: float with get, set
abstract w: float with get, set
abstract h: float with get, set
type [<AllowNullLiteral>] ReferenceCache =
inherit CacheItem
abstract link: string with get, set
abstract original: string with get, set
/// if title is different than link text, in the case of [[page name|display name]]
abstract displayText: string option with get, set
type [<AllowNullLiteral>] RequestUrlParam =
abstract url: string with get, set
abstract ``method``: string option with get, set
abstract contentType: string option with get, set
abstract body: U2<string, ArrayBuffer> option with get, set
abstract headers: obj with get, set
type [<AllowNullLiteral>] RequestUrlResponse =
abstract status: float with get, set
abstract headers: obj with get, set
abstract arrayBuffer: ArrayBuffer with get, set
abstract json: obj option with get, set
abstract text: string with get, set
type [<AllowNullLiteral>] Scope =
/// <param name="modifiers">- `Mod`, `Ctrl`, `Meta`, `Shift`, or `Alt`. `Mod` translates to `Meta` on macOS and `Ctrl` otherwise.</param>
/// <param name="key">- Keycode from https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values</param>
/// <param name="func">- the callback</param>
abstract register: modifiers: ResizeArray<Modifier> * key: string option * func: KeymapEventListener -> KeymapEventHandler
abstract unregister: handler: KeymapEventHandler -> unit
type [<AllowNullLiteral>] ScopeStatic =
[<Emit "new $0($1...)">] abstract Create: ?parent: Scope -> Scope
type [<AllowNullLiteral>] SearchComponent =
inherit AbstractTextComponent<HTMLInputElement>
abstract clearButtonEl: HTMLElement with get, set
abstract onChanged: unit -> unit
type [<AllowNullLiteral>] SearchComponentStatic =
[<Emit "new $0($1...)">] abstract Create: containerEl: HTMLElement -> SearchComponent
type SearchMatches =
ResizeArray<SearchMatchPart>
type SearchMatchPart =
float * float
type [<AllowNullLiteral>] SearchResult =
abstract score: float with get, set
abstract matches: SearchMatches with get, set
type [<AllowNullLiteral>] SearchResultContainer =
abstract ``match``: SearchResult with get, set
type [<AllowNullLiteral>] SectionCache =
inherit CacheItem
/// The block ID of this section, if defined.
abstract id: string option with get, set
/// The type string generated by the parser.
abstract ``type``: string with get, set
type [<AllowNullLiteral>] Setting =
abstract settingEl: HTMLElement with get, set
abstract infoEl: HTMLElement with get, set
abstract nameEl: HTMLElement with get, set
abstract descEl: HTMLElement with get, set
abstract controlEl: HTMLElement with get, set
abstract components: ResizeArray<BaseComponent> with get, set
abstract setName: name: U2<string, DocumentFragment> -> Setting
abstract setDesc: desc: U2<string, DocumentFragment> -> Setting
abstract setClass: cls: string -> Setting
abstract setTooltip: tooltip: string -> Setting
abstract setHeading: unit -> Setting
abstract setDisabled: disabled: bool -> Setting
abstract addButton: cb: (ButtonComponent -> obj option) -> Setting
abstract addExtraButton: cb: (ExtraButtonComponent -> obj option) -> Setting
abstract addToggle: cb: (ToggleComponent -> obj option) -> Setting
abstract addText: cb: (TextComponent -> obj option) -> Setting
abstract addSearch: cb: (SearchComponent -> obj option) -> Setting
abstract addTextArea: cb: (TextAreaComponent -> obj option) -> Setting
abstract addMomentFormat: cb: (MomentFormatComponent -> obj option) -> Setting
abstract addDropdown: cb: (DropdownComponent -> obj option) -> Setting
abstract addSlider: cb: (SliderComponent -> obj option) -> Setting
/// Facilitates chaining
abstract ``then``: cb: (Setting -> obj option) -> Setting
abstract clear: unit -> Setting
type [<AllowNullLiteral>] SettingStatic =
[<Emit "new $0($1...)">] abstract Create: containerEl: HTMLElement -> Setting
type [<AllowNullLiteral>] SettingTab =
abstract app: App with get, set
abstract containerEl: HTMLElement with get, set
abstract display: unit -> obj option
abstract hide: unit -> obj option
type [<AllowNullLiteral>] SettingTabStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> SettingTab
type [<AllowNullLiteral>] SliderComponent =
inherit ValueComponent<float>
abstract sliderEl: HTMLInputElement with get, set
abstract setDisabled: disabled: bool -> SliderComponent
abstract setLimits: min: float * max: float * step: U2<float, string> -> SliderComponent
abstract getValue: unit -> float
abstract setValue: value: float -> SliderComponent
abstract getValuePretty: unit -> string
abstract setDynamicTooltip: unit -> SliderComponent
abstract showTooltip: unit -> unit
abstract onChange: callback: (float -> obj option) -> SliderComponent
type [<AllowNullLiteral>] SliderComponentStatic =
[<Emit "new $0($1...)">] abstract Create: containerEl: HTMLElement -> SliderComponent
type [<StringEnum>] [<RequireQualifiedAccess>] SplitDirection =
| Vertical
| Horizontal
type [<AllowNullLiteral>] Stat =
abstract ``type``: StatType with get, set
abstract ctime: float with get, set
abstract mtime: float with get, set
abstract size: float with get, set
type [<AllowNullLiteral>] SubpathResult =
abstract start: Loc with get, set
abstract ``end``: Loc option with get, set
type [<AllowNullLiteral>] SuggestModal<'T> =
inherit Modal
inherit ISuggestOwner<'T>
abstract limit: float with get, set
abstract emptyStateText: string with get, set
abstract inputEl: HTMLInputElement with get, set
abstract resultContainerEl: HTMLElement with get, set
abstract setPlaceholder: placeholder: string -> unit
abstract setInstructions: instructions: ResizeArray<Instruction> -> unit
abstract onNoSuggestion: unit -> unit
/// Called when the user makes a selection.
abstract selectSuggestion: value: 'T * evt: U2<MouseEvent, KeyboardEvent> -> unit
// abstract getSuggestions: query: string -> U2<ResizeArray<'T>, Promise<ResizeArray<'T>>> //TODO: set thisd
abstract getSuggestions: query: string -> U2<ResizeArray<'T>, Promise<ResizeArray<'T>>>
/// Render the suggestion item into DOM.
abstract renderSuggestion: value: 'T * el: HTMLElement -> obj option
abstract onChooseSuggestion: item: 'T * evt: U2<MouseEvent, KeyboardEvent> -> obj option
type [<AllowNullLiteral>] SuggestModalStatic =
[<Emit "new $0($1...)">] abstract Create: app: App -> SuggestModal<'T>
/// This can be either a `TFile` or a `TFolder`.
type [<AllowNullLiteral>] TAbstractFile =
abstract vault: Vault with get, set
abstract path: string with get, set
abstract name: string with get, set
abstract parent: TFolder with get, set
/// This can be either a `TFile` or a `TFolder`.
type [<AllowNullLiteral>] TAbstractFileStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> TAbstractFile
type [<AllowNullLiteral>] TagCache =
inherit CacheItem
abstract tag: string with get, set
type [<AllowNullLiteral>] Tasks =
abstract add: callback: (unit -> Promise<obj option>) -> unit
abstract addPromise: promise: Promise<obj option> -> unit
abstract isEmpty: unit -> bool
abstract promise: unit -> Promise<obj option>
type [<AllowNullLiteral>] TasksStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> Tasks
type [<AllowNullLiteral>] TextAreaComponent =
inherit AbstractTextComponent<HTMLTextAreaElement>
type [<AllowNullLiteral>] TextAreaComponentStatic =
[<Emit "new $0($1...)">] abstract Create: containerEl: HTMLElement -> TextAreaComponent
type [<AllowNullLiteral>] TextComponent =
inherit AbstractTextComponent<HTMLInputElement>
type [<AllowNullLiteral>] TextComponentStatic =
[<Emit "new $0($1...)">] abstract Create: containerEl: HTMLElement -> TextComponent
/// This class implements a plaintext-based editable file view, which can be loaded and saved given an editor.
///
/// Note that by default, this view only saves when it's closing. To implement auto-save, your editor should
/// call `this.requestSave()` when the content is changed.
type [<AllowNullLiteral>] TextFileView =
inherit EditableFileView
/// In memory data
abstract data: string with get, set
/// Debounced save in 2 seconds from now
abstract requestSave: (unit -> unit) with get, set
abstract onUnloadFile: file: TFile -> Promise<unit>
abstract onLoadFile: file: TFile -> Promise<unit>
abstract save: ?clear: bool -> Promise<unit>
/// Gets the data from the editor. This will be called to save the editor contents to the file.
abstract getViewData: unit -> string
/// Set the data to the editor. This is used to load the file contents.
///
/// If clear is set, then it means we're opening a completely different file.
/// In that case, you should call clear(), or implement a slightly more efficient
/// clearing mechanism given the new data to be set.
abstract setViewData: data: string * clear: bool -> unit
/// Clear the editor. This is usually called when we're about to open a completely
/// different file, so it's best to clear any editor states like undo-redo history,
/// and any caches/indexes associated with the previous file contents.
abstract clear: unit -> unit
/// This class implements a plaintext-based editable file view, which can be loaded and saved given an editor.
///
/// Note that by default, this view only saves when it's closing. To implement auto-save, your editor should
/// call `this.requestSave()` when the content is changed.
type [<AllowNullLiteral>] TextFileViewStatic =
[<Emit "new $0($1...)">] abstract Create: leaf: WorkspaceLeaf -> TextFileView
type [<AllowNullLiteral>] TFile =
inherit TAbstractFile
abstract stat: FileStats with get, set
abstract basename: string with get, set
abstract extension: string with get, set
type [<AllowNullLiteral>] TFileStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> TFile
type [<AllowNullLiteral>] TFolder =
inherit TAbstractFile
abstract children: ResizeArray<TAbstractFile> with get, set
abstract isRoot: unit -> bool
type [<AllowNullLiteral>] TFolderStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> TFolder
type [<AllowNullLiteral>] ToggleComponent =
inherit ValueComponent<bool>
abstract toggleEl: HTMLElement with get, set
abstract setDisabled: disabled: bool -> ToggleComponent
abstract getValue: unit -> bool
abstract setValue: on: bool -> ToggleComponent
abstract setTooltip: tooltip: string -> ToggleComponent
abstract onClick: unit -> unit
abstract onChange: callback: (bool -> obj option) -> ToggleComponent
type [<AllowNullLiteral>] ToggleComponentStatic =
[<Emit "new $0($1...)">] abstract Create: containerEl: HTMLElement -> ToggleComponent
type UserEvent =
U4<MouseEvent, KeyboardEvent, TouchEvent, PointerEvent>
type [<AllowNullLiteral>] ValueComponent<'T> =
inherit BaseComponent
abstract registerOptionListener: listeners: obj * key: string -> ValueComponent<'T>
abstract getValue: unit -> 'T
abstract setValue: value: 'T -> ValueComponent<'T>
type [<AllowNullLiteral>] ValueComponentStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> ValueComponent<'T>
type [<AllowNullLiteral>] Vault =
inherit Events
abstract adapter: DataAdapter with get, set
/// Gets the path to the config folder.
/// This value is typically `.obsidian` but it could be different.
abstract configDir: string with get, set
/// Gets the name of the vault
abstract getName: unit -> string
abstract getAbstractFileByPath: path: string -> TAbstractFile option
abstract getRoot: unit -> TFolder
abstract create: path: string * data: string * ?options: DataWriteOptions -> Promise<TFile>
abstract createBinary: path: string * data: ArrayBuffer * ?options: DataWriteOptions -> Promise<TFile>
abstract createFolder: path: string -> Promise<unit>
abstract read: file: TFile -> Promise<string>
abstract cachedRead: file: TFile -> Promise<string>
abstract readBinary: file: TFile -> Promise<ArrayBuffer>
abstract getResourcePath: file: TFile -> string
/// <param name="file">- The file or folder to be deleted</param>
/// <param name="force">- Should attempt to delete folder even if it has hidden children</param>
abstract delete: file: TAbstractFile * ?force: bool -> Promise<unit>
/// <summary>Tries to move to system trash. If that isn't successful/allowed, use local trash</summary>
/// <param name="file">- The file or folder to be deleted</param>
/// <param name="system">- Should move to system trash</param>
abstract trash: file: TAbstractFile * system: bool -> Promise<unit>
abstract rename: file: TAbstractFile * newPath: string -> Promise<unit>
abstract modify: file: TFile * data: string * ?options: DataWriteOptions -> Promise<unit>
abstract modifyBinary: file: TFile * data: ArrayBuffer * ?options: DataWriteOptions -> Promise<unit>
abstract append: file: TFile * data: string * ?options: DataWriteOptions -> Promise<unit>
abstract copy: file: TFile * newPath: string -> Promise<TFile>
abstract getAllLoadedFiles: unit -> ResizeArray<TAbstractFile>
abstract getMarkdownFiles: unit -> ResizeArray<TFile>
abstract getFiles: unit -> ResizeArray<TFile>
[<Emit "$0.on('create',$1,$2)">] abstract on_create: callback: (TAbstractFile -> obj option) * ?ctx: obj -> EventRef
[<Emit "$0.on('modify',$1,$2)">] abstract on_modify: callback: (TAbstractFile -> obj option) * ?ctx: obj -> EventRef
[<Emit "$0.on('delete',$1,$2)">] abstract on_delete: callback: (TAbstractFile -> obj option) * ?ctx: obj -> EventRef
[<Emit "$0.on('rename',$1,$2)">] abstract on_rename: callback: (TAbstractFile -> string -> obj option) * ?ctx: obj -> EventRef
[<Emit "$0.on('closed',$1,$2)">] abstract on_closed: callback: (unit -> obj option) * ?ctx: obj -> EventRef
type [<AllowNullLiteral>] VaultStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> Vault
abstract recurseChildren: root: TFolder * cb: (TAbstractFile -> obj option) -> unit
type [<AllowNullLiteral>] View =
inherit Component
abstract app: App with get, set
abstract icon: string with get, set
abstract navigation: bool with get, set
abstract leaf: WorkspaceLeaf with get, set
abstract containerEl: HTMLElement with get, set
abstract onOpen: unit -> Promise<unit>
abstract onClose: unit -> Promise<unit>
abstract getViewType: unit -> string
abstract getState: unit -> obj option
abstract setState: state: obj option * result: ViewStateResult -> Promise<unit>
abstract getEphemeralState: unit -> obj option
abstract setEphemeralState: state: obj option -> unit
abstract getIcon: unit -> string
/// Called when the size of this view is changed.
abstract onResize: unit -> unit
abstract getDisplayText: unit -> string
abstract onHeaderMenu: menu: Menu -> unit
type [<AllowNullLiteral>] ViewStatic =
[<Emit "new $0($1...)">] abstract Create: leaf: WorkspaceLeaf -> View
type [<AllowNullLiteral>] ViewCreator =
[<Emit "$0($1...)">] abstract Invoke: leaf: WorkspaceLeaf -> View
type [<AllowNullLiteral>] ViewState =
abstract ``type``: string with get, set
abstract state: obj option with get, set
abstract active: bool option with get, set
abstract pinned: bool option with get, set
abstract group: WorkspaceLeaf option with get, set
type [<AllowNullLiteral>] ViewStateResult =
interface end
type [<AllowNullLiteral>] Workspace =
inherit Events
abstract leftSplit: U2<WorkspaceSidedock, WorkspaceMobileDrawer> with get, set
abstract rightSplit: U2<WorkspaceSidedock, WorkspaceMobileDrawer> with get, set
abstract leftRibbon: WorkspaceRibbon with get, set
abstract rightRibbon: WorkspaceRibbon with get, set
abstract rootSplit: WorkspaceSplit with get, set
abstract activeLeaf: WorkspaceLeaf option with get, set
abstract containerEl: HTMLElement with get, set
abstract layoutReady: bool with get, set
abstract requestSaveLayout: (unit -> unit) with get, set
abstract requestSaveHistory: (unit -> unit) with get, set
/// Runs the callback function right away if layout is already ready,
/// or push it to a queue to be called later when layout is ready.
abstract onLayoutReady: callback: (unit -> obj option) -> unit
abstract changeLayout: workspace: obj option -> Promise<unit>
abstract getLayout: unit -> obj option
abstract createLeafInParent: parent: WorkspaceSplit * index: float -> WorkspaceLeaf
abstract splitLeaf: source: WorkspaceItem * newLeaf: WorkspaceItem * ?direction: SplitDirection * ?before: bool -> unit
abstract createLeafBySplit: leaf: WorkspaceLeaf * ?direction: SplitDirection * ?before: bool -> WorkspaceLeaf
abstract splitActiveLeaf: ?direction: SplitDirection -> WorkspaceLeaf
abstract splitLeafOrActive: ?leaf: WorkspaceLeaf * ?direction: SplitDirection -> WorkspaceLeaf
abstract duplicateLeaf: leaf: WorkspaceLeaf * ?direction: SplitDirection -> Promise<WorkspaceLeaf>
abstract getUnpinnedLeaf: ?``type``: string -> WorkspaceLeaf
abstract getLeaf: ?newLeaf: bool -> WorkspaceLeaf
abstract openLinkText: linktext: string * sourcePath: string * ?newLeaf: bool * ?openViewState: OpenViewState -> Promise<unit>
/// <summary>Sets the active leaf</summary>
/// <param name="leaf">- The new active leaf</param>
/// <param name="pushHistory">- Whether to push the navigation history, or replace the current navigation history.</param>
/// <param name="focus">- Whether to ask the leaf to focus.</param>
abstract setActiveLeaf: leaf: WorkspaceLeaf * ?pushHistory: bool * ?focus: bool -> unit
abstract getLeafById: id: string -> WorkspaceLeaf
abstract getGroupLeaves: group: string -> ResizeArray<WorkspaceLeaf>
abstract getMostRecentLeaf: unit -> WorkspaceLeaf
abstract getLeftLeaf: split: bool -> WorkspaceLeaf
abstract getRightLeaf: split: bool -> WorkspaceLeaf
abstract getActiveViewOfType: ``type``: Constructor<'T> -> 'T option
abstract getActiveFile: unit -> TFile option
abstract iterateRootLeaves: callback: (WorkspaceLeaf -> obj option) -> unit
abstract iterateAllLeaves: callback: (WorkspaceLeaf -> obj option) -> unit
abstract getLeavesOfType: viewType: string -> ResizeArray<WorkspaceLeaf>
abstract detachLeavesOfType: viewType: string -> unit
abstract revealLeaf: leaf: WorkspaceLeaf -> unit
abstract getLastOpenFiles: unit -> ResizeArray<string>
/// Calling this function will update/reconfigure the options of all markdown panes.
/// It is fairly expensive, so it should not be called frequently.
abstract updateOptions: unit -> unit
abstract iterateCodeMirrors: callback: (obj -> obj option) -> unit
[<Emit "$0.on('quick-preview',$1,$2)">] abstract ``on_quick-preview``: callback: (TFile -> string -> obj option) * ?ctx: obj -> EventRef
[<Emit "$0.on('resize',$1,$2)">] abstract on_resize: callback: (unit -> obj option) * ?ctx: obj -> EventRef
[<Emit "$0.on('click',$1,$2)">] abstract on_click: callback: (MouseEvent -> obj option) * ?ctx: obj -> EventRef
[<Emit "$0.on('active-leaf-change',$1,$2)">] abstract ``on_active-leaf-change``: callback: (WorkspaceLeaf option -> obj option) * ?ctx: obj -> EventRef
[<Emit "$0.on('file-open',$1,$2)">] abstract ``on_file-open``: callback: (TFile option -> obj option) * ?ctx: obj -> EventRef
[<Emit "$0.on('layout-change',$1,$2)">] abstract ``on_layout-change``: callback: (unit -> obj option) * ?ctx: obj -> EventRef
/// Triggered when the CSS of the app has changed.
[<Emit "$0.on('css-change',$1,$2)">] abstract ``on_css-change``: callback: (unit -> obj option) * ?ctx: obj -> EventRef
/// Triggered when the user opens the context menu on a file.
[<Emit "$0.on('file-menu',$1,$2)">] abstract ``on_file-menu``: callback: (Menu -> TAbstractFile -> string -> WorkspaceLeaf -> obj option) * ?ctx: obj -> EventRef
/// Triggered when the user opens the context menu on an editor.
[<Emit "$0.on('editor-menu',$1,$2)">] abstract ``on_editor-menu``: callback: (Menu -> Editor -> MarkdownView -> obj option) * ?ctx: obj -> EventRef
/// Triggered when changes to an editor has been applied, either programmatically or from a user event.
[<Emit "$0.on('editor-change',$1,$2)">] abstract ``on_editor-change``: callback: (Editor -> MarkdownView -> obj option) * ?ctx: obj -> EventRef
/// Triggered when the editor receives a paste event.
/// Check for `evt.defaultPrevented` before attempting to handle this event, and return if it has been already handled.
/// Use `evt.preventDefault()` to indicate that you've handled the event.
[<Emit "$0.on('editor-paste',$1,$2)">] abstract ``on_editor-paste``: callback: (ClipboardEvent -> Editor -> MarkdownView -> obj option) * ?ctx: obj -> EventRef
/// Triggered when the editor receives a drop event.
/// Check for `evt.defaultPrevented` before attempting to handle this event, and return if it has been already handled.
/// Use `evt.preventDefault()` to indicate that you've handled the event.
[<Emit "$0.on('editor-drop',$1,$2)">] abstract ``on_editor-drop``: callback: (DragEvent -> Editor -> MarkdownView -> obj option) * ?ctx: obj -> EventRef
[<Emit "$0.on('codemirror',$1,$2)">] abstract on_codemirror: callback: (obj -> obj option) * ?ctx: obj -> EventRef
/// Triggered when the app is about to quit. Not guaranteed to actually run.
/// Perform some best effort cleanup here.
[<Emit "$0.on('quit',$1,$2)">] abstract on_quit: callback: (Tasks -> obj option) * ?ctx: obj -> EventRef
type [<AllowNullLiteral>] WorkspaceStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> Workspace
type [<AllowNullLiteral>] WorkspaceItem =
inherit Events
abstract getRoot: unit -> WorkspaceItem
type [<AllowNullLiteral>] WorkspaceItemStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> WorkspaceItem
type [<AllowNullLiteral>] WorkspaceLeaf =
inherit WorkspaceItem
abstract view: View with get, set
abstract openFile: file: TFile * ?openState: OpenViewState -> Promise<unit>
abstract ``open``: view: View -> Promise<View>
abstract getViewState: unit -> ViewState
abstract setViewState: viewState: ViewState * ?eState: obj -> Promise<unit>
abstract getEphemeralState: unit -> obj option
abstract setEphemeralState: state: obj option -> unit
abstract togglePinned: unit -> unit
abstract setPinned: pinned: bool -> unit
abstract setGroupMember: other: WorkspaceLeaf -> unit
abstract setGroup: group: string -> unit
abstract detach: unit -> unit
abstract getIcon: unit -> string
abstract getDisplayText: unit -> string
abstract onResize: unit -> unit
[<Emit "$0.on('pinned-change',$1,$2)">] abstract ``on_pinned-change``: callback: (bool -> obj option) * ?ctx: obj -> EventRef
[<Emit "$0.on('group-change',$1,$2)">] abstract ``on_group-change``: callback: (string -> obj option) * ?ctx: obj -> EventRef
type [<AllowNullLiteral>] WorkspaceLeafStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> WorkspaceLeaf
type [<AllowNullLiteral>] WorkspaceMobileDrawer =
inherit WorkspaceParent
abstract collapsed: bool with get, set
abstract expand: unit -> unit
abstract collapse: unit -> unit
abstract toggle: unit -> unit
type [<AllowNullLiteral>] WorkspaceMobileDrawerStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> WorkspaceMobileDrawer
type [<AllowNullLiteral>] WorkspaceParent =
inherit WorkspaceItem
type [<AllowNullLiteral>] WorkspaceParentStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> WorkspaceParent
type [<AllowNullLiteral>] WorkspaceRibbon =
interface end
type [<AllowNullLiteral>] WorkspaceRibbonStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> WorkspaceRibbon
type [<AllowNullLiteral>] WorkspaceSidedock =
inherit WorkspaceSplit
abstract collapsed: bool with get, set
abstract toggle: unit -> unit
abstract collapse: unit -> unit
abstract expand: unit -> unit
type [<AllowNullLiteral>] WorkspaceSidedockStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> WorkspaceSidedock
type [<AllowNullLiteral>] WorkspaceSplit =
inherit WorkspaceParent
type [<AllowNullLiteral>] WorkspaceSplitStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> WorkspaceSplit
type [<AllowNullLiteral>] WorkspaceTabs =
inherit WorkspaceParent
type [<AllowNullLiteral>] WorkspaceTabsStatic =
[<Emit "new $0($1...)">] abstract Create: unit -> WorkspaceTabs
type [<AllowNullLiteral>] Platform =
/// The UI is in desktop mode.
abstract isDesktop: bool with get, set
/// The UI is in mobile mode.
abstract isMobile: bool with get, set
/// We're running the electron-based desktop app.
abstract isDesktopApp: bool with get, set
/// We're running the capacitor-js mobile app.
abstract isMobileApp: bool with get, set
/// We're running the iOS app.
abstract isIosApp: bool with get, set
/// We're running the Android app.
abstract isAndroidApp: bool with get, set
/// We're on a macOS device, or a device that pretends to be one (like iPhones and iPads).
/// Typically used to detect whether to use command-based hotkeys vs ctrl-based hotkeys.
abstract isMacOS: bool with get, set
/// We're running in Safari.
/// Typically used to provide workarounds for Safari bugs.
abstract isSafari: bool with get, set
type [<AllowNullLiteral>] DomElementInfoAttr =
[<Emit "$0[$1]{{=$2}}">] abstract Item: key: string -> U3<string, float, bool> option with get, set
type [<StringEnum>] [<RequireQualifiedAccess>] AjaxOptionsMethod =
| [<CompiledName "GET">] GET
| [<CompiledName "POST">] POST
type [<StringEnum>] [<RequireQualifiedAccess>] StatType =
| File
| Folder