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

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

@@ -1 +1,106 @@
-export * from '../../../../../../cjs/obsidian/@types/Dataview/data-model/serialized/markdown.cjs';
+/** Serialized / API facing data types for Dataview objects. */
+import type { DateTime } from 'luxon';
+import type { Pos } from 'obsidian';
+import type {
+  Link,
+  Literal
+} from '../../data-model/value.d.d.mts';
+export interface SMarkdownPage {
+  file: {
+    path: string;
+    folder: string;
+    name: string;
+    link: Link;
+    outlinks: Link[];
+    inlinks: Link[];
+    etags: string[];
+    tags: string[];
+    aliases: string[];
+    lists: SListItem[];
+    tasks: STask[];
+    ctime: DateTime;
+    cday: DateTime;
+    mtime: DateTime;
+    mday: DateTime;
+    size: number;
+    ext: string;
+    starred: boolean;
+    day?: DateTime;
+  };
+  /** Additional fields added by field data. */
+  [key: string]: any;
+}
+/** A serialized list item. */
+export type SListItem = SListEntry | STask;
+/** Shared data between list items. */
+export interface SListItemBase {
+  /** The symbol used to start this list item, like '1.' or '1)' or '*'. */
+  symbol: string;
+  /** A link to the closest thing to this list item (a block, a section, or a file). */
+  link: Link;
+  /** The section that contains this list item. */
+  section: Link;
+  /** The path of the file that contains this item. */
+  path: string;
+  /** The line this item starts on. */
+  line: number;
+  /** The number of lines this item spans. */
+  lineCount: number;
+  /** The internal Obsidian tracker of the exact position of this line. */
+  position: Pos;
+  /** The line number of the list that this item is part of. */
+  list: number;
+  /** If present, the block ID for this item. */
+  blockId?: string;
+  /** The line number of the parent item to this list, if relevant. */
+  parent?: number;
+  /** The children elements of this list item. */
+  children: SListItem[];
+  /** Links contained inside this list item. */
+  outlinks: Link[];
+  /** The raw text of this item. */
+  text: string;
+  /**
+   * If present, overrides 'text' when rendered in task views. You should not mutate 'text' since it is used to
+   * validate a list item when editing it.
+   */
+  visual?: string;
+  /** Whether this item has any metadata annotations on it. */
+  annotated?: boolean;
+  /** Any tags present in this task. */
+  tags: string[];
+  /** @deprecated use 'children' instead. */
+  subtasks: SListItem[];
+  /** @deprecated use 'task' instead. */
+  real: boolean;
+  /** @deprecated use 'section' instead. */
+  header: Link;
+  /** Additional fields added by annotations. */
+  [key: string]: any;
+}
+/** A serialized list item as seen by users; this is not a task. */
+export interface SListEntry extends SListItemBase {
+  task: false;
+}
+/** A serialized task. */
+export interface STask extends SListItemBase {
+  task: true;
+  /** The status of this task, the text between the brackets ('[ ]'). Will be a space if the task is currently unchecked. */
+  status: string;
+  /** Indicates whether the task has any value other than empty space. */
+  checked: boolean;
+  /** Indicates whether the task explicitly has been marked "completed" ('x' or 'X'). */
+  completed: boolean;
+  /** Indicates whether the task and ALL subtasks have been completed. */
+  fullyCompleted: boolean;
+  /** If present, then the time that this task was created. */
+  created?: Literal;
+  /** If present, then the time that this task was due. */
+  due?: Literal;
+  /** If present, then the time that this task was completed. */
+  completion?: Literal;
+  /** If present, then the day that this task can be started. */
+  start?: Literal;
+  /** If present, then the day that work on this task is scheduled. */
+  scheduled?: Literal;
+}

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

@@ -1 +1,7 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/data-model/transferable.cjs';
+/** Simplifies passing dataview values across the JS web worker barrier. */
+export declare namespace Transferable {
+  /** Convert a literal value to a serializer-friendly transferable value. */
+  function transferable(value: any): any;
+  /** Convert a transferable value back to a literal value we can work with. */
+  function value(transferable: any): any;
+}

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

@@ -1 +1,175 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/data-model/value.cjs';
+import type {
+  DateTime,
+  Duration
+} from 'luxon';
+import type { QuerySettings } from '../settings.d.d.mts';
+/** Shorthand for a mapping from keys to values. */
+export type DataObject = {
+  [key: string]: Literal;
+};
+/** The literal types supported by the query engine. */
+export type LiteralType = 'boolean' | 'number' | 'string' | 'date' | 'duration' | 'link' | 'array' | 'object' | 'function' | 'null' | 'html' | 'widget';
+/** The raw values that a literal can take on. */
+export type Literal = boolean | number | string | DateTime | Duration | Link | Array<Literal> | DataObject | Function | null | HTMLElement | Widget;
+/** A grouping on a type which supports recursively-nested groups. */
+export type GroupElement<T> = {
+  key: Literal;
+  rows: Grouping<T>;
+};
+export type Grouping<T> = T[] | GroupElement<T>[];
+/** Maps the string type to it's external, API-facing representation. */
+export type LiteralRepr<T extends LiteralType> = T extends 'boolean' ? boolean
+  : T extends 'number' ? number
+  : T extends 'string' ? string
+  : T extends 'duration' ? Duration
+  : T extends 'date' ? DateTime
+  : T extends 'null' ? null
+  : T extends 'link' ? Link
+  : T extends 'array' ? Array<Literal>
+  : T extends 'object' ? Record<string, Literal>
+  : T extends 'function' ? Function
+  : T extends 'html' ? HTMLElement
+  : T extends 'widget' ? Widget
+  : any;
+/** A wrapped literal value which can be switched on. */
+export type WrappedLiteral =
+  | LiteralWrapper<'string'>
+  | LiteralWrapper<'number'>
+  | LiteralWrapper<'boolean'>
+  | LiteralWrapper<'date'>
+  | LiteralWrapper<'duration'>
+  | LiteralWrapper<'link'>
+  | LiteralWrapper<'array'>
+  | LiteralWrapper<'object'>
+  | LiteralWrapper<'html'>
+  | LiteralWrapper<'widget'>
+  | LiteralWrapper<'function'>
+  | LiteralWrapper<'null'>;
+export interface LiteralWrapper<T extends LiteralType> {
+  type: T;
+  value: LiteralRepr<T>;
+}
+export declare namespace Values {
+  /** Convert an arbitrary value into a reasonable, Markdown-friendly string if possible. */
+  function toString(field: any, setting?: QuerySettings, recursive?: boolean): string;
+  /** Wrap a literal value so you can switch on it easily. */
+  function wrapValue(val: Literal): WrappedLiteral | undefined;
+  /** Recursively map complex objects at the leaves. */
+  function mapLeaves(val: Literal, func: (t: Literal) => Literal): Literal;
+  /** Compare two arbitrary JavaScript values. Produces a total ordering over ANY possible dataview value. */
+  function compareValue(val1: Literal, val2: Literal, linkNormalizer?: (link: string) => string): number;
+  /** Find the corresponding Dataview type for an arbitrary value. */
+  function typeOf(val: any): LiteralType | undefined;
+  /** Determine if the given value is "truthy" (i.e., is non-null and has data in it). */
+  function isTruthy(field: Literal): boolean;
+  /** Deep copy a field. */
+  function deepCopy<T extends Literal>(field: T): T;
+  function isString(val: any): val is string;
+  function isNumber(val: any): val is number;
+  function isDate(val: any): val is DateTime;
+  function isDuration(val: any): val is Duration;
+  function isNull(val: any): val is null | undefined;
+  function isArray(val: any): val is any[];
+  function isBoolean(val: any): val is boolean;
+  function isLink(val: any): val is Link;
+  function isWidget(val: any): val is Widget;
+  function isHtml(val: any): val is HTMLElement;
+  /** Checks if the given value is an object (and not any other dataview-recognized object-like type). */
+  function isObject(val: any): val is Record<string, any>;
+  function isFunction(val: any): val is Function;
+}
+export declare namespace Groupings {
+  /** Determines if the given group entry is a standalone value, or a grouping of sub-entries. */
+  function isElementGroup<T>(entry: T | GroupElement<T>): entry is GroupElement<T>;
+  /** Determines if the given array is a grouping array. */
+  function isGrouping<T>(entry: Grouping<T>): entry is GroupElement<T>[];
+  /** Count the total number of elements in a recursive grouping. */
+  function count<T>(elements: Grouping<T>): number;
+}
+/** The Obsidian 'link', used for uniquely describing a file, header, or block. */
+export declare class Link {
+  /** The file path this link points to. */
+  path: string;
+  /** The display name associated with the link. */
+  display?: string;
+  /** The block ID or header this link points to within a file, if relevant. */
+  subpath?: string;
+  /** Is this link an embedded link (!)? */
+  embed: boolean;
+  /** The type of this link, which determines what 'subpath' refers to, if anything. */
+  type: 'file' | 'header' | 'block';
+  /** Create a link to a specific file. */
+  static file(path: string, embed?: boolean, display?: string): Link;
+  static infer(linkpath: string, embed?: boolean, display?: string): Link;
+  /** Create a link to a specific file and header in that file. */
+  static header(path: string, header: string, embed?: boolean, display?: string): Link;
+  /** Create a link to a specific file and block in that file. */
+  static block(path: string, blockId: string, embed?: boolean, display?: string): Link;
+  static fromObject(object: Record<string, any>): Link;
+  private constructor();
+  /** Checks for link equality (i.e., that the links are pointing to the same exact location). */
+  equals(other: Link): boolean;
+  /** Convert this link to it's markdown representation. */
+  toString(): string;
+  /** Convert this link to a raw object which is serialization-friendly. */
+  toObject(): Record<string, any>;
+  /** Update this link with a new path. */
+  withPath(path: string): any;
+  /** Return a new link which points to the same location but with a new display value. */
+  withDisplay(display?: string): Link;
+  /** Convert a file link into a link to a specific header. */
+  withHeader(header: string): Link;
+  /** Convert any link into a link to its file. */
+  toFile(): Link;
+  /** Convert this link into an embedded link. */
+  toEmbed(): Link;
+  /** Convert this link into a non-embedded link. */
+  fromEmbed(): Link;
+  /** Convert this link to markdown so it can be rendered. */
+  markdown(): string;
+  /** Convert the inner part of the link to something that Obsidian can open / understand. */
+  obsidianLink(): string;
+  /** The stripped name of the file this link points to. */
+  fileName(): string;
+}
+/**
+ * A trivial base class which just defines the '$widget' identifier type. Subtypes of
+ * widget are responsible for adding whatever metadata is relevant. If you want your widget
+ * to have rendering functionality (which you probably do), you should extend `RenderWidget`.
+ */
+export declare abstract class Widget {
+  $widget: string;
+  constructor($widget: string);
+  /**
+   * Attempt to render this widget in markdown, if possible; if markdown is not possible,
+   * then this will attempt to render as HTML. Note that many widgets have interactive
+   * components or difficult functional components and the `markdown` function can simply
+   * return a placeholder in this case (such as `<function>` or `<task-list>`).
+   */
+  abstract markdown(): string;
+}
+/** A trivial widget which renders a (key, value) pair, and allows accessing the key and value. */
+export declare class ListPairWidget extends Widget {
+  key: Literal;
+  value: Literal;
+  constructor(key: Literal, value: Literal);
+  markdown(): string;
+}
+/** A simple widget which renders an external link. */
+export declare class ExternalLinkWidget extends Widget {
+  url: string;
+  display?: string | undefined;
+  constructor(url: string, display?: string | undefined);
+  markdown(): string;
+}
+export declare namespace Widgets {
+  /** Create a list pair widget matching the given key and value. */
+  function listPair(key: Literal, value: Literal): ListPairWidget;
+  /** Create an external link widget which renders an external Obsidian link. */
+  function externalLink(url: string, display?: string): ExternalLinkWidget;
+  /** Checks if the given widget is a list pair widget. */
+  function isListPair(widget: Widget): widget is ListPairWidget;
+  function isExternalLink(widget: Widget): widget is ExternalLinkWidget;
+  /** Determines if the given widget is any kind of built-in widget with special rendering handling. */
+  function isBuiltin(widget: Widget): boolean;
+}

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

@@ -1 +1,43 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/expression/binaryop.cjs';
+/** Provides a global dispatch table for evaluating binary operators, including comparison. */
+import type { Result } from '../api/result.d.d.mts';
+import type {
+  Literal,
+  LiteralRepr,
+  LiteralType
+} from '../data-model/value.d.d.mts';
+import type { Context } from '../expression/context.d.d.mts';
+import type { BinaryOp } from '../expression/field.d.d.mts';
+/** A literal type or a catch-all '*'. */
+export type LiteralTypeOrAll = LiteralType | '*';
+/** Maps a literal type or the catch-all '*'. */
+export type LiteralReprAll<T extends LiteralTypeOrAll> = T extends '*' ? Literal : T extends LiteralType ? LiteralRepr<T> : any;
+/** An implementation for a binary operator. */
+export type BinaryOpImpl<A extends Literal, B extends Literal> = (first: A, second: B, ctx: Context) => Literal;
+/** An implementation of a comparator (returning a number) which then automatically defines all of the comparison operators. */
+export type CompareImpl<T extends Literal> = (first: T, second: T, ctx: Context) => number;
+/** Provides implementations for binary operators on two types using a registry. */
+export declare class BinaryOpHandler {
+  private map;
+  static create(): BinaryOpHandler;
+  constructor();
+  register<T extends LiteralTypeOrAll, U extends LiteralTypeOrAll>(
+    left: T,
+    op: BinaryOp,
+    right: U,
+    func: BinaryOpImpl<LiteralReprAll<T>, LiteralReprAll<U>>
+  ): BinaryOpHandler;
+  registerComm<T extends LiteralTypeOrAll, U extends LiteralTypeOrAll>(
+    left: T,
+    op: BinaryOp,
+    right: U,
+    func: BinaryOpImpl<LiteralReprAll<T>, LiteralReprAll<U>>
+  ): BinaryOpHandler;
+  /** Implement a comparison function. */
+  compare<T extends LiteralTypeOrAll>(type: T, compare: CompareImpl<LiteralReprAll<T>>): BinaryOpHandler;
+  /** Attempt to evaluate the given binary operator on the two literal fields. */
+  evaluate(op: BinaryOp, left: Literal, right: Literal, ctx: Context): Result<Literal, string>;
+  /** Create a string representation of the given triplet for unique lookup in the map. */
+  static repr(op: BinaryOp, left: LiteralTypeOrAll, right: LiteralTypeOrAll): string;
+}
+/** Configure and create a binary OP handler with the given parameters. */
+export declare function createBinaryOps(linkNormalizer: (x: string) => string): BinaryOpHandler;

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

@@ -1 +1,49 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/expression/context.cjs';
+/** Core implementation of the query language evaluation engine. */
+import type { Result } from '../api/result.d.d.mts';
+import type { Literal } from '../data-model/value.d.d.mts';
+import type { QuerySettings } from '../settings.d.d.mts';
+import type { BinaryOpHandler } from './binaryop.d.d.mts';
+import type { Field } from './field.d.d.mts';
+import type { FunctionImpl } from './functions.d.d.mts';
+/** Handles link resolution and normalization inside of a context. */
+export interface LinkHandler {
+  /** Resolve a link to the metadata it contains. */
+  resolve(path: string): Record<string, Literal> | null;
+  /**
+   * Normalize a link to it's fully-qualified path for comparison purposes.
+   * If the path does not exist, returns it unchanged.
+   */
+  normalize(path: string): string;
+  /** Return true if the given path actually exists, false otherwise. */
+  exists(path: string): boolean;
+}
+/**
+ * Evaluation context that expressions can be evaluated in. Includes global state, as well as available functions and a handler
+ * for binary operators.
+ */
+export declare class Context {
+  linkHandler: LinkHandler;
+  settings: QuerySettings;
+  globals: Record<string, Literal>;
+  binaryOps: BinaryOpHandler;
+  functions: Record<string, FunctionImpl>;
+  /**
+   * Create a new context with the given namespace of globals, as well as optionally with custom binary operator, function,
+   * and link handlers.
+   */
+  constructor(
+    linkHandler: LinkHandler,
+    settings: QuerySettings,
+    globals?: Record<string, Literal>,
+    binaryOps?: BinaryOpHandler,
+    functions?: Record<string, FunctionImpl>
+  );
+  /** Set a global value in this context. */
+  set(name: string, value: Literal): Context;
+  /** Get the value of a global variable by name. Returns null if not present. */
+  get(name: string): Literal;
+  /** Try to evaluate an arbitrary field in this context, raising an exception on failure. */
+  tryEvaluate(field: Field, data?: Record<string, Literal>): Literal;
+  /** Evaluate an arbitrary field in this context. */
+  evaluate(field: Field, data?: Record<string, Literal>): Result<Literal, string>;
+}

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

@@ -1 +1,82 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/expression/field.cjs';
+/** Defines the AST for a field which can be evaluated. */
+import type { Literal } from '../data-model/value.d.d.mts';
+/** Comparison operators which yield true/false. */
+export type CompareOp = '>' | '>=' | '<=' | '<' | '=' | '!=';
+/** Arithmetic operators which yield numbers and other values. */
+export type ArithmeticOp = '+' | '-' | '*' | '/' | '%' | '&' | '|';
+/** All valid binary operators. */
+export type BinaryOp = CompareOp | ArithmeticOp;
+/** A (potentially computed) field to select or compare against. */
+export type Field = BinaryOpField | VariableField | LiteralField | FunctionField | IndexField | NegatedField | LambdaField | ObjectField | ListField;
+/** Literal representation of some field type. */
+export interface LiteralField {
+  type: 'literal';
+  value: Literal;
+}
+/** A variable field for a variable with a given name. */
+export interface VariableField {
+  type: 'variable';
+  name: string;
+}
+/** A list, which is an ordered collection of fields. */
+export interface ListField {
+  type: 'list';
+  values: Field[];
+}
+/** An object, which is a mapping of name to field. */
+export interface ObjectField {
+  type: 'object';
+  values: Record<string, Field>;
+}
+/** A binary operator field which combines two subnodes somehow. */
+export interface BinaryOpField {
+  type: 'binaryop';
+  left: Field;
+  right: Field;
+  op: BinaryOp;
+}
+/** A function field which calls a function on 0 or more arguments. */
+export interface FunctionField {
+  type: 'function';
+  /** Either the name of the function being called, or a Function object. */
+  func: Field;
+  /** The arguments being passed to the function. */
+  arguments: Field[];
+}
+export interface LambdaField {
+  type: 'lambda';
+  /** An ordered list of named arguments. */
+  arguments: string[];
+  /** The field which should be evaluated with the arguments in context. */
+  value: Field;
+}
+/** A field which indexes a variable into another variable. */
+export interface IndexField {
+  type: 'index';
+  /** The field to index into. */
+  object: Field;
+  /** The index. */
+  index: Field;
+}
+/** A field which negates the value of the original field. */
+export interface NegatedField {
+  type: 'negated';
+  /** The child field to negated. */
+  child: Field;
+}
+/** Utility methods for creating & comparing fields. */
+export declare namespace Fields {
+  function variable(name: string): VariableField;
+  function literal(value: Literal): LiteralField;
+  function binaryOp(left: Field, op: BinaryOp, right: Field): Field;
+  function index(obj: Field, index: Field): IndexField;
+  /** Converts a string in dot-notation-format into a variable which indexes. */
+  function indexVariable(name: string): Field;
+  function lambda(args: string[], value: Field): LambdaField;
+  function func(func: Field, args: Field[]): FunctionField;
+  function list(values: Field[]): ListField;
+  function object(values: Record<string, Field>): ObjectField;
+  function negate(child: Field): NegatedField;
+  function isCompareOp(op: BinaryOp): op is CompareOp;
+  const NULL: LiteralField;
+}

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

@@ -1 +1,149 @@
-export * from '../../../../../cjs/obsidian/@types/Dataview/expression/functions.cjs';
+/** Default function implementations for the expression evaluator. */
+import type { Literal } from '../data-model/value.d.d.mts';
+import type {
+  LiteralReprAll,
+  LiteralTypeOrAll
+} from './binaryop.d.d.mts';
+import type { Context } from './context.d.d.mts';
+/**
+ * A function implementation which takes in a function context and a variable number of arguments. Throws an error if an
+ * invalid number/type of arguments are passed.
+ */
+export type FunctionImpl = (context: Context, ...rest: Literal[]) => Literal;
+/** A "bound" function implementation which has already had a function context passed to it. */
+export type BoundFunctionImpl = (...args: Literal[]) => Literal;
+/** A function variant used in the function builder which holds the argument types. */
+interface FunctionVariant {
+  args: LiteralTypeOrAll[];
+  varargs: boolean;
+  /** The implementing function for this specific variant. */
+  impl: FunctionImpl;
+}
+/**
+ * Allows for the creation of functions that check the number and type of their arguments, and dispatch
+ * to different implementations based on the types of the inputs.
+ */
+export declare class FunctionBuilder {
+  name: string;
+  variants: FunctionVariant[];
+  vectorized: Record<number, number[]>;
+  constructor(name: string);
+  /** Add a general function variant which accepts any number of arguments of any type. */
+  vararg(impl: FunctionImpl): FunctionBuilder;
+  /** Add a function variant which takes in a single argument. */
+  add1<T extends LiteralTypeOrAll>(argType: T, impl: (a: LiteralReprAll<T>, context: Context) => Literal): FunctionBuilder;
+  /** Add a function variant which takes in two typed arguments. */
+  add2<T extends LiteralTypeOrAll, U extends LiteralTypeOrAll>(
+    arg1: T,
+    arg2: U,
+    impl: (a: LiteralReprAll<T>, b: LiteralReprAll<U>, context: Context) => Literal
+  ): FunctionBuilder;
+  /** Add a function variant which takes in three typed arguments. */
+  add3<T extends LiteralTypeOrAll, U extends LiteralTypeOrAll, V extends LiteralTypeOrAll>(
+    arg1: T,
+    arg2: U,
+    arg3: V,
+    impl: (a: LiteralReprAll<T>, b: LiteralReprAll<U>, c: LiteralReprAll<V>, context: Context) => Literal
+  ): FunctionBuilder;
+  /** Add vectorized variants which accept the given number of arguments and delegate. */
+  vectorize(numArgs: number, positions: number[]): FunctionBuilder;
+  /** Return a function which checks the number and type of arguments, passing them on to the first matching variant. */
+  build(): FunctionImpl;
+}
+/** Utilities for managing function implementations. */
+export declare namespace Functions {
+  /** Bind a context to a function implementation, yielding a function which does not need the context argument. */
+  function bind(func: FunctionImpl, context: Context): BoundFunctionImpl;
+  /** Bind a context to all functions in the given map, yielding a new map of bound functions. */
+  function bindAll(funcs: Record<string, FunctionImpl>, context: Context): Record<string, BoundFunctionImpl>;
+}
+/**
+ * Collection of all defined functions; defined here so that they can be called from within dataview,
+ * and test code.
+ */
+export declare namespace DefaultFunctions {
+  const typeOf: FunctionImpl;
+  /** Compute the length of a data type. */
+  const length: FunctionImpl;
+  /** List constructor function. */
+  const list: FunctionImpl;
+  /** Object constructor function. */
+  const object: FunctionImpl;
+  /** Internal link constructor function. */
+  const link: FunctionImpl;
+  /** Embed and un-embed a link. */
+  const embed: FunctionImpl;
+  /** External link constructor function. */
+  const elink: FunctionImpl;
+  /** Date constructor function. */
+  const date: FunctionImpl;
+  /** Duration constructor function. */
+  const dur: FunctionImpl;
+  /** Format a date using a luxon/moment-style date format. */
+  const dateformat: FunctionImpl;
+  const durationformat: FunctionImpl;
+  const localtime: FunctionImpl;
+  /** Number constructor function. */
+  const number: FunctionImpl;
+  /** Format a number using a standard currency format. */
+  const currencyformat: FunctionImpl;
+  /**
+   * Convert any value to a reasonable internal string representation. Most useful for dates, strings, numbers, and
+   * so on.
+   */
+  const string: FunctionImpl;
+  const round: FunctionImpl;
+  const trunc: FunctionImpl;
+  const floor: FunctionImpl;
+  const ceil: FunctionImpl;
+  const min: FunctionImpl;
+  const max: FunctionImpl;
+  const minby: FunctionImpl;
+  const maxby: FunctionImpl;
+  const striptime: FunctionImpl;
+  const contains: FunctionImpl;
+  const icontains: FunctionImpl;
+  const econtains: FunctionImpl;
+  const containsword: FunctionImpl;
+  /** Extract 0 or more keys from a given object via indexing. */
+  const extract: FunctionImpl;
+  const reverse: FunctionImpl;
+  const sort: FunctionImpl;
+  const regextest: FunctionImpl;
+  const regexmatch: FunctionImpl;
+  const regexreplace: FunctionImpl;
+  const lower: FunctionImpl;
+  const upper: FunctionImpl;
+  const replace: FunctionImpl;
+  /** Split a string on a given string. */
+  const split: FunctionImpl;
+  const startswith: FunctionImpl;
+  const endswith: FunctionImpl;
+  const padleft: FunctionImpl;
+  const padright: FunctionImpl;
+  const substring: FunctionImpl;
+  const truncate: FunctionImpl;
+  const fdefault: FunctionImpl;
+  const ldefault: FunctionImpl;
+  const choice: FunctionImpl;
+  const hash: FunctionImpl;
+  const reduce: FunctionImpl;
+  const sum: FunctionImpl;
+  const average: FunctionImpl;
+  const product: FunctionImpl;
+  const join: FunctionImpl;
+  const any: FunctionImpl;
+  const all: FunctionImpl;
+  const none: FunctionImpl;
+  const filter: FunctionImpl;
+  const unique: FunctionImpl;
+  const map: FunctionImpl;
+  const nonnull: FunctionImpl;
+  /** Gets an object containing a link's own properties */
+  const meta: FunctionImpl;
+  const flat: FunctionImpl;
+  const slice: FunctionImpl;
+}
+/** Default function implementations for the expression evaluator. */
+export declare const DEFAULT_FUNCTIONS: Record<string, FunctionImpl>;
+export {};