obsidian-dev-utils 16.3.0 → 16.4.0

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

@@ -1,109 +1,136 @@
-import type { DateTime, Duration } from "luxon";
-import type { QuerySettings } from "../settings.d.ts";
+import type {
+  DateTime,
+  Duration
+} from 'luxon';
+import type { QuerySettings } from '../settings.d.ts';
 /** Shorthand for a mapping from keys to values. */
 export type DataObject = {
-    [key: string]: Literal;
+  [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";
+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>;
+  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;
+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 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>;
+  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;
+  /** 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;
+  /** 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;
+  /** 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
@@ -111,38 +138,38 @@ export declare class Link {
  * 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;
+  $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;
+  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;
+  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;
+  /** 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/obsidian/@types/Dataview/expression/binaryop.d.ts

@@ -1,29 +1,43 @@
 /** Provides a global dispatch table for evaluating binary operators, including comparison. */
-import type { LiteralRepr, LiteralType, Literal } from "../data-model/value.d.ts";
-import type { Result } from "../api/result.d.ts";
-import type { BinaryOp } from "../expression/field.d.ts";
-import type { Context } from "../expression/context.d.ts";
+import type { Result } from '../api/result.d.ts';
+import type {
+  Literal,
+  LiteralRepr,
+  LiteralType
+} from '../data-model/value.d.ts';
+import type { Context } from '../expression/context.d.ts';
+import type { BinaryOp } from '../expression/field.d.ts';
 /** A literal type or a catch-all '*'. */
-export type LiteralTypeOrAll = LiteralType | "*";
+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;
+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;
+  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/obsidian/@types/Dataview/expression/context.d.ts

@@ -1,43 +1,49 @@
 /** Core implementation of the query language evaluation engine. */
-import type { Literal } from "../data-model/value.d.ts";
-import type { Result } from "../api/result.d.ts";
-import type { BinaryOpHandler } from "./binaryop.d.ts";
-import type { Field } from "./field.d.ts";
-import type { FunctionImpl } from "./functions.d.ts";
-import type { QuerySettings } from "../settings.d.ts";
+import type { Result } from '../api/result.d.ts';
+import type { Literal } from '../data-model/value.d.ts';
+import type { QuerySettings } from '../settings.d.ts';
+import type { BinaryOpHandler } from './binaryop.d.ts';
+import type { Field } from './field.d.ts';
+import type { FunctionImpl } from './functions.d.ts';
 /** 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;
+  /** 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>;
+  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/obsidian/@types/Dataview/expression/field.d.ts

@@ -1,82 +1,82 @@
 /** Defines the AST for a field which can be evaluated. */
-import type { Literal } from "../data-model/value.d.ts";
+import type { Literal } from '../data-model/value.d.ts';
 /** Comparison operators which yield true/false. */
-export type CompareOp = ">" | ">=" | "<=" | "<" | "=" | "!=";
+export type CompareOp = '>' | '>=' | '<=' | '<' | '=' | '!=';
 /** Arithmetic operators which yield numbers and other values. */
-export type ArithmeticOp = "+" | "-" | "*" | "/" | "%" | "&" | "|";
+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;
+  type: 'literal';
+  value: Literal;
 }
 /** A variable field for a variable with a given name. */
 export interface VariableField {
-    type: "variable";
-    name: string;
+  type: 'variable';
+  name: string;
 }
 /** A list, which is an ordered collection of fields. */
 export interface ListField {
-    type: "list";
-    values: Field[];
+  type: 'list';
+  values: Field[];
 }
 /** An object, which is a mapping of name to field. */
 export interface ObjectField {
-    type: "object";
-    values: Record<string, Field>;
+  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;
+  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[];
+  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;
+  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;
+  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;
+  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;
+  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;
 }