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

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

@@ -1 +1,38 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/api/result.cjs';
+/** Functional return type for error handling. */
+export declare class Success<T, E> {
+  value: T;
+  successful: true;
+  constructor(value: T);
+  map<U>(f: (a: T) => U): Result<U, E>;
+  flatMap<U>(f: (a: T) => Result<U, E>): Result<U, E>;
+  mapErr<U>(f: (e: E) => U): Result<T, U>;
+  bimap<T2, E2>(succ: (a: T) => T2, _fail: (b: E) => E2): Result<T2, E2>;
+  orElse(_value: T): T;
+  cast<U>(): Result<U, E>;
+  orElseThrow(_message?: (e: E) => string): T;
+}
+/** Functional return type for error handling. */
+export declare class Failure<T, E> {
+  error: E;
+  successful: false;
+  constructor(error: E);
+  map<U>(_f: (a: T) => U): Result<U, E>;
+  flatMap<U>(_f: (a: T) => Result<U, E>): Result<U, E>;
+  mapErr<U>(f: (e: E) => U): Result<T, U>;
+  bimap<T2, E2>(_succ: (a: T) => T2, fail: (b: E) => E2): Result<T2, E2>;
+  orElse(value: T): T;
+  cast<U>(): Result<U, E>;
+  orElseThrow(message?: (e: E) => string): T;
+}
+export type Result<T, E> = Success<T, E> | Failure<T, E>;
+/** Monadic 'Result' type which encapsulates whether a procedure succeeded or failed, as well as it's return value. */
+export declare namespace Result {
+  /** Construct a new success result wrapping the given value. */
+  function success<T, E>(value: T): Result<T, E>;
+  /** Construct a new failure value wrapping the given error. */
+  function failure<T, E>(error: E): Result<T, E>;
+  /** Join two results with a bi-function and return a new result. */
+  function flatMap2<T1, T2, O, E>(first: Result<T1, E>, second: Result<T2, E>, f: (a: T1, b: T2) => Result<O, E>): Result<O, E>;
+  /** Join two results with a bi-function and return a new result. */
+  function map2<T1, T2, O, E>(first: Result<T1, E>, second: Result<T2, E>, f: (a: T1, b: T2) => O): Result<O, E>;
+}

package/dist/lib/esm/obsidian/@types/Dataview/data-import/common.d.mts

@@ -1 +1,3 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/data-import/common.cjs';
+/** Common utilities for extracting tags, links, and other business from metadata. */
+/** Extract all tags from the given source string. */
+export declare function extractTags(source: string): Set<string>;

package/dist/lib/esm/obsidian/@types/Dataview/data-import/csv.d.mts

@@ -1 +1,3 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/data-import/csv.cjs';
+import type { DataObject } from '../data-model/value.d.d.mts';
+/** Parse a CSV file into a collection of data rows. */
+export declare function parseCsv(content: string): DataObject[];

package/dist/lib/esm/obsidian/@types/Dataview/data-import/inline-field.d.mts

@@ -1 +1,42 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/data-import/inline-field.cjs';
+/** Parse inline fields and other embedded metadata in a line. */
+import type { Literal } from '../data-model/value.d.d.mts';
+/** A parsed inline field. */
+export interface InlineField {
+  /** The raw parsed key. */
+  key: string;
+  /** The raw value of the field. */
+  value: string;
+  /** The start column of the field. */
+  start: number;
+  /** The start column of the *value* for the field. */
+  startValue: number;
+  /** The end column of the field. */
+  end: number;
+  /** If this inline field was defined via a wrapping ('[' or '('), then the wrapping that was used. */
+  wrapping?: string;
+}
+/** The wrapper characters that can be used to define an inline field. */
+export declare const INLINE_FIELD_WRAPPERS: Readonly<Record<string, string>>;
+/** Parse a textual inline field value into something we can work with. */
+export declare function parseInlineValue(value: string): Literal;
+/** Extracts inline fields of the form '[key:: value]' from a line of text. This is done in a relatively
+ * "robust" way to avoid failing due to bad nesting or other interfering Markdown symbols:
+ *
+ * - Look for any wrappers ('[' and '(') in the line, trying to parse whatever comes after it as an inline key::.
+ * - If successful, scan until you find a matching end bracket, and parse whatever remains as an inline value.
+ */
+export declare function extractInlineFields(line: string, includeTaskFields?: boolean): InlineField[];
+/** Attempt to extract a full-line field (Key:: Value consuming the entire content line). */
+export declare function extractFullLineField(text: string): InlineField | undefined;
+export declare const CREATED_DATE_REGEX: RegExp;
+export declare const DUE_DATE_REGEX: RegExp;
+export declare const DONE_DATE_REGEX: RegExp;
+export declare const SCHEDULED_DATE_REGEX: RegExp;
+export declare const START_DATE_REGEX: RegExp;
+export declare const EMOJI_REGEXES: {
+  regex: RegExp;
+  key: string;
+}[];
+/** Sets or replaces the value of an inline field; if the value is 'undefined', deletes the key. */
+export declare function setInlineField(source: string, key: string, value?: string): string;
+export declare function setEmojiShorthandCompletionField(source: string, value?: string): string;

package/dist/lib/esm/obsidian/@types/Dataview/data-import/markdown-file.d.mts

@@ -1 +1,52 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/data-import/markdown-file.cjs';
+/** Importer for markdown documents. */
+import type {
+  CachedMetadata,
+  FileStats,
+  FrontMatterCache,
+  HeadingCache
+} from 'obsidian';
+import type { InlineField } from '../data-import/inline-field.d.d.mts';
+import type {
+  ListItem,
+  PageMetadata
+} from '../data-model/markdown.d.d.mts';
+import type {
+  Link,
+  Literal
+} from '../data-model/value.d.d.mts';
+/** Extract markdown metadata from the given Obsidian markdown file. */
+export declare function parsePage(path: string, contents: string, stat: FileStats, metadata: CachedMetadata): PageMetadata;
+/** Extract tags intelligently from frontmatter. Handles arrays, numbers, and strings. */
+export declare function extractTags(metadata: FrontMatterCache): string[];
+/** Extract aliases intelligently from frontmatter. Handles arrays, numbers, and strings.  */
+export declare function extractAliases(metadata: FrontMatterCache): string[];
+/** Split a frontmatter list into separate elements; handles actual lists, comma separated lists, and single elements. */
+export declare function splitFrontmatterTagOrAlias(data: any, on: RegExp): string[];
+/** Parse raw (newline-delimited) markdown, returning inline fields, list items, and other metadata. */
+export declare function parseMarkdown(path: string, contents: string[], metadata: CachedMetadata, linksByLine: Record<number, Link[]>): {
+  fields: Map<string, Literal[]>;
+  lists: ListItem[];
+};
+export declare const LIST_ITEM_REGEX: RegExp;
+/**
+ * Parse list items from the page + metadata. This requires some additional parsing above whatever Obsidian provides,
+ * since Obsidian only gives line numbers.
+ */
+export declare function parseLists(
+  path: string,
+  content: string[],
+  metadata: CachedMetadata,
+  linksByLine: Record<number, Link[]>
+): [ListItem[], Map<string, Literal[]>];
+/** Recursively convert frontmatter into fields. We have to dance around YAML structure. */
+export declare function parseFrontmatter(value: any): Literal;
+/** Add a parsed inline field to the output map. */
+export declare function addRawInlineField(field: InlineField, output: Map<string, Literal[]>): void;
+/** Add a raw inline field to an output map, canonicalizing as needed. */
+export declare function addInlineField(key: string, value: Literal, output: Map<string, Literal[]>): void;
+/** Given a raw list of inline field values, add normalized keys and squash them. */
+export declare function finalizeInlineFields(fields: Map<string, Literal[]>): Map<string, Literal>;
+/** Copy all fields of 'source' into 'target'. */
+export declare function mergeFieldGroups(target: Map<string, Literal[]>, source: Map<string, Literal[]>): void;
+/** Find the header that is most immediately above the given line number. */
+export declare function findPreviousHeader(line: number, headers: HeadingCache[]): string | undefined;

package/dist/lib/esm/obsidian/@types/Dataview/data-import/persister.d.mts

@@ -1 +1,32 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/data-import/persister.cjs';
+type LocalForage = typeof import('localforage');
+
+import type { PageMetadata } from '../data-model/markdown.d.d.mts';
+/** A piece of data that has been cached for a specific version and time. */
+export interface Cached<T> {
+  /** The version of Dataview that the data was written to cache with. */
+  version: string;
+  /** The time that the data was written to cache. */
+  time: number;
+  /** The data that was cached. */
+  data: T;
+}
+/** Simpler wrapper for a file-backed cache for arbitrary metadata. */
+export declare class LocalStorageCache {
+  appId: string;
+  version: string;
+  persister: LocalForage;
+  constructor(appId: string, version: string);
+  /** Drop the entire cache instance and re-create a new fresh instance. */
+  recreate(): Promise<void>;
+  /** Load file metadata by path. */
+  loadFile(path: string): Promise<Cached<Partial<PageMetadata>> | null | undefined>;
+  /** Store file metadata by path. */
+  storeFile(path: string, data: Partial<PageMetadata>): Promise<void>;
+  /** Drop old file keys that no longer exist. */
+  synchronize(existing: string[] | Set<string>): Promise<Set<string>>;
+  /** Obtain a list of all metadata keys. */
+  allKeys(): Promise<string[]>;
+  /** Obtain a list of all persisted files. */
+  allFiles(): Promise<string[]>;
+  fileKey(path: string): string;
+}

package/dist/lib/esm/obsidian/@types/Dataview/data-import/web-worker/import-entry.d.mts

@@ -1 +1 @@
-export * from '../../../../../../cjs/obsidian/@types/Dataview/data-import/web-worker/import-entry.cjs';
+export {};

package/dist/lib/esm/obsidian/@types/Dataview/data-import/web-worker/import-impl.d.mts

@@ -1 +1,6 @@
-export * from '../../../../../../cjs/obsidian/@types/Dataview/data-import/web-worker/import-impl.cjs';
+import type {
+  CachedMetadata,
+  FileStats
+} from 'obsidian';
+import type { PageMetadata } from '../../data-model/markdown.d.d.mts';
+export declare function runImport(path: string, contents: string, stats: FileStats, metadata: CachedMetadata): Partial<PageMetadata>;

package/dist/lib/esm/obsidian/@types/Dataview/data-import/web-worker/import-manager.d.mts

@@ -1 +1,37 @@
-export * from '../../../../../../cjs/obsidian/@types/Dataview/data-import/web-worker/import-manager.cjs';
+/** Controls and creates Dataview file importers, allowing for asynchronous loading and parsing of files. */
+import type {
+  Component,
+  MetadataCache,
+  TFile,
+  Vault
+} from 'obsidian';
+/** Callback when a file is resolved. */
+type FileCallback = (p: any) => void;
+/** Multi-threaded file parser which debounces rapid file requests automatically. */
+export declare class FileImporter extends Component {
+  numWorkers: number;
+  vault: Vault;
+  metadataCache: MetadataCache;
+  workers: Worker[];
+  /** Tracks which workers are actively parsing a file, to make sure we properly delegate results. */
+  busy: boolean[];
+  /** List of files which have been queued for a reload. */
+  reloadQueue: TFile[];
+  /** Fast-access set which holds the list of files queued to be reloaded; used for debouncing. */
+  reloadSet: Set<string>;
+  /** Paths -> promises for file reloads which have not yet been queued. */
+  callbacks: Map<string, [FileCallback, FileCallback][]>;
+  constructor(numWorkers: number, vault: Vault, metadataCache: MetadataCache);
+  /**
+   * Queue the given file for reloading. Multiple reload requests for the same file in a short time period will be de-bounced
+   * and all be resolved by a single actual file reload.
+   */
+  reload<T>(file: TFile): Promise<T>;
+  /** Finish the parsing of a file, potentially queueing a new file. */
+  private finish;
+  /** Send a new task to the given worker ID. */
+  private send;
+  /** Find the next available, non-busy worker; return undefined if all workers are busy. */
+  private nextAvailableWorker;
+}
+export {};

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

@@ -1 +1,186 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/data-index/index.cjs';
+/** Stores various indices on all files in the vault to make dataview generation fast. */
+import type { DateTime } from 'luxon';
+import type {
+  App,
+  Component,
+  MetadataCache,
+  TAbstractFile,
+  TFile,
+  Vault
+} from 'obsidian';
+import type { Result } from '../api/result.d.d.mts';
+import type { LocalStorageCache } from '../data-import/persister.d.d.mts';
+import type { FileImporter } from '../data-import/web-worker/import-manager.d.d.mts';
+import type { PageMetadata } from '../data-model/markdown.d.d.mts';
+import type { DataObject } from '../data-model/value.d.d.mts';
+/** Aggregate index which has several sub-indices and will initialize all of them. */
+export declare class FullIndex extends Component {
+  app: App;
+  indexVersion: string;
+  onChange: () => void;
+  /** Generate a full index from the given vault. */
+  static create(app: App, indexVersion: string, onChange: () => void): FullIndex;
+  /** Whether all files in the vault have been indexed at least once. */
+  initialized: boolean;
+  /** I/O access to the Obsidian vault contents. */
+  vault: Vault;
+  /** Access to in-memory metadata, useful for parsing and metadata lookups. */
+  metadataCache: MetadataCache;
+  /** Persistent IndexedDB backing store, used for faster startup. */
+  persister: LocalStorageCache;
+  pages: Map<string, PageMetadata>;
+  /** Map files -> tags in that file, and tags -> files. This version includes subtags. */
+  tags: ValueCaseInsensitiveIndexMap;
+  /** Map files -> exact tags in that file, and tags -> files. This version does not automatically add subtags. */
+  etags: ValueCaseInsensitiveIndexMap;
+  /** Map files -> linked files in that file, and linked file -> files that link to it. */
+  links: IndexMap;
+  /** Search files by path prefix. */
+  prefix: PrefixIndex;
+  /** Allows for efficient lookups of whether a file is starred or not. */
+  starred: StarredCache;
+  /** Caches data in CSV files. */
+  csv: CsvCache;
+  /**
+   * The current "revision" of the index, which monotonically increases for every index change. Use this to determine
+   * if you are up to date.
+   */
+  revision: number;
+  /** Asynchronously parses files in the background using web workers. */
+  importer: FileImporter;
+  /** Construct a new index using the app data and a current data version. */
+  private constructor();
+  /** Trigger a metadata event on the metadata cache. */
+  private trigger;
+  /** "Touch" the index, incrementing the revision number and causing downstream views to reload. */
+  touch(): void;
+  /** Runs through the whole vault to set up initial file metadata. */
+  initialize(): void;
+  /** Drops the local storage cache and re-indexes all files; this should generally be used if you expect cache issues. */
+  reinitialize(): Promise<void>;
+  /** Internal asynchronous initializer. */
+  private _initialize;
+  rename(file: TAbstractFile, oldPath: string): void;
+  /** Queue a file for reloading; this is done asynchronously in the background and may take a few seconds. */
+  reload(file: TFile): Promise<{
+    cached: boolean;
+    skipped: boolean;
+  }>;
+  /** Import a file directly from disk, skipping the cache. */
+  private import;
+  /** Finish the reloading of file metadata by adding it to in memory indexes. */
+  private finish;
+}
+/** Indexes files by their full prefix - essentially a simple prefix tree. */
+export declare class PrefixIndex extends Component {
+  vault: Vault;
+  updateRevision: () => void;
+  static create(vault: Vault, updateRevision: () => void): PrefixIndex;
+  constructor(vault: Vault, updateRevision: () => void);
+  private walk;
+  /** Get the list of all files under the given path. */
+  get(prefix: string, filter?: (path: string) => boolean): Set<string>;
+  /** Determines if the given path exists in the prefix index. */
+  pathExists(path: string): boolean;
+  /** Determines if the given prefix exists in the prefix index. */
+  nodeExists(prefix: string): boolean;
+  /**
+   * Use the in-memory prefix index to convert a relative path to an absolute one.
+   */
+  resolveRelative(path: string, origin?: string): string;
+}
+/** Simple path filters which filter file types. */
+export declare namespace PathFilters {
+  function csv(path: string): boolean;
+  function markdown(path: string): boolean;
+}
+/**
+ * Caches in-use CSVs to make high-frequency reloads (such as actively looking at a document
+ * that uses CSV) fast.
+ */
+export declare class CsvCache extends Component {
+  vault: Vault;
+  static CACHE_EXPIRY_SECONDS: number;
+  cache: Map<string, {
+    data: DataObject[];
+    loadTime: DateTime;
+  }>;
+  cacheClearInterval: number;
+  constructor(vault: Vault);
+  /** Load a CSV file from the cache, doing a fresh load if it has not been loaded. */
+  get(path: string): Promise<Result<DataObject[], string>>;
+  /** Do the actual raw loading of a CSV path (which is either local or an HTTP request). */
+  private loadInternal;
+  /** Clear old entries in the cache (as measured by insertion time). */
+  private clearOldEntries;
+}
+export type StarredEntry = {
+  type: 'group';
+  items: StarredEntry[];
+  title: string;
+} | {
+  type: 'file';
+  path: string;
+  title: string;
+} | {
+  type: 'folder';
+} | {
+  type: 'query';
+};
+/** Optional connector to the Obsidian 'Starred' plugin which allows for efficiently querying if a file is starred or not. */
+export declare class StarredCache extends Component {
+  app: App;
+  onUpdate: () => void;
+  /** Initial delay before checking the cache; we need to wait for it to asynchronously load the initial stars. */
+  static INITIAL_DELAY: number;
+  /** How frequently to check for star updates. */
+  static REFRESH_INTERVAL: number;
+  /** Set of all starred file paths. */
+  private stars;
+  constructor(app: App, onUpdate: () => void);
+  /** Determines if the given path is starred. */
+  starred(path: string): boolean;
+  private reload;
+  /** Fetch all starred files from the stars plugin, if present. */
+  private static fetch;
+}
+/** A generic index which indexes variables of the form key -> value[], allowing both forward and reverse lookups. */
+export declare class IndexMap {
+  /** Maps key -> values for that key. */
+  map: Map<string, Set<string>>;
+  /** Cached inverse map; maps value -> keys that reference that value. */
+  invMap: Map<string, Set<string>>;
+  /** Create a new, empty index map. */
+  constructor();
+  /** Returns all values for the given key. */
+  get(key: string): Set<string>;
+  /** Returns all keys that reference the given key. Mutating the returned set is not allowed. */
+  getInverse(value: string): Readonly<Set<string>>;
+  /** Sets the key to the given values; this will delete the old mapping for the key if one was present. */
+  set(key: string, values: Set<string>): this;
+  /** Clears all values for the given key so they can be re-added. */
+  delete(key: string): boolean;
+  /** Rename all references to the given key to a new value. */
+  rename(oldKey: string, newKey: string): boolean;
+  /** Clear the entire index. */
+  clear(): void;
+  static EMPTY_SET: Readonly<Set<string>>;
+}
+/** Index map wrapper which is case-insensitive in the key. */
+export declare class ValueCaseInsensitiveIndexMap {
+  delegate: IndexMap;
+  /** Create a new, empty case insensitive index map. */
+  constructor(delegate?: IndexMap);
+  /** Returns all values for the given key. */
+  get(key: string): Set<string>;
+  /** Returns all keys that reference the given value. Mutating the returned set is not allowed. */
+  getInverse(value: string): Readonly<Set<string>>;
+  /** Sets the key to the given values; this will delete the old mapping for the key if one was present. */
+  set(key: string, values: Set<string>): this;
+  /** Clears all values for the given key so they can be re-added. */
+  delete(key: string): boolean;
+  /** Rename all references to the given key to a new value. */
+  rename(oldKey: string, newKey: string): boolean;
+  /** Clear the entire index. */
+  clear(): void;
+}

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

@@ -1 +1,23 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/data-index/resolver.cjs';
+/** Collect data matching a source query. */
+import type { Result } from '../api/result.d.d.mts';
+import type { FullIndex } from '../data-index/index.d.d.mts';
+import type {
+  DataObject,
+  Literal
+} from '../data-model/value.d.d.mts';
+import type { Source } from './source.d.d.mts';
+/** A data row which has an ID and associated data (like page link / page data). */
+export type Datarow<T> = {
+  id: Literal;
+  data: T;
+};
+/** Find source paths which match the given source. */
+export declare function matchingSourcePaths(source: Source, index: FullIndex, originFile?: string): Result<Set<string>, string>;
+/** Convert a path to the data for that path; usually markdown pages, but could also be other file types (like CSV).  */
+export declare function resolvePathData(path: string, index: FullIndex): Promise<Result<Datarow<DataObject>[], string>>;
+/** Convert a CSV path to the data in the CSV (in dataview format). */
+export declare function resolveCsvData(path: string, index: FullIndex): Promise<Result<Datarow<DataObject>[], string>>;
+/** Convert a path pointing to a markdown page, into the associated metadata. */
+export declare function resolveMarkdownData(path: string, index: FullIndex): Result<Datarow<DataObject>[], string>;
+/** Resolve a source to the collection of data rows that it matches. */
+export declare function resolveSource(source: Source, index: FullIndex, originFile?: string): Promise<Result<Datarow<DataObject>[], string>>;

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

@@ -1 +1,71 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/data-index/source.cjs';
+/** AST implementation for queries over data sources. */
+/** The source of files for a query. */
+export type Source = TagSource | CsvSource | FolderSource | LinkSource | EmptySource | NegatedSource | BinaryOpSource;
+/** Valid operations for combining sources. */
+export type SourceOp = '&' | '|';
+/** A tag as a source of data. */
+export interface TagSource {
+  type: 'tag';
+  /** The tag to source from. */
+  tag: string;
+}
+/** A csv as a source of data. */
+export interface CsvSource {
+  type: 'csv';
+  /** The path to the CSV file. */
+  path: string;
+}
+/** A folder prefix as a source of data. */
+export interface FolderSource {
+  type: 'folder';
+  /** The folder prefix to source from. */
+  folder: string;
+}
+/** Either incoming or outgoing links to a given file. */
+export interface LinkSource {
+  type: 'link';
+  /** The file to look for links to/from.  */
+  file: string;
+  /**
+   * The direction to look - if incoming, then all files linking to the target file. If outgoing, then all files
+   * which the file links to.
+   */
+  direction: 'incoming' | 'outgoing';
+}
+/** A source which is everything EXCEPT the files returned by the given source. */
+export interface NegatedSource {
+  type: 'negate';
+  /** The source to negate. */
+  child: Source;
+}
+/** A source which yields nothing. */
+export interface EmptySource {
+  type: 'empty';
+}
+/** A source made by combining subsources with a logical operators. */
+export interface BinaryOpSource {
+  type: 'binaryop';
+  op: SourceOp;
+  left: Source;
+  right: Source;
+}
+/** Utility functions for creating and manipulating sources. */
+export declare namespace Sources {
+  /** Create a source which searches from a tag. */
+  function tag(tag: string): TagSource;
+  /** Create a source which fetches from a CSV file. */
+  function csv(path: string): CsvSource;
+  /** Create a source which searches for files under a folder prefix. */
+  function folder(prefix: string): FolderSource;
+  /** Create a source which searches for files which link to/from a given file. */
+  function link(file: string, incoming: boolean): LinkSource;
+  /** Create a source which joins two sources by a logical operator (and/or). */
+  function binaryOp(left: Source, op: SourceOp, right: Source): Source;
+  /** Create a source which takes the intersection of two sources. */
+  function and(left: Source, right: Source): Source;
+  /** Create a source which takes the union of two sources. */
+  function or(left: Source, right: Source): Source;
+  /** Create a source which negates the underlying source. */
+  function negate(child: Source): NegatedSource;
+  function empty(): EmptySource;
+}

package/dist/lib/esm/obsidian/@types/Dataview/data-model/markdown.d.mts

@@ -1 +1,115 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/data-model/markdown.cjs';
+import type { DateTime } from 'luxon';
+import type { Pos } from 'obsidian';
+import type { FullIndex } from '../data-index/index.d.d.mts';
+import type {
+  SListItem,
+  SMarkdownPage
+} from '../data-model/serialized/markdown.d.d.mts';
+import type {
+  Link,
+  Literal
+} from '../data-model/value.d.d.mts';
+import type { DataObject } from '../index.d.d.mts';
+/** All extracted markdown file metadata obtained from a file. */
+export declare class PageMetadata {
+  /** The path this file exists at. */
+  path: string;
+  /** Obsidian-provided date this page was created. */
+  ctime: DateTime;
+  /** Obsidian-provided date this page was modified. */
+  mtime: DateTime;
+  /** Obsidian-provided size of this page in bytes. */
+  size: number;
+  /** The day associated with this page, if relevant. */
+  day?: DateTime;
+  /** The first H1/H2 header in the file. May not exist. */
+  title?: string;
+  /** All of the fields contained in this markdown file - both frontmatter AND in-file links. */
+  fields: Map<string, Literal>;
+  /** All of the exact tags (prefixed with '#') in this file overall. */
+  tags: Set<string>;
+  /** All of the aliases defined for this file. */
+  aliases: Set<string>;
+  /** All OUTGOING links (including embeds, header + block links) in this file. */
+  links: Link[];
+  /** All list items contained within this page. Filter for tasks to get just tasks. */
+  lists: ListItem[];
+  /** The raw frontmatter for this document. */
+  frontmatter: Record<string, Literal>;
+  constructor(path: string, init?: Partial<PageMetadata>);
+  /** Canonicalize raw links and other data in partial data with normalizers, returning a completed object. */
+  static canonicalize(data: Partial<PageMetadata>, linkNormalizer: (link: Link) => Link): PageMetadata;
+  /** The name (based on path) of this file. */
+  name(): string;
+  /** The containing folder (based on path) of this file. */
+  folder(): string;
+  /** The extension of this file (likely 'md'). */
+  extension(): string;
+  /** Return a set of tags AND all of their parent tags (so #hello/yes would become #hello, #hello/yes). */
+  fullTags(): Set<string>;
+  /** Convert all links in this file to file links. */
+  fileLinks(): Link[];
+  /** Map this metadata to a full object; uses the index for additional data lookups.  */
+  serialize(index: FullIndex, cache?: ListSerializationCache): SMarkdownPage;
+}
+/** A list item inside of a list. */
+export declare class ListItem {
+  /** The symbol ('*', '-', '1.') used to define this list item. */
+  symbol: string;
+  /** A link which points to this task, or to the closest block that this task is contained in. */
+  link: Link;
+  /** A link to the section that contains this list element; could be a file if this is not in a section. */
+  section: Link;
+  /** The text of this list item. This may be multiple lines of markdown. */
+  text: string;
+  /** The line that this list item starts on in the file. */
+  line: number;
+  /** The number of lines that define this list item. */
+  lineCount: number;
+  /** The line number for the first list item in the list this item belongs to. */
+  list: number;
+  /** Any links contained within this list item. */
+  links: Link[];
+  /** The tags contained within this list item. */
+  tags: Set<string>;
+  /** The raw Obsidian-provided position for where this task is. */
+  position: Pos;
+  /** The line number of the parent list item, if present; if this is undefined, this is a root item. */
+  parent?: number;
+  /** The line numbers of children of this list item. */
+  children: number[];
+  /** The block ID for this item, if one is present. */
+  blockId?: string;
+  /** Any fields defined in this list item. For tasks, this includes fields underneath the task. */
+  fields: Map<string, Literal[]>;
+  task?: {
+    /** The text in between the brackets of the '[ ]' task indicator ('[X]' would yield 'X', for example.) */
+    status: string;
+    /** Whether or not this task has been checked in any way (it's status is not empty/space). */
+    checked: boolean;
+    /** Whether or not this task was completed; derived from 'status' by checking if the field 'X' or 'x'. */
+    completed: boolean;
+    /** Whether or not this task and all of it's subtasks are completed. */
+    fullyCompleted: boolean;
+  };
+  constructor(init?: Partial<ListItem>);
+  id(): string;
+  file(): Link;
+  markdown(): string;
+  created(): Literal | undefined;
+  due(): Literal | undefined;
+  completed(): Literal | undefined;
+  start(): Literal | undefined;
+  scheduled(): Literal | undefined;
+  /** Create an API-friendly copy of this list item. De-duplication is done via the provided cache. */
+  serialize(cache: ListSerializationCache): SListItem;
+}
+/** De-duplicates list items across section metadata and page metadata. */
+export declare class ListSerializationCache {
+  listItems: Record<number, ListItem>;
+  cache: Record<number, SListItem>;
+  seen: Set<number>;
+  constructor(listItems: ListItem[]);
+  get(lineno: number): SListItem | undefined;
+}
+export declare function addFields(fields: Map<string, Literal[]>, target: DataObject): DataObject;