df-script 1.4.0 → 1.5.0

package/dist/columnExpressions/mixins/StringExpr.js

@@ -2,31 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StringExpr = exports.StringExprNamespace = void 0;
 const ExprBase_1 = require("../ExprBase");
-const utils_1 = require("../../utils");
+const utils_1 = require("../utils");
+const utils_2 = require("../../utils");
 class StringExprNamespace {
     expr;
     constructor(expr) {
         this.expr = expr;
     }
     _deriveString(fn) {
-        return (0, ExprBase_1.derive)(this.expr, (0, ExprBase_1.kleeneUnary)((v) => fn(String(v))));
+        return (0, ExprBase_1.derive)(this.expr, (0, utils_1.kleeneUnary)((v) => fn(String(v))));
     }
-    concat(other) {
-        return (0, ExprBase_1.derive)(this.expr, (0, ExprBase_1.kleeneBinary)(this.expr, other, (v, o) => String(v) + String(o)));
-    }
-    contains(pattern) {
+    _patternGuard(pattern, fn) {
         if (pattern == null) {
             return (0, ExprBase_1.derive)(this.expr, (vArray) => new Array(vArray.length).fill(null));
         }
-        return this._deriveString((str) => {
-            return pattern instanceof RegExp ? pattern.test(str) : str.includes(pattern);
-        });
+        return fn();
+    }
+    concat(other) {
+        return (0, ExprBase_1.derive)(this.expr, (0, utils_1.kleeneBinary)(this.expr, other, (v, o) => String(v) + String(o)));
+    }
+    contains(pattern) {
+        return this._patternGuard(pattern, () => this._deriveString((str) => pattern instanceof RegExp ? pattern.test(str) : str.includes(pattern)));
     }
     count_matches(pattern) {
-        if (pattern == null) {
-            return (0, ExprBase_1.derive)(this.expr, (vArray) => new Array(vArray.length).fill(null));
-        }
-        return this._deriveString((str) => {
+        return this._patternGuard(pattern, () => this._deriveString((str) => {
             if (pattern instanceof RegExp) {
                 const regex = pattern.global
                     ? pattern
@@ -43,7 +42,7 @@ class StringExprNamespace {
                 }
                 return count;
             }
-        });
+        }));
     }
     decode_uri_component() {
         return this._deriveString((str) => {
@@ -72,15 +71,12 @@ class StringExprNamespace {
         return this._deriveString((str) => str.split(""));
     }
     extract(pattern, group = 0) {
-        if (pattern == null) {
-            return (0, ExprBase_1.derive)(this.expr, (vArray) => new Array(vArray.length).fill(null));
-        }
-        return this._deriveString((str) => {
+        return this._patternGuard(pattern, () => this._deriveString((str) => {
             const match = str.match(pattern);
             if (!match)
                 return null;
             return match[group] !== undefined ? match[group] : null;
-        });
+        }));
     }
     len() {
         return this.len_chars();
@@ -104,16 +100,10 @@ class StringExprNamespace {
         return this.lpad(width, fill);
     }
     replace(pattern, replacement) {
-        if (pattern == null) {
-            return (0, ExprBase_1.derive)(this.expr, (vArray) => new Array(vArray.length).fill(null));
-        }
-        return this._deriveString((str) => str.replace(pattern, replacement));
+        return this._patternGuard(pattern, () => this._deriveString((str) => str.replace(pattern, replacement)));
     }
     replace_all(pattern, replacement) {
-        if (pattern == null) {
-            return (0, ExprBase_1.derive)(this.expr, (vArray) => new Array(vArray.length).fill(null));
-        }
-        return this._deriveString((str) => {
+        return this._patternGuard(pattern, () => this._deriveString((str) => {
             if (pattern instanceof RegExp) {
                 const regex = pattern.global
                     ? pattern
@@ -121,7 +111,7 @@ class StringExprNamespace {
                 return str.replace(regex, replacement);
             }
             return str.replaceAll(pattern, replacement);
-        });
+        }));
     }
     reverse() {
         return this._deriveString((str) => str.split("").reverse().join(""));
@@ -146,17 +136,17 @@ class StringExprNamespace {
         return this._deriveString((str) => str.startsWith(prefix));
     }
     strip_chars(characters, options) {
-        return this._deriveString((str) => (0, utils_1.stripChars)(str, characters, { mode: "both", ...options }));
+        return this._deriveString((str) => (0, utils_2.stripChars)(str, characters, { mode: "both", ...options }));
     }
     strip_chars_end(characters, options) {
-        return this._deriveString((str) => (0, utils_1.stripChars)(str, characters, { mode: "end", ...options }));
+        return this._deriveString((str) => (0, utils_2.stripChars)(str, characters, { mode: "end", ...options }));
     }
     strip_chars_start(characters, options) {
-        return this._deriveString((str) => (0, utils_1.stripChars)(str, characters, { mode: "start", ...options }));
+        return this._deriveString((str) => (0, utils_2.stripChars)(str, characters, { mode: "start", ...options }));
     }
     strip_prefix(prefix) {
         return this._deriveString((str) => {
-            return (0, utils_1.stripChars)(str, prefix, {
+            return (0, utils_2.stripChars)(str, prefix, {
                 mode: "start",
                 maxScanStart: 1,
                 maxMatchesStart: 1,
@@ -167,7 +157,7 @@ class StringExprNamespace {
     }
     strip_suffix(suffix) {
         return this._deriveString((str) => {
-            return (0, utils_1.stripChars)(str, suffix, {
+            return (0, utils_2.stripChars)(str, suffix, {
                 mode: "end",
                 maxScanEnd: 1,
                 maxMatchesEnd: 1,
@@ -177,11 +167,11 @@ class StringExprNamespace {
         });
     }
     strptime(format, strict = true) {
-        return this._deriveString((str) => (0, utils_1.strptime)(str, format, strict));
+        return this._deriveString((str) => (0, utils_2.strptime)(str, format, strict));
     }
     to_date() {
         return this._deriveString((str) => {
-            const d = (0, utils_1.toValidDate)(str);
+            const d = (0, utils_2.toValidDate)(str);
             if (!d)
                 return null;
             const copy = new Date(d);
@@ -190,26 +180,26 @@ class StringExprNamespace {
         });
     }
     to_datetime() {
-        return this._deriveString(utils_1.toValidDate);
+        return this._deriveString(utils_2.toValidDate);
     }
     to_decimal(precision, scale) {
-        return this._deriveString((str) => (0, utils_1.toValidDecimal)(str, { precision, scale }));
+        return this._deriveString((str) => (0, utils_2.toValidDecimal)(str, { precision, scale }));
     }
     to_integer() {
-        return this._deriveString((str) => (0, utils_1.toValidInt)(str));
+        return this._deriveString((str) => (0, utils_2.toValidInt)(str));
     }
     to_lowercase() {
         return this.lower();
     }
     to_time() {
         return this._deriveString((str) => {
-            const d = (0, utils_1.toValidDate)(str);
+            const d = (0, utils_2.toValidDate)(str);
             if (d)
                 return d.toISOString().split("T")[1].slice(0, 12);
             const trimmed = str.trim();
-            if (utils_1.TIME_PREFIX_REGEX.test(trimmed)) {
-                const td = new Date(`1970-01-01T${trimmed}${utils_1.ZONE_OFFSET_REGEX.test(trimmed) ? "" : "Z"}`);
-                if ((0, utils_1.isValidDateObj)(td)) {
+            if (utils_2.TIME_PREFIX_REGEX.test(trimmed)) {
+                const td = new Date(`1970-01-01T${trimmed}${utils_2.ZONE_OFFSET_REGEX.test(trimmed) ? "" : "Z"}`);
+                if ((0, utils_2.isValidDateObj)(td)) {
                     return td.toISOString().split("T")[1].slice(0, 12);
                 }
             }
@@ -239,11 +229,9 @@ class StringExprNamespace {
     }
 }
 exports.StringExprNamespace = StringExprNamespace;
-const StringExpr = (Base) => {
-    return class extends Base {
-        get str() {
-            return new StringExprNamespace(this);
-        }
-    };
-};
+class StringExpr extends ExprBase_1.ExprBase {
+    get str() {
+        return new StringExprNamespace(this);
+    }
+}
 exports.StringExpr = StringExpr;

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/StructExpr.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructExpr = exports.StructExprNamespace = void 0;
+const ExprBase_1 = require("../ExprBase");
+let ColumnExprClass = null;
+function toColExpr(col) {
+    if (col == null) {
+        throw new Error("Column reference cannot be null or undefined.");
+    }
+    if (!ColumnExprClass) {
+        ColumnExprClass = require("../ColumnExpr").ColumnExpr;
+    }
+    return ColumnExprClass.isColExpr(col) ? col : new ColumnExprClass(col);
+}
+class StructExprNamespace {
+    expr;
+    constructor(expr) {
+        this.expr = expr;
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                if (prop in target) {
+                    return Reflect.get(target, prop, receiver);
+                }
+                if (typeof prop === "string") {
+                    return target.field(prop);
+                }
+                return Reflect.get(target, prop, receiver);
+            }
+        });
+    }
+    field(name) {
+        return (0, ExprBase_1.derive)(this.expr, (vArray) => {
+            const height = vArray.length;
+            const result = new Array(height);
+            for (let i = 0; i < height; i++) {
+                const v = vArray[i];
+                result[i] = (v != null && typeof v === "object") ? v[name] : null;
+            }
+            return result;
+        }).alias(name);
+    }
+    rename_fields(mapping) {
+        return (0, ExprBase_1.derive)(this.expr, (vArray) => {
+            const height = vArray.length;
+            const result = new Array(height);
+            const keys = Object.keys(mapping);
+            const keysLen = keys.length;
+            for (let i = 0; i < height; i++) {
+                const v = vArray[i];
+                if (v == null || typeof v !== "object") {
+                    result[i] = null;
+                    continue;
+                }
+                const newObj = {};
+                const origKeys = Object.keys(v);
+                const origLen = origKeys.length;
+                for (let k = 0; k < origLen; k++) {
+                    const key = origKeys[k];
+                    newObj[key] = v[key];
+                }
+                for (let j = 0; j < keysLen; j++) {
+                    const oldKey = keys[j];
+                    if (oldKey in newObj) {
+                        const newKey = mapping[oldKey];
+                        newObj[newKey] = newObj[oldKey];
+                        delete newObj[oldKey];
+                    }
+                }
+                result[i] = newObj;
+            }
+            return result;
+        });
+    }
+    with_fields(fields) {
+        return (0, ExprBase_1.derive)(this.expr, (vArray, columns) => {
+            const height = vArray.length;
+            const result = new Array(height);
+            const resolved = [];
+            if (Array.isArray(fields)) {
+                const fieldsLen = fields.length;
+                for (let j = 0; j < fieldsLen; j++) {
+                    const f = fields[j];
+                    const expr = toColExpr(f);
+                    const name = expr.outputName || expr.colName;
+                    if (!name) {
+                        throw new Error("Expressions passed to struct.with_fields must have a name/alias.");
+                    }
+                    resolved.push({ name, expr });
+                }
+            }
+            else if (fields && typeof fields === "object") {
+                const keys = Object.keys(fields);
+                const keysLen = keys.length;
+                for (let j = 0; j < keysLen; j++) {
+                    const name = keys[j];
+                    const expr = toColExpr(fields[name]);
+                    resolved.push({ name, expr });
+                }
+            }
+            const resolvedLen = resolved.length;
+            const fieldValues = new Array(resolvedLen);
+            for (let j = 0; j < resolvedLen; j++) {
+                fieldValues[j] = resolved[j].expr.evaluate(columns, height);
+            }
+            for (let i = 0; i < height; i++) {
+                const v = vArray[i];
+                if (v == null || typeof v !== "object") {
+                    result[i] = null;
+                    continue;
+                }
+                const newObj = {};
+                const origKeys = Object.keys(v);
+                const origLen = origKeys.length;
+                for (let k = 0; k < origLen; k++) {
+                    const key = origKeys[k];
+                    newObj[key] = v[key];
+                }
+                for (let j = 0; j < resolvedLen; j++) {
+                    newObj[resolved[j].name] = fieldValues[j][i];
+                }
+                result[i] = newObj;
+            }
+            return result;
+        });
+    }
+    unnest() {
+        const newInst = (0, ExprBase_1.derive)(this.expr);
+        newInst.isUnnest = true;
+        newInst.baseExpr = this.expr;
+        return newInst;
+    }
+}
+exports.StructExprNamespace = StructExprNamespace;
+class StructExpr extends ExprBase_1.ExprBase {
+    get struct() {
+        return new StructExprNamespace(this);
+    }
+}
+exports.StructExpr = StructExpr;

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/TemporalExpr.js

@@ -2,25 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemporalExpr = exports.DateTimeExprNamespace = void 0;
 const ExprBase_1 = require("../ExprBase");
-const utils_1 = require("../../utils");
+const utils_1 = require("../utils");
+const utils_2 = require("../../utils");
 class DateTimeExprNamespace {
     expr;
     constructor(expr) {
         this.expr = expr;
     }
     _deriveDate(fn) {
-        return (0, ExprBase_1.derive)(this.expr, (0, ExprBase_1.kleeneUnary)((v) => {
-            const d = (0, utils_1.toValidDate)(v);
+        return (0, ExprBase_1.derive)(this.expr, (0, utils_1.kleeneUnary)((v) => {
+            const d = (0, utils_2.toValidDate)(v);
             return d ? fn(d) : null;
         }));
     }
     _deriveDuration(fn) {
-        return (0, ExprBase_1.derive)(this.expr, (0, ExprBase_1.kleeneUnary)((v) => {
+        return (0, ExprBase_1.derive)(this.expr, (0, utils_1.kleeneUnary)((v) => {
             return typeof v === "number" ? fn(v) : null;
         }));
     }
     century() {
-        return this._deriveDate(utils_1.getCentury);
+        return this._deriveDate(utils_2.getCentury);
     }
     date() {
         return this._deriveDate((d) => new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate())));
@@ -32,19 +33,19 @@ class DateTimeExprNamespace {
         return this._deriveDate((d) => d.getUTCDate());
     }
     epoch(unit = "ms") {
-        return this._deriveDate((d) => (0, utils_1.toEpoch)(d, unit));
+        return this._deriveDate((d) => (0, utils_2.toEpoch)(d, unit));
     }
     hour() {
         return this._deriveDate((d) => d.getUTCHours());
     }
     is_leap_year() {
-        return this._deriveDate(utils_1.isLeapYear);
+        return this._deriveDate(utils_2.isLeapYear);
     }
     microsecond() {
-        return this._deriveDate((d) => d.getUTCMilliseconds() * utils_1.US_PER_MS);
+        return this._deriveDate((d) => d.getUTCMilliseconds() * utils_2.US_PER_MS);
     }
     millennium() {
-        return this._deriveDate(utils_1.getMillennium);
+        return this._deriveDate(utils_2.getMillennium);
     }
     millisecond() {
         return this._deriveDate((d) => d.getUTCMilliseconds());
@@ -56,25 +57,25 @@ class DateTimeExprNamespace {
         return this._deriveDate((d) => d.getUTCMonth() + 1);
     }
     month_end() {
-        return this._deriveDate((d) => (0, utils_1.getMonthOffset)(d, 1, 0));
+        return this._deriveDate((d) => (0, utils_2.getMonthOffset)(d, 1, 0));
     }
     month_start() {
-        return this._deriveDate((d) => (0, utils_1.getMonthOffset)(d, 0, 1));
+        return this._deriveDate((d) => (0, utils_2.getMonthOffset)(d, 0, 1));
     }
     nanosecond() {
-        return this._deriveDate((d) => d.getUTCMilliseconds() * utils_1.NS_PER_MS);
+        return this._deriveDate((d) => d.getUTCMilliseconds() * utils_2.NS_PER_MS);
     }
     ordinal_day() {
-        return this._deriveDate(utils_1.getOrdinalDay);
+        return this._deriveDate(utils_2.getOrdinalDay);
     }
     quarter() {
-        return this._deriveDate(utils_1.getQuarter);
+        return this._deriveDate(utils_2.getQuarter);
     }
     second() {
         return this._deriveDate((d) => d.getUTCSeconds());
     }
     strftime(format, locale) {
-        return this._deriveDate((d) => (0, utils_1.strftime)(d, format, locale));
+        return this._deriveDate((d) => (0, utils_2.strftime)(d, format, locale));
     }
     time() {
         return this._deriveDate((d) => d.toISOString().split("T")[1].slice(0, 12));
@@ -86,28 +87,28 @@ class DateTimeExprNamespace {
         return this.strftime(format, locale);
     }
     total_days() {
-        return this._deriveDuration((v) => v / utils_1.MS_PER_DAY);
+        return this._deriveDuration((v) => v / utils_2.MS_PER_DAY);
     }
     total_hours() {
-        return this._deriveDuration((v) => v / utils_1.MS_PER_HOUR);
+        return this._deriveDuration((v) => v / utils_2.MS_PER_HOUR);
     }
     total_microseconds() {
-        return this._deriveDuration((v) => v * utils_1.US_PER_MS);
+        return this._deriveDuration((v) => v * utils_2.US_PER_MS);
     }
     total_milliseconds() {
         return this._deriveDuration((v) => v);
     }
     total_minutes() {
-        return this._deriveDuration((v) => v / utils_1.MS_PER_MINUTE);
+        return this._deriveDuration((v) => v / utils_2.MS_PER_MINUTE);
     }
     total_nanoseconds() {
-        return this._deriveDuration((v) => v * utils_1.NS_PER_MS);
+        return this._deriveDuration((v) => v * utils_2.NS_PER_MS);
     }
     total_seconds() {
-        return this._deriveDuration((v) => v / utils_1.MS_PER_SECOND);
+        return this._deriveDuration((v) => v / utils_2.MS_PER_SECOND);
     }
     week() {
-        return this._deriveDate(utils_1.getISOWeek);
+        return this._deriveDate(utils_2.getISOWeek);
     }
     weekday() {
         return this._deriveDate((d) => d.getUTCDay() || 7);
@@ -117,11 +118,9 @@ class DateTimeExprNamespace {
     }
 }
 exports.DateTimeExprNamespace = DateTimeExprNamespace;
-const TemporalExpr = (Base) => {
-    return class extends Base {
-        get dt() {
-            return new DateTimeExprNamespace(this);
-        }
-    };
-};
+class TemporalExpr extends ExprBase_1.ExprBase {
+    get dt() {
+        return new DateTimeExprNamespace(this);
+    }
+}
 exports.TemporalExpr = TemporalExpr;

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;
+}