tw5-typed 0.6.7 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tw5-typed",
-  "version": "0.6.7",
+  "version": "0.7.0",
   "scripts": {
     "check": "tsc --noEmit && eslint src/**/*.ts",
     "docs": "docs-ts",
@@ -9,6 +9,7 @@
     "docs:generate": "npm run docs:generate:api && npm run docs:generate:copy",
     "docs:generate:api": "rimraf docs/api && typedoc --options typedoc.json",
     "docs:generate:copy": "zx scripts/copy-readme.mjs",
+    "update": "npm-check-updates -u && dprint config update",
     "prepublishOnly": "tsc --noEmit"
   },
   "description": "Types for tiddlywiki",
@@ -47,30 +48,31 @@
     ]
   },
   "dependencies": {
-    "@types/codemirror": "^5.60.15",
-    "@types/echarts": "^4.9.22",
-    "@types/node": "^20.11.24"
+    "@types/codemirror": "^5.60.17",
+    "@types/echarts": "^5.0.0",
+    "@types/node": "^24.10.1"
   },
   "devDependencies": {
-    "@docusaurus/core": "^3.1.1",
-    "@docusaurus/preset-classic": "^3.1.1",
-    "@docusaurus/types": "^3.1.1",
-    "@mdx-js/react": "^3.0.1",
+    "@docusaurus/core": "^3.9.2",
+    "@docusaurus/preset-classic": "^3.9.2",
+    "@docusaurus/types": "^3.9.2",
+    "@mdx-js/react": "^3.1.1",
     "@modern-js/eslint-config": "latest",
     "@modern-js/tsconfig": "latest",
     "docs-ts": "^0.8.0",
-    "dprint": "^0.45.0",
-    "eslint-config-tidgi": "^1.2.2",
-    "husky": "^9.0.11",
-    "lint-staged": "^15.2.2",
-    "prism-react-renderer": "^2.3.1",
-    "react": "^18.2.0",
-    "rimraf": "^5.0.5",
-    "tiddlywiki": "^5.3.3",
-    "type-fest": "^4.10.3",
-    "typedoc": "^0.25.9",
-    "typedoc-plugin-markdown": "^3.17.1",
-    "typescript": "^5.3.3",
-    "zx": "^7.2.3"
+    "dprint": "^0.50.2",
+    "eslint-config-tidgi": "^2.2.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.6",
+    "npm-check-updates": "^19.1.2",
+    "prism-react-renderer": "^2.4.1",
+    "react": "^19.2.0",
+    "rimraf": "^6.1.0",
+    "tiddlywiki": "^5.3.8",
+    "type-fest": "^5.2.0",
+    "typedoc": "^0.28.14",
+    "typedoc-plugin-markdown": "^4.9.0",
+    "typescript": "^5.9.3",
+    "zx": "^8.8.5"
   }
 }

package/src/core.d.ts

@@ -42,7 +42,11 @@ declare module 'tiddlywiki' {
     Syncer: new() => Syncer;
     Tiddler: typeof Tiddler;
     Wiki: typeof Wiki;
-    addUnloadTask(task: any);
+    /**
+     * Add another unload task
+     * @param task - Function to be called on unload
+     */
+    addUnloadTask(task: any): void;
     boot: IBoot;
 
     browser: null | {
@@ -110,33 +114,89 @@ declare module 'tiddlywiki' {
     hooks: IHooks;
     keyboardManager: KeyboardManager;
     language: ILanguage;
+    /**
+     * Load the metadata fields in the .meta file corresponding to a particular file
+     * @param filepath - The path to the file
+     * @returns The metadata fields or null if no .meta file exists
+     */
     loadMetadataForFile(filepath: string): ITiddlerFields | null;
+    /**
+     * Load a plugin by name from the given search paths
+     * @param name - Name of the plugin (e.g., "tiddlywiki/filesystemadaptor")
+     * @param paths - Array of file paths to search for it
+     */
     loadPlugin(name: string, paths: string[]): void;
+    /**
+     * Load the tiddlers from a plugin folder, and package them up into a proper JSON plugin tiddler
+     * @param filepath - Path to the plugin folder
+     * @param excludeRegExp - Optional regex for files to exclude
+     * @returns Plugin info object or null if not a valid plugin
+     */
     loadPluginFolder(
       filepath: string,
       excludeRegExp?: RegExp,
     ): IPluginInfo | null;
+    /**
+     * Load multiple plugins
+     * @param plugins - Array of plugin names (e.g., ["tiddlywiki/filesystemadaptor"])
+     * @param libraryPath - Path of library folder for these plugins (relative to core path)
+     * @param environmentVariable - Environment variable name for these plugins
+     */
     loadPlugins(plugins: string[], libraryPath: string, environmentVariable?: string): void;
+    /**
+     * Load tiddlers in browser environment
+     */
     loadTiddlersBrowser(): void;
+    /**
+     * Load the tiddlers contained in a particular file (and optionally extract fields from the accompanying .meta file)
+     * @param filepath - The path to the file to load
+     * @param defaultFields - Optional default fields to apply to loaded tiddlers
+     * @returns Object containing filepath, type, tiddlers array, and hasMetaFile flag
+     */
     loadTiddlersFromFile(
       filepath: string,
       defaultFields?: Record<string, unknown>,
     ): ITiddlersInFile;
+    /**
+     * Load all the tiddlers recursively from a directory, including honouring `tiddlywiki.files` files for drawing in external files
+     * @param filepath - The path to load from
+     * @param excludeRegExp - Optional regex for files to exclude
+     * @returns Array of objects containing filepath, type, tiddlers array, and hasMetaFile flag
+     * @description Note that no file information is returned for externally loaded tiddlers, just the `tiddlers` property.
+     */
     loadTiddlersFromPath(
       filepath: string,
       excludeRegExp?: RegExp,
-    ): ITiddlerFields[];
+    ): ITiddlersInFile[];
+    /**
+     * Load all the tiddlers defined by a `tiddlywiki.files` specification file
+     * @param filepath - Pathname of the directory containing the specification file
+     * @param excludeRegExp - Optional regex for files to exclude
+     * @returns Array of objects containing filepath, type, tiddlers array, and hasMetaFile flag
+     */
     loadTiddlersFromSpecification(
       filepath: string,
       excludeRegExp?: RegExp,
-    ): ITiddlerFields[];
+    ): ITiddlersInFile[];
 
+    /**
+     * Load tiddlers in Node.js environment
+     * @description Load boot tiddlers, core tiddlers, extra plugins, and wiki tiddlers
+     */
     loadTiddlersNode(): void;
 
+    /**
+     * Load wiki tiddlers from a wiki directory
+     * @param wikiPath - Path to the wiki directory
+     * @param options - Options for loading
+     * @param options.parentPaths - Array of parent paths that we mustn't recurse into
+     * @param options.readOnly - True if the tiddler file paths should not be retained
+     * @returns Wiki info object or null if no tiddlywiki.info file exists
+     */
     loadWikiTiddlers(
       wikiPath: string,
-      options?: { parentPaths?: string; readOnly?: boolean },
-    ): IWikiInfo;
+      options?: { parentPaths?: string[]; readOnly?: boolean },
+    ): IWikiInfo | null;
 
     locationHash: string;
 

package/src/modules/filters/index.d.ts

@@ -1,7 +1,7 @@
 declare module 'tiddlywiki' {
   /**
    * # Usage
-   * 
+   *
    * ```ts
    * const yourFilter: IFilterOperator = (source,operator) => {
    * 	var results = [];
@@ -12,7 +12,7 @@ declare module 'tiddlywiki' {
    * 	return results;
    * }
    * ```
-   * 
+   *
    * # Overview
 
 Filter operators are modules (tiddlers of type `application/javascript`) with their `module-type` field set to `filteroperator`, exporting one or more functions implementing a filter.

package/src/modules/server/index.d.ts

@@ -96,7 +96,7 @@ declare module 'tiddlywiki' {
     */
     isAuthorized(
       authorizationType: 'readers' | 'writers',
-      username?: string | undefined,
+      username?: string,
     ): boolean;
     close(): void;
   }

package/src/modules/utils/dom/dom.d.ts

@@ -201,10 +201,10 @@ declare module '$:/core/modules/utils/dom.js' {
    */
   export function copyToClipboard(
     text: string,
-    options?: { 
-      doNotNotify?: boolean,
-      successNotification?: string, // default is $:/language/Notifications/CopiedToClipboard/Succeeded
-      failureNotification?: string
+    options?: {
+      doNotNotify?: boolean;
+      successNotification?: string; // default is $:/language/Notifications/CopiedToClipboard/Succeeded
+      failureNotification?: string;
     },
   ): boolean;
 

package/src/modules/utils/dom/modal.d.ts

@@ -1,4 +1,4 @@
-  /// <reference path="../../widgets/index.d.ts" />
+/// <reference path="../../widgets/index.d.ts" />
 /// <reference path="../../../wiki/index.d.ts" />
 
 declare module 'tiddlywiki' {

package/src/modules/utils/filesystem.d.ts

@@ -18,7 +18,7 @@ declare module 'tiddlywiki' {
 }
 
 declare module '$:/core/modules/utils/filesystem.js' {
-  import type { Tiddler, Wiki, FileInfo } from 'tiddlywiki';
+  import type { FileInfo, Tiddler, Wiki } from 'tiddlywiki';
 
   /**
    * Return the subdirectories of a path

package/src/modules/utils/index.d.ts

@@ -21,7 +21,6 @@ declare module 'tiddlywiki' {
   import * as LinkedList from '$:/core/modules/utils/linked-list.js';
   import * as performance from '$:/core/modules/utils/performance.js';
   // import the class directly, to fix: Property 'log' does not exist on type 'typeof Logger'.ts(2339)
-  import * as parsetree from '$:/core/modules/utils/parsetree.js';
   import * as parseutils from '$:/core/modules/utils/parseutils.js';
   import * as pluginMaker from '$:/core/modules/utils/pluginmaker.js';
   import * as transliterate from '$:/core/modules/utils/transliterate.js';
@@ -30,14 +29,13 @@ declare module 'tiddlywiki' {
   import * as editionInfo from '$:/core/modules/utils/edition-info.js';
   import * as escapecss from '$:/core/modules/utils/escapecss.js';
 
-  type IUtilsModules =
+  type IUtilitiesModules =
     & Pick<typeof dom, keyof typeof dom>
     & Pick<typeof logger, keyof typeof logger>
     & Pick<typeof filesystem, keyof typeof filesystem>
     & Pick<typeof utils, keyof typeof utils>
     & Pick<typeof LinkedList, keyof typeof LinkedList>
     & Pick<typeof performance, keyof typeof performance>
-    & Pick<typeof parsetree, keyof typeof parsetree>
     & Pick<typeof parseutils, keyof typeof parseutils>
     & Pick<typeof pluginMaker, keyof typeof pluginMaker>
     & Pick<typeof transliterate, keyof typeof transliterate>

package/src/modules/widgets/index.d.ts

@@ -168,13 +168,24 @@ declare module 'tiddlywiki' {
      * @param {string } name name of the variable
      * @param {string} value value of the variable
      * @param {IWidgetVariableParam[]} [params=[]] array of `{name: string, default: string}` for each parameter
-     * @param {boolean} [isMacroDefinition=true] true if the variable is set via a \define macro pragma (and hence should have variable substitution performed)
+     * @param {boolean} [isMacroDefinition=false] true if the variable is set via a \define macro pragma (and hence should have variable substitution performed)
+     * @param {object} [options] Additional options
+     * @param {boolean} [options.isProcedureDefinition] true if the variable is set via a \procedure pragma
+     * @param {boolean} [options.isFunctionDefinition] true if the variable is set via a \function pragma
+     * @param {boolean} [options.isWidgetDefinition] true if the variable is set via a \widget pragma
+     * @param {boolean} [options.configTrimWhiteSpace] whether to trim whitespace
      */
     setVariable(
       name: string,
       value: string,
       parameters?: IWidgetVariableParameter[],
       isMacroDefinition?: boolean,
+      options?: {
+        configTrimWhiteSpace?: boolean;
+        isFunctionDefinition?: boolean;
+        isProcedureDefinition?: boolean;
+        isWidgetDefinition?: boolean;
+      },
     ): void;
 
     /**
@@ -254,10 +265,14 @@ declare module 'tiddlywiki' {
      * @zh
      * 计算微件的属性的当前值。返回一个已经改变的属性名称的哈希图
      *
+     * @param {object} [options] Options
+     * @param {Function} [options.filterFn] only include attributes where filterFn(name) returns true
      * @return Object with keys of the names of the attributes that have changed
      * @memberof Widget
      */
-    computeAttributes(): Record<string, true>;
+    computeAttributes(options?: {
+      filterFn?: (name: string) => boolean;
+    }): Record<string, true>;
 
     computeAttribute(attribute: string): string;
 
@@ -302,9 +317,15 @@ declare module 'tiddlywiki' {
      * Assign the computed attributes of the widget to a domNode
      * options include:
      * * `excludeEventAttributes`: ignores attributes whose name begins with "on"
+     * * `sourcePrefix`: prefix of attributes that are to be directly assigned (defaults to the empty string)
+     * * `destPrefix`: prefix to be applied to attribute names that are to be directly assigned (defaults to the empty string)
+     * * `changedAttributes`: hashmap by attribute name of attributes to process (if missing, process all attributes)
      * @zh
      * 将微件的计算属性分配给一个 domNode, 选项包括:
      * * `excludeEventAttributes`: 忽略名称以 "on "开头的属性
+     * * `sourcePrefix`: 要直接分配的属性的前缀（默认为空字符串）
+     * * `destPrefix`: 要应用到直接分配的属性名称的前缀（默认为空字符串）
+     * * `changedAttributes`: 按属性名称的哈希图，要处理的属性（如果缺失，处理所有属性）
      * 一些特殊的属性：
      * * `xlink:<xlink-name>`
      * * `style.<css-style-name>`
@@ -315,7 +336,12 @@ declare module 'tiddlywiki' {
      */
     assignAttributes(
       domNode: Element,
-      options?: { excludeEventAttributes?: boolean },
+      options?: {
+        changedAttributes?: Record<string, string>;
+        destPrefix?: string;
+        excludeEventAttributes?: boolean;
+        sourcePrefix?: string;
+      },
     );
 
     /**
@@ -392,6 +418,14 @@ declare module 'tiddlywiki' {
       handler: (event: IWidgetEvent) => undefined | Promise<void> | boolean,
     ): void;
 
+    /**
+     * Remove an event listener
+     */
+    removeEventListener(
+      type: string,
+      handler: (event: IWidgetEvent) => undefined | Promise<void> | boolean,
+    ): void;
+
     /**
      * Dispatch an event to a widget. If the widget doesn't handle the event then it is also dispatched to the parent widget
      * Events added via `addEventListener`, like `tm-notify`, can be invoked by this.
@@ -479,12 +513,65 @@ declare module 'tiddlywiki' {
       variables?: Record<string, string>,
     ): boolean;
 
+    /**
+     * @en
+     * Execute action tiddlers by tag
+     * @zh
+     * 按标签执行 action tiddlers
+     *
+     * @param {string} tag The tag to filter action tiddlers
+     * @param {IWidgetEvent} event The widget event
+     * @param {Record<string, string>} variables Optional variables to pass to the action string
+     * @memberof Widget
+     */
+    invokeActionsByTag(
+      tag: string,
+      event?: IWidgetEvent | null,
+      variables?: Record<string, string>,
+    ): void;
+
+    /**
+     * @en
+     * Find child `<$data>` widgets recursively. The tag name allows aliased versions of the widget to be found too
+     * @zh
+     * 递归查找子 `<$data>` widgets。标签名称允许查找该 widget 的别名版本
+     *
+     * @param {Widget[]} children The children widgets to search
+     * @param {string} tag The tag name to search for (e.g., "$data")
+     * @param {Function} callback Callback function called for each found widget
+     * @memberof Widget
+     */
+    findChildrenDataWidgets(
+      children: Widget[],
+      tag: string,
+      callback: (widget: Widget) => void,
+    ): void;
+
     removeLocalDomNodes(): void;
 
     /**
      * Make a fake widget with specified variables, suitable for variable lookup in filters
      */
     makeFakeWidgetWithVariables(variables: Record<string, string>): Widget;
+
+    /**
+     * @en
+     * Evaluate a variable with parameters. This is a static convenience method that attempts to evaluate a variable as a function, returning an array of strings
+     * @zh
+     * 使用参数评估变量。这是一个静态便捷方法，尝试将变量作为函数评估，返回字符串数组
+     *
+     * @param {Widget} widget The widget context for variable lookup
+     * @param {string} name The variable name to evaluate
+     * @param {IGetWidgetVariableOptions} options Options for variable evaluation
+     * @returns {string[]} Array of result strings
+     * @static
+     * @memberof Widget
+     */
+    static evaluateVariable(
+      widget: Widget,
+      name: string,
+      options?: IGetWidgetVariableOptions,
+    ): string[];
   }
 }
 

package/src/utils/index.d.ts

@@ -106,7 +106,7 @@ declare module 'tiddlywiki' {
     text?: string;
   }
 
-  interface IUtilsBoot {
+  interface IUtilitiesBoot {
     Crypto: typeof Crypto;
     PasswordPrompt: typeof PasswordPrompt;
 
@@ -458,5 +458,5 @@ declare module 'tiddlywiki' {
     transliterationPairs: Record<string, string>;
   }
 
-  export type IUtils = IUtilsBoot & IUtilsModules;
+  export type IUtils = IUtilitiesBoot & IUtilsModules;
 }

package/src/wiki/index.d.ts

@@ -16,14 +16,18 @@ declare module 'tiddlywiki' {
     | 'text/html'
     | 'text/vnd.tiddlywiki'
     | 'text/plain';
-  export type ITiddlerFieldsParam = Omit<
-    Partial<ITiddlerFields>,
-    'created' | 'modified'
-  > & { created?: string; modified?: string };
-  export type ITiddlerJSONResult = Omit<
-    Partial<ITiddlerFieldsParam>,
-    'list' | 'tags'
-  > & { list?: string; tags?: string };
+  export type ITiddlerFieldsParam =
+    & Omit<
+      Partial<ITiddlerFields>,
+      'created' | 'modified'
+    >
+    & { created?: string; modified?: string };
+  export type ITiddlerJSONResult =
+    & Omit<
+      Partial<ITiddlerFieldsParam>,
+      'list' | 'tags'
+    >
+    & { list?: string; tags?: string };
   export class Wiki {
     /**
      * Wiki constructor. State is stored in private members that only a small number of privileged accessor methods have direct access. Methods added via the prototype have to use these accessors and cannot access the state data directly.
@@ -47,12 +51,104 @@ declare module 'tiddlywiki' {
     getTiddlersAsJson(filter: string, spaces?: string): string;
     /**
      * Get JSON string of tiddler. Note that this will make lists like tags/list to be string, instead of array. And result is a string, not an object.
-     * @param title 
+     * @param title
      * @returns a stringified JSON with type ITiddlerJSONResult. You will need to use `JSON.parse` on it.
      */
     getTiddlerAsJson(title: string): string;
     deleteTiddler(title: string): void;
     each(callback: (tiddler: Tiddler, title: string) => void): void;
+    /**
+     * For every tiddler invoke a callback(title,tiddler) with `this` set to the wiki object.
+     * @param options Options include sortField, excludeTag, includeSystem
+     * @param callback Function to be called for each tiddler
+     */
+    forEachTiddler(options: { sortField?: string; excludeTag?: string; includeSystem?: boolean }, callback: (title: string, tiddler: Tiddler) => void): void;
+    forEachTiddler(callback: (title: string, tiddler: Tiddler) => void): void;
+    /**
+     * Sort an array of tiddler titles by a specified field
+     * @param titles Array of titles (sorted in place)
+     * @param sortField Name of field to sort by
+     * @param isDescending True if the sort should be descending
+     * @param isCaseSensitive True if the sort should consider upper and lower case letters to be different
+     * @param isNumeric True if the sort should be numeric
+     * @param isAlphaNumeric True if the sort should be alphanumeric
+     */
+    sortTiddlers(titles: string[], sortField: string, isDescending?: boolean, isCaseSensitive?: boolean, isNumeric?: boolean, isAlphaNumeric?: boolean): void;
+    /**
+     * Return an array of tiddler titles that match a search string
+     * @param text The text string to search for
+     * @param options Search options
+     */
+    search(text: string, options?: {
+      /** An iterator function for the source tiddlers */
+      source?: (callback: (tiddler: Tiddler, title: string) => void) => void;
+      /** An array of tiddler titles to exclude from the search */
+      exclude?: string[];
+      /** If true returns tiddlers that do not contain the specified string */
+      invert?: boolean;
+      /** If true forces a case sensitive search */
+      caseSensitive?: boolean;
+      /** If specified, restricts the search to the specified field, or an array of field names */
+      field?: string | string[];
+      /** If true, forces all but regexp searches to be anchored to the start of text */
+      anchored?: boolean;
+      /** If true, the field options are inverted to specify the fields that are not to be searched */
+      excludeField?: boolean;
+      /** Searches for literal string */
+      literal?: boolean;
+      /** Same as literal except runs of whitespace are treated as a single space */
+      whitespace?: boolean;
+      /** Treats the search term as a regular expression */
+      regexp?: boolean;
+      /** Treats search string as a list of tokens, and matches if all tokens are found */
+      words?: boolean;
+      /** Treats search string as a list of tokens, and matches if at least ONE token is found */
+      some?: boolean;
+    }): string[];
+    /**
+     * Check whether the text of a tiddler matches a given value
+     * @param title Tiddler title
+     * @param targetText Text to compare with
+     * @param options Comparison options
+     */
+    checkTiddlerText(title: string, targetText: string, options?: { noTrim?: boolean; caseSensitive?: boolean }): boolean;
+    /**
+     * Return the content of a tiddler as an array containing each line
+     * @param title Title of the tiddler
+     * @param field Field name (defaults to "list")
+     * @param index Data index (key) to get, if you are getting a JSON data tiddler
+     * @returns Array of strings parsed from the field/index value
+     */
+    getTiddlerList(title: string, field?: string, index?: string): string[];
+    /**
+     * Get the value of a text reference. Text references can have any of these forms:
+     * - <tiddlertitle>
+     * - <tiddlertitle>!!<fieldname>
+     * - !!<fieldname> - specifies a field of the current tiddlers
+     * - <tiddlertitle>##<index>
+     * @param textRef The text reference string
+     * @param defaultText Default text to return if the reference is not found
+     * @param currTiddlerTitle Current tiddler title for relative references
+     */
+    getTextReference(textReference: string, defaultText?: string, currentTiddlerTitle?: string): string | undefined;
+    /**
+     * Set the value of a text reference
+     * @param textRef The text reference string
+     * @param value The value to set
+     * @param currTiddlerTitle Current tiddler title for relative references
+     */
+    setTextReference(textReference: string, value: string, currentTiddlerTitle?: string): void;
+    /**
+     * Delete a text reference
+     * @param textRef The text reference string
+     * @param currTiddlerTitle Current tiddler title for relative references
+     */
+    deleteTextReference(textReference: string, currentTiddlerTitle?: string): void;
+    /**
+     * Count the number of tiddlers in the wiki
+     * @param excludeTag Optional tag to exclude from the count
+     */
+    countTiddlers(excludeTag?: string): number;
     /**
      * Return a named global cache object. Global cache objects are cleared whenever a tiddler change.
      * You can put anything into the cache.
@@ -74,6 +170,11 @@ declare module 'tiddlywiki' {
      * clear all cache, will be called when a tiddler is changed
      */
     clearGlobalCache(): void;
+    /**
+     * Clear all caches associated with a particular tiddler, or if the title is null, clear all caches for all tiddlers
+     * @param title Tiddler title or null to clear all caches
+     */
+    clearCache(title?: string | null): void;
     /**
      * Compile filter string to be a function that execute the filter in the wiki.
      * You can pass an optional iterator that provide the input to the returned function. If no iterator is provided, filter will use first operator to get input.
@@ -89,7 +190,6 @@ declare module 'tiddlywiki' {
       widget?: Widget,
     ) => string[];
     /**
-     *
      * @param filterString
      * @param widget an optional widget node for retrieving the current tiddler etc.
      * @param source an iterator function for the source tiddlers, called source(iterator), where iterator is called as iterator(tiddler,title)
@@ -227,7 +327,7 @@ declare module 'tiddlywiki' {
     deserializeTiddlers(
       type: string,
       text: string,
-      srcFields?: ITiddlerFieldsParam,
+      sourceFields?: ITiddlerFieldsParam,
       options?: IParseOptions,
     ): ITiddlerFieldsParam[];
     /**
@@ -318,6 +418,33 @@ declare module 'tiddlywiki' {
     getShadowSource(title: string): string | null;
     getTiddlerBacklinks(targetTitle: string): string[];
     getTiddlerLinks(title: string): string[];
+    /**
+     * Return an array of tiddler titles that are directly linked within the given parse tree
+     * @param parseTreeRoot The parse tree root node
+     */
+    extractLinks(parseTreeRoot: IParseTreeNode[]): string[];
+    /**
+     * Return an array of tiddler titles that are directly transcluded within the given parse tree
+     * @param parseTreeRoot The parse tree root node
+     * @param title The tiddler being parsed (to ignore self-referential transclusions)
+     */
+    extractTranscludes(parseTreeRoot: IParseTreeNode[], title?: string): string[];
+    /**
+     * Return an array of tiddler titles that are transcluded from the specified tiddler
+     * @param title Tiddler title
+     */
+    getTiddlerTranscludes(title: string): string[];
+    /**
+     * Return an array of tiddler titles that transclude to the specified tiddler
+     * @param targetTitle Target tiddler title
+     */
+    getTiddlerBacktranscludes(targetTitle: string): string[];
+    /**
+     * Lookup a given tiddler and return a list of all the tiddlers that include it in the specified list field
+     * @param targetTitle Target tiddler title
+     * @param fieldName Field name (defaults to "list")
+     */
+    findListingsOfTiddler(targetTitle: string, fieldName?: string): string[];
     getPluginInfo(title: string): { tiddlers: Record<string, ITiddlerFields> };
     getChangeCount(title: string): number;
     /**
@@ -325,6 +452,165 @@ declare module 'tiddlywiki' {
       options.prefix must be a string
     */
     generateNewTitle(baseTitle: string, options: { prefix?: string }): string;
+    /**
+     * Get a subtiddler from a plugin or data tiddler
+     * @param title Title of the plugin or data tiddler
+     * @param subTiddlerTitle Title of the subtiddler within the bundle
+     */
+    getSubTiddler(title: string, subTiddlerTitle: string): Tiddler | null;
+    /**
+     * Return a hashmap of tiddler titles that are referenced but not defined
+     */
+    getMissingTitles(): string[];
+    /**
+     * Return an array of tiddler titles that are not linked from any other tiddler
+     */
+    getOrphanTitles(): string[];
+    /**
+     * Sorts an array of tiddler titles according to an ordered list
+     * @param array Array of tiddler titles to sort
+     * @param listTitle Title of tiddler containing the ordered list
+     */
+    sortByList(array: string[], listTitle: string): string[];
+    /**
+     * Get a hashmap by tag of arrays of tiddler titles
+     */
+    getTagMap(): Record<string, string[]>;
+    /**
+     * Find any existing draft of a specified tiddler
+     * @param targetTitle Title of the target tiddler
+     */
+    findDraft(targetTitle: string): string | undefined;
+    /**
+     * Check whether the specified draft tiddler has been modified
+     * @param title Title of the draft tiddler
+     */
+    isDraftModified(title: string): boolean;
+    /**
+     * Add a new tiddler to the story river
+     * @param title A title string or an array of title strings
+     * @param fromTitle The title of the tiddler from which the navigation originated
+     * @param storyTitle Title of story tiddler (defaults to $:/StoryList)
+     * @param options Additional options
+     * @deprecated Use story.addToStory() from the story object instead
+     */
+    addToStory(title: string | string[], fromTitle?: string, storyTitle?: string, options?: any): void;
+    /**
+     * Add a new record to the top of the history stack
+     * @param title A title string or an array of title strings
+     * @param fromPageRect Page coordinates of the origin of the navigation
+     * @param historyTitle Title of history tiddler (defaults to $:/HistoryList)
+     * @deprecated Use story.addToHistory() from the story object instead
+     */
+    addToHistory(title: string | string[], fromPageRect?: any, historyTitle?: string): void;
+    /**
+     * Generate a draft title for a given tiddler
+     * @param title Title of the tiddler to create a draft for
+     */
+    generateDraftTitle(title: string): string;
+    /**
+     * Convert a title to a URL-friendly slug
+     * @param title Title to slugify
+     * @param options Options (currently unused)
+     */
+    slugify(title: string, options?: any): string;
+    /**
+     * Invoke the available upgrader modules
+     * @param titles Array of tiddler titles to be processed
+     * @param tiddlers Hashmap by title of tiddler fields of pending import tiddlers
+     */
+    invokeUpgraders(titles: string[], tiddlers: Record<string, ITiddlerFields>): Record<string, string>;
+    /**
+     * Determine whether a plugin by title is dynamically loadable
+     * @param title Plugin title
+     */
+    doesPluginRequireReload(title: string): boolean;
+    /**
+     * Determine whether a plugin info structure is dynamically loadable
+     * @param pluginInfo Plugin info object
+     */
+    doesPluginInfoRequireReload(pluginInfo: any): boolean | null;
+    /**
+     * Execute an action string without an associated context widget
+     * @param actions Action string to execute
+     * @param event Event object
+     * @param variables Variables hashmap
+     * @param options Options including parentWidget
+     */
+    invokeActionString(actions: string, event?: any, variables?: Record<string, string>, options?: { parentWidget?: Widget }): void;
+    /**
+     * Read an array of browser File objects
+     * @param files Array of File objects
+     * @param options Options or callback function
+     */
+    readFiles(files: File[], options?: { callback?: (tiddlerFieldsArray: ITiddlerFields[]) => void } | ((tiddlerFieldsArray: ITiddlerFields[]) => void)): number;
+    /**
+     * Read a browser File object
+     * @param file File object
+     * @param options Options or callback function
+     */
+    readFile(file: File, options?: { callback?: (tiddlerFieldsArray: ITiddlerFields[]) => void; deserializer?: string } | ((tiddlerFieldsArray: ITiddlerFields[]) => void)): void;
+    /**
+     * Lower level utility to read the content of a browser File object
+     * @param file File object
+     * @param type MIME type
+     * @param isBinary Whether the file is binary
+     * @param deserializer Deserializer name
+     * @param callback Callback function
+     */
+    readFileContent(file: File, type: string, isBinary: boolean, deserializer: string | undefined, callback: (tiddlerFieldsArray: ITiddlerFields[]) => void): void;
+    /**
+     * Get substituted text with variable and filter replacements
+     * @param text Text to perform substitutions on
+     * @param widget Widget for context
+     * @param options Options including substitutions array
+     */
+    getSubstitutedText(text: string, widget: Widget, options?: { substitutions?: Array<{ name: string; value: string }> }): string;
+    /**
+     * Parse a text reference and get parser info
+     * @param title Title of tiddler
+     * @param field Field name
+     * @param index Index name
+     * @param options Options including subTiddler and defaultType
+     */
+    getTextReferenceParserInfo(
+      title: string,
+      field?: string,
+      index?: string,
+      options?: { subTiddler?: string; defaultType?: string },
+    ): { parserType: string | null; sourceText: string | null };
+    /**
+     * Parse a text reference
+     * @param title Title of tiddler
+     * @param field Field name
+     * @param index Index name
+     * @param options Parse options
+     */
+    parseTextReference(title: string, field?: string, index?: string, options?: IParseOptions): WikiParser | null;
+    /**
+     * Get the size of tiddler event queue
+     */
+    getSizeOfTiddlerEventQueue(): number;
+    /**
+     * Clear the tiddler event queue
+     */
+    clearTiddlerEventQueue(): void;
+    /**
+     * Enqueue a tiddler event (internal method)
+     * @param title Tiddler title
+     * @param isDeleted Whether the tiddler was deleted
+     * @param isShadow Whether this is a shadow tiddler change
+     */
+    enqueueTiddlerEvent(title: string, isDeleted?: boolean, isShadow?: boolean): void;
+    /**
+     * Initialize parsers (internal method)
+     * @param moduleType Module type
+     */
+    initParsers(moduleType?: string): void;
+    /**
+     * Add indexers to this wiki (internal method)
+     */
+    addIndexersToWiki(): void;
 
     removeEventListener(
       type: string,
@@ -336,11 +622,11 @@ declare module 'tiddlywiki' {
       handler: (event: unknown) => void | Promise<void>,
     ): void;
     addEventListener(
-      type: "change",
+      type: 'change',
       handler: (change: IChangedTiddlers) => void | Promise<void>,
     ): void;
     addEventListener(
-      type: "lazyLoad",
+      type: 'lazyLoad',
       handler: (title: string) => void | Promise<void>,
     ): void;
 
@@ -349,11 +635,11 @@ declare module 'tiddlywiki' {
       dataOrEvent: unknown,
     ): void;
     dispatchEvent(
-      type: "change",
+      type: 'change',
       change: IChangedTiddlers,
     ): void;
     dispatchEvent(
-      type: "lazyLoad",
+      type: 'lazyLoad',
       title: string,
     ): void;
   }