df-script 1.4.0 → 1.6.0

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

@@ -1,67 +1,43 @@
-import type { IExpr } from "../../types";
-import type { ExprConstructor, RandomOptions } from "../types";
-export declare const ArithmeticExpr: <TBase extends ExprConstructor>(Base: TBase) => {
-    new (...args: any[]): {
-        abs(): /*elided*/ any;
-        acos(): /*elided*/ any;
-        acosh(): /*elided*/ any;
-        add(val: number | 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 | IExpr | null): /*elided*/ any;
-        exp(): /*elided*/ any;
-        expm1(): /*elided*/ any;
-        floor(): /*elided*/ any;
-        floordiv(val: number | IExpr | null): /*elided*/ any;
-        hypot(val: number | IExpr | null): /*elided*/ any;
-        log(base?: number): /*elided*/ any;
-        log1p(): /*elided*/ any;
-        mod(val: number | IExpr | null): /*elided*/ any;
-        mul(val: number | IExpr | null): /*elided*/ any;
-        negate(): /*elided*/ any;
-        pow(val: number | IExpr | null): /*elided*/ any;
-        radians(): /*elided*/ any;
-        rand(seed?: number, { min, max, integer }?: RandomOptions): /*elided*/ any;
-        round(decimals?: number): /*elided*/ any;
-        sign(): /*elided*/ any;
-        sin(): /*elided*/ any;
-        sinh(): /*elided*/ any;
-        sqrt(): /*elided*/ any;
-        sub(val: number | IExpr | null): /*elided*/ any;
-        tan(): /*elided*/ any;
-        tanh(): /*elided*/ any;
-        trunc(): /*elided*/ any;
-        ops: import("../../types").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("../../types").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | 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 { RandomOptions, NumericArg } from "../types";
+import { ExprBase } from "../ExprBase";
+export declare class ArithmeticExpr extends ExprBase {
+    abs(): this;
+    acos(): this;
+    acosh(): this;
+    add(val: NumericArg): this;
+    asin(): this;
+    asinh(): this;
+    atan(): this;
+    atan2(val: NumericArg): this;
+    atanh(): this;
+    cbrt(): this;
+    ceil(): this;
+    clip(lower?: number | null, upper?: number | null): this;
+    copysign(val: NumericArg): this;
+    cos(): this;
+    cosh(): this;
+    degrees(): this;
+    div(val: NumericArg): this;
+    exp(): this;
+    expm1(): this;
+    floor(): this;
+    floordiv(val: NumericArg): this;
+    hypot(val: NumericArg): this;
+    log(base?: number): this;
+    log1p(): this;
+    mod(val: NumericArg): this;
+    mul(val: NumericArg): this;
+    negate(): this;
+    pow(val: NumericArg): this;
+    radians(): this;
+    rand(seed?: number, { min, max, integer }?: RandomOptions): this;
+    round(decimals?: number): this;
+    sign(): this;
+    sin(): this;
+    sinh(): this;
+    sqrt(): this;
+    sub(val: NumericArg): this;
+    tan(): this;
+    tanh(): this;
+    trunc(): this;
+}

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

@@ -0,0 +1,39 @@
+import { ExprBase } from "../ExprBase";
+import { SortArrayOptions, StepSliceArrayOptions } from "../../utils";
+import type { UniqueArrayStatsOptions, JoinArrayOptions, ExplodeOptions, IExpr } from "../../types";
+export declare class ArrayExprNamespace {
+    expr: any;
+    constructor(expr: any);
+    _deriveArray(fn: (arr: any[] | ArrayBufferView) => any): any;
+    all(): any;
+    any(): any;
+    contains(item: any): any;
+    contains_all(items: ArrayLike<any>): any;
+    contains_any(items: ArrayLike<any>): any;
+    count_matches(item: any): any;
+    drop_nulls(): any;
+    explode({ empty_as_null, keep_nulls }?: ExplodeOptions): any;
+    first(null_on_oob?: boolean): any;
+    gather(indices: number | ArrayLike<number>, null_on_oob?: boolean): any;
+    gather_every(options?: StepSliceArrayOptions): any;
+    get(index: number, null_on_oob?: boolean): any;
+    join(separator?: string, options?: JoinArrayOptions): any;
+    last(null_on_oob?: boolean): any;
+    len(): any;
+    lengths(): any;
+    max(): any;
+    mean(): any;
+    median(): any;
+    min(): any;
+    mode(): any;
+    n_unique(options?: UniqueArrayStatsOptions): any;
+    reverse(): any;
+    slice(offset: number, length?: number): any;
+    sort(options?: SortArrayOptions): any;
+    sum(): any;
+    unique(options?: UniqueArrayStatsOptions): any;
+    eval(expr: IExpr): any;
+}
+export declare class ArrayExpr extends ExprBase {
+    get arr(): ArrayExprNamespace;
+}

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

@@ -1,60 +1,31 @@
-import type { ExprConstructor } from "../types";
-export declare const ComparisonExpr: <TBase extends ExprConstructor>(Base: TBase) => {
-    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;
-    };
-} & TBase;
+import { ExprBase } from "../ExprBase";
+export declare class ComparisonExpr extends ExprBase {
+    between(lower: any, upper: any, closed?: "both" | "left" | "right" | "none"): this;
+    eq(val: any): this;
+    eq_missing(val: any): this;
+    ge(val: any): this;
+    gt(val: any): this;
+    has_nulls(): any;
+    is_close(other: any, { abs_tol, rel_tol, nans_equal }?: {
+        abs_tol?: number;
+        rel_tol?: number;
+        nans_equal?: boolean;
+    }): this;
+    is_duplicated(): this;
+    is_empty({ ignoreNulls }?: {
+        ignoreNulls?: boolean;
+    }): this;
+    is_finite(): this;
+    is_in(values: any[] | any): this;
+    is_infinite(): this;
+    is_nan(): this;
+    is_not_nan(): this;
+    is_not_null(): this;
+    is_null(): this;
+    is_unique(): this;
+    le(val: any): this;
+    lt(val: any): this;
+    ne(val: any): this;
+    ne_missing(val: any): this;
+    not_in(values: any[] | any): this;
+}

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

@@ -1,4 +1,6 @@
-import type { ExprConstructor } from "../types";
+import { ExprBase } from "../ExprBase";
+import { SortListOptions, StepSliceListOptions } from "../../utils";
+import type { UniqueListStatsOptions, JoinListOptions, ExplodeOptions, IExpr } from "../../types";
 export declare class ListExprNamespace {
     expr: any;
     constructor(expr: any);
@@ -6,17 +8,16 @@ export declare class ListExprNamespace {
     all(): any;
     any(): any;
     contains(item: any): any;
-    contains_all(items: any[]): any;
-    contains_any(items: any[]): any;
+    contains_all(items: ArrayLike<any>): any;
+    contains_any(items: ArrayLike<any>): any;
     count_matches(item: any): any;
     drop_nulls(): any;
+    explode({ empty_as_null, keep_nulls }?: ExplodeOptions): any;
     first(null_on_oob?: boolean): any;
-    gather(indices: number | number[], null_on_oob?: boolean): any;
-    gather_every(n: number, offset?: number): any;
+    gather(indices: number | ArrayLike<number>, null_on_oob?: boolean): any;
+    gather_every(options?: StepSliceListOptions): any;
     get(index: number, null_on_oob?: boolean): any;
-    join(separator: string, { ignoreNulls }?: {
-        ignoreNulls?: boolean;
-    }): any;
+    join(separator?: string, options?: JoinListOptions): any;
     last(null_on_oob?: boolean): any;
     len(): any;
     lengths(): any;
@@ -25,39 +26,14 @@ export declare class ListExprNamespace {
     median(): any;
     min(): any;
     mode(): any;
-    n_unique(): any;
+    n_unique(options?: UniqueListStatsOptions): any;
     reverse(): any;
     slice(offset: number, length?: number): any;
-    sort(descending?: boolean): any;
+    sort(options?: SortListOptions): any;
     sum(): any;
-    unique(): any;
+    unique(options?: UniqueListStatsOptions): any;
+    eval(expr: IExpr): any;
+}
+export declare class ListExpr extends ExprBase {
+    get list(): ListExprNamespace;
 }
-export declare const ListExpr: <TBase extends ExprConstructor>(Base: TBase) => {
-    new (...args: any[]): {
-        get list(): 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;
-    };
-} & TBase;

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

@@ -1,33 +1,7 @@
-import type { ExprConstructor } from "../types";
-export declare const LogicalExpr: <TBase extends ExprConstructor>(Base: TBase) => {
-    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;
-    };
-} & TBase;
+import { ExprBase } from "../ExprBase";
+export declare class LogicalExpr extends ExprBase {
+    and(other: any): this;
+    not(): this;
+    or(other: any): this;
+    xor(other: any): this;
+}

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

@@ -1,31 +1,6 @@
-import type { ExprConstructor } from "../types";
-export declare const ManipulationExpr: <TBase extends ExprConstructor>(Base: TBase) => {
-    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;
-    };
-} & TBase;
+import { ExprBase } from "../ExprBase";
+import type { FillNullOptions } from "../../types";
+export declare class ManipulationExpr extends ExprBase {
+    fill_null({ value, strategy, limit }?: FillNullOptions): this;
+    reverse(): this;
+}

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

@@ -1,10 +1,11 @@
 import type { IExpr } from "../../types";
-import type { ExprConstructor } from "../types";
+import { ExprBase } from "../ExprBase";
 import { StripCharsOptions } from "../../utils";
 export declare class StringExprNamespace {
     expr: any;
     constructor(expr: any);
     _deriveString(fn: (v: string) => any): any;
+    _patternGuard(pattern: any, fn: () => any): any;
     concat(other: string | IExpr): any;
     contains(pattern: string | RegExp): any;
     count_matches(pattern: string | RegExp): any;
@@ -20,8 +21,8 @@ export declare class StringExprNamespace {
     lpad(width: number, fill?: string): any;
     pad_end(width: number, fill?: string): any;
     pad_start(width: number, fill?: string): any;
-    replace(pattern: string | RegExp, replacement: string): any;
-    replace_all(pattern: string | RegExp, replacement: string): any;
+    replace(pattern: string | RegExp, replacement: string | ((match: string, ...args: any[]) => string)): any;
+    replace_all(pattern: string | RegExp, replacement: string | ((match: string, ...args: any[]) => string)): any;
     reverse(): any;
     rpad(width: number, fill?: string): any;
     slice(offset: number, length?: number): any;
@@ -48,32 +49,6 @@ export declare class StringExprNamespace {
     upper(): any;
     zfill(width: number): any;
 }
-export declare const StringExpr: <TBase extends ExprConstructor>(Base: TBase) => {
-    new (...args: any[]): {
-        get str(): StringExprNamespace;
-        ops: import("../../types").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("../../types").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | 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;
+export declare class StringExpr extends ExprBase {
+    get str(): StringExprNamespace;
+}

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

@@ -0,0 +1,16 @@
+import { ExprBase } from "../ExprBase";
+import type { IntoExpr, IExpr } from "../../types";
+export declare class StructExprNamespace {
+    expr: IExpr;
+    constructor(expr: IExpr);
+    field(name: string): IExpr;
+    rename_fields(mapping: Record<string, string>): IExpr;
+    with_fields(fields: IntoExpr[] | Record<string, IntoExpr>): IExpr;
+    unnest(): IExpr;
+}
+export interface StructExprNamespace {
+    [key: string]: any;
+}
+export declare class StructExpr extends ExprBase {
+    get struct(): StructExprNamespace;
+}

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

@@ -1,5 +1,5 @@
 import type { TimeUnit } from "../../types";
-import type { ExprConstructor } from "../types";
+import { ExprBase } from "../ExprBase";
 export declare class DateTimeExprNamespace {
     expr: any;
     constructor(expr: any);
@@ -38,32 +38,6 @@ export declare class DateTimeExprNamespace {
     weekday(): any;
     year(): any;
 }
-export declare const TemporalExpr: <TBase extends ExprConstructor>(Base: TBase) => {
-    new (...args: any[]): {
-        get dt(): DateTimeExprNamespace;
-        ops: import("../../types").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("../../types").AggFn<any> | null;
-        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;
+export declare class TemporalExpr extends ExprBase {
+    get dt(): DateTimeExprNamespace;
+}

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

@@ -1,50 +1,28 @@
 import type { IExpr } from "../../types";
-import type { ExprConstructor } from "../types";
-export declare const WindowExpr: <TBase extends ExprConstructor>(Base: TBase) => {
-    new (...args: any[]): {
-        partitionBy: (string | 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 | IExpr | (string | 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("../../types").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("../../types").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("../../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 { ExprBase } from "../ExprBase";
+export declare class WindowExpr extends ExprBase {
+    partitionBy: (string | IExpr)[] | null;
+    _window(evaluateWindow: (this: IExpr, groupPreValues: any[], partitionIndices: number[], currentIndex: number) => any): this;
+    _rolling(windowSize: number, aggFn: (vals: any[]) => any): this;
+    _cum(reverse: boolean, initialVal: any, stepFn: (acc: any, val: any) => any, postFn?: (acc: any, hasValid: boolean) => any): this;
+    get isWindow(): boolean;
+    cum_count(reverse?: boolean): this;
+    cum_max(reverse?: boolean): this;
+    cum_min(reverse?: boolean): this;
+    cum_prod(reverse?: boolean): this;
+    cum_sum(reverse?: boolean): this;
+    dense_rank(): this;
+    lag(offset?: number, defaultVal?: any): this;
+    lead(offset?: number, defaultVal?: any): this;
+    over(columns: string | IExpr | (string | IExpr)[]): this;
+    rank(): this;
+    rolling_max(windowSize: number): this;
+    rolling_mean(windowSize: number): this;
+    rolling_median(windowSize: number): this;
+    rolling_min(windowSize: number): this;
+    rolling_quantile(quantile: number, windowSize: number): this;
+    rolling_rank(windowSize: number): this;
+    rolling_std(windowSize: number): this;
+    rolling_sum(windowSize: number): this;
+    row_number(): this;
+}

package/dist/columnExpressions/types.d.ts

@@ -5,3 +5,4 @@ export interface RandomOptions {
     max?: number;
     integer?: boolean;
 }
+export type NumericArg = number | IExpr | null;

package/dist/columnExpressions/utils.d.ts

@@ -0,0 +1,4 @@
+import type { IExpr, ColumnData, ColumnDict } from "../types";
+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[];
+export declare function evaluateExpression(expr: IExpr, columns: ColumnDict, height: number): ColumnData;

package/dist/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const NEWLINE = "\n";
+export declare const CARRIAGE_RETURN = "\r";
+export declare const UTF8_BOM = "\uFEFF";
+export declare const MS_PER_SECOND = 1000;
+export declare const MS_PER_MINUTE = 60000;
+export declare const MS_PER_HOUR = 3600000;
+export declare const MS_PER_DAY = 86400000;
+export declare const US_PER_MS = 1000;
+export declare const NS_PER_MS = 1000000;
+export declare const US_PER_MS_BI = 1000n;
+export declare const NS_PER_MS_BI = 1000000n;

package/dist/dataframe/constants.d.ts

@@ -1 +1,4 @@
 export declare const KEY_SEPARATOR = "\0";
+export declare const NEWLINE = "\n";
+export declare const CARRIAGE_RETURN = "\r";
+export declare const UTF8_BOM = "\uFEFF";