df-script 1.9.0 → 2.0.0

package/dist/api.d.ts

@@ -1,49 +1,54 @@
 import { DataFrame } from "./dataframe";
-import { ColumnExpr, lit, all, exclude, coalesce, when, implode, seq_range, element, struct, duration } from "./columnExpressions";
+import { ColumnExpr, lit, all, exclude, coalesce, when, implode, seqRange, element, struct, duration } from "./columnExpressions";
 import { DataType } from "./datatypes";
-import { concat, read_json, read_csv } from "./functions";
+import { concat, readJson, readCsv } from "./functions";
 import type { RowRecord, DataFrameSchema, ColumnDict, InferSchema } from "./types";
 declare function data<S extends DataFrameSchema>(data: any[] | ColumnDict, schema: S): DataFrame<InferSchema<S>>;
 declare function data<T extends RowRecord = any>(data: T[] | ColumnDict, schema?: DataFrameSchema): DataFrame<T>;
 export declare const $df: {
-    data: typeof data;
-    col: <T = any>(name: keyof T | string | (keyof T | string)[] | DataType | Function | (DataType | Function)[]) => ColumnExpr<T>;
+    Int8: import("./datatypes").Int8Type;
+    Int16: import("./datatypes").Int16Type;
+    Int32: import("./datatypes").Int32Type;
+    Int64: import("./datatypes").Int64Type;
+    UInt8: import("./datatypes").UInt8Type;
+    UInt16: import("./datatypes").UInt16Type;
+    UInt32: import("./datatypes").UInt32Type;
+    UInt64: import("./datatypes").UInt64Type;
+    Float32: import("./datatypes").Float32Type;
+    Float64: import("./datatypes").Float64Type;
+    Decimal: (precision?: number, scale?: number) => import("./datatypes").DecimalType;
+    Boolean: import("./datatypes").BooleanType;
+    Utf8: import("./datatypes").Utf8Type;
+    Binary: import("./datatypes").BinaryType;
+    Date: import("./datatypes").DateType;
+    Datetime: import("./datatypes").DatetimeType;
+    Time: import("./datatypes").TimeType;
+    Duration: import("./datatypes").DurationType;
+    Object: import("./datatypes").ObjectType;
+    Null: import("./datatypes").NullType;
+    Array: <TInner>(inner: import("./datatypes").RegisteredDataType & DataType<TInner>) => import("./datatypes").ArrayType<TInner>;
+    Struct: <TFields extends RowRecord>(fields: { [K in keyof TFields]: import("./datatypes").RegisteredDataType & DataType<TFields[K]>; }) => import("./datatypes").StructType<TFields>;
+    Numeric: typeof import("./datatypes").NumericDataType;
+    Integer: typeof import("./datatypes").IntegerDataType;
+    SignedInteger: typeof import("./datatypes").SignedIntegerType;
+    UnsignedInteger: typeof import("./datatypes").UnsignedIntegerType;
+    Float: typeof import("./datatypes").FloatDataType;
+    Temporal: typeof import("./datatypes").TemporalDataType;
+    Nested: typeof import("./datatypes").NestedDataType;
     all: typeof all;
-    exclude: typeof exclude;
     coalesce: typeof coalesce;
+    col: <T = any>(name: keyof T | string | (keyof T | string)[] | RegExp | RegExp[] | DataType | Function | (DataType | Function)[]) => ColumnExpr<T>;
     concat: typeof concat;
-    read_json: typeof read_json;
-    read_csv: typeof read_csv;
-    lit: typeof lit;
-    when: typeof when;
-    implode: typeof implode;
-    seq_range: typeof seq_range;
+    data: typeof data;
+    duration: typeof duration;
     element: typeof element;
+    exclude: typeof exclude;
+    implode: typeof implode;
+    lit: typeof lit;
+    readCsv: typeof readCsv;
+    readJson: typeof readJson;
+    seqRange: typeof seqRange;
     struct: typeof struct;
-    duration: typeof duration;
-    DataType: {
-        Int8: import("./datatypes").Int8Type;
-        Int16: import("./datatypes").Int16Type;
-        Int32: import("./datatypes").Int32Type;
-        Int64: import("./datatypes").Int64Type;
-        UInt8: import("./datatypes").UInt8Type;
-        UInt16: import("./datatypes").UInt16Type;
-        UInt32: import("./datatypes").UInt32Type;
-        UInt64: import("./datatypes").UInt64Type;
-        Float32: import("./datatypes").Float32Type;
-        Float64: import("./datatypes").Float64Type;
-        Decimal: (precision?: number, scale?: number) => import("./datatypes").DecimalType;
-        Boolean: import("./datatypes").BooleanType;
-        Utf8: import("./datatypes").Utf8Type;
-        Binary: import("./datatypes").BinaryType;
-        Date: import("./datatypes").DateType;
-        Datetime: import("./datatypes").DatetimeType;
-        Time: import("./datatypes").TimeType;
-        Duration: import("./datatypes").DurationType;
-        Object: import("./datatypes").ObjectType;
-        Null: import("./datatypes").NullType;
-        Array: <TInner>(inner: import("./datatypes").RegisteredDataType & DataType<TInner>) => import("./datatypes").ArrayType<TInner>;
-        Struct: <TFields extends RowRecord>(fields: { [K in keyof TFields]: import("./datatypes").RegisteredDataType & DataType<TFields[K]>; }) => import("./datatypes").StructType<TFields>;
-    };
+    when: typeof when;
 };
 export {};

package/dist/columnExpressions/ColumnExpr.d.ts

@@ -1,14 +1,9 @@
 import { ExprBase } from "./ExprBase";
-import { ArithmeticExpr } from "./mixins/ArithmeticExpr";
-import { ComparisonExpr } from "./mixins/ComparisonExpr";
-import { AggregationExpr } from "./mixins/AggregationExpr";
-import { WindowExpr } from "./mixins/WindowExpr";
+import { StandardExpr } from "./mixins/StandardExpr";
 import { StringExpr } from "./mixins/StringExpr";
-import { LogicalExpr } from "./mixins/LogicalExpr";
 import { TemporalExpr } from "./mixins/TemporalExpr";
 import { ArrayExpr } from "./mixins/ArrayExpr";
 import { StructExpr } from "./mixins/StructExpr";
-import { ManipulationExpr } from "./mixins/ManipulationExpr";
 import { DataType } from "../datatypes";
 import type { IntoExpr, IExpr, DataFrameSchema, ColumnDict } from "../types";
 export declare class ColumnExpr<T> extends ExprBase {
@@ -17,6 +12,8 @@ export declare class ColumnExpr<T> extends ExprBase {
     _excludedCols: string[];
     _targetType?: any;
     _targetTypes?: any[];
+    _pattern?: RegExp;
+    _patterns?: RegExp[];
     static isColExpr(v: unknown): v is ColumnExpr<any>;
     static toColExpr(col: IntoExpr | IntoExpr[]): ColumnExpr<any>;
     /**
@@ -25,9 +22,9 @@ export declare class ColumnExpr<T> extends ExprBase {
      * @category ColumnExpression
      * @syntax $df.col(<column_name>).{symbol}(...)
      */
-    constructor(colName: keyof T | string | (keyof T | string)[] | DataType | Function | (DataType | Function)[]);
+    constructor(colName: keyof T | string | (keyof T | string)[] | RegExp | RegExp[] | DataType | Function | (DataType | Function)[]);
 }
-export interface ColumnExpr<T> extends ArithmeticExpr, ComparisonExpr, AggregationExpr, WindowExpr, StringExpr, LogicalExpr, TemporalExpr, ArrayExpr, StructExpr, ManipulationExpr {
+export interface ColumnExpr<T> extends StandardExpr, StringExpr, TemporalExpr, ArrayExpr, StructExpr {
 }
 /**
  * @internal

package/dist/columnExpressions/functions/all.d.ts

@@ -7,22 +7,22 @@ import { ColumnExpr } from "../ColumnExpr";
  * @category ColumnExpression
  * @syntax $df.{symbol}(...)
  * @example
- * >>> const df = $df.data({ a: [1, 2], b: [3, 4] })
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
  * >>> df
  * shape: (2, 2)
- * ┌─────┬─────┐
- * │ a   │ b   │
- * ├─────┼─────┤
- * │ 1   │ 3   │
- * │ 2   │ 4   │
- * └─────┴─────┘
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
  * >>> df.select($df.all())
  * shape: (2, 2)
- * ┌─────┬─────┐
- * │ a   │ b   │
- * ├─────┼─────┤
- * │ 1   │ 3   │
- * │ 2   │ 4   │
- * └─────┴─────┘
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
  */
 export declare function all(): ColumnExpr<any>;

package/dist/columnExpressions/functions/coalesce.d.ts

@@ -9,7 +9,7 @@ import type { IExpr, ValidScalarTypes } from "../../types";
  * @category ColumnExpression
  * @syntax $df.{symbol}(...)
  * @example
- * >>> const df = $df.data({ a: [1, null, null], b: [null, 2, null] })
+ * >>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })
  * >>> df
  * shape: (3, 2)
  * ┌──────┬──────┐
@@ -17,7 +17,7 @@ import type { IExpr, ValidScalarTypes } from "../../types";
  * ├──────┼──────┤
  * │ 1    │ null │
  * │ null │ 2    │
- * │ null │ null │
+ * │ 3    │ null │
  * └──────┴──────┘
  * >>> df.select($df.coalesce($df.col("a"), $df.col("b"), $df.lit(3)).alias("coalesced"))
  * shape: (3, 1)

package/dist/columnExpressions/functions/duration.d.ts

@@ -1,33 +1,28 @@
 import { ColumnExpr } from "../ColumnExpr";
-import type { IntoExpr, DatetimeTimeUnit } from "../../types";
-export interface DurationOptions {
-    weeks?: IntoExpr | number;
-    days?: IntoExpr | number;
-    hours?: IntoExpr | number;
-    minutes?: IntoExpr | number;
-    seconds?: IntoExpr | number;
-    milliseconds?: IntoExpr | number;
-    microseconds?: IntoExpr | number;
-    nanoseconds?: IntoExpr | number;
-    timeUnit?: DatetimeTimeUnit;
-}
+import type { DurationOptions } from "../../types";
 /**
- * Constructs a Duration expression column from numeric values, column references, or expressions.
+ * Constructs a Duration expression column from numeric values, string intervals, column references, or expressions.
  *
- * @param {DurationOptions} [options] Duration component options (weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds, timeUnit).
+ * @param {DurationOptions | string} [options] Duration component options or string interval (e.g. "1d 12h").
  * @returns {ColumnExpr<any>} A column expression with the calculated duration values.
  * @namespace $df
  * @category ColumnExpression
  * @syntax $df.duration(options)
  * @example
- * >>> const df = $df.data({ dt: ["2026-01-01"], add: [1, 2] })
- * >>> df.select($df.col("dt").cast($df.DataType.Datetime).add($df.duration({ days: "add" })).alias("add_days"))
- * shape: (2, 1)
+ * >>> const df = $df.data({ date: ["2026-05-20T10:00:00.123Z"] })
+ * >>> df
+ * shape: (1, 1)
  * ┌──────────────────────────┐
- * │ add_days                 │
+ * │ date                     │
  * ├──────────────────────────┤
- * │ 2026-01-02T00:00:00.000Z │
- * │ 2026-01-03T00:00:00.000Z │
+ * │ 2026-05-20T10:00:00.123Z │
+ * └──────────────────────────┘
+ * >>> df.select($df.col("date").cast($df.Datetime).add($df.duration({ days: 1 })).alias("plus_1_day"))
+ * shape: (1, 1)
+ * ┌──────────────────────────┐
+ * │ plus_1_day               │
+ * ├──────────────────────────┤
+ * │ 2026-05-21T10:00:00.123Z │
  * └──────────────────────────┘
  */
-export declare function duration(options?: DurationOptions): ColumnExpr<any>;
+export declare function duration(options?: DurationOptions | string): ColumnExpr<any>;

package/dist/columnExpressions/functions/element.d.ts

@@ -9,22 +9,22 @@ import { ColumnExpr } from "../ColumnExpr";
  * @category ColumnExpression
  * @syntax $df.{symbol}(...)
  * @example
- * >>> const df = $df.data({ a: [[1, 5, 10], [2, 8]] })
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
  * >>> df
  * shape: (2, 1)
- * ┌────────────┐
- * │ a          │
- * ├────────────┤
- * │ [1, 5, 10] │
- * │ [2, 8]     │
- * └────────────┘
- * >>> df.select($df.col("a").arr.filter($df.element().gt(5)).alias("filtered"))
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+ * >>> df.select($df.col("a").arr.filter($df.element().gt(2)).alias("filtered"))
  * shape: (2, 1)
  * ┌──────────┐
  * │ filtered │
  * ├──────────┤
- * │ [10]     │
- * │ [8]      │
+ * │ [3]      │
+ * │ [4, 5]   │
  * └──────────┘
  */
 export declare function element<T = any>(): ColumnExpr<T>;

package/dist/columnExpressions/functions/exclude.d.ts

@@ -8,22 +8,22 @@ import { ColumnExpr } from "../ColumnExpr";
  * @category ColumnExpression
  * @syntax $df.{symbol}(...)
  * @example
- * >>> const df = $df.data({ id: [101, 102], val: [10, 20] })
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
  * >>> df
  * shape: (2, 2)
- * ┌─────┬─────┐
- * │ id  │ val │
- * ├─────┼─────┤
- * │ 101 │ 10  │
- * │ 102 │ 20  │
- * └─────┴─────┘
- * >>> df.select($df.exclude("id"))
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
+ * >>> df.select($df.exclude("a"))
  * shape: (2, 1)
- * ┌─────┐
- * │ val │
- * ├─────┤
- * │ 10  │
- * │ 20  │
- * └─────┘
+ * ┌───┐
+ * │ b │
+ * ├───┤
+ * │ x │
+ * │ y │
+ * └───┘
  */
 export declare function exclude(columns: string | string[]): ColumnExpr<any>;

package/dist/columnExpressions/functions/implode.d.ts

@@ -9,23 +9,23 @@ import type { IntoExpr } from "../../types";
  * @category ColumnExpression
  * @syntax $df.{symbol}(...)
  * @example
- * >>> const df = $df.data({ group: ["A", "A", "B"], val: [1, 2, 3] })
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
  * >>> df
  * shape: (3, 2)
  * ┌───────┬─────┐
  * │ group │ val │
  * ├───────┼─────┤
- * │ A     │ 1   │
- * │ A     │ 2   │
- * │ B     │ 3   │
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
  * └───────┴─────┘
- * >>> df.group_by("group").agg($df.implode("val").alias("imploded"))
+ * >>> df.groupBy("group").agg($df.implode("val").alias("imploded"))
  * shape: (2, 2)
  * ┌───────┬──────────┐
  * │ group │ imploded │
  * ├───────┼──────────┤
- * │ A     │ [1, 2]   │
- * │ B     │ [3]      │
+ * │ A     │ [10, 20] │
+ * │ B     │ [30]     │
  * └───────┴──────────┘
  */
 export declare function implode(column: IntoExpr | IntoExpr[]): ColumnExpr<any>;

package/dist/columnExpressions/functions/lit.d.ts

@@ -1,5 +1,5 @@
 import { ColumnExpr } from "../ColumnExpr";
-import type { SeqRangeOptions } from "./seq_range";
+import type { SeqRangeOptions } from "./seqRange";
 export type LitOptions = Pick<SeqRangeOptions, "dtype" | "name">;
 /**
  * Creates a literal column expression that repeats the given value for all rows.
@@ -13,15 +13,15 @@ export type LitOptions = Pick<SeqRangeOptions, "dtype" | "name">;
  * @category ColumnExpression
  * @syntax $df.{symbol}(...)
  * @example
- * >>> const df = $df.data({ a: [1, 2] })
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
  * >>> df
- * shape: (2, 1)
- * ┌───┐
- * │ a │
- * ├───┤
- * │ 1 │
- * │ 2 │
- * └───┘
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
  * >>> df.select($df.lit(42).alias("answer"))
  * shape: (2, 1)
  * ┌────────┐

package/dist/columnExpressions/functions/seqRange.d.ts

@@ -0,0 +1,69 @@
+import { ColumnExpr } from "../ColumnExpr";
+import type { RegisteredDataType } from "../../types";
+import { CumulativeStepContext, IndependentStepContext } from "../../utils";
+export type SeqRangeOptions = {
+    n?: number;
+    dtype?: RegisteredDataType;
+    name?: string;
+} & ({
+    mode: "constant";
+} | {
+    mode?: "cumulative";
+    step?: number | ((context: CumulativeStepContext) => any);
+} | {
+    mode: "independent";
+    step?: number | ((context: IndependentStepContext) => any);
+}) & ({
+    strict?: true;
+} | {
+    strict: false;
+    pad?: boolean;
+    truncate?: boolean;
+    padValue?: any;
+    startIndex?: number;
+    endIndex?: number;
+});
+/**
+ * Creates a column expression that generates a range of values.
+ * If mode is "cumulative" (default) or "independent", it generates a sequence.
+ * If mode is "constant", it repeats the given value.
+ *
+ * @param value The initial value to start the sequence or the constant value to repeat.
+ * @param [options] Configuration options.
+ * @param [options.n] The number of values to generate. Defaults to the slice/DataFrame height.
+ * @param [options.dtype] The registered data type to coerce/allocate for the generated sequence.
+ * @param [options.name] The name of the output column.
+ * @param [options.mode] The sequence generation mode ("constant", "cumulative", or "independent").
+ * @param [options.step] The step value or function to compute the step at each row.
+ * @param [options.strict] If true, throws an error if the generated sequence height does not match the target height.
+ * @param [options.pad] In non-strict mode, pads the sequence with `padValue` if it is shorter than target range.
+ * @param [options.truncate] In non-strict mode, truncates the sequence if it exceeds target range.
+ * @param [options.padValue] The value to use for padding in non-strict mode.
+ * @param [options.startIndex] The starting index in the DataFrame to insert the sequence.
+ * @param [options.endIndex] The ending index in the DataFrame to insert the sequence.
+ * @returns {ColumnExpr<any>} A column expression generating the sequence.
+ * @namespace $df
+ * @category ColumnExpression
+ * @syntax $df.{symbol}(...)
+ * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+ * >>> df.select($df.seqRange(1, { step: 2 }).alias("odd"))
+ * shape: (3, 1)
+ * ┌─────┐
+ * │ odd │
+ * ├─────┤
+ * │ 1   │
+ * │ 3   │
+ * │ 5   │
+ * └─────┘
+ */
+export declare function seqRange(value: any, options?: SeqRangeOptions): ColumnExpr<any>;

package/dist/columnExpressions/functions/struct.d.ts

@@ -13,12 +13,12 @@ import type { IntoExpr } from "../../types";
  * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
  * >>> df
  * shape: (2, 2)
- * ┌─────┬─────┐
- * │ a   │ b   │
- * ├─────┼─────┤
- * │ 1   │ x   │
- * │ 2   │ y   │
- * └─────┴─────┘
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
  * >>> df.select($df.struct({ x: "a", y: "b" }).alias("coord"))
  * shape: (2, 1)
  * ┌──────────────────┐

package/dist/columnExpressions/functions/when.d.ts

@@ -1,24 +1,20 @@
 import { ColumnExpr } from "../ColumnExpr";
 import type { IExpr, ValidScalarTypes } from "../../types";
-type WhenArg = IExpr | ValidScalarTypes | any[];
+type WhenArg = IExpr | ValidScalarTypes | any[] | Record<string, any>;
 export declare class WhenThenChain {
     private _predicates;
     private _values;
-    constructor(predicates: WhenArg[], values: WhenArg[]);
-    then(value: WhenArg): WhenThen;
-}
-export declare class When {
-    private _predicates;
-    constructor(predicate: WhenArg);
+    constructor(_predicates: WhenArg[], _values?: WhenArg[]);
     then(value: WhenArg): WhenThen;
 }
+export { WhenThenChain as When };
 export declare class WhenThen extends ColumnExpr<any> {
     _predicates: WhenArg[];
     _values: WhenArg[];
     _otherwise: WhenArg;
     get _otherwiseValue(): WhenArg;
     get _branchOperands(): WhenArg[];
-    constructor(predicates?: WhenArg[], values?: WhenArg[], otherwise?: WhenArg);
+    constructor(_predicates?: WhenArg[], _values?: WhenArg[], _otherwise?: WhenArg);
     when(predicate: WhenArg): WhenThenChain;
     otherwise(value: WhenArg): WhenThen;
 }
@@ -26,31 +22,32 @@ export declare class WhenThen extends ColumnExpr<any> {
  * Provides conditional branch evaluations inside column expressions.
  *
  * @param {WhenArg} predicate The boolean condition or expression.
- * @returns {When} A When object builder to chain `.then()` and `.otherwise()`/`.when()`.
+ * @returns {WhenThenChain} A When object builder to chain `.then()` and `.otherwise()`/`.when()`.
  * @namespace $df
  * @category ColumnExpression
  * @syntax $df.{symbol}(...)
  * @example
- * >>> const df = $df.data({ score: [75, 95] })
+ * >>> const df = $df.data({ a: [1, 2, 3] })
  * >>> df
- * shape: (2, 1)
- * ┌───────┐
- * │ score │
- * ├───────┤
- * │ 75    │
- * │ 95    │
- * └───────┘
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
  * >>> df.select(
- * ...   $df.when($df.col("score").gt(90)).then("A")
- * ...     .otherwise("B").alias("grade")
+ * ...   $df.when($df.col("a").gt(2)).then("High")
+ * ...     .otherwise("Low").alias("tier")
  * ... )
- * shape: (2, 1)
- * ┌───────┐
- * │ grade │
- * ├───────┤
- * │ B     │
- * │ A     │
- * └───────┘
+ * shape: (3, 1)
+ * ┌──────┐
+ * │ tier │
+ * ├──────┤
+ * │ Low  │
+ * │ Low  │
+ * │ High │
+ * └──────┘
  */
-export declare function when(predicate: WhenArg): When;
-export {};
+export declare function when(predicate: WhenArg): WhenThenChain;

package/dist/columnExpressions/index.d.ts

@@ -1,14 +1,10 @@
 export * from "./constants";
 export * from "./types";
 export * from "./ExprBase";
-export * from "./mixins/ArithmeticExpr";
-export * from "./mixins/LogicalExpr";
-export * from "./mixins/ComparisonExpr";
+export * from "./mixins/StandardExpr";
+export * from "./mixins/ArrayExpr";
 export * from "./mixins/StringExpr";
-export * from "./mixins/AggregationExpr";
-export * from "./mixins/WindowExpr";
 export * from "./mixins/TemporalExpr";
-export * from "./mixins/ArrayExpr";
 export * from "./mixins/StructExpr";
 export * from "./ColumnExpr";
 export * from "./functions/lit";
@@ -17,7 +13,7 @@ export * from "./functions/exclude";
 export * from "./functions/coalesce";
 export * from "./functions/when";
 export * from "./functions/implode";
-export * from "./functions/seq_range";
+export * from "./functions/seqRange";
 export * from "./functions/element";
 export * from "./functions/struct";
 export * from "./functions/duration";