@uwdata/mosaic-sql 0.13.0 → 0.14.1

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

@@ -1,195 +1,197 @@
 /**
  * Logical and (AND) operator.
- * @param {...import('../types.js').ExprVarArgs} clauses The input expressions.
+ * @param {...ExprVarArgs} clauses The input expressions.
  * @returns {AndNode}
  */
-export function and(...clauses: import("../types.js").ExprVarArgs[]): AndNode<any>;
+export function and(...clauses: ExprVarArgs[]): AndNode<any>;
 /**
  * Logical or (OR) operator.
- * @param {...import('../types.js').ExprVarArgs} clauses The input expressions.
+ * @param {...ExprVarArgs} clauses The input expressions.
  * @returns {OrNode}
  */
-export function or(...clauses: import("../types.js").ExprVarArgs[]): OrNode<any>;
+export function or(...clauses: ExprVarArgs[]): OrNode<any>;
 /**
  * Logical not (NOT) operator.
- * @param {import('../types.js').ExprValue} expr The expression to negate.
+ * @param {ExprValue} expr The expression to negate.
  * @returns {UnaryOpNode}
  */
-export function not(expr: import("../types.js").ExprValue): UnaryOpNode;
+export function not(expr: ExprValue): UnaryOpNode;
 /**
  * Null check (IS NULL) operator.
- * @param {import('../types.js').ExprValue} expr The expression to test.
+ * @param {ExprValue} expr The expression to test.
  * @returns {UnaryPosftixOpNode}
  */
-export function isNull(expr: import("../types.js").ExprValue): UnaryPosftixOpNode;
+export function isNull(expr: ExprValue): UnaryPosftixOpNode;
 /**
  * Non-null check (IS NOT NULL) operator.
- * @param {import('../types.js').ExprValue} expr The expression to test.
+ * @param {ExprValue} expr The expression to test.
  * @returns {UnaryPosftixOpNode}
  */
-export function isNotNull(expr: import("../types.js").ExprValue): UnaryPosftixOpNode;
+export function isNotNull(expr: ExprValue): UnaryPosftixOpNode;
 /**
  * Bitwise not (~) operator.
- * @param {import('../types.js').ExprValue} expr The input expression.
+ * @param {ExprValue} expr The input expression.
  * @returns {UnaryOpNode}
  */
-export function bitNot(expr: import("../types.js").ExprValue): UnaryOpNode;
+export function bitNot(expr: ExprValue): UnaryOpNode;
 /**
  * Bitwise and (&) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function bitAnd(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function bitAnd(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Bitwise or (|) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function bitOr(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function bitOr(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Bit shift left (<<) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function bitLeft(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function bitLeft(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Bit shift right (>>) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function bitRight(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function bitRight(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Addition (+) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function add(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function add(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Subtraction (-) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function sub(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function sub(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Multiplication (*) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function mul(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function mul(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Division (/) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function div(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function div(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Integer division (//) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function idiv(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function idiv(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Modulo (%) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function mod(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function mod(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Exponentiation (**) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function pow(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function pow(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Equality comparision (=) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function eq(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function eq(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Non-equality comparision (<>) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function neq(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function neq(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Less-than comparision (<) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function lt(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function lt(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Greater-than comparision (>) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function gt(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function gt(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Less-than or equal comparision (<=) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function lte(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function lte(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Greater-than or equal comparision (>=) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function gte(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function gte(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Null-inclusive non-equality (IS DISTINCT FROM) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function isDistinct(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function isDistinct(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Null-inclusive equality (IS NOT DISTINCT FROM) operator.
- * @param {import('../types.js').ExprValue} left The left argument.
- * @param {import('../types.js').ExprValue} right The right argument.
+ * @param {ExprValue} left The left argument.
+ * @param {ExprValue} right The right argument.
  * @returns {BinaryOpNode}
  */
-export function isNotDistinct(left: import("../types.js").ExprValue, right: import("../types.js").ExprValue): BinaryOpNode;
+export function isNotDistinct(left: ExprValue, right: ExprValue): BinaryOpNode;
 /**
  * Range inclusion (BETWEEN) operator.
- * @param {import('../types.js').ExprValue} expr The expression to test.
- * @param {import('../types.js').ExprValue[]} extent The range extent.
+ * @param {ExprValue} expr The expression to test.
+ * @param {ExprValue[]} extent The range extent.
  * @returns {BetweenOpNode}
  */
-export function isBetween(expr: import("../types.js").ExprValue, extent: import("../types.js").ExprValue[]): BetweenOpNode;
+export function isBetween(expr: ExprValue, extent: ExprValue[]): BetweenOpNode;
 /**
  * Range exclusion (NOT BETWEEN) operator.
- * @param {import('../types.js').ExprValue} expr The expression to test.
- * @param {import('../types.js').ExprValue[]} extent The range extent.
+ * @param {ExprValue} expr The expression to test.
+ * @param {ExprValue[]} extent The range extent.
  * @returns {NotBetweenOpNode}
  */
-export function isNotBetween(expr: import("../types.js").ExprValue, extent: import("../types.js").ExprValue[]): NotBetweenOpNode;
+export function isNotBetween(expr: ExprValue, extent: ExprValue[]): NotBetweenOpNode;
 /**
  * Set inclusion (IN) operator.
- * @param {import('../types.js').ExprValue} expr The expression to test.
- * @param {import('../types.js').ExprValue[]} values The included values.
+ * @param {ExprValue} expr The expression to test.
+ * @param {ExprValue[]} values The included values.
  * @returns {InOpNode}
  */
-export function isIn(expr: import("../types.js").ExprValue, values: import("../types.js").ExprValue[]): InOpNode;
+export function isIn(expr: ExprValue, values: ExprValue[]): InOpNode;
+import type { ExprVarArgs } from '../types.js';
 import { AndNode } from '../ast/logical-op.js';
 import { OrNode } from '../ast/logical-op.js';
+import type { ExprValue } from '../types.js';
 import { UnaryOpNode } from '../ast/unary-op.js';
 import { UnaryPosftixOpNode } from '../ast/unary-op.js';
 import { BinaryOpNode } from '../ast/binary-op.js';

package/dist/types/functions/order-by.d.ts

@@ -1,17 +1,18 @@
 /**
  * Indicate ascending sort order for an expression.
- * @param {import('../types.js').ExprValue} expr An expression to order by.
+ * @param {ExprValue} expr An expression to order by.
  * @param {boolean | undefined} [nullsFirst] Flag indicating if null values
  *  should be sorted first.
  * @returns {OrderByNode}
  */
-export function asc(expr: import("../types.js").ExprValue, nullsFirst?: boolean | undefined): OrderByNode;
+export function asc(expr: ExprValue, nullsFirst?: boolean | undefined): OrderByNode;
 /**
  * Indicate descending sort order for an expression.
- * @param {import('../types.js').ExprValue} expr An expression to order by.
+ * @param {ExprValue} expr An expression to order by.
  * @param {boolean | undefined} [nullsFirst] Flag indicating if null values
  *  should be sorted first.
  * @returns {OrderByNode}
  */
-export function desc(expr: import("../types.js").ExprValue, nullsFirst?: boolean | undefined): OrderByNode;
+export function desc(expr: ExprValue, nullsFirst?: boolean | undefined): OrderByNode;
+import type { ExprValue } from '../types.js';
 import { OrderByNode } from '../ast/order-by.js';

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

@@ -1,37 +1,38 @@
 /**
  * Function that converts geometry data to GeoJSON format.
- * @param {import('../types.js').ExprValue} expr The input expression.
+ * @param {ExprValue} expr The input expression.
  * @returns {FunctionNode}
  */
-export function geojson(expr: import("../types.js").ExprValue): FunctionNode;
+export function geojson(expr: ExprValue): FunctionNode;
 /**
  * Function that returns a spatial x position (using ST_X).
- * @param {import('../types.js').ExprValue} expr The input expression.
+ * @param {ExprValue} expr The input expression.
  * @returns {FunctionNode}
  */
-export function x(expr: import("../types.js").ExprValue): FunctionNode;
+export function x(expr: ExprValue): FunctionNode;
 /**
  * Function that returns a spatial y position (using ST_Y).
- * @param {import('../types.js').ExprValue} expr The input expression.
+ * @param {ExprValue} expr The input expression.
  * @returns {FunctionNode}
  */
-export function y(expr: import("../types.js").ExprValue): FunctionNode;
+export function y(expr: ExprValue): FunctionNode;
 /**
  * Function that returns the centroid point for geometry data.
- * @param {import('../types.js').ExprValue} expr The input expression.
+ * @param {ExprValue} expr The input expression.
  * @returns {FunctionNode}
  */
-export function centroid(expr: import("../types.js").ExprValue): FunctionNode;
+export function centroid(expr: ExprValue): FunctionNode;
 /**
  * Function that returns the centroid x-coordinate for geometry data.
- * @param {import('../types.js').ExprValue} expr The input expression.
+ * @param {ExprValue} expr The input expression.
  * @returns {FunctionNode}
  */
-export function centroidX(expr: import("../types.js").ExprValue): FunctionNode;
+export function centroidX(expr: ExprValue): FunctionNode;
 /**
  * Function that returns yhe centroid y-coordinate for geometry data.
- * @param {import('../types.js').ExprValue} expr The input expression.
+ * @param {ExprValue} expr The input expression.
  * @returns {FunctionNode}
  */
-export function centroidY(expr: import("../types.js").ExprValue): FunctionNode;
-import { FunctionNode } from '../ast/function.js';
+export function centroidY(expr: ExprValue): FunctionNode;
+import type { ExprValue } from '../types.js';
+import type { FunctionNode } from '../ast/function.js';

package/dist/types/functions/sql-template-tag.d.ts

@@ -1,8 +1,5 @@
 /**
- * @typedef {import('../ast/node.js').ExprNode
- *  | import('../types.js').ParamLike
- *  | string | number | boolean | Date
- * } TemplateValue
+ * @typedef { ExprNode | ParamLike | string | number | boolean | Date } TemplateValue
  */
 /**
  * Template tag function for SQL fragments. Interpolated values
@@ -12,5 +9,7 @@
  * @param {...TemplateValue} exprs Template expression values.
  */
 export function sql(strings: TemplateStringsArray, ...exprs: TemplateValue[]): FragmentNode;
-export type TemplateValue = import("../ast/node.js").ExprNode | import("../types.js").ParamLike | string | number | boolean | Date;
+export type TemplateValue = ExprNode | ParamLike | string | number | boolean | Date;
 import { FragmentNode } from '../ast/fragment.js';
+import type { ExprNode } from '../ast/node.js';
+import type { ParamLike } from '../types.js';

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

@@ -1,9 +1,9 @@
 /**
  * Function that returns true if a string contains a regexp pattern,
  * false otherwise.
- * @param {import('../types.js').ExprValue} string The string match against.
- * @param {import('../types.js').StringValue} pattern The regular expression pattern to match.
- * @param {import('../types.js').StringValue} [options] Regular expression options:
+ * @param {ExprValue} string The string match against.
+ * @param {StringValue} pattern The regular expression pattern to match.
+ * @param {StringValue} [options] Regular expression options:
  *  'c': case-sensitive matching
  *  'i': case-insensitive matching
  *  'l': match literals instead of regular expression tokens
@@ -12,44 +12,46 @@
  *  's': non-newline sensitive matching
  * @returns {FunctionNode}
  */
-export function regexp_matches(string: import("../types.js").ExprValue, pattern: import("../types.js").StringValue, options?: import("../types.js").StringValue): FunctionNode;
+export function regexp_matches(string: ExprValue, pattern: StringValue, options?: StringValue): FunctionNode;
 /**
  * Function that returns true if search_string is found within string.
- * @param {import('../types.js').ExprValue} string The string to match against.
- * @param {import('../types.js').StringValue} search_string The substring to search for.
+ * @param {ExprValue} string The string to match against.
+ * @param {StringValue} search_string The substring to search for.
  * @returns {FunctionNode}
  */
-export function contains(string: import("../types.js").ExprValue, search_string: import("../types.js").StringValue): FunctionNode;
+export function contains(string: ExprValue, search_string: StringValue): FunctionNode;
 /**
  * Function that returns true if string begins with search_string.
- * @param {import('../types.js').ExprValue} string The string to match against.
- * @param {import('../types.js').StringValue} search_string The substring to search for.
+ * @param {ExprValue} string The string to match against.
+ * @param {StringValue} search_string The substring to search for.
  * @returns {FunctionNode}
  */
-export function prefix(string: import("../types.js").ExprValue, search_string: import("../types.js").StringValue): FunctionNode;
+export function prefix(string: ExprValue, search_string: StringValue): FunctionNode;
 /**
  * Function that returns true if string ends with search_string.
- * @param {import('../types.js').ExprValue} string The string to match against.
- * @param {import('../types.js').StringValue} search_string The substring to search for.
+ * @param {ExprValue} string The string to match against.
+ * @param {StringValue} search_string The substring to search for.
  * @returns {FunctionNode}
  */
-export function suffix(string: import("../types.js").ExprValue, search_string: import("../types.js").StringValue): FunctionNode;
+export function suffix(string: ExprValue, search_string: StringValue): FunctionNode;
 /**
  * Function that converts string to lower case.
- * @param {import('../types.js').ExprValue} string The string to convert.
+ * @param {ExprValue} string The string to convert.
  * @returns {FunctionNode}
  */
-export function lower(string: import("../types.js").ExprValue): FunctionNode;
+export function lower(string: ExprValue): FunctionNode;
 /**
  * Function that converts string to upper case.
- * @param {import('../types.js').ExprValue} string The string to convert.
+ * @param {ExprValue} string The string to convert.
  * @returns {FunctionNode}
  */
-export function upper(string: import("../types.js").ExprValue): FunctionNode;
+export function upper(string: ExprValue): FunctionNode;
 /**
  * Function that returns the number of characters in string.
- * @param {import('../types.js').ExprValue} value The string to measure.
+ * @param {ExprValue} value The string to measure.
  * @returns {FunctionNode}
  */
-export function length(value: import("../types.js").ExprValue): FunctionNode;
-import { FunctionNode } from '../ast/function.js';
+export function length(value: ExprValue): FunctionNode;
+import type { ExprValue } from '../types.js';
+import type { StringValue } from '../types.js';
+import type { FunctionNode } from '../ast/function.js';

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

@@ -0,0 +1,8 @@
+/**
+ * Returns the first non-null argument.
+ * @param {...ExprValue} expr The input expressions.
+ * @returns {FunctionNode}
+ */
+export function coalesce(...expr: ExprValue[]): FunctionNode;
+import type { ExprValue } from '../types.js';
+import type { FunctionNode } from '../ast/function.js';

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

@@ -31,57 +31,59 @@ export function cume_dist(): WindowNode;
 /**
  * Create a window function that returns an integer ranging from 1 to the
  * argument value, dividing the partition as equally as possible.
- * @param {import('../types.js').NumberValue} num_buckets The number of
+ * @param {NumberValue} num_buckets The number of
  *  quantile buckets.
  * @returns {WindowNode}
  */
-export function ntile(num_buckets: import("../types.js").NumberValue): WindowNode;
+export function ntile(num_buckets: NumberValue): WindowNode;
 /**
  * Create a window function that returns the expression evaluated at the row
  * that is offset rows before the current row within the partition.
  * If there is no such row, instead return default (which must be of the same
  * type as the expression). Both offset and default are evaluated with respect
  * to the current row. If omitted, offset defaults to 1 and default to null.
- * @param {import('../types.js').ExprValue} expr The expression to evaluate.
- * @param {import('../types.js').NumberValue} [offset] The row offset
+ * @param {ExprValue} expr The expression to evaluate.
+ * @param {NumberValue} [offset] The row offset
  *  (default `1`).
  * @param {*} [defaultValue] The default value (default `null`).
  * @returns {WindowNode}
  */
-export function lag(expr: import("../types.js").ExprValue, offset?: import("../types.js").NumberValue, defaultValue?: any): WindowNode;
+export function lag(expr: ExprValue, offset?: NumberValue, defaultValue?: any): WindowNode;
 /**
  * Create a window function that returns the expression evaluated at the row
  * that is offset rows after the current row within the partition.
  * If there is no such row, instead return default (which must be of the same
  * type as the expression). Both offset and default are evaluated with respect
  * to the current row. If omitted, offset defaults to 1 and default to null.
- * @param {import('../types.js').ExprValue} expr The expression to evaluate.
- * @param {import('../types.js').NumberValue} [offset] The row offset
+ * @param {ExprValue} expr The expression to evaluate.
+ * @param {NumberValue} [offset] The row offset
  *  (default `1`).
  * @param {*} [defaultValue] The default value (default `null`).
  * @returns {WindowNode}
  */
-export function lead(expr: import("../types.js").ExprValue, offset?: import("../types.js").NumberValue, defaultValue?: any): WindowNode;
+export function lead(expr: ExprValue, offset?: NumberValue, defaultValue?: any): WindowNode;
 /**
  * Create a window function that returns the expression evaluated at the row
  * that is the first row of the window frame.
- * @param {import('../types.js').ExprValue} expr The expression to evaluate.
+ * @param {ExprValue} expr The expression to evaluate.
  * @returns {WindowNode}
  */
-export function first_value(expr: import("../types.js").ExprValue): WindowNode;
+export function first_value(expr: ExprValue): WindowNode;
 /**
  * Create a window function that returns the expression evaluated at the row
  * that is the last row of the window frame.
- * @param {import('../types.js').ExprValue} expr The expression to evaluate.
+ * @param {ExprValue} expr The expression to evaluate.
  * @returns {WindowNode}
  */
-export function last_value(expr: import("../types.js").ExprValue): WindowNode;
+export function last_value(expr: ExprValue): WindowNode;
 /**
  * Create a window function that returns the expression evaluated at the
  * nth row of the window frame (counting from 1), or null if no such row.
- * @param {import('../types.js').ExprValue} expr The expression to evaluate.
- * @param {import('../types.js').NumberValue} nth The 1-based window frame index.
+ * @param {ExprValue} expr The expression to evaluate.
+ * @param {NumberValue} nth The 1-based window frame index.
  * @returns {WindowNode}
  */
-export function nth_value(expr: import("../types.js").ExprValue, nth: import("../types.js").NumberValue): WindowNode;
-import { WindowNode } from '../ast/window.js';
+export function nth_value(expr: ExprValue, nth: NumberValue): WindowNode;
+import type { WindowNode } from '../ast/window.js';
+import type { NumberValue } from '../types.js';
+import type { ExprValue } from '../types.js';

package/dist/types/index.d.ts

@@ -18,17 +18,21 @@ export { column } from "./functions/column.js";
 export { cte } from "./functions/cte.js";
 export { literal } from "./functions/literal.js";
 export { sql } from "./functions/sql-template-tag.js";
+export { coalesce } from "./functions/util.js";
 export { rewrite } from "./visit/rewrite.js";
 export { walk } from "./visit/walk.js";
 export { loadExtension } from "./load/extension.js";
 export { bin1d } from "./transforms/bin-1d.js";
 export { bin2d } from "./transforms/bin-2d.js";
+export { binDate } from "./transforms/bin-date.js";
+export { binHistogram } from "./transforms/bin-histogram.js";
 export { binLinear1d } from "./transforms/bin-linear-1d.js";
 export { binLinear2d } from "./transforms/bin-linear-2d.js";
 export { lineDensity } from "./transforms/line-density.js";
 export { m4 } from "./transforms/m4.js";
 export { scaleTransform } from "./transforms/scales.js";
 export { isParamLike } from "./util/type-check.js";
+export { timeInterval } from "./transforms/util/time-interval.js";
 export { BetweenOpNode, NotBetweenOpNode } from "./ast/between-op.js";
 export { CaseNode, WhenNode } from "./ast/case.js";
 export { ColumnParamNode, isColumnParam } from "./ast/column-param.js";
@@ -52,3 +56,4 @@ export { collectAggregates, collectColumns, collectParams, isAggregateExpression
 export { createTable, createSchema } from "./load/create.js";
 export { loadCSV, loadJSON, loadObjects, loadParquet, loadSpatial } from "./load/load.js";
 export { asLiteral, asNode, asTableRef, asVerbatim, over } from "./util/ast.js";
+export { binSpec, binStep } from "./transforms/util/bin-step.js";

package/dist/types/transforms/bin-1d.d.ts

@@ -1,6 +1,6 @@
 /**
  * Compute binned values over a one-dimensional extent.
- * @param {import('../types.js').ExprValue} x The expression to bin.
+ * @param {ExprValue} x The expression to bin.
  *  The expression must return numeric values. For example, to bin
  *  datetime values, the input expression might map them to numeric
  *  values such as milliseconds since the epoch.
@@ -11,4 +11,5 @@
  * @param {boolean} [reverse] Flag indicating if bins should be
  *  produced in reverse order from *hi* to *lo* (default `false`).
  */
-export function bin1d(x: import("../types.js").ExprValue, lo: number, hi: number, bins: number, reverse?: boolean): import("../index.js").BinaryOpNode;
+export function bin1d(x: ExprValue, lo: number, hi: number, bins: number, reverse?: boolean): import("../index.js").BinaryOpNode;
+import type { ExprValue } from '../types.js';

package/dist/types/transforms/bin-2d.d.ts

@@ -6,13 +6,14 @@
  * and uses a 2D integer bin index of the form (xbin + num_xbins * ybin).
  * @param {SelectQuery} q The input query. The FROM and WHERE clauses should
  *  be added to the query separately, either before or after this method.
- * @param {import('../types.js').ExprValue} xp The x bin expression.
- * @param {import('../types.js').ExprValue} yp The y bin expression.
- * @param {Record<string, import('../types.js').ExprValue>} aggs Named
+ * @param {ExprValue} xp The x bin expression.
+ * @param {ExprValue} yp The y bin expression.
+ * @param {Record<string, ExprValue>} aggs Named
  *  aggregate expressions over bins.
  * @param {number} xn The number of bins along the x dimension
  * @param {string[]} groupby Group by expressions.
  * @returns {SelectQuery} The input query, with binning expressions added.
  */
-export function bin2d(q: SelectQuery, xp: import("../types.js").ExprValue, yp: import("../types.js").ExprValue, aggs: Record<string, import("../types.js").ExprValue>, xn: number, groupby: string[]): SelectQuery;
-import { SelectQuery } from '../ast/query.js';
+export function bin2d(q: SelectQuery, xp: ExprValue, yp: ExprValue, aggs: Record<string, ExprValue>, xn: number, groupby: string[]): SelectQuery;
+import type { SelectQuery } from '../ast/query.js';
+import type { ExprValue } from '../types.js';