df-script 1.9.0 → 2.0.0

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

@@ -12,80 +12,88 @@ export declare class AggregationExpr extends ExprBase {
      * Aggregation: Returns true if all values in the group are truthy.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A", "B"], val: [true, true, false] })
-     * >>> df.group_by("group").agg($df.col("val").all().alias("all_true"))
-     * shape: (2, 2)
-     * ┌───────┬──────────┐
-     * │ group │ all_true │
-     * ├───────┼──────────┤
-     * │ "A"   │ true     │
-     * │ "B"   │ false    │
-     * └───────┴──────────┘
+ * >>> const df = $df.data({ a: [true, true, false, false], b: [true, false, true, false] })
+ * >>> df
+ * shape: (4, 2)
+ * ┌───────┬───────┐
+ * │ a     │ b     │
+ * ├───────┼───────┤
+ * │ true  │ true  │
+ * │ true  │ false │
+ * │ false │ true  │
+ * │ false │ false │
+ * └───────┴───────┘
+     * >>> df.select($df.col("a").all().alias("all_true"))
+     * shape: (1, 1)
+     * ┌──────────┐
+     * │ all_true │
+     * ├──────────┤
+     * │ false    │
+     * └──────────┘
      */
     all(): this;
-    /**
-     * Aggregation: Checks if all values in the group are null.
-     * @returns ColumnExpression
-     * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [null, null] })
-     * >>> df.group_by("group").agg($df.col("val").all_null().alias("is_null"))
-     * shape: (1, 2)
-     * ┌───────┬─────────┐
-     * │ group │ is_null │
-     * ├───────┼─────────┤
-     * │ "A"   │ true    │
-     * └───────┴─────────┘
-     */
-    all_null(): this;
     /**
      * Aggregation: Checks if any value in the group is truthy.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A", "B"], val: [true, false, false] })
-     * >>> df.group_by("group").agg($df.col("val").any().alias("any_true"))
-     * shape: (2, 2)
-     * ┌───────┬──────────┐
-     * │ group │ any_true │
-     * ├───────┼──────────┤
-     * │ "A"   │ true     │
-     * │ "B"   │ false    │
-     * └───────┴──────────┘
+ * >>> const df = $df.data({ a: [true, true, false, false], b: [true, false, true, false] })
+ * >>> df
+ * shape: (4, 2)
+ * ┌───────┬───────┐
+ * │ a     │ b     │
+ * ├───────┼───────┤
+ * │ true  │ true  │
+ * │ true  │ false │
+ * │ false │ true  │
+ * │ false │ false │
+ * └───────┴───────┘
+     * >>> df.select($df.col("a").any().alias("any_true"))
+     * shape: (1, 1)
+     * ┌──────────┐
+     * │ any_true │
+     * ├──────────┤
+     * │ true     │
+     * └──────────┘
      */
     any(): this;
-    /**
-     * Aggregation: Checks if any value in the group is null.
-     * @returns ColumnExpression
-     * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [10, null] })
-     * >>> df.group_by("group").agg($df.col("val").any_null().alias("has_null"))
-     * shape: (1, 2)
-     * ┌───────┬──────────┐
-     * │ group │ has_null │
-     * ├───────┼──────────┤
-     * │ "A"   │ true     │
-     * └───────┴──────────┘
-     */
-    any_null(): this;
     /**
      * Aggregation: Finds the index of the maximum value in the group.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 50, 20] })
-     * >>> df.select($df.col("val").arg_max().alias("max_idx"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.select($df.col("val").argMax().alias("max_idx"))
      * shape: (1, 1)
      * ┌─────────┐
      * │ max_idx │
      * ├─────────┤
-     * │ 1       │
+     * │ 2       │
      * └─────────┘
      */
-    arg_max(): this;
+    argMax(): this;
     /**
      * Aggregation: Finds the index of the minimum value in the group.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 50, 20] })
-     * >>> df.select($df.col("val").arg_min().alias("min_idx"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.select($df.col("val").argMin().alias("min_idx"))
      * shape: (1, 1)
      * ┌─────────┐
      * │ min_idx │
@@ -93,18 +101,28 @@ export declare class AggregationExpr extends ExprBase {
      * │ 0       │
      * └─────────┘
      */
-    arg_min(): this;
+    argMin(): this;
     /**
      * Aggregation: Computes the arithmetic mean of the group.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [10, 20] })
-     * >>> df.group_by("group").agg($df.col("val").avg().alias("mean"))
-     * shape: (1, 2)
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.groupBy("group").agg($df.col("val").avg().alias("mean"))
+     * shape: (2, 2)
      * ┌───────┬──────┐
      * │ group │ mean │
      * ├───────┼──────┤
-     * │ "A"   │ 15   │
+     * │ A     │ 15   │
+     * │ B     │ 30   │
      * └───────┴──────┘
      */
     avg(): this;
@@ -112,22 +130,40 @@ export declare class AggregationExpr extends ExprBase {
      * Aggregation: Computes bitwise AND across all elements in the group.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [0b11, 0b10] })
-     * >>> df.select($df.col("val").bitwise_and().alias("res"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.select($df.col("a").bitwiseAnd().alias("res"))
      * shape: (1, 1)
      * ┌─────┐
      * │ res │
      * ├─────┤
-     * │ 2   │
+     * │ 0   │
      * └─────┘
      */
-    bitwise_and(): this;
+    bitwiseAnd(): this;
     /**
      * Aggregation: Computes bitwise OR across all elements in the group.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [0b01, 0b10] })
-     * >>> df.select($df.col("val").bitwise_or().alias("res"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.select($df.col("a").bitwiseOr().alias("res"))
      * shape: (1, 1)
      * ┌─────┐
      * │ res │
@@ -135,28 +171,46 @@ export declare class AggregationExpr extends ExprBase {
      * │ 3   │
      * └─────┘
      */
-    bitwise_or(): this;
+    bitwiseOr(): this;
     /**
      * Aggregation: Computes bitwise XOR across all elements in the group.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [0b11, 0b10] })
-     * >>> df.select($df.col("val").bitwise_xor().alias("res"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.select($df.col("a").bitwiseXor().alias("res"))
      * shape: (1, 1)
      * ┌─────┐
      * │ res │
      * ├─────┤
-     * │ 1   │
+     * │ 0   │
      * └─────┘
      */
-    bitwise_xor(): this;
+    bitwiseXor(): this;
     /**
      * Aggregation: Computes the Pearson correlation coefficient between two columns.
      * @param other The target column expression to correlate with.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ x: [1, 2, 3], y: [2, 4, 6] })
-     * >>> df.select($df.col("x").corr($df.col("y")).alias("correlation"))
+ * >>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───┬────┐
+ * │ a │ b  │
+ * ├───┼────┤
+ * │ 1 │ 10 │
+ * │ 2 │ 20 │
+ * │ 3 │ 30 │
+ * └───┴────┘
+     * >>> df.select($df.col("a").corr($df.col("b")).alias("correlation"))
      * shape: (1, 1)
      * ┌─────────────┐
      * │ correlation │
@@ -170,13 +224,23 @@ export declare class AggregationExpr extends ExprBase {
      * @param options Config flags including whether to count null values.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [10, null] })
-     * >>> df.group_by("group").agg($df.col("val").count().alias("cnt"))
-     * shape: (1, 2)
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.groupBy("group").agg($df.col("val").count().alias("cnt"))
+     * shape: (2, 2)
      * ┌───────┬─────┐
      * │ group │ cnt │
      * ├───────┼─────┤
-     * │ "A"   │ 1   │
+     * │ A     │ 2   │
+     * │ B     │ 1   │
      * └───────┴─────┘
      */
     count(options?: {
@@ -187,13 +251,22 @@ export declare class AggregationExpr extends ExprBase {
      * @param other The target column expression to compute covariance with.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ x: [1, 2, 3], y: [2, 4, 6] })
-     * >>> df.select($df.col("x").cov($df.col("y")).alias("covariance"))
+ * >>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───┬────┐
+ * │ a │ b  │
+ * ├───┼────┤
+ * │ 1 │ 10 │
+ * │ 2 │ 20 │
+ * │ 3 │ 30 │
+ * └───┴────┘
+     * >>> df.select($df.col("a").cov($df.col("b")).alias("covariance"))
      * shape: (1, 1)
      * ┌────────────┐
      * │ covariance │
      * ├────────────┤
-     * │ 2          │
+     * │ 10         │
      * └────────────┘
      */
     cov(other: any): this;
@@ -202,13 +275,22 @@ export declare class AggregationExpr extends ExprBase {
      * @param other The other column expression to compute the dot product with.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ x: [1, 2, 3], y: [2, 3, 4] })
-     * >>> df.select($df.col("x").dot($df.col("y")).alias("dot_product"))
+ * >>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───┬────┐
+ * │ a │ b  │
+ * ├───┼────┤
+ * │ 1 │ 10 │
+ * │ 2 │ 20 │
+ * │ 3 │ 30 │
+ * └───┴────┘
+     * >>> df.select($df.col("a").dot($df.col("b")).alias("dot_product"))
      * shape: (1, 1)
      * ┌─────────────┐
      * │ dot_product │
      * ├─────────────┤
-     * │ 20          │
+     * │ 140         │
      * └─────────────┘
      */
     dot(other: any): this;
@@ -217,13 +299,22 @@ export declare class AggregationExpr extends ExprBase {
      * @param options Entropy options ({ base?: number, normalize?: boolean }, default base=Math.E, normalize=true).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: ["a", "b", "a", "c"] })
-     * >>> df.select($df.col("val").entropy().alias("h"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.select($df.col("a").entropy().alias("h"))
      * shape: (1, 1)
      * ┌──────────┐
      * │ h        │
      * ├──────────┤
-     * │ 1.039721 │
+     * │ 1.386294 │
      * └──────────┘
      */
     entropy(options?: EntropyOptions): this;
@@ -231,27 +322,70 @@ export declare class AggregationExpr extends ExprBase {
      * Aggregation: Finds the first value in the group.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [10, 20] })
-     * >>> df.group_by("group").agg($df.col("val").first().alias("first_val"))
-     * shape: (1, 2)
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.groupBy("group").agg($df.col("val").first().alias("first_val"))
+     * shape: (2, 2)
      * ┌───────┬───────────┐
      * │ group │ first_val │
      * ├───────┼───────────┤
-     * │ "A"   │ 10        │
+     * │ A     │ 10        │
+     * │ B     │ 30        │
      * └───────┴───────────┘
      */
     first(): this;
+    /**
+     * Aggregation: Checks if any value in the group is null.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌──────┬──────┐
+ * │ a    │ b    │
+ * ├──────┼──────┤
+ * │ 1    │ null │
+ * │ null │ 2    │
+ * │ 3    │ null │
+ * └──────┴──────┘
+     * >>> df.select($df.col("a").hasNulls().alias("has_nulls"))
+     * shape: (1, 1)
+     * ┌───────────┐
+     * │ has_nulls │
+     * ├───────────┤
+     * │ true      │
+     * └───────────┘
+     */
+    hasNulls(): this;
     /**
      * Aggregation: Combines all values in the group into a single array/list cell.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [10, 20] })
-     * >>> df.group_by("group").agg($df.col("val").implode().alias("list_val"))
-     * shape: (1, 2)
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.groupBy("group").agg($df.col("val").implode().alias("list_val"))
+     * shape: (2, 2)
      * ┌───────┬──────────┐
      * │ group │ list_val │
      * ├───────┼──────────┤
-     * │ "A"   │ [10, 20] │
+     * │ A     │ [10, 20] │
+     * │ B     │ [30]     │
      * └───────┴──────────┘
      */
     implode(): this;
@@ -260,13 +394,22 @@ export declare class AggregationExpr extends ExprBase {
      * @param options Kurtosis calculation options ({ fisher?: boolean, bias?: boolean }, default fisher=true, bias=true).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [1, 2, 3, 4, 5] })
-     * >>> df.select($df.col("val").kurtosis().alias("kurt"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.select($df.col("a").kurtosis().alias("kurt"))
      * shape: (1, 1)
      * ┌───────┐
      * │ kurt  │
      * ├───────┤
-     * │ -1.3  │
+     * │ -1.36 │
      * └───────┘
      */
     kurtosis(options?: KurtosisOptions): this;
@@ -274,13 +417,23 @@ export declare class AggregationExpr extends ExprBase {
      * Aggregation: Finds the last value in the group.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [10, 20] })
-     * >>> df.group_by("group").agg($df.col("val").last().alias("last_val"))
-     * shape: (1, 2)
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.groupBy("group").agg($df.col("val").last().alias("last_val"))
+     * shape: (2, 2)
      * ┌───────┬──────────┐
      * │ group │ last_val │
      * ├───────┼──────────┤
-     * │ "A"   │ 20       │
+     * │ A     │ 20       │
+     * │ B     │ 30       │
      * └───────┴──────────┘
      */
     last(): this;
@@ -288,13 +441,23 @@ export declare class AggregationExpr extends ExprBase {
      * Aggregation: Finds the maximum value in the group.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [10, 50] })
-     * >>> df.group_by("group").agg($df.col("val").max().alias("max_val"))
-     * shape: (1, 2)
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.groupBy("group").agg($df.col("val").max().alias("max_val"))
+     * shape: (2, 2)
      * ┌───────┬─────────┐
      * │ group │ max_val │
      * ├───────┼─────────┤
-     * │ "A"   │ 50      │
+     * │ A     │ 20      │
+     * │ B     │ 30      │
      * └───────┴─────────┘
      */
     max(): this;
@@ -303,27 +466,46 @@ export declare class AggregationExpr extends ExprBase {
      * @param by Column or expression to order by.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ name: ["a", "b", "c"], score: [10, 50, 20] })
-     * >>> df.select($df.col("name").max_by($df.col("score")).alias("top_scorer"))
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.select($df.col("group").maxBy($df.col("val")).alias("top_group"))
      * shape: (1, 1)
-     * ┌────────────┐
-     * │ top_scorer │
-     * ├────────────┤
-     * │ "b"        │
-     * └────────────┘
+     * ┌───────────┐
+     * │ top_group │
+     * ├───────────┤
+     * │ B         │
+     * └───────────┘
      */
-    max_by(by: any): this;
+    maxBy(by: any): this;
     /**
      * Aggregation: Computes the arithmetic mean of elements in the group.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [10, 30] })
-     * >>> df.group_by("group").agg($df.col("val").mean().alias("mean_val"))
-     * shape: (1, 2)
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.groupBy("group").agg($df.col("val").mean().alias("mean_val"))
+     * shape: (2, 2)
      * ┌───────┬──────────┐
      * │ group │ mean_val │
      * ├───────┼──────────┤
-     * │ "A"   │ 20       │
+     * │ A     │ 15       │
+     * │ B     │ 30       │
      * └───────┴──────────┘
      */
     mean(): this;
@@ -331,13 +513,23 @@ export declare class AggregationExpr extends ExprBase {
      * Aggregation: Computes the 50th percentile median.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A", "A"], val: [10, 50, 20] })
-     * >>> df.group_by("group").agg($df.col("val").median().alias("med"))
-     * shape: (1, 2)
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.groupBy("group").agg($df.col("val").median().alias("med"))
+     * shape: (2, 2)
      * ┌───────┬─────┐
      * │ group │ med │
      * ├───────┼─────┤
-     * │ "A"   │ 20  │
+     * │ A     │ 15  │
+     * │ B     │ 30  │
      * └───────┴─────┘
      */
     median(): this;
@@ -345,13 +537,23 @@ export declare class AggregationExpr extends ExprBase {
      * Aggregation: Finds the minimum value in the group.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [10, 50] })
-     * >>> df.group_by("group").agg($df.col("val").min().alias("min_val"))
-     * shape: (1, 2)
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.groupBy("group").agg($df.col("val").min().alias("min_val"))
+     * shape: (2, 2)
      * ┌───────┬─────────┐
      * │ group │ min_val │
      * ├───────┼─────────┤
-     * │ "A"   │ 10      │
+     * │ A     │ 10      │
+     * │ B     │ 30      │
      * └───────┴─────────┘
      */
     min(): this;
@@ -360,28 +562,46 @@ export declare class AggregationExpr extends ExprBase {
      * @param by Column or expression to order by.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ name: ["a", "b", "c"], score: [10, 50, 20] })
-     * >>> df.select($df.col("name").min_by($df.col("score")).alias("lowest_scorer"))
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.select($df.col("group").minBy($df.col("val")).alias("lowest_group"))
      * shape: (1, 1)
      * ┌──────────────┐
-     * │ lowest_scorer│
+     * │ lowest_group │
      * ├──────────────┤
-     * │ "a"          │
+     * │ A            │
      * └──────────────┘
      */
-    min_by(by: any): this;
+    minBy(by: any): this;
     /**
      * Aggregation: Finds the statistical mode (most frequent value).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A", "A"], val: [5, 5, 10] })
-     * >>> df.group_by("group").agg($df.col("val").mode().alias("mode_val"))
-     * shape: (1, 2)
-     * ┌───────┬──────────┐
-     * │ group │ mode_val │
-     * ├───────┼──────────┤
-     * │ "A"   │ 5        │
-     * └───────┴──────────┘
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.select($df.col("group").mode().alias("mode_group"))
+     * shape: (1, 1)
+     * ┌────────────┐
+     * │ mode_group │
+     * ├────────────┤
+     * │ ["A"]      │
+     * └────────────┘
      */
     mode(): this;
     /**
@@ -389,85 +609,140 @@ export declare class AggregationExpr extends ExprBase {
      * @param options Uniqueness options.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A", "A"], val: [5, 5, 10] })
-     * >>> df.group_by("group").agg($df.col("val").n_unique().alias("unique_cnt"))
-     * shape: (1, 2)
-     * ┌───────┬────────────┐
-     * │ group │ unique_cnt │
-     * ├───────┼────────────┤
-     * │ "A"   │ 2          │
-     * └───────┴────────────┘
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.select($df.col("group").nUnique().alias("unique_cnt"))
+     * shape: (1, 1)
+     * ┌────────────┐
+     * │ unique_cnt │
+     * ├────────────┤
+     * │ 2          │
+     * └────────────┘
      */
-    n_unique(options?: UniqueArrayStatsOptions): this;
+    nUnique(options?: UniqueArrayStatsOptions): this;
     /**
      * Aggregation: Finds the maximum value in the group, taking NaN values into account (NaN propagates).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [10, NaN] })
-     * >>> df.group_by("group").agg($df.col("val").nan_max().alias("nan_max_val"))
-     * shape: (1, 2)
-     * ┌───────┬─────────────┐
-     * │ group │ nan_max_val │
-     * ├───────┼─────────────┤
-     * │ "A"   │ NaN         │
-     * └───────┴─────────────┘
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.select($df.col("val").nanMax().alias("nan_max_val"))
+     * shape: (1, 1)
+     * ┌─────────────┐
+     * │ nan_max_val │
+     * ├─────────────┤
+     * │ 30          │
+     * └─────────────┘
      */
-    nan_max(): this;
+    nanMax(): this;
     /**
      * Aggregation: Finds the minimum value in the group, taking NaN values into account (NaN propagates).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [10, NaN] })
-     * >>> df.group_by("group").agg($df.col("val").nan_min().alias("nan_min_val"))
-     * shape: (1, 2)
-     * ┌───────┬─────────────┐
-     * │ group │ nan_min_val │
-     * ├───────┼─────────────┤
-     * │ "A"   │ NaN         │
-     * └───────┴─────────────┘
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.select($df.col("val").nanMin().alias("nan_min_val"))
+     * shape: (1, 1)
+     * ┌─────────────┐
+     * │ nan_min_val │
+     * ├─────────────┤
+     * │ 10          │
+     * └─────────────┘
      */
-    nan_min(): this;
+    nanMin(): this;
     /**
      * Aggregation: Counts the number of null or missing records.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [10, null] })
-     * >>> df.group_by("group").agg($df.col("val").null_count().alias("nulls"))
-     * shape: (1, 2)
-     * ┌───────┬───────┐
-     * │ group │ nulls │
-     * ├───────┼───────┤
-     * │ "A"   │ 1     │
-     * └───────┴───────┘
+ * >>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌──────┬──────┐
+ * │ a    │ b    │
+ * ├──────┼──────┤
+ * │ 1    │ null │
+ * │ null │ 2    │
+ * │ 3    │ null │
+ * └──────┴──────┘
+     * >>> df.select($df.col("a").nullCount().alias("nulls"))
+     * shape: (1, 1)
+     * ┌───────┐
+     * │ nulls │
+     * ├───────┤
+     * │ 1     │
+     * └───────┘
      */
-    null_count(): this;
+    nullCount(): this;
     /**
      * Aggregation: Computes the specific quantile values (0.0 to 1.0).
      * @param q The quantile parameter value between 0.0 and 1.0.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 20, 30, 40] })
-     * >>> df.select($df.col("val").quantile(0.75).alias("q75"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.select($df.col("a").quantile(0.75).alias("q75"))
      * shape: (1, 1)
-     * ┌─────┐
-     * │ q75 │
-     * ├─────┤
-     * │ 32.5│
-     * └─────┘
+     * ┌──────┐
+     * │ q75  │
+     * ├──────┤
+     * │ 3.25 │
+     * └──────┘
      */
     quantile(q: number): this;
     /**
      * Aggregation: Computes the product of all elements in the group.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [2, 5] })
-     * >>> df.group_by("group").agg($df.col("val").product().alias("p"))
-     * shape: (1, 2)
-     * ┌───────┬────┐
-     * │ group │ p  │
-     * ├───────┼────┤
-     * │ "A"   │ 10 │
-     * └───────┴────┘
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.groupBy("group").agg($df.col("val").product().alias("p"))
+     * shape: (2, 2)
+     * ┌───────┬─────┐
+     * │ group │ p   │
+     * ├───────┼─────┤
+     * │ A     │ 200 │
+     * │ B     │ 30  │
+     * └───────┴─────┘
      */
     product(): this;
     /**
@@ -475,24 +750,41 @@ export declare class AggregationExpr extends ExprBase {
      * @param options Skew calculation options ({ bias?: boolean }, default bias=true).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [1, 2, 5, 10, 20] })
-     * >>> df.select($df.col("val").skew().alias("skewness"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.select($df.col("a").skew().alias("skewness"))
      * shape: (1, 1)
      * ┌──────────┐
      * │ skewness │
      * ├──────────┤
-     * │ 0.859427 │
+     * │ 0        │
      * └──────────┘
      */
     skew(options?: SkewOptions): this;
     /**
      * Aggregation: Computes the Spearman rank correlation coefficient.
-
      * @param other The other column expression to correlate with.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ x: [1, 2, 3], y: [5, 6, 7] })
-     * >>> df.select($df.col("x").spearman_corr($df.col("y")).alias("spearman"))
+ * >>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───┬────┐
+ * │ a │ b  │
+ * ├───┼────┤
+ * │ 1 │ 10 │
+ * │ 2 │ 20 │
+ * │ 3 │ 30 │
+ * └───┴────┘
+     * >>> df.select($df.col("a").spearmanCorr($df.col("b")).alias("spearman"))
      * shape: (1, 1)
      * ┌──────────┐
      * │ spearman │
@@ -500,32 +792,51 @@ export declare class AggregationExpr extends ExprBase {
      * │ 1        │
      * └──────────┘
      */
-    spearman_corr(other: any): this;
+    spearmanCorr(other: any): this;
     /**
      * Aggregation: Computes sample standard deviation.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A", "A"], val: [10, 20, 30] })
-     * >>> df.group_by("group").agg($df.col("val").std().alias("std_dev"))
-     * shape: (1, 2)
-     * ┌───────┬─────────┐
-     * │ group │ std_dev │
-     * ├───────┼─────────┤
-     * │ "A"   │ 10      │
-     * └───────┴─────────┘
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.select($df.col("val").std().alias("std_dev"))
+     * shape: (1, 1)
+     * ┌─────────┐
+     * │ std_dev │
+     * ├─────────┤
+     * │ 10      │
+     * └─────────┘
      */
     std(): this;
     /**
      * Aggregation: Computes the sum of elements in the group.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [10, 20] })
-     * >>> df.group_by("group").agg($df.col("val").sum().alias("total"))
-     * shape: (1, 2)
+ * >>> const df = $df.data({ group: ["A", "A", "B"], val: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───────┬─────┐
+ * │ group │ val │
+ * ├───────┼─────┤
+ * │ A     │ 10  │
+ * │ A     │ 20  │
+ * │ B     │ 30  │
+ * └───────┴─────┘
+     * >>> df.groupBy("group").agg($df.col("val").sum().alias("total"))
+     * shape: (2, 2)
      * ┌───────┬───────┐
      * │ group │ total │
      * ├───────┼───────┤
-     * │ "A"   │ 30    │
+     * │ A     │ 30    │
+     * │ B     │ 30    │
      * └───────┴───────┘
      */
     sum(): this;
@@ -533,14 +844,23 @@ export declare class AggregationExpr extends ExprBase {
      * Aggregation: Computes sample variance.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ group: ["A", "A", "A"], val: [10, 20, 30] })
-     * >>> df.group_by("group").agg($df.col("val").variance().alias("v"))
-     * shape: (1, 2)
-     * ┌───────┬─────┐
-     * │ group │ v   │
-     * ├───────┼─────┤
-     * │ "A"   │ 100 │
-     * └───────┴─────┘
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.select($df.col("val").variance().alias("v"))
+     * shape: (1, 1)
+     * ┌─────┐
+     * │ v   │
+     * ├─────┤
+     * │ 100 │
+     * └─────┘
      */
     variance(): this;
     /**
@@ -548,14 +868,23 @@ export declare class AggregationExpr extends ExprBase {
      * @param weights The weight values or column expression.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: [10, 20], weight: [1, 3] })
-     * >>> df.select($df.col("val").w_avg($df.col("weight")).alias("w_mean"))
+ * >>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───┬────┐
+ * │ a │ b  │
+ * ├───┼────┤
+ * │ 1 │ 10 │
+ * │ 2 │ 20 │
+ * │ 3 │ 30 │
+ * └───┴────┘
+     * >>> df.select($df.col("a").wAvg($df.col("b")).alias("w_mean"))
      * shape: (1, 1)
-     * ┌────────┐
-     * │ w_mean │
-     * ├────────┤
-     * │ 17.5   │
-     * └────────┘
+     * ┌──────────┐
+     * │ w_mean   │
+     * ├──────────┤
+     * │ 2.333333 │
+     * └──────────┘
      */
-    w_avg(weights: any): this;
+    wAvg(weights: any): this;
 }