obsidian-dev-utils 19.1.2-beta.2 → 19.1.2-beta.4

package/dist/lib/esm/codemirror/StateFieldSpec.d.mts

@@ -1 +1,68 @@
-export * from '../../cjs/codemirror/StateFieldSpec.cjs';
+/**
+ * @packageDocumentation StateFieldSpec
+ * Contains a specification for a state field.
+ */
+import type { EditorState, Extension, StateField, Transaction } from '@codemirror/state';
+/**
+ * A specification for a state field.
+ */
+export interface StateFieldSpec<Value> {
+    /**
+     * Compare two values of the field, returning `true` when they are
+     * the same. This is used to avoid recomputing facets that depend
+     * on the field when its value did not change. Defaults to using
+     * `===`.
+     *
+     * @param a - The first value to compare.
+     * @param b - The second value to compare.
+     * @returns `true` if the values are the same, `false` otherwise.
+     */
+    compare?: (a: Value, b: Value) => boolean;
+    /**
+     * Creates the initial value for the field when a state is created.
+     *
+     * @param state - The state to create the value for.
+     * @returns The initial value for the field.
+     */
+    create: (state: EditorState) => Value;
+    /**
+     * A function that deserializes the JSON representation of this
+     * field's content.
+     *
+     * @param json - The JSON representation of the value.
+     * @param state - The state to deserialize the value for.
+     * @returns The deserialized value.
+     */
+    fromJSON?: (json: unknown, state: EditorState) => Value;
+    /**
+     * Provide extensions based on this field. The given function will
+     * be called once with the initialized field. It will usually want
+     * to call some facet's [`from`](https://codemirror.net/6/docs/ref/#state.Facet.from) method to
+     * create facet inputs from this field, but can also return other
+     * extensions that should be enabled when the field is present in a
+     * configuration.
+     *
+     * @param field - The initialized field.
+     * @returns The extensions to enable when the field is present in a configuration.
+     */
+    provide?: (field: StateField<Value>) => Extension;
+    /**
+     * A function used to serialize this field's content to JSON. Only
+     * necessary when this field is included in the argument to
+     * [`EditorState.toJSON`](https://codemirror.net/6/docs/ref/#state.EditorState.toJSON).
+     *
+     * @param value - The value to serialize.
+     * @param state - The state to serialize the value for.
+     * @returns The serialized value.
+     */
+    toJSON?: (value: Value, state: EditorState) => unknown;
+    /**
+     * Compute a new value from the field's previous value and a
+     * [transaction](https://codemirror.net/6/docs/ref/#state.Transaction).
+     *
+     * @param value - The previous value of the field.
+     * @param transaction - The transaction to compute the new value from.
+     * @returns The new value of the field.
+     */
+    update: (value: Value, transaction: Transaction) => Value;
+}

package/dist/lib/esm/codemirror/index.d.mts

@@ -1 +1 @@
-export * from '../../cjs/codemirror/index.cjs';
+export * as StateFieldSpec from './StateFieldSpec.ts';

package/dist/lib/esm/index.d.mts

@@ -1 +1,20 @@
-export * from '../cjs/index.cjs';
+export * as Async from './Async.ts';
+export * as Blob from './Blob.ts';
+export * as codemirror from './codemirror/index.ts';
+export * as CssClass from './CssClass.ts';
+export * as Debug from './Debug.ts';
+export * as DebugController from './DebugController.ts';
+export * as Enum from './Enum.ts';
+export * as Error from './Error.ts';
+export * as Function from './Function.ts';
+export * as HTMLElement from './HTMLElement.ts';
+export * as Library from './Library.ts';
+export * as Object from './Object.ts';
+export * as obsidian from './obsidian/index.ts';
+export * as Path from './Path.ts';
+export * as RegExp from './RegExp.ts';
+export * as ScriptUtils from './ScriptUtils/index.ts';
+export * as String from './String.ts';
+export * as Transformers from './Transformers/index.ts';
+export * as url from './url.ts';
+export * as ValueProvider from './ValueProvider.ts';

package/dist/lib/esm/obsidian/@types/Dataview/api/data-array.d.mts

@@ -1 +1,136 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/api/data-array.cjs';
+import type { QuerySettings } from '../settings.d.d.mts';
+/** A function which maps an array element to some value. */
+export type ArrayFunc<T, O> = (elem: T, index: number, arr: T[]) => O;
+/** A function which compares two types. */
+export type ArrayComparator<T> = (a: T, b: T) => number;
+/** Finds the value of the lowest value type in a grouping. */
+export type LowestKey<T> = T extends {
+  key: any;
+  rows: any;
+} ? LowestKey<T['rows'][0]>
+  : T;
+/** A ridiculous type which properly types the result of the 'groupIn' command. */
+export type Ingrouped<U, T> = T extends {
+  key: any;
+  rows: any;
+} ? {
+    key: T['key'];
+    rows: Ingrouped<U, T['rows'][0]>;
+  }
+  : {
+    key: U;
+    rows: T[];
+  };
+/**
+ * Proxied interface which allows manipulating array-based data. All functions on a data array produce a NEW array
+ * (i.e., the arrays are immutable).
+ */
+export interface DataArray<T> {
+  /** The total number of elements in the array. */
+  length: number;
+  /** Filter the data array down to just elements which match the given predicate. */
+  where(predicate: ArrayFunc<T, boolean>): DataArray<T>;
+  /** Alias for 'where' for people who want array semantics. */
+  filter(predicate: ArrayFunc<T, boolean>): DataArray<T>;
+  /** Map elements in the data array by applying a function to each. */
+  map<U>(f: ArrayFunc<T, U>): DataArray<U>;
+  /** Map elements in the data array by applying a function to each, then flatten the results to produce a new array. */
+  flatMap<U>(f: ArrayFunc<T, U[]>): DataArray<U>;
+  /** Mutably change each value in the array, returning the same array which you can further chain off of. */
+  mutate(f: ArrayFunc<T, void>): DataArray<T>;
+  /** Limit the total number of entries in the array to the given value. */
+  limit(count: number): DataArray<T>;
+  /**
+   * Take a slice of the array. If `start` is undefined, it is assumed to be 0; if `end` is undefined, it is assumed
+   * to be the end of the array.
+   */
+  slice(start?: number, end?: number): DataArray<T>;
+  /** Concatenate the values in this data array with those of another iterable / data array / array. */
+  concat(other: Iterable<T>): DataArray<T>;
+  /** Return the first index of the given (optionally starting the search) */
+  indexOf(element: T, fromIndex?: number): number;
+  /** Return the first element that satisfies the given predicate. */
+  find(pred: ArrayFunc<T, boolean>): T | undefined;
+  /** Find the index of the first element that satisfies the given predicate. Returns -1 if nothing was found. */
+  findIndex(pred: ArrayFunc<T, boolean>, fromIndex?: number): number;
+  /** Returns true if the array contains the given element, and false otherwise. */
+  includes(element: T): boolean;
+  /**
+   * Return a string obtained by converting each element in the array to a string, and joining it with the
+   * given separator (which defaults to ', ').
+   */
+  join(sep?: string): string;
+  /**
+   * Return a sorted array sorted by the given key; an optional comparator can be provided, which will
+   * be used to compare the keys in lieu of the default dataview comparator.
+   */
+  sort<U>(key: ArrayFunc<T, U>, direction?: 'asc' | 'desc', comparator?: ArrayComparator<U>): DataArray<T>;
+  /**
+   * Mutably modify the current array with an in place sort; this is less flexible than a regular sort in exchange
+   * for being a little more performant. Only use this is performance is a serious consideration.
+   */
+  sortInPlace<U>(key: (v: T) => U, direction?: 'asc' | 'desc', comparator?: ArrayComparator<U>): DataArray<T>;
+  /**
+   * Return an array where elements are grouped by the given key; the resulting array will have objects of the form
+   * { key: <key value>, rows: DataArray }.
+   */
+  groupBy<U>(key: ArrayFunc<T, U>, comparator?: ArrayComparator<U>): DataArray<{
+    key: U;
+    rows: DataArray<T>;
+  }>;
+  /**
+   * If the array is not grouped, groups it as `groupBy` does; otherwise, groups the elements inside each current
+   * group. This allows for top-down recursive grouping which may be easier than bottom-up grouping.
+   */
+  groupIn<U>(key: ArrayFunc<LowestKey<T>, U>, comparator?: ArrayComparator<U>): DataArray<Ingrouped<U, T>>;
+  /**
+   * Return distinct entries. If a key is provided, then rows with distinct keys are returned.
+   */
+  distinct<U>(key?: ArrayFunc<T, U>, comparator?: ArrayComparator<U>): DataArray<T>;
+  /** Return true if the predicate is true for all values. */
+  every(f: ArrayFunc<T, boolean>): boolean;
+  /** Return true if the predicate is true for at least one value. */
+  some(f: ArrayFunc<T, boolean>): boolean;
+  /** Return true if the predicate is FALSE for all values. */
+  none(f: ArrayFunc<T, boolean>): boolean;
+  /** Return the first element in the data array. Returns undefined if the array is empty. */
+  first(): T;
+  /** Return the last element in the data array. Returns undefined if the array is empty. */
+  last(): T;
+  /** Map every element in this data array to the given key, and then flatten it.*/
+  to(key: string): DataArray<any>;
+  /** Map every element in this data array to the given key; unlike to(), does not flatten the result. */
+  into(key: string): DataArray<any>;
+  /**
+   * Recursively expand the given key, flattening a tree structure based on the key into a flat array. Useful for handling
+   * hierarchical data like tasks with 'subtasks'.
+   */
+  expand(key: string): DataArray<any>;
+  /** Run a lambda on each element in the array. */
+  forEach(f: ArrayFunc<T, void>): void;
+  /** Calculate the sum of the elements in the array. */
+  sum(): number;
+  /** Calculate the average of the elements in the array. */
+  avg(): number;
+  /** Calculate the minimum of the elements in the array. */
+  min(): number;
+  /** Calculate the maximum of the elements in the array. */
+  max(): number;
+  /** Convert this to a plain javascript array. */
+  array(): T[];
+  /** Allow iterating directly over the array. */
+  [Symbol.iterator](): Iterator<T>;
+  /** Map indexes to values. */
+  [index: number]: any;
+  /** Automatic flattening of fields. Equivalent to implicitly calling `array.to("field")` */
+  [field: string]: any;
+}
+/** Provides utility functions for generating data arrays. */
+export declare namespace DataArray {
+  /** Create a new Dataview data array. */
+  function wrap<T>(raw: T[] | DataArray<T>, settings: QuerySettings): DataArray<T>;
+  /** Create a new DataArray from an iterable object. */
+  function from<T>(raw: Iterable<T>, settings: QuerySettings): DataArray<T>;
+  /** Return true if the given object is a data array. */
+  function isDataArray(obj: any): obj is DataArray<any>;
+}

package/dist/lib/esm/obsidian/@types/Dataview/api/extensions.d.mts

@@ -1 +1,15 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/api/extensions.cjs';
+import type { STask } from '../data-model/serialized/markdown.d.d.mts';
+/** A general function for deciding how to check a task given it's current state. */
+export type TaskStatusSelector = (task: STask) => Promise<string>;
+/**
+ * A dataview extension; allows for registering new functions, altering views, and altering some more
+ * advanced dataview behavior.
+ */
+export declare class Extension {
+  plugin: string;
+  /** All registered task status selectors for this extension. */
+  taskStatusSelectors: Record<string, TaskStatusSelector>;
+  constructor(plugin: string);
+  /** Register a task status selector under the given name. */
+  taskStatusSelector(name: string, selector: TaskStatusSelector): Extension;
+}

package/dist/lib/esm/obsidian/@types/Dataview/api/inline-api.d.mts

@@ -1 +1,186 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/api/inline-api.cjs';
+/** Fancy wrappers for the JavaScript API, used both by external plugins AND by the dataview javascript view. */
+import type {
+  DateTime,
+  Duration
+} from 'luxon';
+import * as Luxon from 'luxon';
+import type {
+  App,
+  Component
+} from 'obsidian';
+import type {
+  DataviewApi,
+  DataviewIOApi,
+  QueryApiSettings,
+  QueryResult
+} from '../api/plugin-api.d.d.mts';
+import type { Result } from '../api/result.d.d.mts';
+import type { FullIndex } from '../data-index/index.d.d.mts';
+import type { SListItem } from '../data-model/serialized/markdown.d.d.mts';
+import type {
+  DataObject,
+  Grouping,
+  Link,
+  Literal,
+  Values,
+  Widgets
+} from '../data-model/value.d.d.mts';
+import type { Context } from '../expression/context.d.d.mts';
+import type { BoundFunctionImpl } from '../expression/functions.d.d.mts';
+import type {
+  DataviewSettings,
+  ExportSettings
+} from '../settings.d.d.mts';
+import type { DataArray } from './data-array.d.d.mts';
+/** Asynchronous API calls related to file / system IO. */
+export declare class DataviewInlineIOApi {
+  api: DataviewIOApi;
+  currentFile: string;
+  constructor(api: DataviewIOApi, currentFile: string);
+  /** Load the contents of a CSV asynchronously, returning a data array of rows (or undefined if it does not exist). */
+  csv(path: string, originFile?: string): Promise<DataArray<DataObject> | undefined>;
+  /** Asynchronously load the contents of any link or path in an Obsidian vault. */
+  load(path: Link | string, originFile?: string): Promise<string | undefined>;
+  /** Normalize a link or path relative to an optional origin file. Returns a textual fully-qualified-path. */
+  normalize(path: Link | string, originFile?: string): string;
+}
+export declare class DataviewInlineApi {
+  /**
+   * The raw dataview indices, which track file <-> metadata relations. Use these if the intuitive API does not support
+   * your use case.
+   */
+  index: FullIndex;
+  /** The component that handles the lifetime of this view. Use it if you are adding custom event handlers/components. */
+  component: Component;
+  /** The path to the current file this script is running in. */
+  currentFilePath: string;
+  /**
+   * The container which holds the output of this view. You can directly append fields to this, if you wish, though
+   * the rendering API is likely to be easier for straight-forward purposes.
+   */
+  container: HTMLElement;
+  /** Directly access the Obsidian app object, such as for reaching out to other plugins. */
+  app: App;
+  /** The general plugin API which much of this inline API delegates to. */
+  api: DataviewApi;
+  /** Settings which determine defaults, incl. many rendering options. */
+  settings: DataviewSettings;
+  /** Evaluation context which expressions can be evaluated in. */
+  evaluationContext: Context;
+  /** Value utilities which allow for type-checking and comparisons. */
+  value: typeof Values;
+  /** Widget utility functions for creating built-in widgets. */
+  widget: typeof Widgets;
+  /** IO utilities which are largely asynchronous. */
+  io: DataviewInlineIOApi;
+  /** Re-exporting of luxon for people who can't easily require it. Sorry! */
+  luxon: typeof Luxon;
+  /** Dataview functions which can be called from DataviewJS. */
+  func: Record<string, BoundFunctionImpl>;
+  constructor(api: DataviewApi, component: Component, container: HTMLElement, currentFilePath: string);
+  /** Return an array of paths (as strings) corresponding to pages which match the query. */
+  pagePaths(query?: string): DataArray<string>;
+  /** Map a page path to the actual data contained within that page. */
+  page(path: string | Link): DataObject | undefined;
+  /** Return an array of page objects corresponding to pages which match the query. */
+  pages(query?: string): DataArray<any>;
+  /** Return the information about the current page. */
+  current(): Record<string, any> | undefined;
+  /** Execute a Dataview query, returning the results in programmatic form. */
+  query(source: string, originFile?: string, settings?: QueryApiSettings): Promise<Result<QueryResult, string>>;
+  /** Error-throwing version of {@link query}. */
+  tryQuery(source: string, originFile?: string, settings?: QueryApiSettings): Promise<QueryResult>;
+  /** Execute a Dataview query, returning the results in Markdown. */
+  queryMarkdown(source: string, originFile?: string, settings?: QueryApiSettings): Promise<Result<string, string>>;
+  /** Error-throwing version of {@link queryMarkdown}. */
+  tryQueryMarkdown(source: string, originFile?: string, settings?: QueryApiSettings): Promise<string>;
+  /**
+   * Evaluate a dataview expression (like '2 + 2' or 'link("hello")'), returning the evaluated result.
+   * This takes an optional second argument which provides definitions for variables, such as:
+   *
+   * ```
+   * dv.evaluate("x + 6", { x: 2 }) = 8
+   * dv.evaluate('link(target)', { target: "Okay" }) = [[Okay]]
+   * ```
+   *
+   * Note that `this` is implicitly available and refers to the current file.
+   *
+   * This method returns a Result type instead of throwing an error; you can check the result of the
+   * execution via `result.successful` and obtain `result.value` or `result.error` accordingly. If
+   * you'd rather this method throw on an error, use `dv.tryEvaluate`.
+   */
+  evaluate(expression: string, context?: DataObject): Result<Literal, string>;
+  /** Error-throwing version of `dv.evaluate`. */
+  tryEvaluate(expression: string, context?: DataObject): Literal;
+  /** Execute a Dataview query and embed it into the current view. */
+  execute(source: string): Promise<void>;
+  /** Execute a DataviewJS query and embed it into the current view. */
+  executeJs(code: string): Promise<void>;
+  /**
+   * Convert an input element or array into a Dataview data-array. If the input is already a data array,
+   * it is returned unchanged.
+   */
+  array(raw: any): DataArray<any>;
+  /** Return true if the given value is a javascript array OR a dataview data array. */
+  isArray(raw: any): raw is DataArray<any> | Array<any>;
+  /** Return true if the given value is a dataview data array; this returns FALSE for plain JS arrays. */
+  isDataArray(raw: unknown): raw is DataArray<any>;
+  /** Create a dataview file link to the given path. */
+  fileLink(path: string, embed?: boolean, display?: string): Link;
+  /** Create a dataview section link to the given path. */
+  sectionLink(path: string, section: string, embed?: boolean, display?: string): Link;
+  /** Create a dataview block link to the given path. */
+  blockLink(path: string, blockId: string, embed?: boolean, display?: string): Link;
+  /** Attempt to extract a date from a string, link or date. */
+  date(pathlike: string | Link | DateTime): DateTime | null;
+  /** Attempt to extract a duration from a string or duration. */
+  duration(dur: string | Duration): Duration | null;
+  /** Parse a raw textual value into a complex Dataview type, if possible. */
+  parse(value: string): Literal;
+  /** Convert a basic JS type into a Dataview type by parsing dates, links, durations, and so on. */
+  literal(value: any): Literal;
+  /** Deep clone the given literal, returning a new literal which is independent of the original. */
+  clone(value: Literal): Literal;
+  /**
+   * Compare two arbitrary JavaScript values using Dataview's default comparison rules. Returns a negative value if
+   * a < b, 0 if a = b, and a positive value if a > b.
+   */
+  compare(a: any, b: any): number;
+  /** Return true if the two given JavaScript values are equal using Dataview's default comparison rules. */
+  equal(a: any, b: any): boolean;
+  /** Render an HTML element, containing arbitrary text. */
+  el<K extends keyof HTMLElementTagNameMap>(el: K, text: any, { container, ...options }?: DomElementInfo & {
+    container?: HTMLElement;
+  }): HTMLElementTagNameMap[K];
+  /** Render an HTML header; the level can be anything from 1 - 6. */
+  header(level: number, text: any, options?: DomElementInfo): HTMLHeadingElement;
+  /** Render an HTML paragraph, containing arbitrary text. */
+  paragraph(text: any, options?: DomElementInfo): HTMLParagraphElement;
+  /** Render an inline span, containing arbitrary text. */
+  span(text: any, options?: DomElementInfo): HTMLSpanElement;
+  /**
+   * Render HTML from the output of a template "view" saved as a file in the vault.
+   * Takes a filename and arbitrary input data.
+   */
+  view(viewName: string, input: any): Promise<void>;
+  /** Render a dataview list of the given values. */
+  list(values?: any[] | DataArray<any>): Promise<void>;
+  /** Render a dataview table with the given headers, and the 2D array of values. */
+  table(headers: string[], values?: any[][] | DataArray<any>): Promise<void>;
+  /** Render a dataview task view with the given tasks. */
+  taskList(tasks: Grouping<SListItem>, groupByFile?: boolean): Promise<void>;
+  /** Render a table directly to markdown, returning the markdown. */
+  markdownTable(headers: string[], values?: any[][] | DataArray<any>, settings?: Partial<ExportSettings>): string;
+  /** Render a list directly to markdown, returning the markdown. */
+  markdownList(values?: any[] | DataArray<any> | undefined, settings?: Partial<ExportSettings>): string;
+  /** Render at ask list directly to markdown, returning the markdown. */
+  markdownTaskList(values: Grouping<SListItem>, settings?: Partial<ExportSettings>): string;
+}
+/**
+ * Evaluate a script where 'this' for the script is set to the given context. Allows you to define global variables.
+ */
+export declare function evalInContext(script: string, context: any): any;
+/**
+ * Evaluate a script possibly asynchronously, if the script contains `async/await` blocks.
+ */
+export declare function asyncEvalInContext(script: string, context: any): Promise<any>;

package/dist/lib/esm/obsidian/@types/Dataview/api/plugin-api.d.mts

@@ -1 +1,209 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/api/plugin-api.cjs';
+/** The general, externally accessible plugin API (available at `app.plugins.plugins.dataview.api` or as global `DataviewAPI`). */
+import type { CompareOperator } from 'compare-versions';
+import type {
+  DateTime,
+  Duration
+} from 'luxon';
+import * as Luxon from 'luxon';
+import type {
+  App,
+  Component,
+  MarkdownPostProcessorContext
+} from 'obsidian';
+import type { Result } from '../api/result.d.d.mts';
+import type { FullIndex } from '../data-index/index.d.d.mts';
+import type { SListItem } from '../data-model/serialized/markdown.d.d.mts';
+import type {
+  DataObject,
+  Grouping,
+  Link,
+  Literal,
+  Values,
+  Widgets
+} from '../data-model/value.d.d.mts';
+import type { Context } from '../expression/context.d.d.mts';
+import type { BoundFunctionImpl } from '../expression/functions.d.d.mts';
+import type { IdentifierMeaning } from '../query/engine.d.d.mts';
+import type { Query } from '../query/query.d.d.mts';
+import type {
+  DataviewSettings,
+  ExportSettings
+} from '../settings.d.d.mts';
+import type { DataArray } from './data-array.d.d.mts';
+/** Asynchronous API calls related to file / system IO. */
+export declare class DataviewIOApi {
+  api: DataviewApi;
+  constructor(api: DataviewApi);
+  /** Load the contents of a CSV asynchronously, returning a data array of rows (or undefined if it does not exist). */
+  csv(path: Link | string, originFile?: string): Promise<DataArray<DataObject> | undefined>;
+  /** Asynchronously load the contents of any link or path in an Obsidian vault. */
+  load(path: Link | string, originFile?: string): Promise<string | undefined>;
+  /** Normalize a link or path relative to an optional origin file. Returns a textual fully-qualified-path. */
+  normalize(path: Link | string, originFile?: string): string;
+}
+/** Global API for accessing the Dataview API, executing dataview queries, and  */
+export declare class DataviewApi {
+  app: App;
+  index: FullIndex;
+  settings: DataviewSettings;
+  private verNum;
+  /** Evaluation context which expressions can be evaluated in. */
+  evaluationContext: Context;
+  /** IO API which supports asynchronous loading of data directly. */
+  io: DataviewIOApi;
+  /** Dataview functions which can be called from DataviewJS. */
+  func: Record<string, BoundFunctionImpl>;
+  /** Value utility functions for comparisons and type-checking. */
+  value: typeof Values;
+  /** Widget utility functions for creating built-in widgets. */
+  widget: typeof Widgets;
+  /** Re-exporting of luxon for people who can't easily require it. Sorry! */
+  luxon: typeof Luxon;
+  constructor(app: App, index: FullIndex, settings: DataviewSettings, verNum: string);
+  /** Utilities to check the current Dataview version and compare it to SemVer version ranges. */
+  version: {
+    current: string;
+    compare: (op: CompareOperator, ver: string) => boolean;
+    satisfies: (range: string) => boolean;
+  };
+  /** Return an array of paths (as strings) corresponding to pages which match the query. */
+  pagePaths(query?: string, originFile?: string): DataArray<string>;
+  /** Map a page path to the actual data contained within that page. */
+  page(path: string | Link, originFile?: string): Record<string, Literal> | undefined;
+  /** Return an array of page objects corresponding to pages which match the source query. */
+  pages(query?: string, originFile?: string): DataArray<Record<string, Literal>>;
+  /** Remaps important metadata to add data arrays.  */
+  private _addDataArrays;
+  /**
+   * Convert an input element or array into a Dataview data-array. If the input is already a data array,
+   * it is returned unchanged.
+   */
+  array(raw: unknown): DataArray<any>;
+  /** Return true if the given value is a javascript array OR a dataview data array. */
+  isArray(raw: unknown): raw is DataArray<any> | Array<any>;
+  /** Return true if the given value is a dataview data array; this returns FALSE for plain JS arrays. */
+  isDataArray(raw: unknown): raw is DataArray<any>;
+  /** Create a dataview file link to the given path. */
+  fileLink(path: string, embed?: boolean, display?: string): Link;
+  /** Create a dataview section link to the given path. */
+  sectionLink(path: string, section: string, embed?: boolean, display?: string): Link;
+  /** Create a dataview block link to the given path. */
+  blockLink(path: string, blockId: string, embed?: boolean, display?: string): Link;
+  /** Attempt to extract a date from a string, link or date. */
+  date(pathlike: string | Link | DateTime): DateTime | null;
+  /** Attempt to extract a duration from a string or duration. */
+  duration(str: string | Duration): Duration | null;
+  /** Parse a raw textual value into a complex Dataview type, if possible. */
+  parse(value: string): Literal;
+  /** Convert a basic JS type into a Dataview type by parsing dates, links, durations, and so on. */
+  literal(value: any): Literal;
+  /** Deep clone the given literal, returning a new literal which is independent of the original. */
+  clone(value: Literal): Literal;
+  /**
+   * Compare two arbitrary JavaScript values using Dataview's default comparison rules. Returns a negative value if
+   * a < b, 0 if a = b, and a positive value if a > b.
+   */
+  compare(a: any, b: any): number;
+  /** Return true if the two given JavaScript values are equal using Dataview's default comparison rules. */
+  equal(a: any, b: any): boolean;
+  /**
+   * Execute an arbitrary Dataview query, returning a query result which:
+   *
+   * 1. Indicates the type of query,
+   * 2. Includes the raw AST of the parsed query.
+   * 3. Includes the output in the form relevant to that query type.
+   *
+   * List queries will return a list of objects ({ id, value }); table queries return a header array
+   * and a 2D array of values; and task arrays return a Grouping<Task> type which allows for recursive
+   * task nesting.
+   */
+  query(source: string | Query, originFile?: string, settings?: QueryApiSettings): Promise<Result<QueryResult, string>>;
+  /** Error-throwing version of {@link query}. */
+  tryQuery(source: string, originFile?: string, settings?: QueryApiSettings): Promise<QueryResult>;
+  /** Execute an arbitrary dataview query, returning the results in well-formatted markdown. */
+  queryMarkdown(source: string | Query, originFile?: string, settings?: Partial<QueryApiSettings & ExportSettings>): Promise<Result<string, string>>;
+  /** Error-throwing version of {@link queryMarkdown}. */
+  tryQueryMarkdown(source: string | Query, originFile?: string, settings?: Partial<QueryApiSettings & ExportSettings>): Promise<string>;
+  /**
+   * Evaluate a dataview expression (like '2 + 2' or 'link("hello")'), returning the evaluated result.
+   * This takes an optional second argument which provides definitions for variables, such as:
+   *
+   * ```
+   * dv.evaluate("x + 6", { x: 2 }) = 8
+   * dv.evaluate('link(target)', { target: "Okay" }) = [[Okay]]
+   * ```
+   *
+   * This method returns a Result type instead of throwing an error; you can check the result of the
+   * execution via `result.successful` and obtain `result.value` or `result.error` accordingly. If
+   * you'd rather this method throw on an error, use `dv.tryEvaluate`.
+   */
+  evaluate(expression: string, context?: DataObject, originFile?: string): Result<Literal, string>;
+  /** Error-throwing version of `dv.evaluate`. */
+  tryEvaluate(expression: string, context?: DataObject, originFile?: string): Literal;
+  /** Evaluate an expression in the context of the given file. */
+  evaluateInline(expression: string, origin: string): Result<Literal, string>;
+  /**
+   * Execute the given query, rendering results into the given container using the components lifecycle.
+   * Your component should be a *real* component which calls onload() on it's child components at some point,
+   * or a MarkdownPostProcessorContext!
+   *
+   * Note that views made in this way are live updating and will automatically clean themselves up when
+   * the component is unloaded or the container is removed.
+   */
+  execute(source: string, container: HTMLElement, component: Component | MarkdownPostProcessorContext, filePath: string): Promise<void>;
+  /**
+   * Execute the given DataviewJS query, rendering results into the given container using the components lifecycle.
+   * See {@link execute} for general rendering semantics.
+   */
+  executeJs(code: string, container: HTMLElement, component: Component | MarkdownPostProcessorContext, filePath: string): Promise<void>;
+  /** Render a dataview list of the given values. */
+  list(values: any[] | DataArray<any> | undefined, container: HTMLElement, component: Component, filePath: string): Promise<void>;
+  /** Render a dataview table with the given headers, and the 2D array of values. */
+  table(headers: string[], values: any[][] | DataArray<any> | undefined, container: HTMLElement, component: Component, filePath: string): Promise<void>;
+  /** Render a dataview task view with the given tasks. */
+  taskList(tasks: Grouping<SListItem>, groupByFile: boolean | undefined, container: HTMLElement, component: Component, filePath?: string): Promise<void>;
+  /** Render an arbitrary value into a container. */
+  renderValue(value: any, container: HTMLElement, component: Component, filePath: string, inline?: boolean): Promise<void>;
+  /** Render data to a markdown table. */
+  markdownTable(headers: string[] | undefined, values: any[][] | DataArray<any> | undefined, settings?: Partial<ExportSettings>): string;
+  /** Render data to a markdown list. */
+  markdownList(values: any[] | DataArray<any> | undefined, settings?: Partial<ExportSettings>): string;
+  /** Render tasks or list items to a markdown task list. */
+  markdownTaskList(values: Grouping<SListItem>, settings?: Partial<ExportSettings>): string;
+}
+/** The result of executing a table query. */
+export type TableResult = {
+  type: 'table';
+  headers: string[];
+  values: Literal[][];
+  idMeaning: IdentifierMeaning;
+};
+/** The result of executing a list query. */
+export type ListResult = {
+  type: 'list';
+  values: Literal[];
+  primaryMeaning: IdentifierMeaning;
+};
+/** The result of executing a task query. */
+export type TaskResult = {
+  type: 'task';
+  values: Grouping<SListItem>;
+};
+/** The result of executing a calendar query. */
+export type CalendarResult = {
+  type: 'calendar';
+  values: {
+    date: DateTime;
+    link: Link;
+    value?: Literal[];
+  }[];
+};
+/** The result of executing a query of some sort. */
+export type QueryResult = TableResult | ListResult | TaskResult | CalendarResult;
+/** Settings when querying the dataview API. */
+export type QueryApiSettings = {
+  /** If present, then this forces queries to include/exclude the implicit id field (such as with `WITHOUT ID`). */
+  forceId?: boolean;
+};
+/** Determines if source-path has a `?no-dataview` annotation that disables dataview. */
+export declare function isDataviewDisabled(sourcePath: string): boolean;