df-script 1.8.0 → 2.0.0

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

@@ -0,0 +1,3234 @@
+import type { IExpr, AggFn, SkewOptions, KurtosisOptions, EntropyOptions, FillNullOptions, RollingOptions } from "../../types";
+import type { RandomOptions, NumericArg, IsCloseOptions } from "../types";
+import { ExprBase } from "../ExprBase";
+import { UniqueArrayStatsOptions } from "../../utils";
+/**
+ * @namespace $df.col
+ * @category ColumnExpression
+ * @syntax $df.col(<column_name>).{symbol}(...)
+ */
+export declare class StandardExpr extends ExprBase {
+    _cum(reverse: boolean, initialVal: any, stepFn: (acc: any, val: any) => any, postFn?: (acc: any, hasValid: boolean) => any): this;
+    _deriveAgg(fn: AggFn<any>): this;
+    _deriveAggBinary(other: any, fn: AggFn<[any, any]>): this;
+    get _isWindow(): boolean;
+    _window(evaluateWindow: (this: IExpr, groupPreValues: any[], partitionIndices: number[], currentIndex: number) => any): this;
+    /**
+     * Computes the absolute value of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").abs().alias("abs_a"))
+     * shape: (3, 2)
+     * ┌───┬───────┐
+     * │ a │ abs_a │
+     * ├───┼───────┤
+     * │ 1 │ 1     │
+     * │ 2 │ 2     │
+     * │ 3 │ 3     │
+     * └───┴───────┘
+     */
+    abs(): this;
+    /**
+     * Adds a scalar value or another column expression.
+     * @param val The number or column expression to add.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").add(10).alias("added"))
+     * shape: (3, 2)
+     * ┌───┬───────┐
+     * │ a │ added │
+     * ├───┼───────┤
+     * │ 1 │ 11    │
+     * │ 2 │ 12    │
+     * │ 3 │ 13    │
+     * └───┴───────┘
+     */
+    add(val: NumericArg): this;
+    /**
+     * Aggregation: Returns true if all values in the group are truthy.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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({ 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").allNull().alias("all_null"))
+     * shape: (1, 1)
+     * ┌──────────┐
+     * │ all_null │
+     * ├──────────┤
+     * │ false    │
+     * └──────────┘
+     */
+    allNull(): this;
+    /**
+     * Logical AND check supporting Kleene logic.
+     * @param other The other boolean column expression or literal value to compare.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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.withColumns($df.col("a").and($df.col("b")).alias("and_res"))
+     * shape: (4, 3)
+     * ┌───────┬───────┬─────────┐
+     * │ a     │ b     │ and_res │
+     * ├───────┼───────┼─────────┤
+     * │ true  │ true  │ true    │
+     * │ true  │ false │ false   │
+     * │ false │ false │ false   │
+     * │ null  │ true  │ null    │
+     * └───────┴───────┴─────────┘
+     */
+    and(other: any): this;
+    /**
+     * Aggregation: Checks if any value in the group is truthy.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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({ 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").anyNull().alias("has_null"))
+     * shape: (1, 1)
+     * ┌──────────┐
+     * │ has_null │
+     * ├──────────┤
+     * │ true     │
+     * └──────────┘
+     */
+    anyNull(): this;
+    /**
+     * Computes the mathematical arccosine (inverse cosine) of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").arccos().alias("arccos_a"))
+     * shape: (3, 2)
+     * ┌───┬──────────┐
+     * │ a │ arccos_a │
+     * ├───┼──────────┤
+     * │ 1 │ 0        │
+     * │ 2 │ null     │
+     * │ 3 │ null     │
+     * └───┴──────────┘
+     */
+    arccos(): this;
+    /**
+     * Computes the hyperbolic arccosine of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").arccosh().alias("arccosh_a"))
+     * shape: (3, 2)
+     * ┌───┬───────────┐
+     * │ a │ arccosh_a │
+     * ├───┼───────────┤
+     * │ 1 │ 0         │
+     * │ 2 │ 1.316958  │
+     * │ 3 │ 1.762747  │
+     * └───┴───────────┘
+     */
+    arccosh(): this;
+    /**
+     * Computes the arcsine of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").arcsin().alias("arcsin_a"))
+     * shape: (3, 2)
+     * ┌───┬──────────┐
+     * │ a │ arcsin_a │
+     * ├───┼──────────┤
+     * │ 1 │ 1.570796 │
+     * │ 2 │ null     │
+     * │ 3 │ null     │
+     * └───┴──────────┘
+     */
+    arcsin(): this;
+    /**
+     * Computes the hyperbolic arcsine of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").arcsinh().alias("arcsinh_a"))
+     * shape: (3, 2)
+     * ┌───┬───────────┐
+     * │ a │ arcsinh_a │
+     * ├───┼───────────┤
+     * │ 1 │ 0.881374  │
+     * │ 2 │ 1.443635  │
+     * │ 3 │ 1.818446  │
+     * └───┴───────────┘
+     */
+    arcsinh(): this;
+    /**
+     * Computes the arctangent of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").arctan().alias("arctan_a"))
+     * shape: (3, 2)
+     * ┌───┬──────────┐
+     * │ a │ arctan_a │
+     * ├───┼──────────┤
+     * │ 1 │ 0.785398 │
+     * │ 2 │ 1.107149 │
+     * │ 3 │ 1.249046 │
+     * └───┴──────────┘
+     */
+    arctan(): this;
+    /**
+     * Computes the quadrant-aware arctangent of two values.
+     * @param val The x denominator number or column expression.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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.withColumns($df.col("a").arctan2($df.col("b")).alias("arctan2_a"))
+     * shape: (3, 3)
+     * ┌───┬────┬───────────┐
+     * │ a │ b  │ arctan2_a │
+     * ├───┼────┼───────────┤
+     * │ 1 │ 10 │ 0.099669  │
+     * │ 2 │ 20 │ 0.099669  │
+     * │ 3 │ 30 │ 0.099669  │
+     * └───┴────┴───────────┘
+     */
+    arctan2(val: NumericArg): this;
+    /**
+     * Computes the hyperbolic arctangent of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").arctanh().alias("arctanh_a"))
+     * shape: (3, 2)
+     * ┌───┬───────────┐
+     * │ a │ arctanh_a │
+     * ├───┼───────────┤
+     * │ 1 │ null      │
+     * │ 2 │ null      │
+     * │ 3 │ null      │
+     * └───┴───────────┘
+     */
+    arctanh(): this;
+    /**
+     * Aggregation: Finds the index of the maximum value in the group.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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 │
+     * ├─────────┤
+     * │ 2       │
+     * └─────────┘
+     */
+    argMax(): this;
+    /**
+     * Aggregation: Finds the index of the minimum value in the group.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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 │
+     * ├─────────┤
+     * │ 0       │
+     * └─────────┘
+     */
+    argMin(): this;
+    /**
+     * Aggregation: Computes the arithmetic mean of the group.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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   │
+     * │ B     │ 30   │
+     * └───────┴──────┘
+     */
+    avg(): this;
+    /**
+     * Checks if values fall inside lower and upper boundaries (inclusive).
+     * @param lower The lower boundary value or expression.
+     * @param upper The upper boundary value or expression.
+     * @param closed Control boundary inclusivity: "both", "left", "right", or "none" (default: "both").
+     * @returns ColumnExpression
+     * @example
+ * >>> 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.withColumns($df.col("a").between(1, 2).alias("in_range"))
+     * shape: (3, 3)
+     * ┌───┬────┬──────────┐
+     * │ a │ b  │ in_range │
+     * ├───┼────┼──────────┤
+     * │ 1 │ 10 │ true     │
+     * │ 2 │ 20 │ true     │
+     * │ 3 │ 30 │ false    │
+     * └───┴────┴──────────┘
+     */
+    between(lower: any, upper: any, closed?: "both" | "left" | "right" | "none"): this;
+    /**
+     * Aggregation: Computes bitwise AND across all elements in the group.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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 │
+     * ├─────┤
+     * │ 0   │
+     * └─────┘
+     */
+    bitwiseAnd(): this;
+    /**
+     * Aggregation: Computes bitwise OR across all elements in the group.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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 │
+     * ├─────┤
+     * │ 3   │
+     * └─────┘
+     */
+    bitwiseOr(): this;
+    /**
+     * Aggregation: Computes bitwise XOR across all elements in the group.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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 │
+     * ├─────┤
+     * │ 0   │
+     * └─────┘
+     */
+    bitwiseXor(): this;
+    /**
+     * Computes the cube root of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").cbrt().alias("cbrt_a"))
+     * shape: (3, 2)
+     * ┌───┬──────────┐
+     * │ a │ cbrt_a   │
+     * ├───┼──────────┤
+     * │ 1 │ 1        │
+     * │ 2 │ 1.259921 │
+     * │ 3 │ 1.44225  │
+     * └───┴──────────┘
+     */
+    cbrt(): this;
+    /**
+     * Rounds column values up to the nearest integer.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").ceil().alias("ceil_a"))
+     * shape: (3, 2)
+     * ┌───┬────────┐
+     * │ a │ ceil_a │
+     * ├───┼────────┤
+     * │ 1 │ 1      │
+     * │ 2 │ 2      │
+     * │ 3 │ 3      │
+     * └───┴────────┘
+     */
+    ceil(): this;
+    /**
+     * Clamps column values between lower and upper numeric thresholds.
+     * @param lower The lower threshold value (default: null).
+     * @param upper The upper threshold value (default: null).
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").clip(2, 3).alias("clipped"))
+     * shape: (3, 2)
+     * ┌───┬─────────┐
+     * │ a │ clipped │
+     * ├───┼─────────┤
+     * │ 1 │ 2       │
+     * │ 2 │ 2       │
+     * │ 3 │ 3       │
+     * └───┴─────────┘
+     */
+    clip(lower?: number | null, upper?: number | null): this;
+    /**
+     * Returns absolute value of expr with the sign of other.
+     * @param val The sign source value or column expression.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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.withColumns($df.col("a").copysign($df.col("b")).alias("signed"))
+     * shape: (3, 3)
+     * ┌───┬────┬────────┐
+     * │ a │ b  │ signed │
+     * ├───┼────┼────────┤
+     * │ 1 │ 10 │ 1      │
+     * │ 2 │ 20 │ 2      │
+     * │ 3 │ 30 │ 3      │
+     * └───┴────┴────────┘
+     */
+    copysign(val: NumericArg): 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({ 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 │
+     * ├─────────────┤
+     * │ 1           │
+     * └─────────────┘
+     */
+    corr(other: any): this;
+    /**
+     * Computes the cosine of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").cos().alias("cos_a"))
+     * shape: (3, 2)
+     * ┌───┬───────────┐
+     * │ a │ cos_a     │
+     * ├───┼───────────┤
+     * │ 1 │ 0.540302  │
+     * │ 2 │ -0.416147 │
+     * │ 3 │ -0.989992 │
+     * └───┴───────────┘
+     */
+    cos(): this;
+    /**
+     * Computes the hyperbolic cosine of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").cosh().alias("cosh_a"))
+     * shape: (3, 2)
+     * ┌───┬───────────┐
+     * │ a │ cosh_a    │
+     * ├───┼───────────┤
+     * │ 1 │ 1.543081  │
+     * │ 2 │ 3.762196  │
+     * │ 3 │ 10.067662 │
+     * └───┴───────────┘
+     */
+    cosh(): this;
+    /**
+     * Computes the cotangent of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").cot().alias("cot_a"))
+     * shape: (3, 2)
+     * ┌───┬───────────┐
+     * │ a │ cot_a     │
+     * ├───┼───────────┤
+     * │ 1 │ 0.642093  │
+     * │ 2 │ -0.457658 │
+     * │ 3 │ -7.015253 │
+     * └───┴───────────┘
+     */
+    cot(): this;
+    /**
+     * Aggregation: Returns the count of records inside the group.
+     * @param options Config flags including whether to count null values.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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     │ 2   │
+     * │ B     │ 1   │
+     * └───────┴─────┘
+     */
+    count(options?: {
+        includeNulls?: boolean;
+    }): this;
+    /**
+     * Aggregation: Computes the covariance between two columns.
+     * @param other The target column expression to compute covariance with.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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 │
+     * ├────────────┤
+     * │ 10         │
+     * └────────────┘
+     */
+    cov(other: any): this;
+    /**
+     * Window: Computes cumulative count.
+     * @param reverse Flag indicating whether to compute from reverse direction.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").cumCount().alias("c_count"))
+     * shape: (3, 2)
+     * ┌─────┬─────────┐
+     * │ val │ c_count │
+     * ├─────┼─────────┤
+     * │ 10  │ 1       │
+     * │ 20  │ 2       │
+     * │ 30  │ 3       │
+     * └─────┴─────────┘
+     */
+    cumCount(reverse?: boolean): this;
+    /**
+     * Window: Computes cumulative maximum value.
+     * @param reverse Flag indicating whether to compute in reverse direction.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").cumMax().alias("c_max"))
+     * shape: (3, 2)
+     * ┌─────┬───────┐
+     * │ val │ c_max │
+     * ├─────┼───────┤
+     * │ 10  │ 10    │
+     * │ 20  │ 20    │
+     * │ 30  │ 30    │
+     * └─────┴───────┘
+     */
+    cumMax(reverse?: boolean): this;
+    /**
+     * Window: Computes cumulative minimum value.
+     * @param reverse Flag indicating whether to compute in reverse direction.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").cumMin().alias("c_min"))
+     * shape: (3, 2)
+     * ┌─────┬───────┐
+     * │ val │ c_min │
+     * ├─────┼───────┤
+     * │ 10  │ 10    │
+     * │ 20  │ 10    │
+     * │ 30  │ 10    │
+     * └─────┴───────┘
+     */
+    cumMin(reverse?: boolean): this;
+    /**
+     * Window: Computes cumulative product of values.
+     * @param reverse Flag indicating whether to compute in reverse direction.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").cumProd().alias("c_prod"))
+     * shape: (4, 2)
+     * ┌───┬────────┐
+     * │ a │ c_prod │
+     * ├───┼────────┤
+     * │ 1 │ 1      │
+     * │ 2 │ 2      │
+     * │ 3 │ 6      │
+     * │ 4 │ 24     │
+     * └───┴────────┘
+     */
+    cumProd(reverse?: boolean): this;
+    /**
+     * Window: Computes cumulative sum of values.
+     * @param reverse Flag indicating whether to compute in reverse direction.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").cumSum().alias("c_sum"))
+     * shape: (3, 2)
+     * ┌─────┬───────┐
+     * │ val │ c_sum │
+     * ├─────┼───────┤
+     * │ 10  │ 10    │
+     * │ 20  │ 30    │
+     * │ 30  │ 60    │
+     * └─────┴───────┘
+     */
+    cumSum(reverse?: boolean): this;
+    /**
+     * Converts angles from radians to degrees.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").degrees().alias("deg"))
+     * shape: (3, 2)
+     * ┌───┬────────────┐
+     * │ a │ deg        │
+     * ├───┼────────────┤
+     * │ 1 │ 57.29578   │
+     * │ 2 │ 114.591559 │
+     * │ 3 │ 171.887339 │
+     * └───┴────────────┘
+     */
+    degrees(): this;
+    /**
+     * Window: Computes dense rank (ranks without gaps) within group partition.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("score").denseRank().alias("dr"))
+     * shape: (2, 2)
+     * ┌───────┬────┐
+     * │ score │ dr │
+     * ├───────┼────┤
+     * │ 75    │ 1  │
+     * │ 95    │ 2  │
+     * └───────┴────┘
+     */
+    denseRank(): this;
+    /**
+     * Divides column values by a scalar or another column expression.
+     * @param val The denominator value or column expression.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").div(2).alias("div_a"))
+     * shape: (3, 2)
+     * ┌───┬───────┐
+     * │ a │ div_a │
+     * ├───┼───────┤
+     * │ 1 │ 0.5   │
+     * │ 2 │ 1     │
+     * │ 3 │ 1.5   │
+     * └───┴───────┘
+     */
+    div(val: NumericArg): this;
+    /**
+     * Aggregation: Computes the dot product with another column.
+     * @param other The other column expression to compute the dot product with.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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 │
+     * ├─────────────┤
+     * │ 140         │
+     * └─────────────┘
+     */
+    dot(other: any): this;
+    /**
+     * Aggregation: Computes the Shannon entropy of a column or group.
+     * @param options Entropy options ({ base?: number, normalize?: boolean }, default base=Math.E, normalize=true).
+     * @returns ColumnExpression
+     * @example
+ * >>> 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.386294 │
+     * └──────────┘
+     */
+    entropy(options?: EntropyOptions): this;
+    /**
+     * Boolean comparison: Returns true if column values match the specified value exactly.
+     * @param val The value or column expression to compare against.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").eq(2).alias("is_two"))
+     * shape: (3, 2)
+     * ┌───┬────────┐
+     * │ a │ is_two │
+     * ├───┼────────┤
+     * │ 1 │ false  │
+     * │ 2 │ true   │
+     * │ 3 │ false  │
+     * └───┴────────┘
+     */
+    eq(val: any): this;
+    /**
+     * Equivalence check that treats null values as equal to each other.
+     * @param val The value or column expression to compare against.
+     * @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.withColumns($df.col("a").eqMissing(null).alias("is_missing"))
+     * shape: (3, 2)
+     * ┌──────┬────────────┐
+     * │ a    │ is_missing │
+     * ├──────┼────────────┤
+     * │ 1    │ false      │
+     * │ null │ true       │
+     * │ 3    │ false      │
+     * └──────┴────────────┘
+     */
+    eqMissing(val: any): this;
+    /**
+     * Computes natural exponent (e^x) of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").exp().alias("exp_a"))
+     * shape: (3, 2)
+     * ┌───┬───────────┐
+     * │ a │ exp_a     │
+     * ├───┼───────────┤
+     * │ 1 │ 2.718282  │
+     * │ 2 │ 7.389056  │
+     * │ 3 │ 20.085537 │
+     * └───┴───────────┘
+     */
+    exp(): this;
+    /**
+     * Computes e^x - 1 for each element in the column.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").expm1().alias("expm1_a"))
+     * shape: (3, 2)
+     * ┌───┬───────────┐
+     * │ a │ expm1_a   │
+     * ├───┼───────────┤
+     * │ 1 │ 1.718282  │
+     * │ 2 │ 6.389056  │
+     * │ 3 │ 19.085537 │
+     * └───┴───────────┘
+     */
+    expm1(): this;
+    /**
+     * Replaces null, undefined, or missing values with a specified value or strategy.
+     * @param options Configuration options including fill value, strategy ("forward", "backward", "zero", "one", "mean", "min", "max"), and optional limit.
+     * @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.withColumns($df.col("a").fillNull({ value: 0 }).alias("filled"))
+     * shape: (3, 2)
+     * ┌──────┬────────┐
+     * │ a    │ filled │
+     * ├──────┼────────┤
+     * │ 1    │ 1      │
+     * │ null │ 0      │
+     * │ 3    │ 3      │
+     * └──────┴────────┘
+     */
+    fillNull({ value, strategy, limit }?: FillNullOptions): this;
+    /**
+     * Filters elements of the column expression where the predicate evaluates to truthy.
+     * @param predicate Boolean column expression used to filter values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.select($df.col("a").filter($df.col("a").gt(1)).alias("filtered"))
+     * shape: (2, 1)
+     * ┌──────────┐
+     * │ filtered │
+     * ├──────────┤
+     * │ 2        │
+     * │ 3        │
+     * └──────────┘
+     */
+    filter(predicate: IExpr): this;
+    /**
+     * Aggregation: Finds the first value in the group.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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        │
+     * │ B     │ 30        │
+     * └───────┴───────────┘
+     */
+    first(): this;
+    /**
+     * Rounds column values down to the nearest integer.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").floor().alias("floor_a"))
+     * shape: (3, 2)
+     * ┌───┬─────────┐
+     * │ a │ floor_a │
+     * ├───┼─────────┤
+     * │ 1 │ 1       │
+     * │ 2 │ 2       │
+     * │ 3 │ 3       │
+     * └───┴─────────┘
+     */
+    floor(): this;
+    /**
+     * Performs integer division floor(x / y) on column values.
+     * @param val The divisor value or column expression.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").floordiv(2).alias("fdiv"))
+     * shape: (3, 2)
+     * ┌───┬──────┐
+     * │ a │ fdiv │
+     * ├───┼──────┤
+     * │ 1 │ 0    │
+     * │ 2 │ 1    │
+     * │ 3 │ 1    │
+     * └───┴──────┘
+     */
+    floordiv(val: NumericArg): this;
+    /**
+     * Boolean comparison: Returns true if greater than or equal to argument.
+     * @param val The value or column expression to compare against.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").ge(2).alias("ge_two"))
+     * shape: (3, 2)
+     * ┌───┬────────┐
+     * │ a │ ge_two │
+     * ├───┼────────┤
+     * │ 1 │ false  │
+     * │ 2 │ true   │
+     * │ 3 │ true   │
+     * └───┴────────┘
+     */
+    ge(val: any): this;
+    /**
+     * Boolean comparison: Returns true if column value is greater than argument.
+     * @param val The value or column expression to compare against.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").gt(2).alias("gt_two"))
+     * shape: (3, 2)
+     * ┌───┬────────┐
+     * │ a │ gt_two │
+     * ├───┼────────┤
+     * │ 1 │ false  │
+     * │ 2 │ false  │
+     * │ 3 │ true   │
+     * └───┴────────┘
+     */
+    gt(val: any): 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;
+    /**
+     * Computes the hypotenuse sqrt(x^2 + y^2) of two values.
+     * @param val The other numeric value or column expression.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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.withColumns($df.col("a").hypot($df.col("b")).alias("hypot_a"))
+     * shape: (3, 3)
+     * ┌───┬────┬───────────┐
+     * │ a │ b  │ hypot_a   │
+     * ├───┼────┼───────────┤
+     * │ 1 │ 10 │ 10.049876 │
+     * │ 2 │ 20 │ 20.099751 │
+     * │ 3 │ 30 │ 30.149627 │
+     * └───┴────┴───────────┘
+     */
+    hypot(val: NumericArg): this;
+    /**
+     * Aggregation: Combines all values in the group into a single array/list cell.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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] │
+     * │ B     │ [30]     │
+     * └───────┴──────────┘
+     */
+    implode(): this;
+    /**
+     * Determines if floating-point values are approximately equal within tolerances.
+     * @param other The value or expression to compare against.
+     * @param options Tolerance values absolute (absTol) and relative (relTol), and NaN options.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").isClose(1.0).alias("close"))
+     * shape: (3, 2)
+     * ┌───┬───────┐
+     * │ a │ close │
+     * ├───┼───────┤
+     * │ 1 │ true  │
+     * │ 2 │ false │
+     * │ 3 │ false │
+     * └───┴───────┘
+     */
+    isClose(other: any, { absTol, relTol, nansEqual }?: IsCloseOptions): this;
+    /**
+     * Checks if values occur more than once in the column.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").isDuplicated().alias("dup"))
+     * shape: (3, 2)
+     * ┌───┬───────┐
+     * │ a │ dup   │
+     * ├───┼───────┤
+     * │ 1 │ false │
+     * │ 2 │ false │
+     * │ 3 │ false │
+     * └───┴───────┘
+     */
+    isDuplicated(): this;
+    /**
+     * Checks if values are finite numbers (not NaN or Infinity).
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").isFinite().alias("finite"))
+     * shape: (3, 2)
+     * ┌───┬────────┐
+     * │ a │ finite │
+     * ├───┼────────┤
+     * │ 1 │ true   │
+     * │ 2 │ true   │
+     * │ 3 │ true   │
+     * └───┴────────┘
+     */
+    isFinite(): this;
+    /**
+     * Checks if column values are members of a specified array or list.
+     * @param values An array of candidate values or a single value to match against.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").isIn(["apple", "banana"]).alias("in_list"))
+     * shape: (3, 2)
+     * ┌──────────┬─────────┐
+     * │ s        │ in_list │
+     * ├──────────┼─────────┤
+     * │ "apple"  │ true    │
+     * │ "banana" │ true    │
+     * │ "cherry" │ false   │
+     * └──────────┴─────────┘
+     */
+    isIn(values: any[] | any): this;
+    /**
+     * Checks if values are positive or negative Infinity.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").isInfinite().alias("inf"))
+     * shape: (3, 2)
+     * ┌───┬───────┐
+     * │ a │ inf   │
+     * ├───┼───────┤
+     * │ 1 │ false │
+     * │ 2 │ false │
+     * │ 3 │ false │
+     * └───┴───────┘
+     */
+    isInfinite(): this;
+    /**
+     * Checks if values are NaN.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").isNan().alias("nan"))
+     * shape: (3, 2)
+     * ┌───┬───────┐
+     * │ a │ nan   │
+     * ├───┼───────┤
+     * │ 1 │ false │
+     * │ 2 │ false │
+     * │ 3 │ false │
+     * └───┴───────┘
+     */
+    isNan(): this;
+    /**
+     * Checks if column values match the N-th distinct value by positive or negative index position.
+     * @param index The 0-based or negative index position into the ordered distinct values (e.g. 0 for first distinct, -1 for last distinct).
+     * @param nullOnOob If true, returns null if index is out of bounds (default: true).
+     * @returns ColumnExpression
+     * @example
+ * >>> 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.withColumns($df.col("a").isNDistinct(0).alias("is_first"))
+     * shape: (3, 3)
+     * ┌───┬────┬──────────┐
+     * │ a │ b  │ is_first │
+     * ├───┼────┼──────────┤
+     * │ 1 │ 10 │ true     │
+     * │ 2 │ 20 │ false    │
+     * │ 3 │ 30 │ false    │
+     * └───┴────┴──────────┘
+     */
+    isNDistinct(index: number, nullOnOob?: boolean): this;
+    /**
+     * Checks if values are not NaN.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").isNotNan().alias("not_nan"))
+     * shape: (3, 2)
+     * ┌───┬─────────┐
+     * │ a │ not_nan │
+     * ├───┼─────────┤
+     * │ 1 │ true    │
+     * │ 2 │ true    │
+     * │ 3 │ true    │
+     * └───┴─────────┘
+     */
+    isNotNan(): this;
+    /**
+     * Checks if column values are non-null and valid (not null, undefined, or missing).
+     * @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.withColumns($df.col("a").isNotNull().alias("valid"))
+     * shape: (3, 2)
+     * ┌──────┬───────┐
+     * │ a    │ valid │
+     * ├──────┼───────┤
+     * │ 1    │ true  │
+     * │ null │ false │
+     * │ 3    │ true  │
+     * └──────┴───────┘
+     */
+    isNotNull(): this;
+    /**
+     * Checks if column values are null, undefined, or missing.
+     * @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.withColumns($df.col("a").isNull().alias("missing"))
+     * shape: (3, 2)
+     * ┌──────┬─────────┐
+     * │ a    │ missing │
+     * ├──────┼─────────┤
+     * │ 1    │ false   │
+     * │ null │ true    │
+     * │ 3    │ false   │
+     * └──────┴─────────┘
+     */
+    isNull(): this;
+    /**
+     * Checks if values occur exactly once in the column.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").isUnique().alias("uniq"))
+     * shape: (3, 2)
+     * ┌───┬──────┐
+     * │ a │ uniq │
+     * ├───┼──────┤
+     * │ 1 │ true │
+     * │ 2 │ true │
+     * │ 3 │ true │
+     * └───┴──────┘
+     */
+    isUnique(): this;
+    /**
+     * Aggregation: Computes the kurtosis (peakedness/tailedness) of a numeric column.
+     * @param options Kurtosis calculation options ({ fisher?: boolean, bias?: boolean }, default fisher=true, bias=true).
+     * @returns ColumnExpression
+     * @example
+ * >>> 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.36 │
+     * └───────┘
+     */
+    kurtosis(options?: KurtosisOptions): this;
+    /**
+     * Window: Shifts values down by offset, filling missing slots with default value.
+     * @param offset Number of rows to shift down (default 1).
+     * @param defaultVal Fallback fill value for empty slots (default null).
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").lag(1, 0).alias("prev"))
+     * shape: (3, 2)
+     * ┌─────┬──────┐
+     * │ val │ prev │
+     * ├─────┼──────┤
+     * │ 10  │ 0    │
+     * │ 20  │ 10   │
+     * │ 30  │ 20   │
+     * └─────┴──────┘
+     */
+    lag(offset?: number, defaultVal?: any): this;
+    /**
+     * Aggregation: Finds the last value in the group.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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       │
+     * │ B     │ 30       │
+     * └───────┴──────────┘
+     */
+    last(): this;
+    /**
+     * Boolean comparison: Returns true if less than or equal to argument.
+     * @param val The value or column expression to compare against.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").le(2).alias("le_two"))
+     * shape: (3, 2)
+     * ┌───┬────────┐
+     * │ a │ le_two │
+     * ├───┼────────┤
+     * │ 1 │ true   │
+     * │ 2 │ true   │
+     * │ 3 │ false  │
+     * └───┴────────┘
+     */
+    le(val: any): this;
+    /**
+     * Window: Shifts values up by offset, filling missing slots with default value.
+     * @param offset Number of rows to shift up (default 1).
+     * @param defaultVal Fallback fill value for empty slots (default null).
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").lead(1, 0).alias("next"))
+     * shape: (3, 2)
+     * ┌─────┬──────┐
+     * │ val │ next │
+     * ├─────┼──────┤
+     * │ 10  │ 20   │
+     * │ 20  │ 30   │
+     * │ 30  │ 0    │
+     * └─────┴──────┘
+     */
+    lead(offset?: number, defaultVal?: any): this;
+    /**
+     * Computes the logarithm of positive values with a specified base.
+     * @param base The base of the logarithm (default: Math.E).
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").log(10).alias("log_a"))
+     * shape: (3, 2)
+     * ┌───┬──────────┐
+     * │ a │ log_a    │
+     * ├───┼──────────┤
+     * │ 1 │ 0        │
+     * │ 2 │ 0.30103  │
+     * │ 3 │ 0.477121 │
+     * └───┴──────────┘
+     */
+    log(base?: number): this;
+    /**
+     * Computes natural logarithm of 1 + x.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").log1p().alias("log1p_a"))
+     * shape: (3, 2)
+     * ┌───┬──────────┐
+     * │ a │ log1p_a  │
+     * ├───┼──────────┤
+     * │ 1 │ 0.693147 │
+     * │ 2 │ 1.098612 │
+     * │ 3 │ 1.386294 │
+     * └───┴──────────┘
+     */
+    log1p(): this;
+    /**
+     * Boolean comparison: Returns true if less than argument.
+     * @param val The value or column expression to compare against.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").lt(2).alias("lt_two"))
+     * shape: (3, 2)
+     * ┌───┬────────┐
+     * │ a │ lt_two │
+     * ├───┼────────┤
+     * │ 1 │ true   │
+     * │ 2 │ false  │
+     * │ 3 │ false  │
+     * └───┴────────┘
+     */
+    lt(val: any): this;
+    /**
+     * Aggregation: Finds the maximum value in the group.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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     │ 20      │
+     * │ B     │ 30      │
+     * └───────┴─────────┘
+     */
+    max(): this;
+    /**
+     * Aggregation: Finds the value in this column corresponding to the maximum value in the `by` expression.
+     * @param by Column or expression to order by.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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_group │
+     * ├───────────┤
+     * │ B         │
+     * └───────────┘
+     */
+    maxBy(by: any): this;
+    /**
+     * Aggregation: Computes the arithmetic mean of elements in the group.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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     │ 15       │
+     * │ B     │ 30       │
+     * └───────┴──────────┘
+     */
+    mean(): this;
+    /**
+     * Aggregation: Computes the 50th percentile median.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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     │ 15  │
+     * │ B     │ 30  │
+     * └───────┴─────┘
+     */
+    median(): this;
+    /**
+     * Aggregation: Finds the minimum value in the group.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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      │
+     * │ B     │ 30      │
+     * └───────┴─────────┘
+     */
+    min(): this;
+    /**
+     * Aggregation: Finds the value in this column corresponding to the minimum value in the `by` expression.
+     * @param by Column or expression to order by.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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_group │
+     * ├──────────────┤
+     * │ A            │
+     * └──────────────┘
+     */
+    minBy(by: any): this;
+    /**
+     * Computes modulo remainder (x % y) of column values.
+     * @param val The divisor value or column expression.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").mod(2).alias("mod_a"))
+     * shape: (3, 2)
+     * ┌───┬───────┐
+     * │ a │ mod_a │
+     * ├───┼───────┤
+     * │ 1 │ 1     │
+     * │ 2 │ 0     │
+     * │ 3 │ 1     │
+     * └───┴───────┘
+     */
+    mod(val: NumericArg): this;
+    /**
+     * Aggregation: Finds the statistical mode (most frequent value).
+     * @returns ColumnExpression
+     * @example
+ * >>> 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;
+    /**
+     * Multiplies column values by a scalar or another column expression.
+     * @param val The multiplier value or column expression.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").mul(5).alias("multiplied"))
+     * shape: (3, 2)
+     * ┌───┬────────────┐
+     * │ a │ multiplied │
+     * ├───┼────────────┤
+     * │ 1 │ 5          │
+     * │ 2 │ 10         │
+     * │ 3 │ 15         │
+     * └───┴────────────┘
+     */
+    mul(val: NumericArg): this;
+    /**
+     * Aggregation: Finds the maximum value in the group, taking NaN values into account (NaN propagates).
+     * @returns ColumnExpression
+     * @example
+ * >>> 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          │
+     * └─────────────┘
+     */
+    nanMax(): this;
+    /**
+     * Aggregation: Finds the minimum value in the group, taking NaN values into account (NaN propagates).
+     * @returns ColumnExpression
+     * @example
+ * >>> 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          │
+     * └─────────────┘
+     */
+    nanMin(): this;
+    /**
+     * Boolean comparison: Returns true if values do not match.
+     * @param val The value or column expression to compare against.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").ne(2).alias("not_two"))
+     * shape: (3, 2)
+     * ┌───┬─────────┐
+     * │ a │ not_two │
+     * ├───┼─────────┤
+     * │ 1 │ true    │
+     * │ 2 │ false   │
+     * │ 3 │ true    │
+     * └───┴─────────┘
+     */
+    ne(val: any): this;
+    /**
+     * Negates column values (-x).
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").negate().alias("negated"))
+     * shape: (3, 2)
+     * ┌───┬─────────┐
+     * │ a │ negated │
+     * ├───┼─────────┤
+     * │ 1 │ -1      │
+     * │ 2 │ -2      │
+     * │ 3 │ -3      │
+     * └───┴─────────┘
+     */
+    negate(): this;
+    /**
+     * Difference check that treats null values as equal to each other.
+     * @param val The value or column expression to compare against.
+     * @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.withColumns($df.col("a").neMissing(null).alias("not_missing"))
+     * shape: (3, 2)
+     * ┌──────┬─────────────┐
+     * │ a    │ not_missing │
+     * ├──────┼─────────────┤
+     * │ 1    │ true        │
+     * │ null │ false       │
+     * │ 3    │ true        │
+     * └──────┴─────────────┘
+     */
+    neMissing(val: any): this;
+    /**
+     * Logical negation.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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.withColumns($df.col("a").not().alias("not_a"))
+     * shape: (4, 3)
+     * ┌───────┬───────┬───────┐
+     * │ a     │ b     │ not_a │
+     * ├───────┼───────┼───────┤
+     * │ true  │ true  │ false │
+     * │ true  │ false │ false │
+     * │ false │ false │ true  │
+     * │ null  │ true  │ null  │
+     * └───────┴───────┴───────┘
+     */
+    not(): this;
+    /**
+     * Checks if values are not elements of a specific array or set list.
+     * @param values An array of candidate values or a single value to match against.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").notIn(["apple", "banana"]).alias("not_in"))
+     * shape: (3, 2)
+     * ┌──────────┬────────┐
+     * │ s        │ not_in │
+     * ├──────────┼────────┤
+     * │ "apple"  │ false  │
+     * │ "banana" │ false  │
+     * │ "cherry" │ true   │
+     * └──────────┴────────┘
+     */
+    notIn(values: any[] | any): this;
+    /**
+     * Aggregation: Counts the number of null or missing records.
+     * @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").nullCount().alias("nulls"))
+     * shape: (1, 1)
+     * ┌───────┐
+     * │ nulls │
+     * ├───────┤
+     * │ 1     │
+     * └───────┘
+     */
+    nullCount(): this;
+    /**
+     * Aggregation: Computes number of unique elements.
+     * @param options Uniqueness options.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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          │
+     * └────────────┘
+     */
+    nUnique(options?: UniqueArrayStatsOptions): this;
+    /**
+     * Logical OR check supporting Kleene logic.
+     * @param other The other boolean column expression or literal value to compare.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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.withColumns($df.col("a").or($df.col("b")).alias("or_res"))
+     * shape: (4, 3)
+     * ┌───────┬───────┬────────┐
+     * │ a     │ b     │ or_res │
+     * ├───────┼───────┼────────┤
+     * │ true  │ true  │ true   │
+     * │ true  │ false │ true   │
+     * │ false │ false │ false  │
+     * │ null  │ true  │ true   │
+     * └───────┴───────┴────────┘
+     */
+    or(other: any): this;
+    /**
+     * Executes a window aggregation partitioned by column keys.
+     * @param columns Column expression or array of columns to partition by.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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.withColumns($df.col("val").sum().over("group").alias("cat_sum"))
+     * shape: (3, 3)
+     * ┌───────┬─────┬─────────┐
+     * │ group │ val │ cat_sum │
+     * ├───────┼─────┼─────────┤
+     * │ A     │ 10  │ 30      │
+     * │ A     │ 20  │ 30      │
+     * │ B     │ 30  │ 30      │
+     * └───────┴─────┴─────────┘
+     */
+    over(columns: string | IExpr | (string | IExpr)[]): this;
+    /**
+     * Raises column values to the specified power.
+     * @param val The exponent power value or column expression.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").pow(2).alias("pow_a"))
+     * shape: (3, 2)
+     * ┌───┬───────┐
+     * │ a │ pow_a │
+     * ├───┼───────┤
+     * │ 1 │ 1     │
+     * │ 2 │ 4     │
+     * │ 3 │ 9     │
+     * └───┴───────┘
+     */
+    pow(val: NumericArg): this;
+    /**
+     * Aggregation: Computes the product of all elements in the group.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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;
+    /**
+     * 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({ 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  │
+     * ├──────┤
+     * │ 3.25 │
+     * └──────┘
+     */
+    quantile(q: number): this;
+    /**
+     * Converts angles from degrees to radians.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").radians().alias("rad"))
+     * shape: (3, 2)
+     * ┌───┬──────────┐
+     * │ a │ rad      │
+     * ├───┼──────────┤
+     * │ 1 │ 0.017453 │
+     * │ 2 │ 0.034907 │
+     * │ 3 │ 0.05236  │
+     * └───┴──────────┘
+     */
+    radians(): this;
+    /**
+     * Fills sequence with pseudo-random generated floats or integers.
+     * @param seed Optional seed to initialize the pseudo-random generator.
+     * @param options Config options including min, max, and integer flag.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").rand(42, { min: 1, max: 10, integer: true }).alias("random"))
+     * shape: (3, 2)
+     * ┌───┬────────┐
+     * │ a │ random │
+     * ├───┼────────┤
+     * │ 1 │ 7      │
+     * │ 2 │ 8      │
+     * │ 3 │ 6      │
+     * └───┴────────┘
+     */
+    rand(seed?: number, { min, max, integer }?: RandomOptions): this;
+    /**
+     * Window: Computes rank within group partition.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("score").rank().alias("rank"))
+     * shape: (2, 2)
+     * ┌───────┬──────┐
+     * │ score │ rank │
+     * ├───────┼──────┤
+     * │ 75    │ 1    │
+     * │ 95    │ 2    │
+     * └───────┴──────┘
+     */
+    rank(options?: {
+        dense?: boolean;
+    }): this;
+    /**
+     * Reverses the order of values in the column.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").reverse().alias("reversed"))
+     * shape: (3, 2)
+     * ┌───┬──────────┐
+     * │ a │ reversed │
+     * ├───┼──────────┤
+     * │ 1 │ 3        │
+     * │ 2 │ 2        │
+     * │ 3 │ 1        │
+     * └───┴──────────┘
+     */
+    reverse(): this;
+    /**
+     * Window: Computes a rolling window reduction using a ColumnExpression or a custom callback function.
+     * @param optionsOrWindowSize Window row count or RollingOptions configuration.
+     * @param exprOrFn ColumnExpression to evaluate over each window slice, or a custom reducer function.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rolling(2, $df.col("val").sum()).alias("r_sum"))
+     * shape: (3, 2)
+     * ┌─────┬───────┐
+     * │ val │ r_sum │
+     * ├─────┼───────┤
+     * │ 10  │ 10    │
+     * │ 20  │ 30    │
+     * │ 30  │ 50    │
+     * └─────┴───────┘
+     */
+    rolling(optionsOrWindowSize: number | RollingOptions, exprOrFn: IExpr | ((vals: any[]) => any)): this;
+    /**
+     * Window: Computes rolling window maximum value.
+     * @param windowSize Size of rolling window.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingMax(2).alias("r_max"))
+     * shape: (3, 2)
+     * ┌─────┬───────┐
+     * │ val │ r_max │
+     * ├─────┼───────┤
+     * │ 10  │ 10    │
+     * │ 20  │ 20    │
+     * │ 30  │ 30    │
+     * └─────┴───────┘
+     */
+    rollingMax(windowSize: number): this;
+    /**
+     * Window: Computes rolling window mean average.
+     * @param windowSize Size of rolling window.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingMean(2).alias("r_mean"))
+     * shape: (3, 2)
+     * ┌─────┬────────┐
+     * │ val │ r_mean │
+     * ├─────┼────────┤
+     * │ 10  │ 10     │
+     * │ 20  │ 15     │
+     * │ 30  │ 25     │
+     * └─────┴────────┘
+     */
+    rollingMean(windowSize: number): this;
+    /**
+     * Window: Computes rolling window median value.
+     * @param windowSize Size of rolling window.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingMedian(2).alias("r_med"))
+     * shape: (3, 2)
+     * ┌─────┬───────┐
+     * │ val │ r_med │
+     * ├─────┼───────┤
+     * │ 10  │ 10    │
+     * │ 20  │ 15    │
+     * │ 30  │ 25    │
+     * └─────┴───────┘
+     */
+    rollingMedian(windowSize: number): this;
+    /**
+     * Window: Computes rolling window minimum value.
+     * @param windowSize Size of rolling window.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingMin(2).alias("r_min"))
+     * shape: (3, 2)
+     * ┌─────┬───────┐
+     * │ val │ r_min │
+     * ├─────┼───────┤
+     * │ 10  │ 10    │
+     * │ 20  │ 10    │
+     * │ 30  │ 20    │
+     * └─────┴───────┘
+     */
+    rollingMin(windowSize: number): this;
+    /**
+     * Window: Computes rolling window quantile value.
+     * @param quantile Quantile boundary between 0.0 and 1.0.
+     * @param windowSize Size of rolling window.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingQuantile(0.5, 2).alias("r_quant"))
+     * shape: (3, 2)
+     * ┌─────┬─────────┐
+     * │ val │ r_quant │
+     * ├─────┼─────────┤
+     * │ 10  │ 10      │
+     * │ 20  │ 15      │
+     * │ 30  │ 25      │
+     * └─────┴─────────┘
+     */
+    rollingQuantile(quantile: number, windowSize: number): this;
+    /**
+     * Window: Computes rolling window rank.
+     * @param windowSize Size of rolling window.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingRank(2).alias("r_rank"))
+     * shape: (3, 2)
+     * ┌─────┬────────┐
+     * │ val │ r_rank │
+     * ├─────┼────────┤
+     * │ 10  │ 1      │
+     * │ 20  │ 2      │
+     * │ 30  │ 2      │
+     * └─────┴────────┘
+     */
+    rollingRank(windowSize: number): this;
+    /**
+     * Window: Computes rolling window standard deviation.
+     * @param windowSize Size of rolling window.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingStd(2).alias("r_std"))
+     * shape: (3, 2)
+     * ┌─────┬────────┐
+     * │ val │ r_std  │
+     * ├─────┼────────┤
+     * │ 10  │ 0      │
+     * │ 20  │ 7.071  │
+     * │ 30  │ 7.071  │
+     * └─────┴────────┘
+     */
+    rollingStd(windowSize: number): this;
+    /**
+     * Window: Computes rolling window sum.
+     * @param windowSize Size of rolling window.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("val").rollingSum(2).alias("r_sum"))
+     * shape: (3, 2)
+     * ┌─────┬───────┐
+     * │ val │ r_sum │
+     * ├─────┼───────┤
+     * │ 10  │ 10    │
+     * │ 20  │ 30    │
+     * │ 30  │ 50    │
+     * └─────┴───────┘
+     */
+    rollingSum(windowSize: number): this;
+    /**
+     * Rounds values to a specific scale of decimal digits.
+     * @param decimals Number of decimal places to round to (default: 0).
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").round(1).alias("rounded"))
+     * shape: (3, 2)
+     * ┌───┬─────────┐
+     * │ a │ rounded │
+     * ├───┼─────────┤
+     * │ 1 │ 1       │
+     * │ 2 │ 2       │
+     * │ 3 │ 3       │
+     * └───┴─────────┘
+     */
+    round(decimals?: number): this;
+    /**
+     * Rounds values to a specific number of significant figures.
+     * @param sigFigs Number of significant figures.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").roundSigFigs(2).alias("sig_figs"))
+     * shape: (3, 2)
+     * ┌───┬──────────┐
+     * │ a │ sig_figs │
+     * ├───┼──────────┤
+     * │ 1 │ 1        │
+     * │ 2 │ 2        │
+     * │ 3 │ 3        │
+     * └───┴──────────┘
+     */
+    roundSigFigs(sigFigs: number): this;
+    /**
+     * Window: Computes 1-indexed row number count within group partitions.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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.withColumns($df.col("val").rowNumber().over("group").alias("rn"))
+     * shape: (3, 3)
+     * ┌───────┬─────┬────┐
+     * │ group │ val │ rn │
+     * ├───────┼─────┼────┤
+     * │ A     │ 10  │ 1  │
+     * │ A     │ 20  │ 2  │
+     * │ B     │ 30  │ 1  │
+     * └───────┴─────┴────┘
+     */
+    rowNumber(): this;
+    /**
+     * Returns sign indicator of column values (-1, 0, or 1).
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").sign().alias("sign_a"))
+     * shape: (3, 2)
+     * ┌───┬────────┐
+     * │ a │ sign_a │
+     * ├───┼────────┤
+     * │ 1 │ 1      │
+     * │ 2 │ 1      │
+     * │ 3 │ 1      │
+     * └───┴────────┘
+     */
+    sign(): this;
+    /**
+     * Computes the sine of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").sin().alias("sin_a"))
+     * shape: (3, 2)
+     * ┌───┬──────────┐
+     * │ a │ sin_a    │
+     * ├───┼──────────┤
+     * │ 1 │ 0.841471 │
+     * │ 2 │ 0.909297 │
+     * │ 3 │ 0.14112  │
+     * └───┴──────────┘
+     */
+    sin(): this;
+    /**
+     * Computes the hyperbolic sine of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").sinh().alias("sinh_a"))
+     * shape: (3, 2)
+     * ┌───┬───────────┐
+     * │ a │ sinh_a    │
+     * ├───┼───────────┤
+     * │ 1 │ 1.175201  │
+     * │ 2 │ 3.62686   │
+     * │ 3 │ 10.017875 │
+     * └───┴───────────┘
+     */
+    sinh(): this;
+    /**
+     * Aggregation: Computes the sample skewness as the Fisher-Pearson coefficient of skewness.
+     * @param options Skew calculation options ({ bias?: boolean }, default bias=true).
+     * @returns ColumnExpression
+     * @example
+ * >>> 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        │
+     * └──────────┘
+     */
+    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({ 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 │
+     * ├──────────┤
+     * │ 1        │
+     * └──────────┘
+     */
+    spearmanCorr(other: any): this;
+    /**
+     * Computes the square root of non-negative column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").sqrt().alias("sqrt_a"))
+     * shape: (3, 2)
+     * ┌───┬──────────┐
+     * │ a │ sqrt_a   │
+     * ├───┼──────────┤
+     * │ 1 │ 1        │
+     * │ 2 │ 1.414214 │
+     * │ 3 │ 1.732051 │
+     * └───┴──────────┘
+     */
+    sqrt(): this;
+    /**
+     * Aggregation: Computes sample standard deviation.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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;
+    /**
+     * Subtracts a scalar or another column expression.
+     * @param val The value or column expression to subtract.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").sub(5).alias("sub_a"))
+     * shape: (3, 2)
+     * ┌───┬───────┐
+     * │ a │ sub_a │
+     * ├───┼───────┤
+     * │ 1 │ -4    │
+     * │ 2 │ -3    │
+     * │ 3 │ -2    │
+     * └───┴───────┘
+     */
+    sub(val: NumericArg): this;
+    /**
+     * Aggregation: Computes the sum of elements in the group.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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    │
+     * │ B     │ 30    │
+     * └───────┴───────┘
+     */
+    sum(): this;
+    /**
+     * Computes the tangent of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").tan().alias("tan_a"))
+     * shape: (3, 2)
+     * ┌───┬───────────┐
+     * │ a │ tan_a     │
+     * ├───┼───────────┤
+     * │ 1 │ 1.557408  │
+     * │ 2 │ -2.18504  │
+     * │ 3 │ -0.142547 │
+     * └───┴───────────┘
+     */
+    tan(): this;
+    /**
+     * Computes the hyperbolic tangent of the column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").tanh().alias("tanh_a"))
+     * shape: (3, 2)
+     * ┌───┬──────────┐
+     * │ a │ tanh_a   │
+     * ├───┼──────────┤
+     * │ 1 │ 0.761594 │
+     * │ 2 │ 0.964028 │
+     * │ 3 │ 0.995055 │
+     * └───┴──────────┘
+     */
+    tanh(): this;
+    /**
+     * Truncates fractional digits of column values.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").trunc().alias("trunc_a"))
+     * shape: (3, 2)
+     * ┌───┬─────────┐
+     * │ a │ trunc_a │
+     * ├───┼─────────┤
+     * │ 1 │ 1       │
+     * │ 2 │ 2       │
+     * │ 3 │ 3       │
+     * └───┴─────────┘
+     */
+    trunc(): this;
+    /**
+     * Aggregation: Computes sample variance.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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;
+    /**
+     * Aggregation: Computes weighted average.
+     * @param weights The weight values or column expression.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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   │
+     * ├──────────┤
+     * │ 2.333333 │
+     * └──────────┘
+     */
+    wAvg(weights: any): this;
+    /**
+     * Logical XOR check.
+     * @param other The other boolean column expression or literal value to compare.
+     * @returns ColumnExpression
+     * @example
+ * >>> 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.withColumns($df.col("a").xor($df.col("b")).alias("xor_res"))
+     * shape: (4, 3)
+     * ┌───────┬───────┬─────────┐
+     * │ a     │ b     │ xor_res │
+     * ├───────┼───────┼─────────┤
+     * │ true  │ true  │ false   │
+     * │ true  │ false │ true    │
+     * │ false │ true  │ true    │
+     * │ false │ false │ false   │
+     * └───────┴───────┴─────────┘
+     */
+    xor(other: any): this;
+}