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

package/dist/lib/esm/obsidian/@types/Dataview/expression/parse.d.mts

@@ -1 +1,163 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/expression/parse.cjs';
+import type {
+  DateTime,
+  Duration
+} from 'luxon';
+import * as P from 'parsimmon';
+import type { Result } from '../api/result.d.d.mts';
+import type {
+  CsvSource,
+  FolderSource,
+  NegatedSource,
+  Source,
+  TagSource
+} from '../data-index/source.d.d.mts';
+import type {
+  Link,
+  Literal
+} from '../data-model/value.d.d.mts';
+import type {
+  BinaryOp,
+  Field,
+  LambdaField,
+  ListField,
+  LiteralField,
+  ObjectField,
+  VariableField
+} from './field.d.d.mts';
+/** Provides a lookup table for unit durations of the given type. */
+export declare const DURATION_TYPES: {
+  year: Duration;
+  years: Duration;
+  yr: Duration;
+  yrs: Duration;
+  month: Duration;
+  months: Duration;
+  mo: Duration;
+  mos: Duration;
+  week: Duration;
+  weeks: Duration;
+  wk: Duration;
+  wks: Duration;
+  w: Duration;
+  day: Duration;
+  days: Duration;
+  d: Duration;
+  hour: Duration;
+  hours: Duration;
+  hr: Duration;
+  hrs: Duration;
+  h: Duration;
+  minute: Duration;
+  minutes: Duration;
+  min: Duration;
+  mins: Duration;
+  m: Duration;
+  second: Duration;
+  seconds: Duration;
+  sec: Duration;
+  secs: Duration;
+  s: Duration;
+};
+/** Shorthand for common dates (relative to right now). */
+export declare const DATE_SHORTHANDS: {
+  now: () => DateTime;
+  today: () => DateTime;
+  yesterday: () => DateTime;
+  tomorrow: () => DateTime;
+  sow: () => DateTime;
+  'start-of-week': () => DateTime;
+  eow: () => DateTime;
+  'end-of-week': () => DateTime;
+  soy: () => DateTime;
+  'start-of-year': () => DateTime;
+  eoy: () => DateTime;
+  'end-of-year': () => DateTime;
+  som: () => DateTime;
+  'start-of-month': () => DateTime;
+  eom: () => DateTime;
+  'end-of-month': () => DateTime;
+};
+/**
+ * Keywords which cannot be used as variables directly. Use `row.<thing>` if it is a variable you have defined and want
+ * to access.
+ */
+export declare const KEYWORDS: string[];
+/** Attempt to parse the inside of a link to pull out display name, subpath, etc. */
+export declare function parseInnerLink(rawlink: string): Link;
+/** Create a left-associative binary parser which parses the given sub-element and separator. Handles whitespace. */
+export declare function createBinaryParser<T, U>(child: P.Parser<T>, sep: P.Parser<U>, combine: (a: T, b: U, c: T) => T): P.Parser<T>;
+export declare function chainOpt<T>(base: P.Parser<T>, ...funcs: ((r: T) => P.Parser<T>)[]): P.Parser<T>;
+export type PostfixFragment = {
+  type: 'dot';
+  field: string;
+} | {
+  type: 'index';
+  field: Field;
+} | {
+  type: 'function';
+  fields: Field[];
+};
+export interface ExpressionLanguage {
+  number: number;
+  string: string;
+  escapeCharacter: string;
+  bool: boolean;
+  tag: string;
+  identifier: string;
+  link: Link;
+  embedLink: Link;
+  rootDate: DateTime;
+  dateShorthand: keyof typeof DATE_SHORTHANDS;
+  date: DateTime;
+  datePlus: DateTime;
+  durationType: keyof typeof DURATION_TYPES;
+  duration: Duration;
+  rawNull: string;
+  binaryPlusMinus: BinaryOp;
+  binaryMulDiv: BinaryOp;
+  binaryCompareOp: BinaryOp;
+  binaryBooleanOp: BinaryOp;
+  tagSource: TagSource;
+  csvSource: CsvSource;
+  folderSource: FolderSource;
+  parensSource: Source;
+  atomSource: Source;
+  linkIncomingSource: Source;
+  linkOutgoingSource: Source;
+  negateSource: NegatedSource;
+  binaryOpSource: Source;
+  source: Source;
+  variableField: VariableField;
+  numberField: LiteralField;
+  boolField: LiteralField;
+  stringField: LiteralField;
+  dateField: LiteralField;
+  durationField: LiteralField;
+  linkField: LiteralField;
+  nullField: LiteralField;
+  listField: ListField;
+  objectField: ObjectField;
+  atomInlineField: Literal;
+  inlineFieldList: Literal[];
+  inlineField: Literal;
+  negatedField: Field;
+  atomField: Field;
+  indexField: Field;
+  lambdaField: LambdaField;
+  dotPostfix: PostfixFragment;
+  indexPostfix: PostfixFragment;
+  functionPostfix: PostfixFragment;
+  binaryMulDivField: Field;
+  binaryPlusMinusField: Field;
+  binaryCompareField: Field;
+  binaryBooleanField: Field;
+  binaryOpField: Field;
+  parensField: Field;
+  field: Field;
+}
+export declare const EXPRESSION: P.TypedLanguage<ExpressionLanguage>;
+/**
+ * Attempt to parse a field from the given text, returning a string error if the
+ * parse failed.
+ */
+export declare function parseField(text: string): Result<Field, string>;

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

@@ -1 +1,55 @@
-export * from '../../../../cjs/obsidian/@types/Dataview/index.cjs';
+export type {
+  DateTime,
+  Duration
+} from 'luxon';
+export type { DataArray } from './api/data-array.d.ts';
+export type { DataviewApi } from './api/plugin-api.d.ts';
+export type {
+  Failure,
+  Result,
+  Success
+} from './api/result.d.ts';
+export type {
+  FullIndex,
+  IndexMap,
+  PrefixIndex
+} from './data-index/index.d.ts';
+export type {
+  ListItem,
+  PageMetadata
+} from './data-model/markdown.d.ts';
+export type {
+  SListEntry,
+  SMarkdownPage,
+  STask
+} from './data-model/serialized/markdown.d.ts';
+export type {
+  DataObject,
+  Link,
+  Literal,
+  LiteralRepr,
+  LiteralType,
+  LiteralWrapper,
+  Widget,
+  WrappedLiteral
+} from './data-model/value.d.ts';
+export type {
+  DATE_SHORTHANDS,
+  DURATION_TYPES,
+  EXPRESSION,
+  ExpressionLanguage,
+  KEYWORDS,
+  parseField
+} from './expression/parse.d.ts';
+export type { QUERY_LANGUAGE } from './query/parse.d.ts';
+export type { Query } from './query/query.d.ts';
+import type { DataviewApi } from './api/plugin-api.d.d.mts';
+import 'obsidian';
+import type { App } from 'obsidian';
+/**
+ * Get the current Dataview API from the app if provided; if not, it is inferred from the global API object installed
+ * on the window.
+ */
+export declare const getAPI: (app?: App) => DataviewApi | undefined;
+/** Determine if Dataview is enabled in the given application. */
+export declare const isPluginEnabled: (app: App) => boolean;

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

@@ -1 +1,52 @@
-export * from '../../../../cjs/obsidian/@types/Dataview/main.cjs';
+import type {
+  Component,
+  MarkdownPostProcessorContext,
+  Plugin
+} from 'obsidian';
+import type { DataviewInlineApi } from './api/inline-api.d.d.mts';
+import type { DataviewApi } from './api/plugin-api.d.d.mts';
+import type { FullIndex } from './data-index/index.d.d.mts';
+import type { DataviewSettings } from './settings.d.d.mts';
+export default class DataviewPlugin extends Plugin {
+  /** Plugin-wide default settings. */
+  settings: DataviewSettings;
+  /** The index that stores all dataview data. */
+  index: FullIndex;
+  /** External-facing plugin API. */
+  api: DataviewApi;
+  /** CodeMirror 6 extensions that dataview installs. Tracked via array to allow for dynamic updates. */
+  private cmExtension;
+  onload(): Promise<void>;
+  registerDataviewjsCodeHighlighting(): void;
+  unregisterDataviewjsCodeHighlighting(): void;
+  private debouncedRefresh;
+  private updateRefreshSettings;
+  onunload(): void;
+  /** Register a markdown post processor with the given priority. */
+  registerPriorityMarkdownPostProcessor(priority: number, processor: (el: HTMLElement, ctx: MarkdownPostProcessorContext) => Promise<void>): void;
+  /** Register a markdown codeblock post processor with the given priority. */
+  registerPriorityCodeblockPostProcessor(
+    language: string,
+    priority: number,
+    processor: (source: string, el: HTMLElement, ctx: MarkdownPostProcessorContext) => Promise<void>
+  ): void;
+  updateEditorExtensions(): void;
+  /**
+   * Based on the source, generate a dataview view. This works by doing an initial parsing pass, and then adding
+   * a long-lived view object to the given component for life-cycle management.
+   */
+  dataview(source: string, el: HTMLElement, component: Component | MarkdownPostProcessorContext, sourcePath: string): Promise<void>;
+  /** Generate a DataviewJS view running the given source in the given element. */
+  dataviewjs(source: string, el: HTMLElement, component: Component | MarkdownPostProcessorContext, sourcePath: string): Promise<void>;
+  /** Render all dataview inline expressions in the given element. */
+  dataviewInline(el: HTMLElement, component: Component | MarkdownPostProcessorContext, sourcePath: string): Promise<void>;
+  /** Update plugin settings. */
+  updateSettings(settings: Partial<DataviewSettings>): Promise<void>;
+  /** @deprecated Call the given callback when the dataview API has initialized. */
+  withApi(callback: (api: DataviewApi) => void): void;
+  /**
+   * Create an API element localized to the given path, with lifecycle management managed by the given component.
+   * The API will output results to the given HTML element.
+   */
+  localApi(path: string, component: Component, el: HTMLElement): DataviewInlineApi;
+}

package/dist/lib/esm/obsidian/@types/Dataview/query/engine.d.mts

@@ -1 +1,103 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/query/engine.cjs';
+/**
+ * Takes a full query and a set of indices, and (hopefully quickly) returns all relevant files.
+ */
+import type { DateTime } from 'luxon';
+import type { Result } from '../api/result.d.d.mts';
+import type { FullIndex } from '../data-index/index.d.d.mts';
+import type { Datarow } from '../data-index/resolver.d.d.mts';
+import type { SListItem } from '../data-model/serialized/markdown.d.d.mts';
+import type {
+  DataObject,
+  Grouping,
+  Link,
+  Literal
+} from '../data-model/value.d.d.mts';
+import type {
+  Context,
+  LinkHandler
+} from '../expression/context.d.d.mts';
+import type { Field } from '../expression/field.d.d.mts';
+import type {
+  Query,
+  QueryOperation
+} from '../query/query.d.d.mts';
+import type { QuerySettings } from '../settings.d.d.mts';
+/** Operation diagnostics collected during the execution of each query step. */
+export interface OperationDiagnostics {
+  timeMs: number;
+  incomingRows: number;
+  outgoingRows: number;
+  errors: {
+    index: number;
+    message: string;
+  }[];
+}
+/** The meaning of the 'id' field for a data row - i.e., where it came from. */
+export type IdentifierMeaning = {
+  type: 'group';
+  name: string;
+  on: IdentifierMeaning;
+} | {
+  type: 'path';
+};
+/** A data row over an object. */
+export type Pagerow = Datarow<DataObject>;
+/** An error during execution. */
+export type ExecutionError = {
+  index: number;
+  message: string;
+};
+/** The result of executing query operations over incoming data rows; includes timing and error information. */
+export interface CoreExecution {
+  data: Pagerow[];
+  idMeaning: IdentifierMeaning;
+  timeMs: number;
+  ops: QueryOperation[];
+  diagnostics: OperationDiagnostics[];
+}
+/** Shared execution code which just takes in arbitrary data, runs operations over it, and returns it + per-row errors. */
+export declare function executeCore(rows: Pagerow[], context: Context, ops: QueryOperation[]): Result<CoreExecution, string>;
+/** Expanded version of executeCore which adds an additional "extraction" step to the pipeline. */
+export declare function executeCoreExtract(
+  rows: Pagerow[],
+  context: Context,
+  ops: QueryOperation[],
+  fields: Record<string, Field>
+): Result<CoreExecution, string>;
+export interface ListExecution {
+  core: CoreExecution;
+  data: Literal[];
+  primaryMeaning: IdentifierMeaning;
+}
+/** Execute a list-based query, returning the final results. */
+export declare function executeList(query: Query, index: FullIndex, origin: string, settings: QuerySettings): Promise<Result<ListExecution, string>>;
+/** Result of executing a table query. */
+export interface TableExecution {
+  core: CoreExecution;
+  names: string[];
+  data: Literal[][];
+  idMeaning: IdentifierMeaning;
+}
+/** Execute a table query. */
+export declare function executeTable(query: Query, index: FullIndex, origin: string, settings: QuerySettings): Promise<Result<TableExecution, string>>;
+/** The result of executing a task query. */
+export interface TaskExecution {
+  core: CoreExecution;
+  tasks: Grouping<SListItem>;
+}
+/** Execute a task query, returning all matching tasks. */
+export declare function executeTask(query: Query, origin: string, index: FullIndex, settings: QuerySettings): Promise<Result<TaskExecution, string>>;
+/** Execute a single field inline a file, returning the evaluated result. */
+export declare function executeInline(field: Field, origin: string, index: FullIndex, settings: QuerySettings): Result<Literal, string>;
+/** The default link resolver used when creating contexts. */
+export declare function defaultLinkHandler(index: FullIndex, origin: string): LinkHandler;
+/** Execute a calendar-based query, returning the final results. */
+export declare function executeCalendar(query: Query, index: FullIndex, origin: string, settings: QuerySettings): Promise<Result<CalendarExecution, string>>;
+export interface CalendarExecution {
+  core: CoreExecution;
+  data: {
+    date: DateTime;
+    link: Link;
+    value?: Literal[];
+  }[];
+}

package/dist/lib/esm/obsidian/@types/Dataview/query/parse.d.mts

@@ -1 +1,44 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/query/parse.cjs';
+import type * as P from 'parsimmon';
+import type { Result } from '../api/result.d.d.mts';
+import type { Source } from '../data-index/source.d.d.mts';
+import type {
+  Comment,
+  FlattenStep,
+  GroupStep,
+  LimitStep,
+  NamedField,
+  Query,
+  QueryHeader,
+  QueryOperation,
+  QuerySortBy,
+  QueryType,
+  SortByStep,
+  WhereStep
+} from './query.d.d.mts';
+/** Typings for the outputs of all of the parser combinators. */
+interface QueryLanguageTypes {
+  queryType: QueryType;
+  comment: Comment;
+  explicitNamedField: NamedField;
+  namedField: NamedField;
+  sortField: QuerySortBy;
+  headerClause: QueryHeader;
+  fromClause: Source;
+  whereClause: WhereStep;
+  sortByClause: SortByStep;
+  limitClause: LimitStep;
+  flattenClause: FlattenStep;
+  groupByClause: GroupStep;
+  clause: QueryOperation;
+  query: Query;
+}
+/** Return a new parser which executes the underlying parser and returns it's raw string representation. */
+export declare function captureRaw<T>(base: P.Parser<T>): P.Parser<[T, string]>;
+/** A parsimmon-powered parser-combinator implementation of the query language. */
+export declare const QUERY_LANGUAGE: P.TypedLanguage<QueryLanguageTypes>;
+/**
+ * Attempt to parse a query from the given query text, returning a string error
+ * if the parse failed.
+ */
+export declare function parseQuery(text: string): Result<Query, string>;
+export {};

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

@@ -1 +1,95 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/query/query.cjs';
+/** Provides an AST for complex queries. */
+import type { Source } from '../data-index/source.d.d.mts';
+import type { Field } from '../expression/field.d.d.mts';
+/** The supported query types (corresponding to view types). */
+export type QueryType = 'list' | 'table' | 'task' | 'calendar';
+/** A single-line comment. */
+export type Comment = string;
+/** Fields used in the query portion. */
+export interface NamedField {
+  /** The effective name of this field. */
+  name: string;
+  /** The value of this field. */
+  field: Field;
+}
+/** A query sort by field, for determining sort order. */
+export interface QuerySortBy {
+  /** The field to sort on. */
+  field: Field;
+  /** The direction to sort in. */
+  direction: 'ascending' | 'descending';
+}
+/** Utility functions for quickly creating fields. */
+export declare namespace QueryFields {
+  function named(name: string, field: Field): NamedField;
+  function sortBy(field: Field, dir: 'ascending' | 'descending'): QuerySortBy;
+}
+/** A query which should render a list of elements. */
+export interface ListQuery {
+  type: 'list';
+  /** What should be rendered in the list. */
+  format?: Field;
+  /** If true, show the default DI field; otherwise, don't. */
+  showId: boolean;
+}
+/** A query which renders a table of elements. */
+export interface TableQuery {
+  type: 'table';
+  /** The fields (computed or otherwise) to select. */
+  fields: NamedField[];
+  /** If true, show the default ID field; otherwise, don't. */
+  showId: boolean;
+}
+/** A query which renders a collection of tasks. */
+export interface TaskQuery {
+  type: 'task';
+}
+/** A query which renders a collection of notes in a calendar view. */
+export interface CalendarQuery {
+  type: 'calendar';
+  /** The date field that we'll be grouping notes by for the calendar view */
+  field: NamedField;
+}
+export type QueryHeader = ListQuery | TableQuery | TaskQuery | CalendarQuery;
+/** A step which only retains rows whose 'clause' field is truthy. */
+export interface WhereStep {
+  type: 'where';
+  clause: Field;
+}
+/** A step which sorts all current rows by the given list of sorts. */
+export interface SortByStep {
+  type: 'sort';
+  fields: QuerySortBy[];
+}
+/** A step which truncates the number of rows to the given amount. */
+export interface LimitStep {
+  type: 'limit';
+  amount: Field;
+}
+/** A step which flattens rows into multiple child rows. */
+export interface FlattenStep {
+  type: 'flatten';
+  field: NamedField;
+}
+/** A step which groups rows into groups by the given field. */
+export interface GroupStep {
+  type: 'group';
+  field: NamedField;
+}
+/** A virtual step which extracts an array of values from each row. */
+export interface ExtractStep {
+  type: 'extract';
+  fields: Record<string, Field>;
+}
+export type QueryOperation = WhereStep | SortByStep | LimitStep | FlattenStep | GroupStep | ExtractStep;
+/**
+ * A query over the Obsidian database. Queries have a specific and deterministic execution order:
+ */
+export interface Query {
+  /** The view type to render this query in. */
+  header: QueryHeader;
+  /** The source that file candidates will come from. */
+  source: Source;
+  /** The operations to apply to the data to produce the final result that will be rendered. */
+  operations: QueryOperation[];
+}

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

@@ -1 +1,60 @@
-export * from '../../../../cjs/obsidian/@types/Dataview/settings.cjs';
+export interface QuerySettings {
+  /** What to render 'null' as in tables. Defaults to '-'. */
+  renderNullAs: string;
+  /** If enabled, tasks in Dataview views will automatically have their completion date appended when they are checked. */
+  taskCompletionTracking: boolean;
+  /** If enabled, automatic completions will use emoji shorthand ✅ YYYY-MM-DD instead of [completion:: date]. */
+  taskCompletionUseEmojiShorthand: boolean;
+  /** The name of the inline field to be added as a task's completion when checked. Only used if completionTracking is enabled and emojiShorthand is not. */
+  taskCompletionText: string;
+  /** Date format of the task's completion timestamp. Only used if completionTracking is enabled and emojiShorthand is not. */
+  taskCompletionDateFormat: string;
+  /** Whether or not subtasks should be recursively completed in addition to their parent task. */
+  recursiveSubTaskCompletion: boolean;
+  /** If true, render a modal which shows no results were returned. */
+  warnOnEmptyResult: boolean;
+  /** Whether or not automatic view refreshing is enabled. */
+  refreshEnabled: boolean;
+  /** The interval that views are refreshed, by default. */
+  refreshInterval: number;
+  /** The default format that dates are rendered in (using luxon's moment-like formatting). */
+  defaultDateFormat: string;
+  /** The default format that date-times are rendered in (using luxon's moment-like formatting). */
+  defaultDateTimeFormat: string;
+  /** Maximum depth that objects will be expanded when being rendered recursively. */
+  maxRecursiveRenderDepth: number;
+  /** The name of the default ID field ('File'). */
+  tableIdColumnName: string;
+  /** The name of default ID fields on grouped data ('Group'). */
+  tableGroupColumnName: string;
+  /** Include the result count as part of the output. */
+  showResultCount: boolean;
+}
+export declare const DEFAULT_QUERY_SETTINGS: QuerySettings;
+export interface ExportSettings {
+  /** Whether or not HTML should be used for formatting in exports. */
+  allowHtml: boolean;
+}
+export declare const DEFAULT_EXPORT_SETTINGS: ExportSettings;
+export interface DataviewSettings extends QuerySettings, ExportSettings {
+  /** The prefix for inline queries by default. */
+  inlineQueryPrefix: string;
+  /** The prefix for inline JS queries by default. */
+  inlineJsQueryPrefix: string;
+  /** If true, inline queries are also evaluated in full codeblocks. */
+  inlineQueriesInCodeblocks: boolean;
+  /** Enable or disable executing DataviewJS queries. */
+  enableDataviewJs: boolean;
+  /** Enable or disable regular inline queries. */
+  enableInlineDataview: boolean;
+  /** Enable or disable executing inline DataviewJS queries. */
+  enableInlineDataviewJs: boolean;
+  /** Enable or disable rendering inline fields prettily in Reading View. */
+  prettyRenderInlineFields: boolean;
+  /** Enable or disable rendering inline fields prettily in Live Preview. */
+  prettyRenderInlineFieldsInLivePreview: boolean;
+  /** The keyword for DataviewJS blocks. */
+  dataviewJsKeyword: string;
+}
+/** Default settings for dataview on install. */
+export declare const DEFAULT_SETTINGS: DataviewSettings;

package/dist/lib/esm/obsidian/@types/Dataview/typings/obsidian-ex.d.mts

@@ -1 +1,28 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/typings/obsidian-ex.cjs';
+import type { Plugin } from 'obsidian';
+import type { DataviewApi } from '../api/plugin-api.d.d.mts';
+
+declare module 'obsidian' {
+  interface MetadataCache {
+    trigger(...args: Parameters<MetadataCache['on']>): void;
+    trigger(name: string, ...data: any[]): void;
+  }
+
+  interface Workspace {
+    /** Sent to rendered dataview components to tell them to possibly refresh */
+    on(name: 'dataview:refresh-views', callback: () => void, ctx?: any): EventRef;
+  }
+}
+
+declare global {
+  interface Window {
+    DataviewAPI?: DataviewApi;
+  }
+}
+
+declare module 'obsidian-typings' {
+  interface PluginsPluginsRecord {
+    dataview?: Plugin & {
+      api: DataviewApi;
+    };
+  }
+}

package/dist/lib/esm/obsidian/@types/Dataview/typings/workers.d.mts

@@ -1 +1,4 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/typings/workers.cjs';
+declare module 'web-worker:*' {
+  const WorkerFactory: new (options: any) => Worker;
+  export default WorkerFactory;
+}

package/dist/lib/esm/obsidian/@types/Dataview/ui/export/markdown.d.mts

@@ -1 +1,15 @@
-export * from '../../../../../../cjs/obsidian/@types/Dataview/ui/export/markdown.cjs';
+import type { SListItem } from '../../data-model/serialized/markdown.d.d.mts';
+import type {
+  Grouping,
+  Literal
+} from '../../data-model/value.d.d.mts';
+import type {
+  ExportSettings,
+  QuerySettings
+} from '../../settings.d.d.mts';
+/** Render a table of literals to Markdown. */
+export declare function markdownTable(headers: string[], values: Literal[][], settings?: QuerySettings & ExportSettings): string;
+/** Render a list of literal elements to a markdown list. */
+export declare function markdownList(values: Literal[], settings?: QuerySettings & ExportSettings): string;
+/** Render the result of a task query to markdown. */
+export declare function markdownTaskList(tasks: Grouping<SListItem>, settings?: QuerySettings & ExportSettings, depth?: number): string;

package/dist/lib/esm/obsidian/@types/Dataview/ui/lp-render.d.mts

@@ -1 +1,37 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/ui/lp-render.cjs';
+import type {
+  EditorSelection,
+  Range
+} from '@codemirror/state';
+import type {
+  Decoration,
+  DecorationSet,
+  EditorView,
+  ViewPlugin,
+  ViewUpdate
+} from '@codemirror/view';
+import type { SyntaxNode } from '@lezer/common';
+import type {
+  App,
+  Component,
+  TFile
+} from 'obsidian';
+import type { DataviewApi } from '../api/plugin-api.d.d.mts';
+import type { FullIndex } from '../data-index/index.d.d.mts';
+import type { DataviewSettings } from '../settings.d.d.mts';
+export declare function selectionAndRangeOverlap(selection: EditorSelection, rangeFrom: number, rangeTo: number): boolean;
+export declare function inlinePlugin(app: App, index: FullIndex, settings: DataviewSettings, api: DataviewApi): ViewPlugin<{
+  decorations: DecorationSet;
+  component: Component;
+  update(update: ViewUpdate): void;
+  updateTree(view: EditorView): void;
+  removeDeco(node: SyntaxNode): void;
+  addDeco(node: SyntaxNode, view: EditorView): void;
+  renderNode(view: EditorView, node: SyntaxNode): {
+    render: boolean;
+    isQuery: boolean;
+  };
+  isInlineQuery(view: EditorView, start: number, end: number): boolean;
+  inlineRender(view: EditorView): DecorationSet | undefined;
+  renderWidget(node: SyntaxNode, view: EditorView, currentFile: TFile): Range<Decoration> | undefined;
+  destroy(): void;
+}>;