@uwdata/mosaic-sql 0.12.2 → 0.14.0

package/dist/types/functions/aggregate.d.ts

@@ -1,229 +1,236 @@
 /**
  * Compute an arg_max aggregate.
- * @param {import('../types.js').ExprValue} y The argument to return.
- * @param {import('../types.js').ExprValue} x The expression to maximize.
+ * @param {ExprValue} y The argument to return.
+ * @param {ExprValue} x The expression to maximize.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function argmax(y: import("../types.js").ExprValue, x: import("../types.js").ExprValue): AggregateNode;
+export function argmax(y: ExprValue, x: ExprValue): AggregateNode;
 /**
  * Compute an arg_min aggregate.
- * @param {import('../types.js').ExprValue} y The argument to return.
- * @param {import('../types.js').ExprValue} x The expression to minimize.
+ * @param {ExprValue} y The argument to return.
+ * @param {ExprValue} x The expression to minimize.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function argmin(y: import("../types.js").ExprValue, x: import("../types.js").ExprValue): AggregateNode;
+export function argmin(y: ExprValue, x: ExprValue): AggregateNode;
 /**
  * Compute an array aggregation.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function arrayAgg(expr: import("../types.js").ExprValue): AggregateNode;
+export function arrayAgg(expr: ExprValue): AggregateNode;
 /**
  * Compute an average aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function avg(expr: import("../types.js").ExprValue): AggregateNode;
+export function avg(expr: ExprValue): AggregateNode;
 /**
  * Compute a correlation aggregate.
- * @param {import('../types.js').ExprValue} x The x expression to aggregate.
- * @param {import('../types.js').ExprValue} y The y expression to aggregate.
+ * @param {ExprValue} x The x expression to aggregate.
+ * @param {ExprValue} y The y expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function corr(x: import("../types.js").ExprValue, y: import("../types.js").ExprValue): AggregateNode;
+export function corr(x: ExprValue, y: ExprValue): AggregateNode;
 /**
  * Compute a count aggregate.
- * @param {import('../types.js').ExprValue} [expr] An optional expression
+ * @param {ExprValue} [expr] An optional expression
  *  to count. If specified, only non-null expression values are counted.
  *  If omitted, all rows within a group are counted.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function count(expr?: import("../types.js").ExprValue): AggregateNode;
+export function count(expr?: ExprValue): AggregateNode;
 /**
  * Compute a sample covariance aggregate.
- * @param {import('../types.js').ExprValue} x The x expression to aggregate.
- * @param {import('../types.js').ExprValue} y The y expression to aggregate.
+ * @param {ExprValue} x The x expression to aggregate.
+ * @param {ExprValue} y The y expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function covariance(x: import("../types.js").ExprValue, y: import("../types.js").ExprValue): AggregateNode;
+export function covariance(x: ExprValue, y: ExprValue): AggregateNode;
 /**
  * Compute a population covariance aggregate.
- * @param {import('../types.js').ExprValue} x The x expression to aggregate.
- * @param {import('../types.js').ExprValue} y The y expression to aggregate.
+ * @param {ExprValue} x The x expression to aggregate.
+ * @param {ExprValue} y The y expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function covarPop(x: import("../types.js").ExprValue, y: import("../types.js").ExprValue): AggregateNode;
+export function covarPop(x: ExprValue, y: ExprValue): AggregateNode;
 /**
  * Compute an entropy aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function entropy(expr: import("../types.js").ExprValue): AggregateNode;
+export function entropy(expr: ExprValue): AggregateNode;
 /**
  * Compute a first aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function first(expr: import("../types.js").ExprValue): AggregateNode;
+export function first(expr: ExprValue): AggregateNode;
+/**
+ * Compute a geomean aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
+ * @returns {AggregateNode} A SQL aggregate function call.
+ */
+export function geomean(expr: ExprValue): AggregateNode;
 /**
  * Compute a sample kurtosis aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function kurtosis(expr: import("../types.js").ExprValue): AggregateNode;
+export function kurtosis(expr: ExprValue): AggregateNode;
 /**
  * Compute a median absolute deviation (MAD) aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function mad(expr: import("../types.js").ExprValue): AggregateNode;
+export function mad(expr: ExprValue): AggregateNode;
 /**
  * Compute a maximum aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function max(expr: import("../types.js").ExprValue): AggregateNode;
+export function max(expr: ExprValue): AggregateNode;
 /**
  * Compute a median aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function median(expr: import("../types.js").ExprValue): AggregateNode;
+export function median(expr: ExprValue): AggregateNode;
 /**
  * Compute a minimum aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function min(expr: import("../types.js").ExprValue): AggregateNode;
+export function min(expr: ExprValue): AggregateNode;
 /**
  * Compute a mode aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function mode(expr: import("../types.js").ExprValue): AggregateNode;
+export function mode(expr: ExprValue): AggregateNode;
 /**
  * Compute a last aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function last(expr: import("../types.js").ExprValue): AggregateNode;
+export function last(expr: ExprValue): AggregateNode;
 /**
  * Compute a product aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function product(expr: import("../types.js").ExprValue): AggregateNode;
+export function product(expr: ExprValue): AggregateNode;
 /**
  * Compute a quantile aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
- * @param {import('../types.js').ExprValue} p The quantile value.
+ * @param {ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} p The quantile value.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function quantile(expr: import("../types.js").ExprValue, p: import("../types.js").ExprValue): AggregateNode;
+export function quantile(expr: ExprValue, p: ExprValue): AggregateNode;
 /**
  * Compute a linear regression reg_avgX aggregate.
- * @param {import('../types.js').ExprValue} x The x expression to aggregate.
- * @param {import('../types.js').ExprValue} y The y expression to aggregate.
+ * @param {ExprValue} x The x expression to aggregate.
+ * @param {ExprValue} y The y expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function regrAvgX(x: import("../types.js").ExprValue, y: import("../types.js").ExprValue): AggregateNode;
+export function regrAvgX(x: ExprValue, y: ExprValue): AggregateNode;
 /**
  * Compute a linear regression reg_avgY aggregate.
- * @param {import('../types.js').ExprValue} x The x expression to aggregate.
- * @param {import('../types.js').ExprValue} y The y expression to aggregate.
+ * @param {ExprValue} x The x expression to aggregate.
+ * @param {ExprValue} y The y expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function regrAvgY(x: import("../types.js").ExprValue, y: import("../types.js").ExprValue): AggregateNode;
+export function regrAvgY(x: ExprValue, y: ExprValue): AggregateNode;
 /**
  * Compute a linear regression count aggregate.
  * This returns the count of rows where both x and y are non-null.
- * @param {import('../types.js').ExprValue} x The x expression to aggregate.
- * @param {import('../types.js').ExprValue} y The y expression to aggregate.
+ * @param {ExprValue} x The x expression to aggregate.
+ * @param {ExprValue} y The y expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function regrCount(x: import("../types.js").ExprValue, y: import("../types.js").ExprValue): AggregateNode;
+export function regrCount(x: ExprValue, y: ExprValue): AggregateNode;
 /**
  * Compute a linear regression intercept aggregate.
- * @param {import('../types.js').ExprValue} x The x expression to aggregate.
- * @param {import('../types.js').ExprValue} y The y expression to aggregate.
+ * @param {ExprValue} x The x expression to aggregate.
+ * @param {ExprValue} y The y expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function regrIntercept(x: import("../types.js").ExprValue, y: import("../types.js").ExprValue): AggregateNode;
+export function regrIntercept(x: ExprValue, y: ExprValue): AggregateNode;
 /**
  * Compute a linear regression R^2 aggregate.
- * @param {import('../types.js').ExprValue} x The x expression to aggregate.
- * @param {import('../types.js').ExprValue} y The y expression to aggregate.
+ * @param {ExprValue} x The x expression to aggregate.
+ * @param {ExprValue} y The y expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function regrR2(x: import("../types.js").ExprValue, y: import("../types.js").ExprValue): AggregateNode;
+export function regrR2(x: ExprValue, y: ExprValue): AggregateNode;
 /**
  * Compute a linear regression regr_sxx aggregate.
- * @param {import('../types.js').ExprValue} x The x expression to aggregate.
- * @param {import('../types.js').ExprValue} y The y expression to aggregate.
+ * @param {ExprValue} x The x expression to aggregate.
+ * @param {ExprValue} y The y expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function regrSXX(x: import("../types.js").ExprValue, y: import("../types.js").ExprValue): AggregateNode;
+export function regrSXX(x: ExprValue, y: ExprValue): AggregateNode;
 /**
  * Compute a linear regression regr_sxy aggregate.
- * @param {import('../types.js').ExprValue} x The x expression to aggregate.
- * @param {import('../types.js').ExprValue} y The y expression to aggregate.
+ * @param {ExprValue} x The x expression to aggregate.
+ * @param {ExprValue} y The y expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function regrSXY(x: import("../types.js").ExprValue, y: import("../types.js").ExprValue): AggregateNode;
+export function regrSXY(x: ExprValue, y: ExprValue): AggregateNode;
 /**
  * Compute a linear regression regr_syy aggregate.
- * @param {import('../types.js').ExprValue} x The x expression to aggregate.
- * @param {import('../types.js').ExprValue} y The y expression to aggregate.
+ * @param {ExprValue} x The x expression to aggregate.
+ * @param {ExprValue} y The y expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function regrSYY(x: import("../types.js").ExprValue, y: import("../types.js").ExprValue): AggregateNode;
+export function regrSYY(x: ExprValue, y: ExprValue): AggregateNode;
 /**
  * Compute a linear regression slope aggregate.
- * @param {import('../types.js').ExprValue} x The x expression to aggregate.
- * @param {import('../types.js').ExprValue} y The y expression to aggregate.
+ * @param {ExprValue} x The x expression to aggregate.
+ * @param {ExprValue} y The y expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function regrSlope(x: import("../types.js").ExprValue, y: import("../types.js").ExprValue): AggregateNode;
+export function regrSlope(x: ExprValue, y: ExprValue): AggregateNode;
 /**
  * Compute a skewness aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function skewness(expr: import("../types.js").ExprValue): AggregateNode;
+export function skewness(expr: ExprValue): AggregateNode;
 /**
  * Compute a sample standard deviation aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function stddev(expr: import("../types.js").ExprValue): AggregateNode;
+export function stddev(expr: ExprValue): AggregateNode;
 /**
  * Compute a population standard deviation aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function stddevPop(expr: import("../types.js").ExprValue): AggregateNode;
+export function stddevPop(expr: ExprValue): AggregateNode;
 /**
  * Compute a string aggregation.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function stringAgg(expr: import("../types.js").ExprValue): AggregateNode;
+export function stringAgg(expr: ExprValue): AggregateNode;
 /**
  * Compute a sum aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function sum(expr: import("../types.js").ExprValue): AggregateNode;
+export function sum(expr: ExprValue): AggregateNode;
 /**
  * Compute a sample variance aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function variance(expr: import("../types.js").ExprValue): AggregateNode;
+export function variance(expr: ExprValue): AggregateNode;
 /**
  * Compute a population variance aggregate.
- * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @param {ExprValue} expr The expression to aggregate.
  * @returns {AggregateNode} A SQL aggregate function call.
  */
-export function varPop(expr: import("../types.js").ExprValue): AggregateNode;
-import { AggregateNode } from '../ast/aggregate.js';
+export function varPop(expr: ExprValue): AggregateNode;
+import type { ExprValue } from '../types.js';
+import type { AggregateNode } from '../ast/aggregate.js';

package/dist/types/functions/case.d.ts

@@ -1,15 +1,13 @@
 /**
  * Create a new conditional CASE statement. If three arguments are provided,
- * acts like a ternary conditional (if, then else). If no arguments are
+ * acts like a ternary conditional (if, then, else). If no arguments are
  * provided, the chained `when` and `else` methods can be used to to complete
  * a conditional statement with WHEN/THEN and ELSE expressions.
- * @param {import('../types.js').ExprValue} [when]
- *  A conditional WHEN expression.
- * @param {import('../types.js').ExprValue} [then]
- *  A THEN value expression.
- * @param {import('../types.js').ExprValue} [other]
- *  An ELSE expression.
+ * @param {ExprValue} [when] A conditional WHEN expression.
+ * @param {ExprValue} [then] A THEN value expression.
+ * @param {ExprValue} [other] An ELSE expression.
  * @returns {CaseNode}
  */
-export function cond(when?: import("../types.js").ExprValue, then?: import("../types.js").ExprValue, other?: import("../types.js").ExprValue): CaseNode;
+export function cond(when?: ExprValue, then?: ExprValue, other?: ExprValue): CaseNode;
+import type { ExprValue } from '../types.js';
 import { CaseNode } from '../ast/case.js';

package/dist/types/functions/column.d.ts

@@ -1,9 +1,11 @@
 /**
  * Create a column reference.
- * @param {string | import('../types.js').ParamLike} name The column name,
+ * @param {string | ParamLike} name The column name,
  *  as a string or as a dynamic parameter.
  * @param {string | string[] | TableRefNode} [table] The table reference.
- * @returns {import('../ast/column-ref.js').ColumnRefNode}
+ * @returns {ColumnRefNode}
  */
-export function column(name: string | import("../types.js").ParamLike, table?: string | string[] | TableRefNode): import("../ast/column-ref.js").ColumnRefNode;
+export function column(name: string | ParamLike, table?: string | string[] | TableRefNode): ColumnRefNode;
+import type { ParamLike } from '../types.js';
 import { TableRefNode } from '../ast/table-ref.js';
+import type { ColumnRefNode } from '../ast/column-ref.js';

package/dist/types/functions/cte.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Create a common table expression (CTE) to include within a WITH clause.
+ * @param {string} name The common table expression (CTE) name.
+ * @param {Query} query The common table expression (CTE) query.
+ * @param {boolean | null} [materialized] The common table expression (CTE)
+ *  materialization flag. If `true`, forces materialization of the CTE.
+ *  If `false`, materialization is not performed. Otherwise (for example, if
+ *  `undefined` or `null`), materialization is decided by the database.
+ * @returns {WithClauseNode}
+ */
+export function cte(name: string, query: Query, materialized?: boolean | null): WithClauseNode;
+import { Query } from '../ast/query.js';
+import { WithClauseNode } from '../ast/with.js';

package/dist/types/functions/datetime.d.ts

@@ -7,38 +7,39 @@
 export function interval(unit: string, steps: number): IntervalNode;
 /**
  * Given a date/time value, return the milliseconds since the UNIX epoch.
- * @param {import('../types.js').ExprValue} expr The date/time expression.
+ * @param {ExprValue} expr The date/time expression.
  * @returns {FunctionNode}
  */
-export function epoch_ms(expr: import("../types.js").ExprValue): FunctionNode;
+export function epoch_ms(expr: ExprValue): FunctionNode;
 /**
  * Perform data binning according to the provided interval unit and steps.
- * @param {import('../types.js').ExprValue} expr The date/time expression to bin.
+ * @param {ExprValue} expr The date/time expression to bin.
  * @param {string} unit The datetime interval unit to bin by.
  * @param {number} [steps=1] The number of interval steps.
  * @returns {FunctionNode}
  */
-export function dateBin(expr: import("../types.js").ExprValue, unit: string, steps?: number): FunctionNode;
+export function dateBin(expr: ExprValue, unit: string, steps?: number): FunctionNode;
 /**
  * Map date/times to a month value, all within the same year for comparison.
  * The resulting value is still date-typed.
- * @param {import('../types.js').ExprValue} expr The date/time expression.
+ * @param {ExprValue} expr The date/time expression.
  * @returns {FunctionNode}
  */
-export function dateMonth(expr: import("../types.js").ExprValue): FunctionNode;
+export function dateMonth(expr: ExprValue): FunctionNode;
 /**
  * Map date/times to a month and day value, all within the same year for
  * comparison. The resulting value is still date-typed.
- * @param {import('../types.js').ExprValue} expr The date/time expression.
+ * @param {ExprValue} expr The date/time expression.
  * @returns {FunctionNode}
  */
-export function dateMonthDay(expr: import("../types.js").ExprValue): FunctionNode;
+export function dateMonthDay(expr: ExprValue): FunctionNode;
 /**
  * Map date/times to a day of the month value, all within the same year and month
  * for comparison. The resulting value is still date-typed.
- * @param {import('../types.js').ExprValue} expr The date/time expression.
+ * @param {ExprValue} expr The date/time expression.
  * @returns {FunctionNode}
  */
-export function dateDay(expr: import("../types.js").ExprValue): FunctionNode;
+export function dateDay(expr: ExprValue): FunctionNode;
 import { IntervalNode } from '../ast/interval.js';
-import { FunctionNode } from '../ast/function.js';
+import type { ExprValue } from '../types.js';
+import type { FunctionNode } from '../ast/function.js';

package/dist/types/functions/numeric.d.ts

@@ -1,93 +1,95 @@
 /**
  * Return true if the floating point value is not a number, false otherwise.
- * @param {import('../types.js').ExprValue} expr The input number.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @param {ExprValue} expr The input number.
+ * @returns {FunctionNode}
  */
-export function isNaN(expr: import("../types.js").ExprValue): import("../ast/function.js").FunctionNode;
+export function isNaN(expr: ExprValue): FunctionNode;
 /**
  * Return true if the floating point value is finite, false otherwise.
- * @param {import('../types.js').ExprValue} expr The input number.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @param {ExprValue} expr The input number.
+ * @returns {FunctionNode}
  */
-export function isFinite(expr: import("../types.js").ExprValue): import("../ast/function.js").FunctionNode;
+export function isFinite(expr: ExprValue): FunctionNode;
 /**
  * Return true if the floating point value is infinite, false otherwise.
- * @param {import('../types.js').ExprValue} expr The input number.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @param {ExprValue} expr The input number.
+ * @returns {FunctionNode}
  */
-export function isInfinite(expr: import("../types.js").ExprValue): import("../ast/function.js").FunctionNode;
+export function isInfinite(expr: ExprValue): FunctionNode;
 /**
  * Selects the largest value.
- * @param {...import('../types.js').ExprValue} expr The input expressions.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @param {...ExprValue} expr The input expressions.
+ * @returns {FunctionNode}
  */
-export function greatest(...expr: import("../types.js").ExprValue[]): import("../ast/function.js").FunctionNode;
+export function greatest(...expr: ExprValue[]): FunctionNode;
 /**
  * Selects the smallest value.
- * @param {...import('../types.js').ExprValue} expr The input expressions.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @param {...ExprValue} expr The input expressions.
+ * @returns {FunctionNode}
  */
-export function least(...expr: import("../types.js").ExprValue[]): import("../ast/function.js").FunctionNode;
+export function least(...expr: ExprValue[]): FunctionNode;
 /**
  * Compute the exponentional function `e ** expr`.
- * @param {import('../types.js').ExprValue} expr The input number.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @param {ExprValue} expr The input number.
+ * @returns {FunctionNode}
  */
-export function exp(expr: import("../types.js").ExprValue): import("../ast/function.js").FunctionNode;
+export function exp(expr: ExprValue): FunctionNode;
 /**
  * Compute a base 10 logarithm.
- * @param {import('../types.js').ExprValue} expr The input number.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @param {ExprValue} expr The input number.
+ * @returns {FunctionNode}
  */
-export function log(expr: import("../types.js").ExprValue): import("../ast/function.js").FunctionNode;
+export function log(expr: ExprValue): FunctionNode;
 /**
  * Compute a natural logarithm.
- * @param {import('../types.js').ExprValue} expr The input number.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @param {ExprValue} expr The input number.
+ * @returns {FunctionNode}
  */
-export function ln(expr: import("../types.js").ExprValue): import("../ast/function.js").FunctionNode;
+export function ln(expr: ExprValue): FunctionNode;
 /**
  * Compute the sign of a number.
- * @param {import('../types.js').ExprValue} expr The input number.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @param {ExprValue} expr The input number.
+ * @returns {FunctionNode}
  */
-export function sign(expr: import("../types.js").ExprValue): import("../ast/function.js").FunctionNode;
+export function sign(expr: ExprValue): FunctionNode;
 /**
  * Compute the absolute value of a number.
- * @param {import('../types.js').ExprValue} expr The input number.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @param {ExprValue} expr The input number.
+ * @returns {FunctionNode}
  */
-export function abs(expr: import("../types.js").ExprValue): import("../ast/function.js").FunctionNode;
+export function abs(expr: ExprValue): FunctionNode;
 /**
  * Compute the square root of a number.
- * @param {import('../types.js').ExprValue} expr The input number.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @param {ExprValue} expr The input number.
+ * @returns {FunctionNode}
  */
-export function sqrt(expr: import("../types.js").ExprValue): import("../ast/function.js").FunctionNode;
+export function sqrt(expr: ExprValue): FunctionNode;
 /**
  * Rounds the number up.
- * @param {import('../types.js').ExprValue} expr The input number.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @param {ExprValue} expr The input number.
+ * @returns {FunctionNode}
  */
-export function ceil(expr: import("../types.js").ExprValue): import("../ast/function.js").FunctionNode;
+export function ceil(expr: ExprValue): FunctionNode;
 /**
  * Rounds the number down.
- * @param {import('../types.js').ExprValue} expr The input number.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @param {ExprValue} expr The input number.
+ * @returns {FunctionNode}
  */
-export function floor(expr: import("../types.js").ExprValue): import("../ast/function.js").FunctionNode;
+export function floor(expr: ExprValue): FunctionNode;
 /**
  * Round to the given decimal places.
- * @param {import('../types.js').ExprValue} expr The input number.
- * @param {import('../types.js').ExprValue} [places] The decimal places.
+ * @param {ExprValue} expr The input number.
+ * @param {ExprValue} [places] The decimal places.
  *  Negative values are allowed, to round to tens, hundreds, etc.
  *  If unspecified, defaults to zero.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @returns {FunctionNode}
  */
-export function round(expr: import("../types.js").ExprValue, places?: import("../types.js").ExprValue): import("../ast/function.js").FunctionNode;
+export function round(expr: ExprValue, places?: ExprValue): FunctionNode;
 /**
  * Truncates the number.
- * @param {import('../types.js').ExprValue} expr The input number.
- * @returns {import('../ast/function.js').FunctionNode}
+ * @param {ExprValue} expr The input number.
+ * @returns {FunctionNode}
  */
-export function trunc(expr: import("../types.js").ExprValue): import("../ast/function.js").FunctionNode;
+export function trunc(expr: ExprValue): FunctionNode;
+import type { ExprValue } from '../types.js';
+import type { FunctionNode } from '../ast/function.js';