obsidian-typings 1.0.2 → 1.0.4

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## v1.0.4
+- Added missing EventRef types
+  - **View Registry:** `view-registered`, `view-unregistered`, `extensions-updated`
+  - **Metadata Cache:** `initialized`, `finished`
+  - **Workspace:** `hover-link`, `tab-group-menu`, `swipe`, `layout-ready`, `url-menu`, `search:results-menu`, `receive-text-menu`,
+            `receive-files-menu`, `canvas:selection-menu`, `canvas:node-menu`, `canvas:node-connection-drop-menu`, `canvas:edge-menu`
+  - **Workspace Leaf:** `history-change`, `leaf-menu`
+- Added missing typings for `Menu` and `MenuItem` classes
+- Added missing typings for `Tree` and `TreeItem` classes (used in `Outline` and `FileExplorer` plugin views)
+- Set vertical height for a split leaf item via `setDimension`
+- Bumped `electron-types` version
+
+## v1.0.3
+- Change `electron-types` types inclusion
+- Added note in `README.md` on automatically including new types
+- Fix lambda definitions and tsc compilatiion
+
 ## v1.0.2
 - Changed `any` type to `unknown` to enforcing explicit type casting
 - Fixed `CONTRIBUTING.md` link in `README.md`

package/README.md

@@ -55,6 +55,19 @@ There are three options for installing this package:
 3. **Add extended typings as submodule** <br> Your IDE will likely pick up the typings automatically when the project is added as a submodule for your plugin, this also makes it simpler to test and submit features to the repository. <br> _Install via:_ `git submodule add https://github.com/Fevol/obsidian-typings.git typings` (or any other folder)
 
 
+> [!NOTE]
+> If you prefer to use the original NPM package name `obsidian-typings`, but don't want to explicitly import its types into your source code, you could adapt your `tsconfig.json` as follows:
+> ```json
+> {
+>     "compilerOptions": {
+>         ...
+>         "types": [
+>             "obsidian-typings"
+>         ]
+>     }
+> }
+> ```
+
 ## Disclaimer
 
 > [!WARNING]

package/obsidian-ex.d.ts

@@ -3,7 +3,8 @@ import {
     Command,
     Component,
     Constructor,
-    EditorRange,
+    EditorRange, 
+    EventRef,
     Events,
     KeymapInfo,
     Loc,
@@ -31,6 +32,11 @@ export * from 'obsidian';
 
 
 // TODO: Interfaces that have not been fully typed yet are marked as @internal with 'unknown'
+// TODO: Add Canvas typings (work off base from Dev-Mike, attribute)
+// TODO: Missing event types on sync plugin (but not the internalplugin itself):
+//  - new-log
+//  - status-change
+
 
 interface Account {
     /**
@@ -321,6 +327,26 @@ interface BlockCache {
     cache: unknown;
 }
 
+interface CanvasConnection {
+    
+}
+
+interface CanvasLeaf extends WorkspaceLeaf {
+
+}
+
+interface CanvasNode {
+    
+}
+
+interface CanvasPlugin extends InternalPlugin {
+
+}
+
+interface CanvasView {
+    
+}
+
 interface CMState extends EditorState {
     vim: {
         inputState: {
@@ -498,7 +524,7 @@ interface CustomCSS extends Component {
     /**
      * @internal
      */
-    queue: WeakMap<unknown, unknown>;
+    queue: WeakMap<object, unknown>;
     /**
      * @internal
      */
@@ -546,7 +572,7 @@ interface CustomCSS extends Component {
      * Fetch legacy theme CSS using the pre-v1.0.0 theme download pipeline
      * @returns string obsidian.css contents
      */
-    downloadLegacyTheme({ repo: string }): Promise<string>;
+    downloadLegacyTheme(arg: { repo: string }): Promise<string>;
     /**
      * Enable translucency of application background
      */
@@ -680,11 +706,35 @@ interface FileExplorerPlugin extends InternalPlugin {
 }
 
 interface FileExplorerView extends View {
+    /**
+     * Mapping of tree self element to abstract file
+     */
     files: WeakMapWrapper<HTMLElement, TAbstractFile>;
-
+    /**
+     * Mapping of file path to tree item
+     */
+    fileItems: Record<string, TreeItem<FileTreeItem>>;
+    /**
+     * Tree view of files
+     */
+    tree: Tree<FileTreeItem>;
+    
     openFileContextMenu(event: Event, fileItemElement: HTMLElement): void;
 }
 
+interface FileTreeItem {
+    file: TAbstractFile;
+}
+
+
+interface GlobalSearchLeaf extends WorkspaceLeaf {
+
+}
+
+interface GlobalSearchPlugin extends InternalPlugin {
+
+}
+
 interface HotkeyManager {
     /**
      * Reference to App
@@ -773,6 +823,18 @@ interface HoverLinkSource {
     defaultMod: boolean;
 }
 
+interface HoverLinkEvent {
+    event: MouseEvent,
+    source: "search" | "editor" | "preview" | "properties" | "graph" | "file-explorer" | "hover-link",
+    hoverParent: WorkspaceLeaf,
+    targetEl: HTMLElement | null,
+    linktext: string,
+    sourcePath?: string,
+    state?: {
+        scroll: unknown,
+    }
+}
+
 interface ImportedAttachments {
     data: Promise<ArrayBuffer>;
     extension: string;
@@ -780,6 +842,37 @@ interface ImportedAttachments {
     name: string;
 }
 
+/**
+ * @internal
+ */
+interface InfinityScroll {
+    height: number;
+    lastScroll: number;
+    queued: unknown | null;
+    renderBlockSize: number;
+    rootEl: unknown;
+    scrollEl: HTMLElement;
+    setWidth: boolean;
+    width: number;
+
+    compute(x: unknown): unknown;
+    findElementTop(x: unknown, y: unknown, z: unknown): unknown;
+    getRootTop(): unknown;
+    invalidate(x: unknown, y: unknown): unknown;
+    invalidateAll(): unknown;
+    measure(x: unknown, y: unknown): unknown;
+    onResize(): unknown;
+    onScroll(): unknown;
+    queueCompute(): unknown;
+    scrollIntoView(x: unknown, y: unknown): unknown;
+    update(x: unknown, y: unknown, z: unknown, u: unknown, v: unknown, w: unknown): unknown;
+    updateVirtualDisplay(x: unknown): unknown;
+    
+    _layout(x: unknown, y: unknown): unknown;
+    _measure(x: unknown): unknown;
+    _precompute(x: unknown): unknown;
+}
+
 interface InternalPlugin extends Plugin {
     disable(): void;
     enable(): void;
@@ -830,8 +923,13 @@ interface InternalPlugins extends Events {
     migration: boolean;
     /**
      * Plugin configs for internal plugins
+     * @remark Prefer usage of getPluginById to access a plugin
      */
-    plugins: Record<InternalPluginName, InternalPlugin>;
+    plugins: {
+        "file-explorer": FileExplorerPlugin,
+        "global-search": GlobalSearchPlugin,
+        [key: string]: InternalPlugin,
+    }
     /**
      * @internal Request save of plugin configs
      */
@@ -843,6 +941,7 @@ interface InternalPlugins extends Events {
      */
     getEnabledPluginById(id: InternalPluginName): InternalPlugin | null;
     getEnabledPluginById(id: 'file-explorer'): FileExplorerPlugin | null;
+    getEnabledPluginById(id: 'global-search'): GlobalSearchPlugin | null;
 
     /**
      * Get all enabled internal plugins
@@ -960,7 +1059,7 @@ interface MetadataTypeManager extends Events {
     /**
      * @internal Get expected widget type for property and the one inferred from the property value
      */
-    getTypeInfo: (arg: { key: string, type: string, value: unknown }) => { inferred: PropertyWidget, expected: PropertyWidget }
+    getTypeInfo(arg: { key: string, type: string, value: unknown }): { inferred: PropertyWidget, expected: PropertyWidget };
     /**
      * Get all properties with an assigned widget type
      */
@@ -1060,6 +1159,7 @@ interface Plugins {
     app: App;
     /**
      * Set of enabled plugin IDs
+     * @remark The plugin ids aren't guaranteed to be either active (in `app.plugins.plugins`) or installed (in `app.plugins.manifests`) 
      */
     enabledPlugins: Set<string>;
     /**
@@ -1067,11 +1167,12 @@ interface Plugins {
      */
     loadingPluginId: string | null;
     /**
-     * Manifests of all the plugins
+     * Manifests of all the plugins that are installed
      */
     manifests: Record<string, PluginManifest>;
     /**
-     * Mapping of plugin ID to plugin instance
+     * Mapping of plugin ID to active plugin instance
+     * @remark Prefer usage of getPlugin to access a plugin
      */
     plugins: Record<string, Plugin>;
     /**
@@ -1410,6 +1511,224 @@ interface ThemeManifest {
     version: '0.0.0' | string;
 }
 
+export interface Token extends EditorRange {
+    type: "tag" | "external-link" | "internal-link";
+}
+
+interface Tree<T> {
+    /**
+     * Currently active item in tree view
+     */
+    activeDom: TreeNode<T> | null;
+    /**
+     * Reference to App
+     */
+    app: App;
+    /**
+     * Container element of the tree view
+     */
+    containerEl: HTMLElement;
+    /**
+     * Currently focused item in tree view
+     */
+    focusedItem: TreeNode<T> | null;
+    /**
+     * Gets the ID of a tree item given its Node
+     */
+    getNodeId: (node: TreeNode<T>) => string | undefined;
+    /**
+     * Handle collapsing of all nodes
+     */
+    handleCollapseAll: () => void;
+    /**
+     * Handle deletion of selected nodes
+     */
+    handleDeleteSelectedItems: () => void | undefined;
+    /**
+     * Handle renaming of focused item
+     */
+    handleRenameFocusedItem: () => void;
+    /**
+     * ID of the view the tree is associated with
+     */
+    id: string;
+    /**
+     * @internal Facilitates rendering of tree view
+     */
+    infinityScroll: InfinityScroll;
+    /**
+     * Whether all items in the tree are collapsed
+     */
+    isAllCollapsed: boolean;
+    /**
+     * Whether tree items should default to collapsed state
+     */
+    prefersCollapsed: boolean;
+    /**
+     * Request saving of the current fold states
+     */
+    requestSaveFolds: () => void;
+    /**
+     * Key scope for tree view
+     */
+    scope: Scope;
+    /**
+     * Currently selected items in tree view
+     */
+    selectedDoms: Set<TreeNode<T>>;
+    /**
+     * The view the tree is associated with
+     */
+    view: View;
+
+    /**
+     * Root item of the tree view
+     */
+    get root(): TreeNode<T>;
+
+    /**
+     * Change the focused item to the next item in specified direction
+     */
+    changeFocusedItem(direction: "forwards" | "backwards"): void;
+    /**
+     * Unselect all selected items in the tree view
+     */
+    clearSelectedDoms(): void;
+    /**
+     * Mark tree item as deselected
+     */
+    deselectItem(node: TreeNode<T>): void;
+    /**
+     * Get the local storage key for the saved tree view folds
+     */
+    getFoldKey(): string;
+    /**
+     * Handle selection of tree item via keyboard event
+     */
+    handleItemSelection(event: MouseEvent, node: TreeNode<T>): void;
+    /**
+     * @internal Registers all keyboard actions to the tree view keyscope
+     */
+    initializeKeyboardNav(): void;
+    /**
+     * Check whether item is a valid tree item
+     */
+    isItem(node: TreeNode<T> | undefined): boolean;
+    /**
+     * Load the saved fold states of the tree view from local storage
+     */
+    loadFolds(): void;
+    /**
+     * Handle keyboard event for moving/selecting tree item below
+     */
+    onKeyArrowDown(event: KeyboardEvent): void;
+    /**
+     * Handle keyboard event for moving through the hierarchy of tree items (and/or folding/unfolding)
+     */
+    onKeyArrowLeft(event: KeyboardEvent): void;
+    /**
+     * Handle keyboard event for moving through the hierarchy of tree items (and/or folding/unfolding)
+     */
+    onKeyArrowRight(event: KeyboardEvent): void;
+    /**
+     * Handle keyboard event for moving/selecting tree item above
+     */
+    onKeyArrowUp(event: KeyboardEvent): void;
+    /**
+     * Handle keyboard event for opening tree item
+     */
+    onKeyOpen(event: KeyboardEvent): void;
+    /**
+     * @internal Update scroll representation on resize
+     */
+    onResize(): void;
+    /**
+     * Save the current fold states of the tree view to local storage
+     */
+    saveFolds(): void;
+    /**
+     * Mark tree item as selected
+     */
+    selectItem(node: TreeNode<T>): void;
+    /**
+     * Set all items in the tree view to be collapsed or expanded
+     */
+    setCollapseAll(collapse: boolean): void;
+    /**
+     * Set the focused item in the tree view
+     */
+    setFocusedItem(node: TreeNode<T>, scrollIntoView?: boolean): void;
+    /**
+     * (Un)Collapse all items in the tree view
+     */
+    toggleCollapseAll(): void;
+}
+    
+    
+
+type TreeNode<T = object> = T & {
+    childrenEl: HTMLElement;
+    el: HTMLElement;
+    info: {
+        childLeft: number;
+        childLeftPadding: number;
+        childTop: number;
+        computed: boolean;
+        height: number;
+        hidden: boolean;
+        next: boolean;
+        queued: boolean;
+        width: number;
+    };
+    pusherEl: HTMLElement;
+    vChildren: {
+        _children: TreeNode<T>[];
+        owner: TreeNode<T>;
+    };
+}
+
+// NOTE: File-explorer root vs Outline root are different (former is a treeitem, latter just a treenode)
+type TreeItem<T> = TreeNode<T> & {
+    collapseEl: HTMLElement;
+    collapsed: boolean;
+    collapsible: boolean;
+    coverEl: HTMLElement;
+    innerEl: HTMLElement;
+    parent: TreeNode<T> | undefined;
+    selfEl: HTMLElement;
+    view: View;
+
+    /**
+     * Execute collapse functionality on mouse click
+     */
+    onCollapseClick(event: MouseEvent): void;
+    /**
+     * Execute item functionality on clicking tree item
+     */
+    onSelfClick(event: MouseEvent): void;
+    /**
+     * Set clickable state of tree item 
+     */
+    setClickable(clickable: boolean): void;
+    /**
+     * Set collapsed state of tree item
+     */
+    setCollapsed(collapsed: boolean, check: boolean): Promise<undefined>;
+    /**
+     * Set collapsible state of tree item
+     */
+    setCollapsible(collapsible: boolean): void;
+    /**
+     * Toggle collapsed state of tree item
+     */
+    toggleCollapsed(check: boolean): Promise<undefined>;
+    /**
+     * @internal Update the tree item's cover element
+     */
+    updateCollapsed(check: boolean): Promise<undefined>;
+}
+
+
 interface ViewRegistry extends Events {
     /**
      * Mapping of file extensions to view type
@@ -1420,6 +1739,21 @@ interface ViewRegistry extends Events {
      */
     viewByType: Record<string, (leaf: WorkspaceLeaf) => View>;
 
+    /**
+     * Called when a view of type has been registered into the registry
+     */
+    on(name: 'view-registered', callback: (type: string) => void): EventRef;
+    
+    /**
+     * Called when a view of type has been unregistered from the registry
+     */
+    on(name: 'view-unregistered', callback: (type: string) => void): EventRef;
+
+    /**
+     * Called when the file extensions mapping has been updated
+     */
+    on(name: 'extensions-updated', callback: () => void): EventRef;
+
     /**
      * Get the view type associated with a file extension
      * @param extension File extension
@@ -1462,7 +1796,7 @@ interface ViewRegistry extends Events {
     unregisterView(type: string): void;
 }
 
-interface WeakMapWrapper<K extends WeakKey, V> extends WeakMap<K, V> {
+interface WeakMapWrapper<K extends object, V> extends WeakMap<K, V> {
     map: WeakMap<K, V>;
 }
 
@@ -2051,7 +2385,7 @@ declare module 'obsidian' {
         /**
          * Adds a search cursor to the editor
          */
-        searchCursor: (searchString: string) => {
+        searchCursor(searchString: string): {
             current(): { from: EditorPosition, to: EditorPosition };
             findAll(): { from: EditorPosition, to: EditorPosition }[];
             findNext(): { from: EditorPosition, to: EditorPosition };
@@ -2297,21 +2631,236 @@ declare module 'obsidian' {
     interface FileSystemAdapter extends DataAdapter {
     }
 
+
+    interface MarkdownEditView {
+        triggerClickableToken(token: Token, new_leaf: boolean): void;
+    }
+    
+    interface MarkdownView {
+        editMode: MarkdownEditView;
+    }
+
     interface MarkdownPreviewView {
         renderer: ReadViewRenderer;
     }
 
     interface Menu {
+        /**
+         * Background for the suggestion menu
+         */
+        bgEl: HTMLElement;
+        /**
+         * The currently active submenu, if any
+         */
+        currentSubmenu?: Menu;
+        /**
+         * DOM element of the menu
+         */
         dom: HTMLElement;
+        /**
+         * Callback to execute when the menu is hidden
+         */
+        hideCallback: () => void;
+        /**
+         * Items contained in the menu
+         */
         items: MenuItem[];
-        onMouseOver(evt: MouseEvent): void;
+        /**
+         * @internal Callback that opens the submenu after a delay
+         */
+        openSubmenuSoon: () => void;
+        /**
+         * Parent menu of the current menu
+         */
+        parentMenu: Menu | null;
+        /**
+         * Scope in which the menu is active
+         */
+        scope: Scope;
+        /**
+         * Sections within the menu
+         */
+        sections: string[];
+        /**
+         * @internal Which menuitem is currently selected
+         */
+        selected: number;
+        /**
+         * @internal Configurations for the submenu configs
+         */
+        submenuConfig: Record<string, { title: string, icon: string }>;
+        /**
+         * @internal Whether the submenu is currently unloading
+         */
+        unloading: boolean;
+        /**
+         * Whether the menu is rendered in native mode
+         */
+        useNativeMenu: boolean;
+
+        /**
+         * @internal Children of the menu
+         */
+        _children: unknown[];
+        /**
+         * @internal Events registered on the menu
+         */
+        _events: unknown[];
+        /**
+         * @internal Whether the menu is loaded
+         */
+        _loaded: boolean;
+        
+        /**
+         * @internal Add a section to the menu
+         */
+        addSections(items: string[]): Menu;
+        /**
+         * @internal Close the currently open submenu
+         */
+        closeSubmenu(): void;
+        /**
+         * @internal Check whether the clicked element is inside the menu
+         */
+        isInside(e: HTMLElement): boolean;
+        /**
+         * @internal Move selection to the next item in the menu
+         * @param e - Keyboard event
+         */
+        onArrowDown(e: KeyboardEvent): boolean;
+        /**
+         * @internal Move selection to the previous item in the menu
+         * @param e - Keyboard event
+         */
+        onArrowUp(e: KeyboardEvent): boolean;
+        /**
+         * @internal Move selection into the submenu
+         */
+        onArrowRight(e: KeyboardEvent): boolean;
+        /**
+         * @internal Move selection out of the submenu
+         */
+        onArrowLeft(e: KeyboardEvent): boolean;
+        /**
+         * @internal Execute selected menu item (does nothing if item is submenu)
+         */
+        onEnter(e: KeyboardEvent): boolean;
+        /**
+         * @internal Pre-emptively closes the menu if click is registered on menu item
+         * @param e
+         */
+        onMenuClick(e: MouseEvent): void;
+        /**
+         * @internal Opens submenu if mouse is hovering over item with submenu
+         * @param e - Mouse event
+         */
+        onMouseOver(e: MouseEvent): boolean;
+        /**
+         * @internal Registers dom events and scope for the menu
+         */
+        onload(): void;
+        /**
+         * @internal Unregisters scope for the menu
+         */
+        onunload():  void;
+        /**
+         * @internal Open the submenu of the selected item
+         * @param item - Item to open submenu for
+         */
+        openSubmenu(item: MenuItem): void;
+        /**
+         * @internal Select the item at the specified index (after either hovering or arrowing over it)
+         * @param index
+         */
+        select(index: number): void;
+        /**
+         * @internal Set the parent element of the menu (i.e. for workspace leaf context menu)
+         * @param el - Element to set as parent
+         */
+        setParentElement(el: HTMLElement): Menu;
+        /**
+         * @internal Add a section to the submenu config
+         * @param section
+         * @param submenu
+         */
+        setSectionSubmenu(section: string, submenu: {title: string, icon: string}): Menu;
+        /**
+         * @internal Sort the items in the menu
+         */
+        sort(): void;
+        /**
+         * @internal Unselect the currently selected item and closes the submenu
+         */
+        unselect(): void;
     }
 
     interface MenuItem {
-        callback: () => void;
+        /**
+         * The callback that is executed when the menu item is clicked
+         */
+        callback?: () => void;
+        /**
+         * Whether the menu item is checked
+         */
+        checked: boolean | null;
+        /**
+         * Check icon element of the menu item, only present if the item is checked
+         */
+        checkIconEl?: HTMLElement;
+        /**
+         * Whether the menu item is disabled
+         */
+        disabled: boolean;
+        /**
+         * Dom element of the menu item
+         */
         dom: HTMLElement;
+        /**
+         * Icon element of the menu item
+         */
+        iconEl: HTMLElement;
+        /**
+         * Menu the item is in
+         */
+        menu: Menu;
+        /**
+         * The section the item belongs to
+         */
+        section: string;
+        /**
+         * The submenu that is attached to the item
+         */
+        submenu: Menu | null;
+        /**
+         * Title of the menu item
+         */
+        titleEl: string;
+
+        /**
+         * @internal Executes the callback of the onClick event (if not disabled)
+         * @param e - Mouse or keyboard event
+         */
+        handleEvent(e: MouseEvent | KeyboardEvent): void;
+        /**
+         * @internal Remove the icon element from the menu item
+         */
+        removeIcon(): void;
+        /**
+         * @deprecated
+         * @internal Calls `setChecked`, prefer usage of that function instead  
+         * @param active - Whether the menu item should be checked 
+         */
+        setActive(active: boolean): void;
+        /**
+         * Create a submenu on the menu item
+         * @tutorial Creates the foldable menus with more options as seen when you right-click in the editor (e.g. "Insert", "Format", ...) 
+         */
         setSubmenu(): Menu;
-        disabled: boolean;
+        /**
+         * @internal Add warning styling to the menu item
+         * @param warning - Whether the menu item should be styled as a warning
+         */
+        setWarning(warning: boolean): void;
     }
 
     interface MetadataCache {
@@ -2384,6 +2933,18 @@ declare module 'obsidian' {
          */
         workerResolve: unknown;
 
+        /**
+         * Called whenever the metadatacache is fully loaded in
+         * @remark 'finished' is also emitted when the cache is initialized
+         */
+        on(name: 'initialized', callback: () => void): EventRef;
+
+        /**
+         * Called whenever the metadatacache has finished updating
+         */
+        on(name: 'finished', callback: () => void): EventRef;
+        
+
         /**
          * Get all property infos of the vault
          */
@@ -2391,7 +2952,7 @@ declare module 'obsidian' {
         /**
          * Get all backlink information for a file
          */
-        getBacklinksForFile: (file?: TFile) => CustomArrayDict<LinkCache>
+        getBacklinksForFile(file?: TFile): CustomArrayDict<LinkCache>
         /**
          * Get paths of all files cached in the vault
          */
@@ -2729,6 +3290,27 @@ declare module 'obsidian' {
         deleted: boolean;
     }
 
+    /**
+     * @internal Used for Obsidian's touch event handling
+     */
+    interface ObsidianTouchEvent {
+        direction: "x" | "y";
+        evt: TouchEvent;
+        points: number;
+        registerCallback: ({
+            move: (x: number) => void,
+            cancel: () => void,
+            finish: (x: number, y: number, z: number) => void
+        }),
+        startX: number;
+        startY: number;
+        targetEl: HTMLElement;
+        touch: Touch;
+        
+        x: number;
+        y: number;
+    }
+
     interface Vault {
         /**
          * Low-level file system adapter for read and write operations
@@ -2753,8 +3335,56 @@ declare module 'obsidian' {
          */
         fileMap: Record<string, TAbstractFile>;
 
+        /**
+         * Called whenever any of Obsidian's settings are changed
+         * @remark Does *not* trigger when a particular plugin's settings are changed, for that, you could monkey-patch the `saveSettings` method of a plugin instance 
+         */
         on(name: 'config-changed', callback: () => void, ctx?: unknown): EventRef;
 
+        /**
+         * @internal Triggered whenever a file gets loaded internally
+         */
+        on(name: 'raw', callback: (path: string) => void, ctx?: unknown): EventRef;
+
+        /**
+         * @internal Not accessible
+         * @remark Always prefer usage of on(name: 'rename', ...) instead
+         */
+        // on(name: 'renamed', callback: (oldPath: string, newPath: string) => void): EventRef;
+        
+        /**
+         * @internal Not accessible
+         * @remark Always prefer usage of on(name: 'modify', ...) instead
+         */
+        // on(name: 'modified', callback: () => void): EventRef;
+        
+        /**
+         * @internal Not accessible
+         */
+        // on(name: 'file-created', callback: () => void): EventRef;
+        
+        /**
+         * @internal Not accessible
+         */
+        // on(name: 'folder-created', callback: () => void): EventRef;
+        
+        /**
+         * @internal Not accessible
+         */
+        // on(name: 'file-removed', callback: () => void): EventRef;
+        
+        /**
+         * @internal Not accessible
+         */
+        // on(name: 'folder-removed', callback: () => void): EventRef;
+        
+        /**
+         * @internal Not accessible
+         */
+        // on(name: 'closed', callback: () => void): EventRef;       
+        
+        
+        
         /**
          * @internal Add file as child/parent to respective folders
          */
@@ -2993,6 +3623,68 @@ declare module 'obsidian' {
          */
         undoHistory: StateHistory[];
 
+        /**
+         * @internal Triggers when user hovers over any note link element (file explorer, editor, ...)
+         * @remark Used for preparing (Ctrl) hover previews
+         */
+        on(name: 'hover-link', callback: (event: HoverLinkEvent) => void, ctx?: unknown): EventRef;
+
+        /**
+         * @internal Called whenever user opens tab group menu (contains e.g. stacked tabs button)
+         */
+        on(name: 'tab-group-menu', callback: (tabMenu: Menu, tabsLeaf: WorkspaceTabs) => void, ctx?: unknown): EventRef;
+
+        /**
+         * @internal Triggers when user swipes open left/right sidebar
+         */
+        on(name: 'swipe', callback: (touchEvents: ObsidianTouchEvent[]) => void, ctx?: unknown): EventRef;
+
+        /**
+         * Triggers when workspace layout is loaded
+         * @remark Prefer usage of onLayoutReady instead
+         */
+        on(name: 'layout-ready', callback: () => void, ctx?: unknown): EventRef;
+        
+        /**
+         * @internal Triggers when user right-clicks on external URL in editor
+         */
+        on(name: 'url-menu', callback: (menu: Menu, url: string) => void, ctx?: unknown): EventRef;
+        
+        /**
+         * Triggers when user clicks on 'N results' button in search view
+         */
+        on(name: 'search:results-menu', callback: (menu: Menu, search: GlobalSearchLeaf) => void, ctx?: unknown): EventRef;
+
+        /**
+         * @internal Called when user shares text on mobile
+         */
+        on(name: 'receive-text-menu', callback: (menu: Menu, x: unknown) => void, ctx?: unknown): EventRef;
+        
+        /**
+         * @internal Called when user shares files on mobile
+         */
+        on(name: 'receive-files-menu', callback: (menu: Menu, x: unknown) => void, ctx?: unknown): EventRef;
+
+        /**
+         * Triggers when the user opens a context menu on a selection of multiple nodes in the canvas
+         */
+        on(name: 'canvas:selection-menu', callback: (menu: Menu, canvasView: CanvasView) => void, ctx?: unknown): EventRef;
+
+        /**
+         * Triggers when the user opens a context menu on a single node in the canvas
+         */
+        on(name: 'canvas:node-menu', callback: (menu: Menu, node: CanvasNode) => void, ctx?: unknown): EventRef;
+
+        /**
+         * Triggers when the user drops edge connection to empty space in the canvas
+         */
+        on(name: 'canvas:node-connection-drop-menu', callback: (menu: Menu, originalNode: CanvasNode, connection: CanvasConnection) => void, ctx?: unknown): EventRef;
+
+        /**
+         * Triggers when the user opens a context menu on a connection in the canvas
+         */
+        on(name: 'canvas:edge-menu', callback: (menu: Menu, connection: CanvasConnection) => void, ctx?: unknown): EventRef;
+
         /**
          * @internal Change active leaf and trigger leaf change event
          */
@@ -3212,6 +3904,25 @@ declare module 'obsidian' {
         tabHeaderEl: HTMLElement;
         tabHeaderInnerIconEl: HTMLElement;
         tabHeaderInnerTitleEl: HTMLElement;
+
+        /**
+         * Triggers when the leaf's history gets updated (e.g. when new file is opened, or moving through history)
+         */
+        on(name: 'history-change', callback: () => void, ctx?: unknown): EventRef;
+
+        /**
+         * Triggers when context menu action is executed on the leaf
+         */
+        on(name: 'leaf-menu', callback: (menu: Menu, leaf: WorkspaceLeaf) => void, ctx?: unknown): EventRef;
+
+        /**
+         * Set the vertical height a leaf may occupy if it is in a split. The height is not set directly, but
+         * by setting the flex-grow (css) of the element. This means to predictably affect the height, you also 
+         * need to use setDimension on the other leafs of the column. (The flex-grow values of every leaf work 
+         basically like a ratio, e.g. 1:2 meaning the first leaf takes 33% of the height, and the second 67%.)
+         * @param flexgrow - sets the flex-grow of the leaf. (0-100)
+         */
+        setDimension(flexgrow?: number | null): void;
     }
 
     interface WorkspaceSplit {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-typings",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Extended type definitions for the Obsidian API (https://obsidian.md)",
   "main": "",
   "types": "obsidian-ex.d.ts",
@@ -9,7 +9,7 @@
     "url": "git+https://github.com/Fevol/obsidian-typings.git"
   },
   "keywords": [
-    "obsmd",
+    "obsdmd",
     "obsidian",
     "typings",
     "API"
@@ -24,8 +24,8 @@
     "obsidian": "^1.4.11"
   },
   "devDependencies": {
-    "@types/electron": "npm:@ophidian/electron-types@^24.3.1",
-    "@types/node": "^20.10.7"
+    "@types/node": "^20.10.7",
+    "@types/electron": "npm:@ophidian/electron-types"
   },
   "scripts": {
     "build": "tsc --build --force"