@uwdata/mosaic-sql 0.16.2 → 0.17.0

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

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

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

@@ -1,18 +0,0 @@
-/**
- * Indicate ascending sort order for an expression.
- * @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: ExprValue, nullsFirst?: boolean | undefined): OrderByNode;
-/**
- * Indicate descending sort order for an expression.
- * @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: 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,38 +0,0 @@
-/**
- * Function that converts geometry data to GeoJSON format.
- * @param {ExprValue} expr The input expression.
- * @returns {FunctionNode}
- */
-export function geojson(expr: ExprValue): FunctionNode;
-/**
- * Function that returns a spatial x position (using ST_X).
- * @param {ExprValue} expr The input expression.
- * @returns {FunctionNode}
- */
-export function x(expr: ExprValue): FunctionNode;
-/**
- * Function that returns a spatial y position (using ST_Y).
- * @param {ExprValue} expr The input expression.
- * @returns {FunctionNode}
- */
-export function y(expr: ExprValue): FunctionNode;
-/**
- * Function that returns the centroid point for geometry data.
- * @param {ExprValue} expr The input expression.
- * @returns {FunctionNode}
- */
-export function centroid(expr: ExprValue): FunctionNode;
-/**
- * Function that returns the centroid x-coordinate for geometry data.
- * @param {ExprValue} expr The input expression.
- * @returns {FunctionNode}
- */
-export function centroidX(expr: ExprValue): FunctionNode;
-/**
- * Function that returns yhe centroid y-coordinate for geometry data.
- * @param {ExprValue} expr The input expression.
- * @returns {FunctionNode}
- */
-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,15 +0,0 @@
-/**
- * @typedef { ExprNode | ParamLike | string | number | boolean | Date } TemplateValue
- */
-/**
- * Template tag function for SQL fragments. Interpolated values
- * may be strings, other SQL expression objects (such as column
- * references), primitive values, or dynamic parameters.
- * @param {TemplateStringsArray} strings Template string constants.
- * @param {...TemplateValue} exprs Template expression values.
- */
-export function sql(strings: TemplateStringsArray, ...exprs: TemplateValue[]): FragmentNode;
-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,57 +0,0 @@
-/**
- * Function that returns true if a string contains a regexp pattern,
- * false otherwise.
- * @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
- *  'm', 'n', 'p': newline sensitive matching
- *  'g': global replace, only available for regexp_replace
- *  's': non-newline sensitive matching
- * @returns {FunctionNode}
- */
-export function regexp_matches(string: ExprValue, pattern: StringValue, options?: StringValue): FunctionNode;
-/**
- * Function that returns true if search_string is found within string.
- * @param {ExprValue} string The string to match against.
- * @param {StringValue} search_string The substring to search for.
- * @returns {FunctionNode}
- */
-export function contains(string: ExprValue, search_string: StringValue): FunctionNode;
-/**
- * Function that returns true if string begins with search_string.
- * @param {ExprValue} string The string to match against.
- * @param {StringValue} search_string The substring to search for.
- * @returns {FunctionNode}
- */
-export function prefix(string: ExprValue, search_string: StringValue): FunctionNode;
-/**
- * Function that returns true if string ends with search_string.
- * @param {ExprValue} string The string to match against.
- * @param {StringValue} search_string The substring to search for.
- * @returns {FunctionNode}
- */
-export function suffix(string: ExprValue, search_string: StringValue): FunctionNode;
-/**
- * Function that converts string to lower case.
- * @param {ExprValue} string The string to convert.
- * @returns {FunctionNode}
- */
-export function lower(string: ExprValue): FunctionNode;
-/**
- * Function that converts string to upper case.
- * @param {ExprValue} string The string to convert.
- * @returns {FunctionNode}
- */
-export function upper(string: ExprValue): FunctionNode;
-/**
- * Function that returns the number of characters in string.
- * @param {ExprValue} value The string to measure.
- * @returns {FunctionNode}
- */
-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/table-ref.d.ts

@@ -1,9 +0,0 @@
-/**
- * Returns a named table or view reference.
- * @param {...(string | string[])} ids Table and namespace identifiers.
- *  For example 'name' or ['schema', 'name'].
- * @returns {TableRefNode | undefined} A table reference, or undefined
- *  if the input identifier list is empty.
- */
-export function tableRef(...ids: (string | string[])[]): TableRefNode | undefined;
-import { TableRefNode } from '../ast/table-ref.js';

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

@@ -1,8 +0,0 @@
-/**
- * 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

@@ -1,89 +0,0 @@
-/**
- * Create a window function that returns the number of the current row
- * within the partition, counting from 1.
- * @returns {WindowNode}
- */
-export function row_number(): WindowNode;
-/**
- * Create a window function that returns the rank of the current row with gaps.
- * This is the same as the row_number of its first peer.
- * @returns {WindowNode}
- */
-export function rank(): WindowNode;
-/**
- * Create a window function that returns the rank of the current row without
- * gaps. The function counts peer groups.
- * @returns {WindowNode}
- */
-export function dense_rank(): WindowNode;
-/**
- * Create a window function that returns the relative rank of the current row.
- * Computed as (rank() - 1) / (total partition rows - 1).
- * @returns {WindowNode}
- */
-export function percent_rank(): WindowNode;
-/**
- * Create a window function that returns the cumulative distribution. Computed
- * as (number of preceding or peer partition rows) / total partition rows.
- * @returns {WindowNode}
- */
-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 {NumberValue} num_buckets The number of
- *  quantile buckets.
- * @returns {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 {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: 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 {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: 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 {ExprValue} expr The expression to evaluate.
- * @returns {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 {ExprValue} expr The expression to evaluate.
- * @returns {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 {ExprValue} expr The expression to evaluate.
- * @param {NumberValue} nth The 1-based window frame index.
- * @returns {WindowNode}
- */
-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-types.d.ts

@@ -1,2 +0,0 @@
-export * from './index.js';
-export * from './types.js';

package/dist/types/index.d.ts

@@ -1,59 +0,0 @@
-export { AggregateNode } from "./ast/aggregate.js";
-export { BinaryOpNode } from "./ast/binary-op.js";
-export { CastNode } from "./ast/cast.js";
-export { FragmentNode } from "./ast/fragment.js";
-export { FromClauseNode } from "./ast/from.js";
-export { FunctionNode } from "./ast/function.js";
-export { InOpNode } from "./ast/in-op.js";
-export { IntervalNode } from "./ast/interval.js";
-export { LiteralNode } from "./ast/literal.js";
-export { OrderByNode } from "./ast/order-by.js";
-export { ParamNode } from "./ast/param.js";
-export { SampleClauseNode } from "./ast/sample.js";
-export { SelectClauseNode } from "./ast/select.js";
-export { VerbatimNode } from "./ast/verbatim.js";
-export { WithClauseNode } from "./ast/with.js";
-export { cond } from "./functions/case.js";
-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";
-export { ColumnRefNode, ColumnNameRefNode, isColumnRef } from "./ast/column-ref.js";
-export { AndNode, OrNode } from "./ast/logical-op.js";
-export { SQLNode, ExprNode, isNode } from "./ast/node.js";
-export { DescribeQuery, Query, SelectQuery, SetOperation, isDescribeQuery, isQuery, isSelectQuery } from "./ast/query.js";
-export { TableRefNode, isTableRef } from "./ast/table-ref.js";
-export { UnaryOpNode, UnaryPosftixOpNode } from "./ast/unary-op.js";
-export { WindowClauseNode, WindowDefNode, WindowFrameNode, WindowFunctionNode, WindowNode } from "./ast/window.js";
-export { argmax, argmin, arrayAgg, avg, corr, count, covariance, covarPop, entropy, first, geomean, kurtosis, mad, max, median, min, mode, last, product, quantile, regrAvgX, regrAvgY, regrCount, regrIntercept, regrR2, regrSXX, regrSXY, regrSYY, regrSlope, skewness, stddev, stddevPop, stringAgg, sum, variance, varPop } from "./functions/aggregate.js";
-export { cast, float32, float64, int32 } from "./functions/cast.js";
-export { dateBin, dateMonth, dateMonthDay, dateDay, epoch_ms, interval } from "./functions/datetime.js";
-export { abs, ceil, exp, floor, greatest, isFinite, isInfinite, isNaN, least, ln, log, round, sign, sqrt, trunc } from "./functions/numeric.js";
-export { and, or, not, isNull, isNotNull, bitNot, bitAnd, bitOr, bitLeft, bitRight, add, sub, mul, div, idiv, mod, pow, eq, neq, lt, gt, lte, gte, isDistinct, isNotDistinct, isBetween, isNotBetween, isIn } from "./functions/operators.js";
-export { asc, desc } from "./functions/order-by.js";
-export { geojson, x, y, centroid, centroidX, centroidY } from "./functions/spatial.js";
-export { regexp_matches, contains, prefix, suffix, lower, upper, length } from "./functions/string.js";
-export { cume_dist, dense_rank, first_value, lag, last_value, lead, nth_value, ntile, percent_rank, rank, row_number } from "./functions/window.js";
-export { collectAggregates, collectColumns, collectParams, isAggregateExpression } from "./visit/visitors.js";
-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/load/create.d.ts

@@ -1,8 +0,0 @@
-export function createTable(name: any, query: any, { replace, temp, view }?: {
-    replace?: boolean;
-    temp?: boolean;
-    view?: boolean;
-}): string;
-export function createSchema(name: any, { strict }?: {
-    strict?: boolean;
-}): string;

package/dist/types/load/extension.d.ts

@@ -1 +0,0 @@
-export function loadExtension(name: any): string;

package/dist/types/load/load.d.ts

@@ -1,12 +0,0 @@
-export function load(method: any, tableName: any, fileName: any, options?: {}, defaults?: {}): string;
-export function loadCSV(tableName: any, fileName: any, options: any): string;
-export function loadJSON(tableName: any, fileName: any, options: any): string;
-export function loadParquet(tableName: any, fileName: any, options: any): string;
-/**
- * Load geometry data within a spatial file format.
- * This method requires that the DuckDB spatial extension is loaded.
- * Supports GeoJSON, TopoJSON, and other comomn spatial formats.
- * For TopoJSON, wet the layer option to indicate the feature to extract.
- */
-export function loadSpatial(tableName: any, fileName: any, options?: {}): string;
-export function loadObjects(tableName: any, data: any, options?: {}): string;

package/dist/types/load/sql-from.d.ts

@@ -1,11 +0,0 @@
-/**
- * Create a SQL query that embeds the given data for loading.
- * @param {*} data The dataset as an array of objects.
- * @param {object} [options] Loading options.
- * @param {string[]|object} [options.columns] The columns to include.
- *   If not specified, the keys of the first data object are used.
- * @returns {string} SQL query string to load data.
- */
-export function sqlFrom(data: any, { columns }?: {
-    columns?: string[] | object;
-}): string;

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

@@ -1,15 +0,0 @@
-/**
- * Compute binned values over a one-dimensional extent.
- * @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.
- * @param {number} lo The low value of the bin extent.
- * @param {number} hi The high value of the bin extent.
- * @param {number} bins The integer number of bins to use within the
- *  defined binning extent.
- * @param {boolean} [reverse] Flag indicating if bins should be
- *  produced in reverse order from *hi* to *lo* (default `false`).
- */
-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

@@ -1,19 +0,0 @@
-/**
- * Perform aggregation over a binned 2D domain. This method takes expressions
- * for the (non-truncated) x and y bin values; these expressions should be
- * in units of grid indices, but can contain fractional components. The
- * resulting query performs grouping and aggregation over the binned domain,
- * 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 {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: 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';

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

@@ -1,44 +0,0 @@
-/**
- * @typedef {object} BinDateOptions
- * @property {TimeUnit} [interval] A string indicating a time interval
- *  unit, such as 'year', 'day', or 'hour'.
- * @property {number} [step] The number of time interval steps to
- *  take, such as 2 years or 3 months.
- * @property {number} [offset] The number of bin steps (default 0) by
- *  which to offset the result.
- * @property {number} [steps] The desired number of binning steps.
- *  This value is a hint, it does not guarantee an exact number of steps.
- */
-/**
- * Return a SQL expression for date/time bins.
- * @param {ExprValue} field The column or expression to bin.
- * @param {[Date|number, Date|number]} extent The min/max extent over which to bin.
- * @param {BinDateOptions} [options] Datetime binning options.
- * @returns {ExprNode}
- */
-export function binDate(field: ExprValue, extent: [Date | number, Date | number], options?: BinDateOptions): ExprNode;
-export type BinDateOptions = {
-    /**
-     * A string indicating a time interval
-     * unit, such as 'year', 'day', or 'hour'.
-     */
-    interval?: TimeUnit;
-    /**
-     * The number of time interval steps to
-     * take, such as 2 years or 3 months.
-     */
-    step?: number;
-    /**
-     * The number of bin steps (default 0) by
-     * which to offset the result.
-     */
-    offset?: number;
-    /**
-     * The desired number of binning steps.
-     * This value is a hint, it does not guarantee an exact number of steps.
-     */
-    steps?: number;
-};
-import type { ExprValue } from '../types.js';
-import type { ExprNode } from '../ast/node.js';
-import type { TimeUnit } from '../types.js';