@ohos-ports/nodejs-polars 0.22.2-beta.0

package/bin/datatypes/index.d.ts

@@ -0,0 +1,42 @@
+export * from "./conversion";
+export * from "./datatype";
+export { Field } from "./field";
+import { type DataType } from "./datatype";
+/** @ignore */
+export type TypedArray = Int8Array | Int16Array | Int32Array | BigInt64Array | Uint8Array | Uint16Array | Uint32Array | BigInt64Array | Float32Array | Float64Array;
+/**
+ *  @ignore
+ */
+export type Optional<T> = T | undefined | null;
+/**
+ * @ignore
+ */
+export type JsDataFrame = any;
+export type NullValues = string | Array<string> | Record<string, string>;
+/**
+ * @ignore
+ */
+export declare const DTYPE_TO_FFINAME: {
+    Int8: string;
+    Int16: string;
+    Int32: string;
+    Int64: string;
+    UInt8: string;
+    UInt16: string;
+    UInt32: string;
+    UInt64: string;
+    Float32: string;
+    Float64: string;
+    Bool: string;
+    Utf8: string;
+    String: string;
+    List: string;
+    Date: string;
+    Datetime: string;
+    Time: string;
+    Object: string;
+    Categorical: string;
+    Struct: string;
+};
+/** @ignore */
+export declare const polarsTypeToConstructor: (dtype: DataType) => CallableFunction;

package/bin/datatypes/index.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polarsTypeToConstructor = exports.DTYPE_TO_FFINAME = exports.Field = void 0;
+__exportStar(require("./conversion"), exports);
+__exportStar(require("./datatype"), exports);
+var field_1 = require("./field");
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return field_1.Field; } });
+const polars_internal_1 = __importDefault(require("../internals/polars_internal"));
+const datatype_1 = require("./datatype");
+/**
+ * @ignore
+ */
+exports.DTYPE_TO_FFINAME = {
+    Int8: "I8",
+    Int16: "I16",
+    Int32: "I32",
+    Int64: "I64",
+    UInt8: "U8",
+    UInt16: "U16",
+    UInt32: "U32",
+    UInt64: "U64",
+    Float32: "F32",
+    Float64: "F64",
+    Bool: "Bool",
+    Utf8: "Str",
+    String: "Str",
+    List: "List",
+    Date: "Date",
+    Datetime: "Datetime",
+    Time: "Time",
+    Object: "Object",
+    Categorical: "Categorical",
+    Struct: "Struct",
+};
+const POLARS_TYPE_TO_CONSTRUCTOR = {
+    Float32(name, values) {
+        return polars_internal_1.default.JsSeries.newOptF64(name, values);
+    },
+    Float64(name, values) {
+        return polars_internal_1.default.JsSeries.newOptF64(name, values);
+    },
+    Int8(name, values) {
+        return polars_internal_1.default.JsSeries.newOptI32(name, values);
+    },
+    Int16(name, values) {
+        return polars_internal_1.default.JsSeries.newOptI32(name, values);
+    },
+    Int32(name, values) {
+        return polars_internal_1.default.JsSeries.newOptI32(name, values);
+    },
+    Int64(name, values) {
+        return polars_internal_1.default.JsSeries.newOptI64(name, values);
+    },
+    UInt8(name, values) {
+        return polars_internal_1.default.JsSeries.newOptU32(name, values);
+    },
+    UInt16(name, values) {
+        return polars_internal_1.default.JsSeries.newOptU32(name, values);
+    },
+    UInt32(name, values) {
+        return polars_internal_1.default.JsSeries.newOptU32(name, values);
+    },
+    UInt64(name, values) {
+        return polars_internal_1.default.JsSeries.newOptU64(name, values);
+    },
+    Date(name, values) {
+        return polars_internal_1.default.JsSeries.newOptI64(name, values);
+    },
+    Datetime(name, values) {
+        return polars_internal_1.default.JsSeries.newOptI64(name, values);
+    },
+    Time(name, values) {
+        return polars_internal_1.default.JsSeries.newAnyValue(name, values, datatype_1.Time);
+    },
+    Bool(name, values) {
+        return polars_internal_1.default.JsSeries.newOptBool(name, values);
+    },
+    Utf8(name, values) {
+        return polars_internal_1.default.JsSeries.newOptStr(name, values);
+    },
+    String(name, values) {
+        return polars_internal_1.default.JsSeries.newOptStr(name, values);
+    },
+    Categorical(name, values) {
+        return polars_internal_1.default.JsSeries.newOptStr(name, values);
+    },
+    List(name, values, dtype) {
+        return polars_internal_1.default.JsSeries.newList(name, values, dtype);
+    },
+    FixedSizeList(name, values, dtype) {
+        return polars_internal_1.default.JsSeries.newList(name, values, dtype);
+    },
+};
+/** @ignore */
+const polarsTypeToConstructor = (dtype) => {
+    const ctor = POLARS_TYPE_TO_CONSTRUCTOR[dtype.variant];
+    if (!ctor) {
+        throw new Error(`Cannot construct Series for type ${dtype.variant}.`);
+    }
+    return ctor;
+};
+exports.polarsTypeToConstructor = polarsTypeToConstructor;

package/bin/error.d.ts

@@ -0,0 +1,7 @@
+export declare class InvalidOperationError extends RangeError {
+    constructor(method: any, dtype: any);
+}
+export declare class NotImplemented extends Error {
+    constructor(method: any, dtype: any);
+}
+export declare const todo: () => Error;

package/bin/error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.todo = exports.NotImplemented = exports.InvalidOperationError = void 0;
+class InvalidOperationError extends RangeError {
+    constructor(method, dtype) {
+        super(`Invalid operation: ${method} is not supported for ${dtype}`);
+    }
+}
+exports.InvalidOperationError = InvalidOperationError;
+class NotImplemented extends Error {
+    constructor(method, dtype) {
+        super(`Invalid operation: ${method} is not supported for ${dtype}`);
+    }
+}
+exports.NotImplemented = NotImplemented;
+const todo = () => new Error("not yet implemented");
+exports.todo = todo;

package/bin/functions.d.ts

@@ -0,0 +1,26 @@
+import { type DataFrame } from "./dataframe";
+import { type LazyDataFrame } from "./lazy/dataframe";
+import { type Series } from "./series";
+import type { ConcatOptions } from "./types";
+/**
+ * _Repeat a single value n times and collect into a Series._
+ * @param value - Value to repeat.
+ * @param n - Number of repeats
+ * @param name - Optional name of the Series
+ * @example
+ *
+ * ```
+ *
+ * >  const s = pl.repeat("a", 5)
+ * >  s.toArray()
+ * ["a", "a", "a", "a", "a"]
+ *
+ * ```
+ */
+export declare function repeat<V>(value: V, n: number, name?: string): Series;
+export declare function concat(items: Array<DataFrame>, options?: ConcatOptions): DataFrame;
+export declare function concat(items: Array<Series>, options?: {
+    rechunk: boolean;
+    parallel: boolean;
+}): Series;
+export declare function concat(items: Array<LazyDataFrame>, options?: ConcatOptions): LazyDataFrame;

package/bin/functions.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repeat = repeat;
+exports.concat = concat;
+const dataframe_1 = require("./dataframe");
+const construction_1 = require("./internals/construction");
+const polars_internal_1 = __importDefault(require("./internals/polars_internal"));
+const dataframe_2 = require("./lazy/dataframe");
+const series_1 = require("./series");
+const utils_1 = require("./utils");
+/**
+ * _Repeat a single value n times and collect into a Series._
+ * @param value - Value to repeat.
+ * @param n - Number of repeats
+ * @param name - Optional name of the Series
+ * @example
+ *
+ * ```
+ *
+ * >  const s = pl.repeat("a", 5)
+ * >  s.toArray()
+ * ["a", "a", "a", "a", "a"]
+ *
+ * ```
+ */
+function repeat(value, n, name = "") {
+    const dtype = (0, construction_1.jsTypeToPolarsType)(value);
+    const s = polars_internal_1.default.JsSeries.repeat(name, value, n, dtype);
+    return (0, series_1._Series)(s);
+}
+/**
+ * Aggregate all the Dataframes/Series in a List of DataFrames/Series to a single DataFrame/Series.
+ * @param items DataFrames/Series/LazyFrames to concatenate.
+ * @param options.rechunk Make sure that the result data is in contiguous memory.
+ * @param options.how Only used if the items are DataFrames. *Defaults to 'vertical'*
+ *     - vertical: Applies multiple `vstack` operations.
+ *     - verticalRelaxed: Same as `vertical`, but additionally coerces columns to their common supertype *if* they are mismatched (eg: Int32 → Int64).
+ *     - horizontal: Stacks Series horizontally and fills with nulls if the lengths don't match.
+ *     - diagonal: Finds a union between the column schemas and fills missing column values with ``null``.
+ *     - diagonalRelaxed: Same as `diagonal`, but additionally coerces columns to their common supertype *if* they are mismatched (eg: Int32 → Int64).
+ *     - align, alignFull, alignLeft, alignRight: Combines frames horizontally,
+ *       auto-determining the common key columns and aligning rows using the same
+ *       logic as `alignFrames` (note that "align" is an alias for "alignFull").
+ *       The "align" strategy determines the type of join used to align the frames,
+ *       equivalent to the "how" parameter on `alignFrames`. Note that the common join columns are automatically coalesced, but other column collisions
+ *       will raise an error (if you need more control over this you should use a suitable `join` method directly).
+ * @param options.parallel - Only relevant for LazyFrames. This determines if the concatenated lazy computations may be executed in parallel.
+ * @example
+ * > const df1 = pl.DataFrame({"a": [1], "b": [3]});
+ * > const df2 = pl.DataFrame({"a": [2], "b": [4]});
+ * > pl.concat([df1, df2]);
+ * shape: (2, 2)
+ * ┌─────┬─────┐
+ * │ a   ┆ b   │
+ * │ --- ┆ --- │
+ * │ i64 ┆ i64 │
+ * ╞═════╪═════╡
+ * │ 1   ┆ 3   │
+ * ├╌╌╌╌╌┼╌╌╌╌╌┤
+ * │ 2   ┆ 4   │
+ * └─────┴─────┘
+ *
+ * > const a = pl.DataFrame({ a: ["a", "b"], b: [1, 2] });
+ * > const b = pl.DataFrame({ c: [5, 6], d: [7, 8], e: [9, 10]});
+ * > pl.concat([a, b], { how: "horizontal" });
+ *
+ * shape: (2, 5)
+ * ┌─────┬─────┬─────┬─────┬──────┐
+ * │ a   ┆ b   ┆ c   ┆ d   ┆ e    │
+ * │ --- ┆ --- ┆ --- ┆ --- ┆ ---  │
+ * │ str ┆ f64 ┆ f64 ┆ f64 ┆ f64  │
+ * ╞═════╪═════╪═════╪═════╪══════╡
+ * │ a   ┆ 1.0 ┆ 5.0 ┆ 7.0 ┆ 9.0  │
+ * │ b   ┆ 2.0 ┆ 6.0 ┆ 8.0 ┆ 10.0 │
+ * └─────┴─────┴─────┴─────┴──────┘
+ *
+ * > const df_d1 = pl.DataFrame({"a": [1], "b": [3]});
+ * > const df_d2 = pl.DataFrame({"a": [2], "c": [4]});
+ * > pl.concat([df_d1, df_d2], { how: "diagonal" });
+ *
+ * shape: (2, 3)
+ * ┌─────┬──────┬──────┐
+ * │ a   ┆ b    ┆ c    │
+ * │ --- ┆ ---  ┆ ---  │
+ * │ i64 ┆ i64  ┆ i64  │
+ * ╞═════╪══════╪══════╡
+ * │ 1   ┆ 3    ┆ null │
+ * │ 2   ┆ null ┆ 4    │
+ * └─────┴──────┴──────┘
+ *
+ *  The "align" strategies require at least one common column to align on:
+
+  >>> const df1 = pl.DataFrame({"id": [1, 2], "x": [3, 4]});
+  >>> const df2 = pl.DataFrame({"id": [2, 3], "y": [5, 6]});
+  >>> const df3 = pl.DataFrame({"id": [1, 3], "z": [7, 8]});
+  >>> pl.concat([df1, df2, df3], how="align"); // equivalent to "alignFull"
+  shape: (3, 4)
+  ┌─────┬──────┬──────┬──────┐
+  │ id  ┆ x    ┆ y    ┆ z    │
+  │ --- ┆ ---  ┆ ---  ┆ ---  │
+  │ i64 ┆ i64  ┆ i64  ┆ i64  │
+  ╞═════╪══════╪══════╪══════╡
+  │ 1   ┆ 3    ┆ null ┆ 7    │
+  │ 2   ┆ 4    ┆ 5    ┆ null │
+  │ 3   ┆ null ┆ 6    ┆ 8    │
+  └─────┴──────┴──────┴──────┘
+  >>> pl.concat([df1, df2, df3], how="alignLeft");
+  shape: (2, 4)
+  ┌─────┬─────┬──────┬──────┐
+  │ id  ┆ x   ┆ y    ┆ z    │
+  │ --- ┆ --- ┆ ---  ┆ ---  │
+  │ i64 ┆ i64 ┆ i64  ┆ i64  │
+  ╞═════╪═════╪══════╪══════╡
+  │ 1   ┆ 3   ┆ null ┆ 7    │
+  │ 2   ┆ 4   ┆ 5    ┆ null │
+  └─────┴─────┴──────┴──────┘
+  >>> pl.concat([df1, df2, df3], how="alignRight");
+  shape: (2, 4)
+  ┌─────┬──────┬──────┬─────┐
+  │ id  ┆ x    ┆ y    ┆ z   │
+  │ --- ┆ ---  ┆ ---  ┆ --- │
+  │ i64 ┆ i64  ┆ i64  ┆ i64 │
+  ╞═════╪══════╪══════╪═════╡
+  │ 1   ┆ null ┆ null ┆ 7   │
+  │ 3   ┆ null ┆ 6    ┆ 8   │
+  └─────┴──────┴──────┴─────┘
+  >>> pl.concat([df1, df2, df3], how="alignInner");
+  shape: (0, 4)
+  ┌─────┬─────┬─────┬─────┐
+  │ id  ┆ x   ┆ y   ┆ z   │
+  │ --- ┆ --- ┆ --- ┆ --- │
+  │ i64 ┆ i64 ┆ i64 ┆ i64 │
+  ╞═════╪═════╪═════╪═════╡
+  └─────┴─────┴─────┴─────┘
+ */
+const computeAlignParams = (items, how) => {
+    const commonCols = (0, utils_1.commonValue)(...items.map((c) => c.columns));
+    const uniqueCols = [...new Set(items.flatMap((c) => c.columns))].sort();
+    // Join methods allowed: "full" | "left" | "inner" | "semi" | "anti" | undefined
+    const joinMethod = how === "align"
+        ? "full"
+        : how.replace("align", "").toLocaleLowerCase();
+    return { commonCols, uniqueCols, joinMethod };
+};
+function concat(items, options = { rechunk: true, parallel: true, how: "vertical" }) {
+    const { rechunk, how, parallel } = options;
+    if (!items.length) {
+        throw new RangeError("cannot concat empty list");
+    }
+    // short-circuit common single-item cases early for all types
+    if (items.length === 1)
+        return items[0];
+    if ((0, utils_1.isDataFrameArray)(items)) {
+        let df;
+        switch (how) {
+            case "align":
+            case "alignFull":
+            case "alignInner":
+            case "alignLeft":
+            case "alignRight": {
+                const { commonCols, uniqueCols, joinMethod } = computeAlignParams(items, how);
+                df = (0, dataframe_1._DataFrame)(items.reduce((acc, curr) => acc.join(curr, { on: commonCols, how: joinMethod, coalesce: true })))
+                    ._df.sort(commonCols)
+                    .select(uniqueCols);
+                break;
+            }
+            case "vertical":
+                df = items.reduce((acc, curr) => acc.vstack(curr));
+                break;
+            case "verticalRelaxed":
+            case "diagonalRelaxed":
+                df = (0, dataframe_2._LazyDataFrame)(polars_internal_1.default.concatLf(items.map((i) => i.inner().lazy()), how, rechunk ?? false, parallel ?? true, true, // to_supertypes
+                true)).collectSync();
+                break;
+            case "horizontal":
+                df = (0, dataframe_1._DataFrame)(polars_internal_1.default.horizontalConcat(items.map((i) => i.inner())));
+                break;
+            case "diagonal":
+                df = (0, dataframe_1._DataFrame)(polars_internal_1.default.diagonalConcat(items.map((i) => i.inner())));
+                break;
+            default:
+                throw new TypeError("unknown concat how option");
+        }
+        return rechunk ? df.rechunk() : df;
+    }
+    if ((0, utils_1.isLazyDataFrameArray)(items)) {
+        let df;
+        if (how?.startsWith("align")) {
+            const { commonCols, uniqueCols, joinMethod } = computeAlignParams(items, how);
+            df = (0, dataframe_2._LazyDataFrame)(items.reduce((acc, curr) => acc.join(curr, { on: commonCols, how: joinMethod, coalesce: true })))
+                ._ldf.sort(commonCols)
+                .select(uniqueCols);
+        }
+        else {
+            df = (0, dataframe_2._LazyDataFrame)(polars_internal_1.default.concatLf(items.map((i) => i.inner()), how, rechunk ?? false, parallel ?? true, true, // to_supertypes
+            true));
+        }
+        return df;
+    }
+    if ((0, utils_1.isSeriesArray)(items)) {
+        const s = items.reduce((acc, curr) => acc.concat(curr));
+        return rechunk ? s.rechunk() : s;
+    }
+    throw new TypeError("can only concat series and dataframes");
+}

package/bin/groupby.d.ts

@@ -0,0 +1,173 @@
+import { type DataFrame } from "./dataframe";
+import type { Expr } from "./lazy/expr";
+import type { ColumnsOrExpr, StartBy } from "./utils";
+declare const inspect: unique symbol;
+/**
+ * Starts a new GroupBy operation.
+ */
+export interface GroupBy {
+    [inspect](): string;
+    /**
+     * Aggregate the groups into Series.
+     */
+    aggList(): DataFrame;
+    /**
+     * __Use multiple aggregations on columns.__
+     * This can be combined with complete lazy API and is considered idiomatic polars.
+     * ___
+     * @param columns - map of 'col' -> 'agg'
+     *
+     *  - using lazy API (recommended): `[col('foo').sum(), col('bar').min()]`
+     *  - using multiple aggs per column: `{'foo': ['sum', 'numUnique'], 'bar': ['min'] }`
+     *  - using single agg per column:  `{'foo': ['sum'], 'bar': 'min' }`
+     * @example
+     * ```
+     * // use lazy api rest parameter style
+     * > df.groupBy('foo', 'bar')
+     * >   .agg(pl.sum('ham'), col('spam').tail(4).sum())
+     *
+     * // use lazy api array style
+     * > df.groupBy('foo', 'bar')
+     * >   .agg([pl.sum('ham'), col('spam').tail(4).sum()])
+     *
+     * // use a mapping
+     * > df.groupBy('foo', 'bar')
+     * >   .agg({'spam': ['sum', 'min']})
+     *
+     * ```
+     */
+    agg(...columns: Expr[]): DataFrame;
+    agg(columns: Record<string, keyof Expr | (keyof Expr)[]>): DataFrame;
+    /**
+     * Return the number of rows in each group.
+     */
+    len(): DataFrame;
+    /**
+     * Aggregate the first values in the group.
+     */
+    first(): DataFrame;
+    /**
+     * Return a `DataFrame` with:
+     *   - the groupby keys
+     *   - the group indexes aggregated as lists
+     */
+    groups(): DataFrame;
+    /**
+     * Return first n rows of each group.
+     * @param n -Number of values of the group to select
+     * @example
+     * ```
+     * > df = pl.DataFrame({
+     * >   "letters": ["c", "c", "a", "c", "a", "b"],
+     * >   "nrs": [1, 2, 3, 4, 5, 6]
+     * > })
+     * > df
+     * shape: (6, 2)
+     * ╭─────────┬─────╮
+     * │ letters ┆ nrs │
+     * │ ---     ┆ --- │
+     * │ str     ┆ i64 │
+     * ╞═════════╪═════╡
+     * │ "c"     ┆ 1   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "c"     ┆ 2   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "a"     ┆ 3   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "c"     ┆ 4   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "a"     ┆ 5   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "b"     ┆ 6   │
+     * ╰─────────┴─────╯
+     * > df.groupby("letters")
+     * >   .head(2)
+     * >   .sort("letters");
+     * > >>
+     * shape: (5, 2)
+     * ╭─────────┬─────╮
+     * │ letters ┆ nrs │
+     * │ ---     ┆ --- │
+     * │ str     ┆ i64 │
+     * ╞═════════╪═════╡
+     * │ "a"     ┆ 3   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "a"     ┆ 5   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "b"     ┆ 6   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "c"     ┆ 1   │
+     * ├╌╌╌╌╌╌╌╌╌┼╌╌╌╌╌┤
+     * │ "c"     ┆ 2   │
+     * ╰─────────┴─────╯
+     * ```
+     */
+    head(n?: number): DataFrame;
+    /**
+     * Aggregate the last values in the group.
+     */
+    last(): DataFrame;
+    /**
+     * Reduce the groups to the maximal value.
+     */
+    max(): DataFrame;
+    /**
+     * Reduce the groups to the mean values.
+     */
+    mean(): DataFrame;
+    /**
+     * Return the median per group.
+     */
+    median(): DataFrame;
+    /**
+     * Reduce the groups to the minimal value.
+     */
+    min(): DataFrame;
+    /**
+     * Count the unique values per group.
+     */
+    nUnique(): DataFrame;
+    /**
+     * Do a pivot operation based on the group key, a pivot column and an aggregation function on the values column.
+     * @param pivotCol - Column to pivot.
+     * @param valuesCol - Column that will be aggregated.
+     *
+     */
+    pivot(pivotCol: string, valuesCol: string): PivotOps;
+    pivot({ pivotCol, valuesCol, }: {
+        pivotCol: string;
+        valuesCol: string;
+    }): PivotOps;
+    /**
+     * Compute the quantile per group.
+     */
+    quantile(quantile: number): DataFrame;
+    /**
+     * Reduce the groups to the sum.
+     */
+    sum(): DataFrame;
+    tail(n?: number): DataFrame;
+    toString(): string;
+}
+export type PivotOps = Pick<GroupBy, "len" | "first" | "max" | "mean" | "median" | "min" | "sum"> & {
+    [inspect](): string;
+};
+/** @ignore */
+export declare function _GroupBy(df: any, by: string[], maintainOrder?: boolean): GroupBy;
+/**
+ * intermediate state of a rolling groupby
+ */
+export interface RollingGroupBy {
+    agg(column: ColumnsOrExpr, ...columns: ColumnsOrExpr[]): DataFrame;
+}
+/** @ignore */
+export declare function RollingGroupBy(df: any, indexColumn: ColumnsOrExpr, period: string, offset?: string, closed?: any, by?: ColumnsOrExpr): RollingGroupBy;
+/**
+ * intermediate state of a dynamic groupby
+ */
+export interface DynamicGroupBy {
+    agg(column: ColumnsOrExpr, ...columns: ColumnsOrExpr[]): DataFrame;
+}
+/** @ignore */
+export declare function DynamicGroupBy(df: any, indexColumn: string, every: string, period?: string, offset?: string, label?: string, includeBoundaries?: boolean, closed?: string, by?: ColumnsOrExpr, startBy?: StartBy): DynamicGroupBy;
+export {};