obsidian-dev-utils 19.0.0 → 19.0.1

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

@@ -1,149 +1 @@
-/** Default function implementations for the expression evaluator. */
-import type { Literal } from '../data-model/value.d.mjs';
-import type {
-  LiteralReprAll,
-  LiteralTypeOrAll
-} from './binaryop.d.mjs';
-import type { Context } from './context.d.mjs';
-/**
- * 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 {};
+export * from './functions.cjs';

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

@@ -1,163 +1 @@
-import type {
-  DateTime,
-  Duration
-} from 'luxon';
-import * as P from 'parsimmon';
-import type { Result } from '../api/result.d.mjs';
-import type {
-  CsvSource,
-  FolderSource,
-  NegatedSource,
-  Source,
-  TagSource
-} from '../data-index/source.d.mjs';
-import type {
-  Link,
-  Literal
-} from '../data-model/value.d.mjs';
-import type {
-  BinaryOp,
-  Field,
-  LambdaField,
-  ListField,
-  LiteralField,
-  ObjectField,
-  VariableField
-} from './field.d.mjs';
-/** 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>;
+export * from './parse.cjs';

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

@@ -1,55 +1 @@
-export type {
-  DateTime,
-  Duration
-} from 'luxon';
-export type { DataArray } from './api/data-array.d.mjs';
-export type { DataviewApi } from './api/plugin-api.d.mjs';
-export type {
-  Failure,
-  Result,
-  Success
-} from './api/result.d.mjs';
-export type {
-  FullIndex,
-  IndexMap,
-  PrefixIndex
-} from './data-index/index.d.mjs';
-export type {
-  ListItem,
-  PageMetadata
-} from './data-model/markdown.d.mjs';
-export type {
-  SListEntry,
-  SMarkdownPage,
-  STask
-} from './data-model/serialized/markdown.d.mjs';
-export type {
-  DataObject,
-  Link,
-  Literal,
-  LiteralRepr,
-  LiteralType,
-  LiteralWrapper,
-  Widget,
-  WrappedLiteral
-} from './data-model/value.d.mjs';
-export type {
-  DATE_SHORTHANDS,
-  DURATION_TYPES,
-  EXPRESSION,
-  ExpressionLanguage,
-  KEYWORDS,
-  parseField
-} from './expression/parse.d.mjs';
-export type { QUERY_LANGUAGE } from './query/parse.d.mjs';
-export type { Query } from './query/query.d.mjs';
-import type { DataviewApi } from './api/plugin-api.d.mjs';
-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;
+export * from './index.cjs';

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

@@ -1,52 +1 @@
-import type {
-  Component,
-  MarkdownPostProcessorContext,
-  Plugin
-} from 'obsidian';
-import type { DataviewInlineApi } from './api/inline-api.d.mjs';
-import type { DataviewApi } from './api/plugin-api.d.mjs';
-import type { FullIndex } from './data-index/index.d.mjs';
-import type { DataviewSettings } from './settings.d.mjs';
-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;
-}
+export * from './main.cjs';

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

@@ -1,103 +1 @@
-/**
- * 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.mjs';
-import type { FullIndex } from '../data-index/index.d.mjs';
-import type { Datarow } from '../data-index/resolver.d.mjs';
-import type { SListItem } from '../data-model/serialized/markdown.d.mjs';
-import type {
-  DataObject,
-  Grouping,
-  Link,
-  Literal
-} from '../data-model/value.d.mjs';
-import type {
-  Context,
-  LinkHandler
-} from '../expression/context.d.mjs';
-import type { Field } from '../expression/field.d.mjs';
-import type {
-  Query,
-  QueryOperation
-} from '../query/query.d.mjs';
-import type { QuerySettings } from '../settings.d.mjs';
-/** 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[];
-  }[];
-}
+export * from './engine.cjs';

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

@@ -1,44 +1 @@
-import * as P from 'parsimmon';
-import type { Result } from '../api/result.d.mjs';
-import type { Source } from '../data-index/source.d.mjs';
-import type {
-  Comment,
-  FlattenStep,
-  GroupStep,
-  LimitStep,
-  NamedField,
-  Query,
-  QueryHeader,
-  QueryOperation,
-  QuerySortBy,
-  QueryType,
-  SortByStep,
-  WhereStep
-} from './query.d.mjs';
-/** 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 {};
+export * from './parse.cjs';

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

@@ -1,95 +1 @@
-/** Provides an AST for complex queries. */
-import type { Source } from '../data-index/source.d.mjs';
-import type { Field } from '../expression/field.d.mjs';
-/** 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[];
-}
+export * from './query.cjs';