df-script 1.4.0 → 1.6.0

package/dist/columnExpressions/ColumnExpr.d.ts

@@ -1,368 +1,30 @@
 import { ExprBase } from "./ExprBase";
-declare const ColumnExpr_base: {
-    new (...args: any[]): {
-        get list(): import("./mixins/ListExpr").ListExprNamespace;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").IExpr)[] | null;
-        windowOp?: {
-            type: string;
-            [key: string]: any;
-        } | null;
-        isWindow?: boolean;
-        alias(name: string): /*elided*/ any;
-        cast(dataType: any): /*elided*/ any;
-        _resolve(val: any, columns: import("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        get dt(): import("./mixins/TemporalExpr").DateTimeExprNamespace;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").IExpr)[] | null;
-        windowOp?: {
-            type: string;
-            [key: string]: any;
-        } | null;
-        isWindow?: boolean;
-        alias(name: string): /*elided*/ any;
-        cast(dataType: any): /*elided*/ any;
-        _resolve(val: any, columns: import("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        and(other: any): /*elided*/ any;
-        not(): /*elided*/ any;
-        or(other: any): /*elided*/ any;
-        xor(other: any): /*elided*/ any;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").IExpr)[] | null;
-        windowOp?: {
-            type: string;
-            [key: string]: any;
-        } | null;
-        isWindow?: boolean;
-        alias(name: string): /*elided*/ any;
-        cast(dataType: any): /*elided*/ any;
-        _resolve(val: any, columns: import("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        get str(): import("./mixins/StringExpr").StringExprNamespace;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").IExpr)[] | null;
-        windowOp?: {
-            type: string;
-            [key: string]: any;
-        } | null;
-        isWindow?: boolean;
-        alias(name: string): /*elided*/ any;
-        cast(dataType: any): /*elided*/ any;
-        _resolve(val: any, columns: import("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        partitionBy: (string | import("..").IExpr)[] | null;
-        _rolling(windowSize: number, aggFn: (vals: any[]) => any): /*elided*/ any;
-        get isWindow(): boolean;
-        cum_count(reverse?: boolean): /*elided*/ any;
-        cum_max(reverse?: boolean): /*elided*/ any;
-        cum_min(reverse?: boolean): /*elided*/ any;
-        cum_prod(reverse?: boolean): /*elided*/ any;
-        cum_sum(reverse?: boolean): /*elided*/ any;
-        dense_rank(): /*elided*/ any;
-        lag(offset?: number, defaultVal?: any): /*elided*/ any;
-        lead(offset?: number, defaultVal?: any): /*elided*/ any;
-        over(columns: string | import("..").IExpr | (string | import("..").IExpr)[]): /*elided*/ any;
-        rank(): /*elided*/ any;
-        rolling_max(windowSize: number): /*elided*/ any;
-        rolling_mean(windowSize: number): /*elided*/ any;
-        rolling_median(windowSize: number): /*elided*/ any;
-        rolling_min(windowSize: number): /*elided*/ any;
-        rolling_quantile(quantile: number, windowSize: number): /*elided*/ any;
-        rolling_rank(windowSize: number): /*elided*/ any;
-        rolling_std(windowSize: number): /*elided*/ any;
-        rolling_sum(windowSize: number): /*elided*/ any;
-        row_number(): /*elided*/ any;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        windowOp?: {
-            type: string;
-            [key: string]: any;
-        } | null;
-        alias(name: string): /*elided*/ any;
-        cast(dataType: any): /*elided*/ any;
-        _resolve(val: any, columns: import("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        aggFn: import("..").AggFn<any> | null;
-        _deriveAgg(fn: import("..").AggFn<any>): /*elided*/ any;
-        all(): /*elided*/ any;
-        all_null(): /*elided*/ any;
-        any(): /*elided*/ any;
-        any_null(): /*elided*/ any;
-        avg(): /*elided*/ any;
-        count(options?: {
-            includeNulls?: boolean;
-        }): /*elided*/ any;
-        first(): /*elided*/ any;
-        last(): /*elided*/ any;
-        max(): /*elided*/ any;
-        mean(): /*elided*/ any;
-        median(): /*elided*/ any;
-        min(): /*elided*/ any;
-        mode(): /*elided*/ any;
-        n_unique(): /*elided*/ any;
-        quantile(q: number): /*elided*/ any;
-        std(): /*elided*/ any;
-        sum(): /*elided*/ any;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").IExpr)[] | null;
-        windowOp?: {
-            type: string;
-            [key: string]: any;
-        } | null;
-        isWindow?: boolean;
-        alias(name: string): /*elided*/ any;
-        cast(dataType: any): /*elided*/ any;
-        _resolve(val: any, columns: import("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        between(lower: any, upper: any, closed?: "both" | "left" | "right" | "none"): /*elided*/ any;
-        eq(val: any): /*elided*/ any;
-        eq_missing(val: any): /*elided*/ any;
-        ge(val: any): /*elided*/ any;
-        gt(val: any): /*elided*/ any;
-        has_nulls(): any;
-        is_close(other: any, options?: {
-            abs_tol?: number;
-            rel_tol?: number;
-            nans_equal?: boolean;
-        }): /*elided*/ any;
-        is_duplicated(): /*elided*/ any;
-        is_empty(options?: {
-            ignoreNulls?: boolean;
-        }): /*elided*/ any;
-        is_finite(): /*elided*/ any;
-        is_first_distinct(): /*elided*/ any;
-        is_in(values: any[] | any): /*elided*/ any;
-        is_infinite(): /*elided*/ any;
-        is_last_distinct(): /*elided*/ any;
-        is_n_distinct(n: number): any;
-        is_nan(): /*elided*/ any;
-        is_not_nan(): /*elided*/ any;
-        is_not_null(): /*elided*/ any;
-        is_null(): /*elided*/ any;
-        is_unique(): /*elided*/ any;
-        le(val: any): /*elided*/ any;
-        lt(val: any): /*elided*/ any;
-        ne(val: any): /*elided*/ any;
-        ne_missing(val: any): /*elided*/ any;
-        not_in(values: any[] | any): /*elided*/ any;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").IExpr)[] | null;
-        windowOp?: {
-            type: string;
-            [key: string]: any;
-        } | null;
-        isWindow?: boolean;
-        alias(name: string): /*elided*/ any;
-        cast(dataType: any): /*elided*/ any;
-        _resolve(val: any, columns: import("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        abs(): /*elided*/ any;
-        acos(): /*elided*/ any;
-        acosh(): /*elided*/ any;
-        add(val: number | import("..").IExpr | null): /*elided*/ any;
-        asin(): /*elided*/ any;
-        asinh(): /*elided*/ any;
-        atan(): /*elided*/ any;
-        atanh(): /*elided*/ any;
-        cbrt(): /*elided*/ any;
-        ceil(): /*elided*/ any;
-        clip(lower?: number | null, upper?: number | null): /*elided*/ any;
-        cos(): /*elided*/ any;
-        cosh(): /*elided*/ any;
-        degrees(): /*elided*/ any;
-        div(val: number | import("..").IExpr | null): /*elided*/ any;
-        exp(): /*elided*/ any;
-        expm1(): /*elided*/ any;
-        floor(): /*elided*/ any;
-        floordiv(val: number | import("..").IExpr | null): /*elided*/ any;
-        hypot(val: number | import("..").IExpr | null): /*elided*/ any;
-        log(base?: number): /*elided*/ any;
-        log1p(): /*elided*/ any;
-        mod(val: number | import("..").IExpr | null): /*elided*/ any;
-        mul(val: number | import("..").IExpr | null): /*elided*/ any;
-        negate(): /*elided*/ any;
-        pow(val: number | import("..").IExpr | null): /*elided*/ any;
-        radians(): /*elided*/ any;
-        rand(seed?: number, { min, max, integer }?: import("./types").RandomOptions): /*elided*/ any;
-        round(decimals?: number): /*elided*/ any;
-        sign(): /*elided*/ any;
-        sin(): /*elided*/ any;
-        sinh(): /*elided*/ any;
-        sqrt(): /*elided*/ any;
-        sub(val: number | import("..").IExpr | null): /*elided*/ any;
-        tan(): /*elided*/ any;
-        tanh(): /*elided*/ any;
-        trunc(): /*elided*/ any;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").IExpr)[] | null;
-        windowOp?: {
-            type: string;
-            [key: string]: any;
-        } | null;
-        isWindow?: boolean;
-        alias(name: string): /*elided*/ any;
-        cast(dataType: any): /*elided*/ any;
-        _resolve(val: any, columns: import("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        fill_null(value: any): /*elided*/ any;
-        reverse(): /*elided*/ any;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").IExpr)[] | null;
-        windowOp?: {
-            type: string;
-            [key: string]: any;
-        } | null;
-        isWindow?: boolean;
-        alias(name: string): /*elided*/ any;
-        cast(dataType: any): /*elided*/ any;
-        _resolve(val: any, columns: import("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & typeof ExprBase;
-export declare class ColumnExpr<T> extends ColumnExpr_base {
+import { ArithmeticExpr } from "./mixins/ArithmeticExpr";
+import { ComparisonExpr } from "./mixins/ComparisonExpr";
+import { AggregationExpr } from "./mixins/AggregationExpr";
+import { WindowExpr } from "./mixins/WindowExpr";
+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 {
     colName: string;
+    colNames?: string[];
     excludedCols: string[];
-    constructor(colName: keyof T | string);
+    targetType?: any;
+    targetTypes?: any[];
+    static isColExpr(v: unknown): v is ColumnExpr<any>;
+    static toColExpr(col: IntoExpr | IntoExpr[]): ColumnExpr<any>;
+    constructor(colName: keyof T | string | (keyof T | string)[] | DataType | Function | (DataType | Function)[]);
 }
-export {};
+export interface ColumnExpr<T> extends ArithmeticExpr, ComparisonExpr, AggregationExpr, WindowExpr, StringExpr, LogicalExpr, TemporalExpr, ArrayExpr, StructExpr, ManipulationExpr {
+}
+/**
+ * Resolves column selectors, expanding wildcards, datatypes, and arrays of columns/types
+ * into concrete ColumnExpr instances.
+ */
+export declare function resolveColumnSelectors(exprs: any[], allKeys: string[], keysToExcludeFromAll?: string[], schema?: DataFrameSchema, columns?: ColumnDict): IExpr[];

package/dist/columnExpressions/ExprBase.d.ts

@@ -1,24 +1,21 @@
-import type { IExpr, OpFn, AggFn, ColumnData, ColumnDict } from "../types";
-import type { DataType } from "../datatypes";
-export declare const kleeneUnary: (fn: (v: any) => any) => (vArray: ColumnData) => any[];
-export declare const kleeneBinary: (expr: IExpr, other: any, fn: (v: any, r: any) => any) => (vArray: ColumnData, columns: ColumnDict) => any[];
+import type { IExpr, OpFn, AggFn, ColumnData, ColumnDict, RegisteredDataType } from "../types";
 export declare const derive: <T extends IExpr>(instance: T, nextOp?: OpFn) => T;
 export declare class ExprBase implements IExpr {
     ops: OpFn[];
     outputName: string;
+    isLiteral?: boolean;
+    literalValue?: any;
     aggFn?: AggFn<any> | null;
     groupingOpsIndex?: number;
     partitionOpsIndex?: number;
     partitionBy: (string | IExpr)[] | null;
+    evaluateWindow?: (groupPreValues: any[], partitionIndices: number[], currentIndex: number) => any;
     _resolve(val: any, columns: ColumnDict, height: number): any;
     alias(name: string): this;
-    cast(dataType: DataType): this;
+    cast(dataType: RegisteredDataType): this;
     debug(label?: string): this;
+    private _getInitialValue;
     evaluate(columns: ColumnDict, height: number): ColumnData;
-    private _evaluatePre;
-    private _evaluatePost;
-    evaluatePrePartition(columns: ColumnDict, height: number): ColumnData;
-    evaluatePostPartition(aggregatedArray: any[], columns: ColumnDict): ColumnData;
-    evaluatePreGrouping(columns: ColumnDict, height: number): ColumnData;
-    evaluatePostGrouping(aggregatedArray: any[], columns: ColumnDict): ColumnData;
+    evaluatePre(opsIndex: number | undefined, columns: ColumnDict, height: number): ColumnData;
+    evaluatePost(opsIndex: number | undefined, aggregatedArray: any[], columns: ColumnDict): ColumnData;
 }

package/dist/columnExpressions/constants.d.ts

@@ -1,2 +1,4 @@
 export declare const ALL_COLUMNS_MARKER = "*";
 export declare const LITERAL_MARKER = "*literal*";
+export declare const COALESCE_MARKER = "*coalesce*";
+export declare const ELEMENT_MARKER = "*element*";

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

@@ -1,3 +1,3 @@
 import { ColumnExpr } from "../ColumnExpr";
-import type { IExpr, Scalar } from "../../types";
-export declare function coalesce(...exprs: (IExpr | Scalar | (IExpr | Scalar)[])[]): ColumnExpr<any>;
+import type { IExpr, ValidScalarTypes } from "../../types";
+export declare function coalesce(...exprs: (IExpr | ValidScalarTypes | (IExpr | ValidScalarTypes)[])[]): ColumnExpr<any>;

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

@@ -0,0 +1,5 @@
+import { ColumnExpr } from "../ColumnExpr";
+/**
+ * Creates an expression referencing the current element(s) of an array during evaluation.
+ */
+export declare function element<T = any>(): ColumnExpr<T>;

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

@@ -0,0 +1,3 @@
+import { ColumnExpr } from "../ColumnExpr";
+import type { IntoExpr } from "../../types";
+export declare function implode(column: IntoExpr | IntoExpr[]): ColumnExpr<any>;

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

@@ -1,5 +1,7 @@
 import { ColumnExpr } from "../ColumnExpr";
+import type { SeqRangeOptions } from "./seq_range";
+export type LitOptions = Pick<SeqRangeOptions, "dtype" | "name">;
 /**
  * Creates a literal column expression that repeats the given value for all rows.
  */
-export declare function lit(value: any): ColumnExpr<any>;
+export declare function lit(value: any, options?: LitOptions): ColumnExpr<any>;

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

@@ -0,0 +1,31 @@
+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.
+ */
+export declare function seq_range(value: any, options?: SeqRangeOptions): ColumnExpr<any>;

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

@@ -1,6 +1,6 @@
 import { ColumnExpr } from "../ColumnExpr";
-import type { IExpr, Scalar } from "../../types";
-type WhenArg = IExpr | Scalar;
+import type { IExpr, ValidScalarTypes } from "../../types";
+type WhenArg = IExpr | ValidScalarTypes;
 export declare class WhenThenChain {
     private predicates;
     private values;

package/dist/columnExpressions/index.d.ts

@@ -1,4 +1,3 @@
-import type { IExpr } from "../types";
 export * from "./constants";
 export * from "./types";
 export * from "./ExprBase";
@@ -9,11 +8,15 @@ export * from "./mixins/StringExpr";
 export * from "./mixins/AggregationExpr";
 export * from "./mixins/WindowExpr";
 export * from "./mixins/TemporalExpr";
-export * from "./mixins/ListExpr";
+export * from "./mixins/ArrayExpr";
+export * from "./mixins/StructExpr";
 export * from "./ColumnExpr";
 export * from "./functions/lit";
 export * from "./functions/all";
 export * from "./functions/exclude";
 export * from "./functions/coalesce";
 export * from "./functions/when";
-export declare function resolveColumnSelectors(exprs: any[], allKeys: string[], keysToExcludeFromAll?: string[]): IExpr[];
+export * from "./functions/implode";
+export * from "./functions/seq_range";
+export * from "./functions/element";
+export * from "./utils";

package/dist/columnExpressions/mixins/AggregationExpr.d.ts

@@ -1,50 +1,25 @@
-import type { AggFn } from "../../types";
-import type { ExprConstructor } from "../types";
-export declare const AggregationExpr: <TBase extends ExprConstructor>(Base: TBase) => {
-    new (...args: any[]): {
-        aggFn: AggFn<any> | null;
-        _deriveAgg(fn: AggFn<any>): /*elided*/ any;
-        all(): /*elided*/ any;
-        all_null(): /*elided*/ any;
-        any(): /*elided*/ any;
-        any_null(): /*elided*/ any;
-        avg(): /*elided*/ any;
-        count(options?: {
-            includeNulls?: boolean;
-        }): /*elided*/ any;
-        first(): /*elided*/ any;
-        last(): /*elided*/ any;
-        max(): /*elided*/ any;
-        mean(): /*elided*/ any;
-        median(): /*elided*/ any;
-        min(): /*elided*/ any;
-        mode(): /*elided*/ any;
-        n_unique(): /*elided*/ any;
-        quantile(q: number): /*elided*/ any;
-        std(): /*elided*/ any;
-        sum(): /*elided*/ any;
-        ops: import("../../types").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("../../types").IExpr)[] | null;
-        windowOp?: {
-            type: string;
-            [key: string]: any;
-        } | null;
-        isWindow?: boolean;
-        alias(name: string): /*elided*/ any;
-        cast(dataType: any): /*elided*/ any;
-        _resolve(val: any, columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData | any;
-        evaluate(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
-        evaluatePreGrouping(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("../../types").ColumnDict): import("../../types").ColumnData;
-        evaluatePrePartition(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("../../types").ColumnDict): import("../../types").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & TBase;
+import type { AggFn, UniqueArrayStatsOptions } from "../../types";
+import { ExprBase } from "../ExprBase";
+export declare class AggregationExpr extends ExprBase {
+    _deriveAgg(fn: AggFn<any>): this;
+    all(): this;
+    all_null(): this;
+    any(): this;
+    any_null(): this;
+    avg(): this;
+    count(options?: {
+        includeNulls?: boolean;
+    }): this;
+    first(): this;
+    implode(): this;
+    last(): this;
+    max(): this;
+    mean(): this;
+    median(): this;
+    min(): this;
+    mode(): this;
+    n_unique(options?: UniqueArrayStatsOptions): this;
+    quantile(q: number): this;
+    std(): this;
+    sum(): this;
+}