@uwdata/mosaic-sql 0.16.2 → 0.18.0

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/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';

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

@@ -1,51 +0,0 @@
-/**
- * @typedef {object} BinHistogramOptions
- * @property {number} [step] An exact binning step to use.
- * @property {number} [steps] The desired number of binning steps.
- *  This value is a hint, it does not guarantee an exact number of steps.
- * @property {number} [minstep] A minimum binning step value. No generated
- *  step can be less than this value.
- * @property {boolean} [nice] A boolean flag (default true) indicating if bin
- *  extents should be snapped to "nice" numbers such as multiples of 5 or 10.
- * @property {number} [offset] The number of bin steps (default 0) by
- *  which to offset the result.
- */
-/**
- * Return a SQL expression for histogram bins.
- * @param {ExprValue} field The column or expression to bin.
- * @param {[number, number]} extent The min/max extent over which to bin.
- * @param {BinHistogramOptions} [options] Binning options.
- * @param {ReturnType<typeof scaleTransform>} [transform] Scale transforms to
- *  apply to create (potentially non-linear) binning intervals.
- * @returns {ExprNode} The resulting SQL expression
- */
-export function binHistogram(field: ExprValue, extent: [number, number], options?: BinHistogramOptions, transform?: ReturnType<typeof scaleTransform>): ExprNode;
-export type BinHistogramOptions = {
-    /**
-     * An exact binning step to use.
-     */
-    step?: number;
-    /**
-     * The desired number of binning steps.
-     * This value is a hint, it does not guarantee an exact number of steps.
-     */
-    steps?: number;
-    /**
-     * A minimum binning step value. No generated
-     * step can be less than this value.
-     */
-    minstep?: number;
-    /**
-     * A boolean flag (default true) indicating if bin
-     * extents should be snapped to "nice" numbers such as multiples of 5 or 10.
-     */
-    nice?: boolean;
-    /**
-     * The number of bin steps (default 0) by
-     * which to offset the result.
-     */
-    offset?: number;
-};
-import type { ExprValue } from '../types.js';
-import { scaleTransform } from './scales.js';
-import type { ExprNode } from '../ast/node.js';

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

@@ -1,12 +0,0 @@
-/**
- * Perform linear binning in one dimension.
- * @param {SelectQuery} query The base query to bin.
- * @param {ExprValue} x The expression to bin.
- * @param {ExprValue} [weight] The expression to weight by.
- * @param {string[]} [groupby] Group by expressions.
- * @returns {Query}
- */
-export function binLinear1d(query: SelectQuery, x: ExprValue, weight?: ExprValue, groupby?: string[]): Query;
-import type { SelectQuery } from '../ast/query.js';
-import type { ExprValue } from '../types.js';
-import { Query } from '../ast/query.js';

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

@@ -1,19 +0,0 @@
-/**
- * Compute densities over a 2D domain using linear binning. The weight of
- * each data point is linearly distributed over adjacent bins, providing
- * a better base for subsequent kernel density estimation. 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.
- * @param {SelectQuery} q The input query. The FROM and WHERE clauses should
- *  be added to the query separately, before this method is invoked.
- * @param {ExprValue} xp The x grid bin expression
- * @param {ExprValue} yp The y grid bin expression
- * @param {ExprValue | undefined} weight Point weights.
- * @param {number} xn The number of x grid bins.
- * @param {string[]} [groupby] Group by expressions.
- * @returns {SelectQuery} A linear binning query for bin `index` and
- *  aggregate `density` columns, in addition to any group by expressions.
- */
-export function binLinear2d(q: SelectQuery, xp: ExprValue, yp: ExprValue, weight: ExprValue | undefined, xn: number, groupby?: string[]): SelectQuery;
-import type { SelectQuery } from '../ast/query.js';
-import type { ExprValue } from '../types.js';

package/dist/types/transforms/line-density.d.ts

@@ -1,24 +0,0 @@
-/**
- * Compute line segment densities over a gridded 2D domain. The returned
- * query uses multiple subqueries (CTEs) to identify line segment end point
- * pairs, perform line rasterization in-database, normalize arc lengths,
- * and then sum results for all line series to produce a density map.
- * Based on Moritz and Fisher's work: https://arxiv.org/abs/1808.06019
- * @param {SelectQuery} q The base query over the data.
- * @param {ExprValue} x Bin expression for x dimension.
- *  Provides gridded x coordinates, potentially with a fractional component.
- * @param {ExprValue} y Bin expression for x dimension.
- *  Provides gridded y coordinates, potentially with a fractional component.
- * @param {string[]} z Group by columns that segment data into individual line
- *  series. An empty array indicates there is only a single line series.
- * @param {number} xn The number of grid bins for the x dimension.
- * @param {number} yn The number of grid bins for the y dimension.
- * @param {string[]} [groupby] Additional group by expressions. Separate
- *  line density maps are created for each of these groups.
- * @param {boolean} [normalize=true] Flag toggling approximate arc-length
- *  normalization to improve accuracy and reduce artifacts (default `true`).
- * @returns {SelectQuery}
- */
-export function lineDensity(q: SelectQuery, x: ExprValue, y: ExprValue, z: string[], xn: number, yn: number, groupby?: string[], normalize?: boolean): SelectQuery;
-import type { SelectQuery } from '../ast/query.js';
-import type { ExprValue } from '../types.js';

package/dist/types/transforms/m4.d.ts

@@ -1,21 +0,0 @@
-/**
- * M4 is an optimization for value-preserving time-series aggregation
- * (https://www.vldb.org/pvldb/vol7/p797-jugel.pdf). This implementation uses
- * an efficient version with a single scan and the aggregate functions
- * argmin and argmax, following https://arxiv.org/pdf/2306.03714.pdf.
- * This method can bin along either the *x* or *y* dimension, as determined
- * by the caller-provided *bin* expression.
- * @param {FromExpr} input The base query or table.
- * @param {ExprValue} bin An expression that maps
- *  time-series values to fractional pixel positions.
- * @param {string} x The x dimension column name.
- * @param {string} y The y dimension column name.
- * @param {ExprNode[]} [groups] Additional
- *  groupby columns, for example for faceted charts.
- * @returns {Query} The resulting M4 query.
- */
-export function m4(input: FromExpr, bin: ExprValue, x: string, y: string, groups?: ExprNode[]): Query;
-import type { FromExpr } from '../types.js';
-import type { ExprValue } from '../types.js';
-import type { ExprNode } from '../ast/node.js';
-import { Query } from '../ast/query.js';

package/dist/types/transforms/scales.d.ts

@@ -1 +0,0 @@
-export function scaleTransform(options: any): any;

package/dist/types/transforms/util/bin-step.d.ts

@@ -1,61 +0,0 @@
-/**
- * @typedef {object} BinOptions
- * @property {number} [step] An exact binning step to use.
- * @property {number} [steps] The desired number of binning steps.
- *  This value is a hint, it does not guarantee an exact number of steps.
- * @property {number} [minstep] A minimum binning step value. No generated
- *  step can be less than this value.
- * @property {boolean} [nice] A boolean flag (default true) indicating if bin
- *  extents should be snapped to "nice" numbers such as multiples of 5 or 10.
- * @property {number} [base] A number indicating the the logarithm base to
- *  use for automatic step size determination. Defaults to base 10.
- */
-/**
- * Generate a numeric binning scheme suitable for a histogram.
- * @param {number} min The minimum value of the extent to bin.
- * @param {number} max The maximum value of the extent to bin.
- * @param {BinOptions} options Binning scheme options.
- */
-export function binSpec(min: number, max: number, options: BinOptions): {
-    min: number;
-    max: number;
-    steps: number;
-};
-/**
- * Determine a bin step interval.
- * @param {number} span The span from maximum to minimum value.
- * @param {number} steps The approximate number of desired bins.
- * @param {number} [minstep=0] The minimum acceptable bin step size.
- * @param {number} [logb=Math.LN10] The log base for determining
- *  orders of magnitude for step sizes. Defaults to log base 10
- *  (`Math.LN10`). For example to use log base 2, provide the
- *  argument `Math.LN2` instead.
- * @returns {number} The bin step interval (bin size).
- */
-export function binStep(span: number, steps: number, minstep?: number, logb?: number): number;
-export type BinOptions = {
-    /**
-     * An exact binning step to use.
-     */
-    step?: number;
-    /**
-     * The desired number of binning steps.
-     * This value is a hint, it does not guarantee an exact number of steps.
-     */
-    steps?: number;
-    /**
-     * A minimum binning step value. No generated
-     * step can be less than this value.
-     */
-    minstep?: number;
-    /**
-     * A boolean flag (default true) indicating if bin
-     * extents should be snapped to "nice" numbers such as multiples of 5 or 10.
-     */
-    nice?: boolean;
-    /**
-     * A number indicating the the logarithm base to
-     * use for automatic step size determination. Defaults to base 10.
-     */
-    base?: number;
-};

package/dist/types/transforms/util/time-interval.d.ts

@@ -1,13 +0,0 @@
-/**
- * Determine a time interval for binning based on provided min
- * and max timestamps and approximate step count.
- * @param {Date|number} min The minimum timestamp value.
- * @param {Date|number} max The maximum timestamp value.
- * @param {number} steps The approximate number of bins desired.
- * @returns {{ unit: TimeUnit, step: number }}
- */
-export function timeInterval(min: Date | number, max: Date | number, steps: number): {
-    unit: TimeUnit;
-    step: number;
-};
-import type { TimeUnit } from '../../types.js';

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

@@ -1,56 +0,0 @@
-/**
- * Test if an AST node is a specific function call.
- * @param {SQLNode} node The SQL AST node to test.
- * @param {string} name The function name.
- * @returns {node is FunctionNode}
- */
-export function isFunctionCall(node: SQLNode, name: string): node is FunctionNode;
-/**
- * Create a new function call AST node.
- * @param {string} name The function name.
- * @param  {...any} args The function arguments.
- * @returns {FunctionNode}
- */
-export function fn(name: string, ...args: any[]): FunctionNode;
-/**
- * Create a new aggregate function AST node.
- * @param {string} name The function name.
- * @param  {...any} args The function arguments.
- * @returns {AggregateNode}
- */
-export function aggFn(name: string, ...args: any[]): AggregateNode;
-/**
- * Create a new window AST node. The output node has an empty window
- * definition. Use chained calls such as `partitionby` and `orderby`
- * to specify the window settings.
- * @param {WindowFunctionName} name The function name.
- * @param  {...any} args The function arguments.
- * @returns {WindowNode}
- */
-export function winFn(name: WindowFunctionName, ...args: any[]): WindowNode;
-/**
- * Process a list of expression inputs. Nested arrays are flattened,
- * null results are removed, and each input is cast (as needed) to
- * be a proper SQL AST node. By default, strings are assumed to be
- * column names, while other primitive values map to SQL literals.
- * Use an alternative *cast* function to change this behavior.
- * @param {any[]} list The list of expression inputs.
- * @param {function} [cast] A function that casts an input value
- *  to a desired type. By default, `asNode` is used to coerce
- *  inputs to AST nodes as needed.
- * @returns {ReturnType<cast>[]}
- */
-export function exprList(list: any[], cast?: Function): ReturnType<Function>[];
-/**
- * Process a list of function arguments, stripping any undefined
- * values from the end of the list.
- * @template T
- * @param {T[]} list The input function arguments.
- * @returns {T[]} The prepared argument list.
- */
-export function argsList<T>(list: T[]): T[];
-import type { SQLNode } from '../ast/node.js';
-import { FunctionNode } from '../ast/function.js';
-import { AggregateNode } from '../ast/aggregate.js';
-import type { WindowFunctionName } from '../types.js';
-import { WindowNode } from '../ast/window.js';

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

@@ -1,3 +0,0 @@
-export function parseIdentifier(id: any): any;
-export function quoteIdentifier(value: any): string;
-export function unquote(s: any): any;

package/dist/types/util/type-check.d.ts

@@ -1,22 +0,0 @@
-/**
- * @import { ParamLike } from '../types.js'
- */
-/**
- * Check if a value is a string.
- * @param {*} value The value to check.
- * @returns {value is string}
- */
-export function isString(value: any): value is string;
-/**
- * Check if a value is an array.
- * @param {*} value The value to check.
- * @returns {value is Array}
- */
-export function isArray(value: any): value is any[];
-/**
- * Check if a value is a dynamic parameter.
- * @param {*} value The value to check.
- * @returns {value is ParamLike}
- */
-export function isParamLike(value: any): value is ParamLike;
-import type { ParamLike } from '../types.js';

package/dist/types/visit/recurse.d.ts

@@ -1,28 +0,0 @@
-export namespace recurse {
-    let AGGREGATE: string[];
-    let BETWEEN: string[];
-    let BINARY: string[];
-    let CASE: string[];
-    let CAST: string[];
-    let COLUMN_PARAM: string[];
-    let COLUMN_REF: string[];
-    let DESCRIBE_QUERY: string[];
-    let EXPRESSION: string[];
-    let FRAGMENT: string[];
-    let FROM_CLAUSE: string[];
-    let FUNCTION: string[];
-    let IN: string[];
-    let LOGICAL_OPERATOR: string[];
-    let NOT_BETWEEN: string[];
-    let ORDER_BY: string[];
-    let PARAM: string[];
-    let SELECT_CLAUSE: string[];
-    let SELECT_QUERY: string[];
-    let SET_OPERATION: string[];
-    let UNARY: string[];
-    let WHEN: string[];
-    let WINDOW: string[];
-    let WINDOW_CLAUSE: string[];
-    let WINDOW_DEF: string[];
-    let WINDOW_FRAME: string[];
-}

package/dist/types/visit/rewrite.d.ts

@@ -1,10 +0,0 @@
-/**
- * Rewrite a SQL expression, based on a map of nodes to replace.
- * This method copies nodes as needed; it does not modify the input node.
- * @param {ExprNode} node The root AST node of the expression.
- * @param {Map<ExprNode, ExprNode>} map The rewrite map.
- *  When encountered, key nodes are replaced by value nodes.
- * @returns {ExprNode}
- */
-export function rewrite(node: ExprNode, map: Map<ExprNode, ExprNode>): ExprNode;
-import type { ExprNode } from '../ast/node.js';

package/dist/types/visit/walk.d.ts

@@ -1,10 +0,0 @@
-/**
- * Perform a traversal of a SQL expression AST.
- * @param {SQLNode} node Root node for AST traversal.
- * @param {VisitorCallback} visit Visitor callback function.
- * @return {VisitorResult}
- */
-export function walk(node: SQLNode, visit: VisitorCallback): VisitorResult;
-import type { SQLNode } from '../ast/node.js';
-import type { VisitorCallback } from '../types.js';
-import type { VisitorResult } from '../types.js';

package/jsconfig.json

@@ -1,11 +0,0 @@
-{
-  "include": ["src/**/*"],
-  "compilerOptions": {
-    "checkJs": true,
-    "noEmit": true,
-    "noImplicitAny": false,
-    "module": "node16",
-    "skipLibCheck": true,
-    "types": []
-  }
-}