df-script 1.8.0 → 2.0.0

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

@@ -1,6 +1,6 @@
 import { ExprBase } from "../ExprBase";
-import { SortArrayOptions, StepSliceArrayOptions } from "../../utils";
-import type { UniqueArrayStatsOptions, JoinArrayOptions, ExplodeOptions, IExpr, AnyTypedArray, ToStructOptions } from "../../types";
+import { UniqueArrayStatsOptions, StepSliceArrayOptions, JoinArrayOptions } from "../../utils";
+import type { SortArrayOptions, ExplodeOptions, IExpr, AnyTypedArray, ToStructOptions } from "../../types";
 /**
  * @namespace $df.col.arr
  * @category ColumnExpression
@@ -10,12 +10,45 @@ export declare class ArrayExprNamespace {
     expr: any;
     constructor(expr: any);
     _deriveArray(fn: (arr: any[] | AnyTypedArray) => any): any;
+    _deriveArrayBinary(other: any, fn: (arr: any[] | AnyTypedArray, val: any) => any): any;
+    /**
+     * Applies an aggregation expression or element-wise calculation over each array cell.
+     * @param expr Aggregation expression (e.g. $df.element().sum() or $df.element().max())
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.agg($df.element().sum()).alias("sum_a"))
+     * shape: (2, 2)
+     * ┌───────────┬───────┐
+     * │ a         │ sum_a │
+     * ├───────────┼───────┤
+     * │ [1, 2, 3] │ 6     │
+     * │ [4, 5]    │ 9     │
+     * └───────────┴───────┘
+     */
+    agg(expr: IExpr): any;
     /**
      * Returns true if all items in nested list cells are truthy.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[true, true], [true, false]] })
-     * >>> df.with_columns($df.col("a").arr.all().alias("all_true"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.all().alias("all_true"))
      * shape: (2, 2)
      * ┌───────────────┬──────────┐
      * │ a             │ all_true │
@@ -29,24 +62,86 @@ export declare class ArrayExprNamespace {
      * Returns true if any item in nested list cells is truthy.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[true, false], [false, false]] })
-     * >>> df.with_columns($df.col("a").arr.any().alias("any_true"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.any().alias("any_true"))
      * shape: (2, 2)
-     * ┌────────────────┬──────────┐
-     * │ a              │ any_true │
-     * ├────────────────┼──────────┤
-     * │ [true, false]  │ true     │
-     * │ [false, false] │ false    │
-     * └────────────────┴──────────┘
+     * ┌───────────────┬──────────┐
+     * │ a             │ any_true │
+     * ├───────────────┼──────────┤
+     * │ [true, true]  │ true     │
+     * │ [true, false] │ true     │
+     * └───────────────┴──────────┘
      */
     any(): any;
+    /**
+     * Finds the index of the maximum value in each array.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.argMax().alias("max_idx"))
+     * shape: (2, 2)
+     * ┌───────────┬─────────┐
+     * │ a         │ max_idx │
+     * ├───────────┼─────────┤
+     * │ [1, 2, 3] │ 2       │
+     * │ [4, 5]    │ 1       │
+     * └───────────┴─────────┘
+     */
+    argMax(): any;
+    /**
+     * Finds the index of the minimum value in each array.
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.argMin().alias("min_idx"))
+     * shape: (2, 2)
+     * ┌───────────┬─────────┐
+     * │ a         │ min_idx │
+     * ├───────────┼─────────┤
+     * │ [1, 2, 3] │ 0       │
+     * │ [4, 5]    │ 0       │
+     * └───────────┴─────────┘
+     */
+    argMin(): any;
     /**
      * Checks if nested lists contain item.
      * @param item The element to search for.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
-     * >>> df.with_columns($df.col("a").arr.contains(3).alias("has_three"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.contains(3).alias("has_three"))
      * shape: (2, 2)
      * ┌───────────┬───────────┐
      * │ a         │ has_three │
@@ -61,24 +156,40 @@ export declare class ArrayExprNamespace {
      * @param items Array of elements that must all be present.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2, 3], [1, 5]] })
-     * >>> df.with_columns($df.col("a").arr.contains_all([1, 2]).alias("has_all"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.containsAll([1, 2]).alias("has_all"))
      * shape: (2, 2)
      * ┌───────────┬─────────┐
      * │ a         │ has_all │
      * ├───────────┼─────────┤
      * │ [1, 2, 3] │ true    │
-     * │ [1, 5]    │ false   │
+     * │ [4, 5]    │ false   │
      * └───────────┴─────────┘
      */
-    contains_all(items: ArrayLike<any>): any;
+    containsAll(items: ArrayLike<any>): any;
     /**
      * Checks if nested lists contain any element in items.
      * @param items Array of elements where at least one must be present.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2], [3, 4]] })
-     * >>> df.with_columns($df.col("a").arr.contains_any([2, 3]).alias("has_any"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.containsAny([2, 3]).alias("has_any"))
      * shape: (2, 2)
      * ┌────────┬─────────┐
      * │ a      │ has_any │
@@ -87,156 +198,227 @@ export declare class ArrayExprNamespace {
      * │ [3, 4] │ true    │
      * └────────┴─────────┘
      */
-    contains_any(items: ArrayLike<any>): any;
+    containsAny(items: ArrayLike<any>): any;
     /**
      * Counts occurrence frequency of item inside nested lists.
      * @param item The value to count occurrences of.
      * @param options Statistics and matching options.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2, 2, 3], [4, 5]] })
-     * >>> df.with_columns($df.col("a").arr.count_matches(2).alias("twos"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.countMatches(2).alias("twos"))
      * shape: (2, 2)
-     * ┌──────────────┬──────┐
-     * │ a            │ twos │
-     * ├──────────────┼──────┤
-     * │ [1, 2, 2, 3] │ 2    │
-     * │ [4, 5]       │ 0    │
-     * └──────────────┴──────┘
+     * ┌───────────┬──────┐
+     * │ a         │ twos │
+     * ├───────────┼──────┤
+     * │ [1, 2, 3] │ 1    │
+     * │ [4, 5]    │ 0    │
+     * └───────────┴──────┘
      */
-    count_matches(item: any, options?: UniqueArrayStatsOptions): any;
+    countMatches(item: any, options?: UniqueArrayStatsOptions): any;
     /**
      * Filters elements of list columns matching a boolean sub-expression.
      * @param expr The boolean column expression to filter by.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 5, 10], [2, 8]] })
-     * >>> df.with_columns($df.col("a").arr.filter($df.element().gt(4)).alias("filtered"))
-     * shape: (2, 2)
-     * ┌────────────┬──────────┐
-     * │ a          │ filtered │
-     * ├────────────┼──────────┤
-     * │ [1, 5, 10] │ [5, 10]  │
-     * │ [2, 8]     │ [8]      │
-     * └────────────┴──────────┘
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.filter($df.element().gt(2)).alias("filtered"))
+     * shape: (2, 2)
+     * ┌───────────┬──────────┐
+     * │ a         │ filtered │
+     * ├───────────┼──────────┤
+     * │ [1, 2, 3] │ [3]      │
+     * │ [4, 5]    │ [4, 5]   │
+     * └───────────┴──────────┘
      */
     filter(expr: IExpr): any;
     /**
-     * Expands lists into row-wise records.
+     * Expands lists into row-wise elements and produces an index mapping for DataFrame unnesting.
      * @param options Config options including handling of empty arrays and nulls.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2], [3]] })
-     * >>> df.explode($df.col("a").arr.explode())
-     * shape: (3, 1)
-     * ┌───┐
-     * │ a │
-     * ├───┤
-     * │ 1 │
-     * │ 2 │
-     * │ 3 │
-     * └───┘
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.select([$df.col("group"), $df.col("values").arr.explode()])
+     * shape: (2, 2)
+     * ┌───────┬────────┐
+     * │ group │ values │
+     * ├───────┼────────┤
+     * │ A     │ 1      │
+     * │ A     │ 2      │
+     * └───────┴────────┘
      */
-    explode({ empty_as_null, keep_nulls }?: ExplodeOptions): any;
+    explode({ emptyAsNull, keepNulls }?: ExplodeOptions): any;
     /**
      * Returns the first element of each list.
-     * @param null_on_oob If true, returns null if the list is empty (default: true).
+     * @param nullOnOob If true, returns null if the list is empty (default: true).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[10, 20], [30]] })
-     * >>> df.with_columns($df.col("a").arr.first().alias("first_a"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.first().alias("first_a"))
      * shape: (2, 2)
-     * ┌──────────┬─────────┐
-     * │ a        │ first_a │
-     * ├──────────┼─────────┤
-     * │ [10, 20] │ 10      │
-     * │ [30]     │ 30      │
-     * └──────────┴─────────┘
+     * ┌───────────┬─────────┐
+     * │ a         │ first_a │
+     * ├───────────┼─────────┤
+     * │ [1, 2, 3] │ 1       │
+     * │ [4, 5]    │ 4       │
+     * └───────────┴─────────┘
      */
-    first(null_on_oob?: boolean): any;
+    first(nullOnOob?: boolean): any;
     /**
      * Gathers specific indices from each nested list.
      * @param indices Index or array of indices to extract.
-     * @param null_on_oob If true, returns null for indices out of bounds (default: true).
+     * @param nullOnOob If true, returns null for indices out of bounds (default: true).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[10, 20, 30], [40, 50]] })
-     * >>> df.with_columns($df.col("a").arr.gather([0, 2]).alias("g"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.gather([0, 2]).alias("g"))
      * shape: (2, 2)
-     * ┌──────────────┬──────────┐
-     * │ a            │ g        │
-     * ├──────────────┼──────────┤
-     * │ [10, 20, 30] │ [10, 30] │
-     * │ [40, 50]     │ [40, null]│
-     * └──────────────┴──────────┘
+     * ┌───────────┬──────────┐
+     * │ a         │ g        │
+     * ├───────────┼──────────┤
+     * │ [1, 2, 3] │ [1, 3]   │
+     * │ [4, 5]    │ [4, null]│
+     * └───────────┴──────────┘
      */
-    gather(indices: number | ArrayLike<number>, null_on_oob?: boolean): any;
+    gather(indices: number | ArrayLike<number>, nullOnOob?: boolean): any;
     /**
      * Gather element slices with custom steps.
      * @param options Config options including offset, limit, and step size.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2, 3, 4], [5, 6, 7]] })
-     * >>> df.with_columns($df.col("a").arr.gather_every({ step: 2 }).alias("ge"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.gatherEvery({ step: 2 }).alias("ge"))
      * shape: (2, 2)
-     * ┌──────────────┬────────┐
-     * │ a            │ ge     │
-     * ├──────────────┼────────┤
-     * │ [1, 2, 3, 4] │ [1, 3] │
-     * │ [5, 6, 7]    │ [5, 7] │
-     * └──────────────┴────────┘
+     * ┌───────────┬────────┐
+     * │ a         │ ge     │
+     * ├───────────┼────────┤
+     * │ [1, 2, 3] │ [1, 3] │
+     * │ [4, 5]    │ [4]    │
+     * └───────────┴────────┘
      */
-    gather_every(options?: StepSliceArrayOptions): any;
+    gatherEvery(options?: StepSliceArrayOptions): any;
     /**
      * Extracts a single list element by its index position.
      * @param index The 0-based or negative index position to extract.
-     * @param null_on_oob If true, returns null if index is out of bounds (default: true).
+     * @param nullOnOob If true, returns null if index is out of bounds (default: true).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[10, 20], [30]] })
-     * >>> df.with_columns($df.col("a").arr.get(1).alias("second"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.get(1).alias("second"))
      * shape: (2, 2)
-     * ┌──────────┬────────┐
-     * │ a        │ second │
-     * ├──────────┼────────┤
-     * │ [10, 20] │ 20     │
-     * │ [30]     │ null   │
-     * └──────────┴────────┘
+     * ┌───────────┬────────┐
+     * │ a         │ second │
+     * ├───────────┼────────┤
+     * │ [1, 2, 3] │ 2      │
+     * │ [4, 5]    │ 5      │
+     * └───────────┴────────┘
      */
-    get(index: number, null_on_oob?: boolean): any;
+    get(index: number, nullOnOob?: boolean): any;
     /**
      * Joins elements of list columns into a single string column.
      * @param separator The character sequence separating list elements.
      * @param options String conversion options.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [["a", "b"], ["c"]] })
-     * >>> df.with_columns($df.col("a").arr.join("-").alias("joined"))
-     * shape: (2, 2)
-     * ┌──────────┬────────┐
-     * │ a        │ joined │
-     * ├──────────┼────────┤
-     * │ ["a","b"]│ "a-b"  │
-     * │ ["c"]    │ "c"    │
-     * └──────────┴────────┘
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.join("-").alias("joined"))
+     * shape: (2, 2)
+     * ┌────────────┬────────┐
+     * │ a          │ joined │
+     * ├────────────┼────────┤
+     * │ ["a", "b"] │ "a-b"  │
+     * │ ["c"]      │ "c"    │
+     * └────────────┴────────┘
      */
     join(separator?: string, options?: JoinArrayOptions): any;
     /**
      * Returns the last element of each list.
-     * @param null_on_oob If true, returns null if the list is empty (default: true).
+     * @param nullOnOob If true, returns null if the list is empty (default: true).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[10, 20], [30]] })
-     * >>> df.with_columns($df.col("a").arr.last().alias("last_a"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.last().alias("last_a"))
      * shape: (2, 2)
-     * ┌──────────┬────────┐
-     * │ a        │ last_a │
-     * ├──────────┼────────┤
-     * │ [10, 20] │ 20     │
-     * │ [30]     │ 30     │
-     * └──────────┴────────┐
+     * ┌───────────┬────────┐
+     * │ a         │ last_a │
+     * ├───────────┼────────┤
+     * │ [1, 2, 3] │ 3      │
+     * │ [4, 5]    │ 5      │
+     * └───────────┴────────┘
      */
-    last(null_on_oob?: boolean): any;
+    last(nullOnOob?: boolean): any;
     /**
      * Returns the length of each list inside the column cell.
      */
@@ -245,59 +427,68 @@ export declare class ArrayExprNamespace {
      * Returns the length of each list inside the column cell.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[10, 20], [30, 40, 50]] })
-     * >>> df.with_columns($df.col("a").arr.lengths().alias("len_a"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.lengths().alias("len_a"))
      * shape: (2, 2)
-     * ┌──────────────┬───────┐
-     * │ a            │ len_a │
-     * ├──────────────┼───────┤
-     * │ [10, 20]     │ 2     │
-     * │ [30, 40, 50] │ 3     │
-     * └──────────────┴───────┘
+     * ┌───────────┬───────┐
+     * │ a         │ len_a │
+     * ├───────────┼───────┤
+     * │ [1, 2, 3] │ 3     │
+     * │ [4, 5]    │ 2     │
+     * └───────────┴───────┘
      */
     lengths(): any;
     /**
      * Returns the maximum value of elements inside each list.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 5, 2], [10, 4]] })
-     * >>> df.with_columns($df.col("a").arr.max().alias("max_a"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.max().alias("max_a"))
      * shape: (2, 2)
      * ┌───────────┬───────┐
      * │ a         │ max_a │
      * ├───────────┼───────┤
-     * │ [1, 5, 2] │ 5     │
-     * │ [10, 4]   │ 10    │
+     * │ [1, 2, 3] │ 3     │
+     * │ [4, 5]    │ 5     │
      * └───────────┴───────┘
      */
     max(): any;
-    /**
-     * Returns the index of maximum value.
-     * @returns ColumnExpression
-     * @example
-     * >>> const df = $df.data({ a: [[1, 5, 2], [10, 4]] })
-     * >>> df.with_columns($df.col("a").arr.max_index().alias("max_idx"))
-     * shape: (2, 2)
-     * ┌───────────┬─────────┐
-     * │ a         │ max_idx │
-     * ├───────────┼─────────┤
-     * │ [1, 5, 2] │ 1       │
-     * │ [10, 4]   │ 0       │
-     * └───────────┴─────────┘
-     */
-    max_index(): any;
     /**
      * Returns average of elements inside each list.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 5, 9], [10, 40]] })
-     * >>> df.with_columns($df.col("a").arr.mean().alias("mean_a"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.mean().alias("mean_a"))
      * shape: (2, 2)
      * ┌───────────┬────────┐
      * │ a         │ mean_a │
      * ├───────────┼────────┤
-     * │ [1, 5, 9] │ 5      │
-     * │ [10, 40]  │ 25     │
+     * │ [1, 2, 3] │ 2      │
+     * │ [4, 5]    │ 4.5    │
      * └───────────┴────────┘
      */
     mean(): any;
@@ -305,60 +496,69 @@ export declare class ArrayExprNamespace {
      * Returns statistical median inside each list.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 3, 5, 7], [10, 20, 30]] })
-     * >>> df.with_columns($df.col("a").arr.median().alias("med"))
-     * shape: (2, 2)
-     * ┌────────────────┬──────┐
-     * │ a              │ med  │
-     * ├────────────────┼──────┤
-     * │ [1, 3, 5, 7]   │ 4    │
-     * │ [10, 20, 30]   │ 20   │
-     * └────────────────┴──────┘
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.median().alias("med"))
+     * shape: (2, 2)
+     * ┌───────────┬──────┐
+     * │ a         │ med  │
+     * ├───────────┼──────┤
+     * │ [1, 2, 3] │ 2    │
+     * │ [4, 5]    │ 4.5  │
+     * └───────────┴──────┘
      */
     median(): any;
     /**
      * Returns minimum of elements inside each list.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 5, 2], [10, 4]] })
-     * >>> df.with_columns($df.col("a").arr.min().alias("min_a"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.min().alias("min_a"))
      * shape: (2, 2)
      * ┌───────────┬───────┐
      * │ a         │ min_a │
      * ├───────────┼───────┤
-     * │ [1, 5, 2] │ 1     │
-     * │ [10, 4]   │ 4     │
+     * │ [1, 2, 3] │ 1     │
+     * │ [4, 5]    │ 4     │
      * └───────────┴───────┘
      */
     min(): any;
-    /**
-     * Returns the index of minimum value.
-     * @returns ColumnExpression
-     * @example
-     * >>> const df = $df.data({ a: [[5, 1, 2], [10, 4]] })
-     * >>> df.with_columns($df.col("a").arr.min_index().alias("min_idx"))
-     * shape: (2, 2)
-     * ┌───────────┬─────────┐
-     * │ a         │ min_idx │
-     * ├───────────┼─────────┤
-     * │ [5, 1, 2] │ 1       │
-     * │ [10, 4]   │ 1       │
-     * └───────────┴─────────┘
-     */
-    min_index(): any;
     /**
      * Returns the mode value inside each list.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2, 2, 3], [5, 5, 6]] })
-     * >>> df.with_columns($df.col("a").arr.mode().alias("mode_a"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.mode().alias("mode_a"))
      * shape: (2, 2)
-     * ┌──────────────┬────────┐
-     * │ a            │ mode_a │
-     * ├──────────────┼────────┤
-     * │ [1, 2, 2, 3] │ 2      │
-     * │ [5, 5, 6]    │ 5      │
-     * └──────────────┴────────┘
+     * ┌───────────┬───────────┐
+     * │ a         │ mode_a    │
+     * ├───────────┼───────────┤
+     * │ [1, 2, 3] │ [1, 2, 3] │
+     * │ [4, 5]    │ [4, 5]    │
+     * └───────────┴───────────┘
      */
     mode(): any;
     /**
@@ -366,23 +566,39 @@ export declare class ArrayExprNamespace {
      * @param options Formatting/statistics parameters.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2, 2, 3], [4, 5]] })
-     * >>> df.with_columns($df.col("a").arr.n_unique().alias("unique_len"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.nUnique().alias("unique_len"))
      * shape: (2, 2)
-     * ┌──────────────┬────────────┐
-     * │ a            │ unique_len │
-     * ├──────────────┼────────────┤
-     * │ [1, 2, 2, 3] │ 3          │
-     * │ [4, 5]       │ 2          │
-     * └──────────────┴────────────┘
+     * ┌───────────┬────────────┐
+     * │ a         │ unique_len │
+     * ├───────────┼────────────┤
+     * │ [1, 2, 3] │ 3          │
+     * │ [4, 5]    │ 2          │
+     * └───────────┴────────────┘
      */
-    n_unique(options?: UniqueArrayStatsOptions): any;
+    nUnique(options?: UniqueArrayStatsOptions): any;
     /**
      * Reverses elements of list columns.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
-     * >>> df.with_columns($df.col("a").arr.reverse().alias("reversed"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.reverse().alias("reversed"))
      * shape: (2, 2)
      * ┌───────────┬───────────┐
      * │ a         │ reversed  │
@@ -397,8 +613,16 @@ export declare class ArrayExprNamespace {
      * @param n Positive or negative offsets shift amount (default: 1).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
-     * >>> df.with_columns($df.col("a").arr.shift(1).alias("shifted"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.shift(1).alias("shifted"))
      * shape: (2, 2)
      * ┌───────────┬──────────────────┐
      * │ a         │ shifted          │
@@ -414,15 +638,23 @@ export declare class ArrayExprNamespace {
      * @param end The slice ending index.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2, 3, 4], [5, 6]] })
-     * >>> df.with_columns($df.col("a").arr.slice(1, 3).alias("sliced"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.slice(1, 3).alias("sliced"))
      * shape: (2, 2)
-     * ┌──────────────┬────────┐
-     * │ a            │ sliced │
-     * ├──────────────┼────────┤
-     * │ [1, 2, 3, 4] │ [2, 3] │
-     * │ [5, 6]       │ [6]    │
-     * └──────────────┴────────┘
+     * ┌───────────┬────────┐
+     * │ a         │ sliced │
+     * ├───────────┼────────┤
+     * │ [1, 2, 3] │ [2, 3] │
+     * │ [4, 5]    │ [5]    │
+     * └───────────┴────────┘
      */
     slice(start?: number, end?: number): any;
     /**
@@ -432,8 +664,16 @@ export declare class ArrayExprNamespace {
      * @param items The elements to insert.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
-     * >>> df.with_columns($df.col("a").arr.splice(1, 1, 10, 20).alias("spliced"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.splice(1, 1, 10, 20).alias("spliced"))
      * shape: (2, 2)
      * ┌───────────┬─────────────────┐
      * │ a         │ spliced         │
@@ -448,14 +688,22 @@ export declare class ArrayExprNamespace {
      * @param options Sort customization parameters (e.g. descending flag).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[3, 1, 2], [5, 4]] })
-     * >>> df.with_columns($df.col("a").arr.sort().alias("sorted"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.sort().alias("sorted"))
      * shape: (2, 2)
      * ┌───────────┬───────────┐
      * │ a         │ sorted    │
      * ├───────────┼───────────┤
-     * │ [3, 1, 2] │ [1, 2, 3] │
-     * │ [5, 4]    │ [4, 5]    │
+     * │ [1, 2, 3] │ [1, 2, 3] │
+     * │ [4, 5]    │ [4, 5]    │
      * └───────────┴───────────┘
      */
     sort(options?: SortArrayOptions): any;
@@ -463,29 +711,45 @@ export declare class ArrayExprNamespace {
      * Returns sample standard deviation of elements inside each list.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2, 3], [10, 20]] })
-     * >>> df.with_columns($df.col("a").arr.std().alias("std_dev"))
-     * shape: (2, 2)
-     * ┌───────────┬─────────┐
-     * │ a         │ std_dev │
-     * ├───────────┼─────────┤
-     * │ [1, 2, 3] │ 1       │
-     * │ [10, 20]  │ 7.071   │
-     * └───────────┴─────────┘
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.std().alias("std_dev"))
+     * shape: (2, 2)
+     * ┌───────────┬──────────┐
+     * │ a         │ std_dev  │
+     * ├───────────┼──────────┤
+     * │ [1, 2, 3] │ 1        │
+     * │ [4, 5]    │ 0.707107 │
+     * └───────────┴──────────┘
      */
     std(): any;
     /**
      * Returns sum of elements inside each list.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2, 3], [10, 20]] })
-     * >>> df.with_columns($df.col("a").arr.sum().alias("sum_a"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.sum().alias("sum_a"))
      * shape: (2, 2)
      * ┌───────────┬───────┐
      * │ a         │ sum_a │
      * ├───────────┼───────┤
      * │ [1, 2, 3] │ 6     │
-     * │ [10, 20]  │ 30    │
+     * │ [4, 5]    │ 9     │
      * └───────────┴───────┘
      */
     sum(): any;
@@ -494,8 +758,16 @@ export declare class ArrayExprNamespace {
      * @param options Config flags including custom field names or upper bound size.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2], [3, 4]] })
-     * >>> df.with_columns($df.col("a").arr.to_struct({ fields: ["x", "y"] }).alias("struct_a"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.toStruct({ fields: ["x", "y"] }).alias("struct_a"))
      * shape: (2, 2)
      * ┌────────┬────────────────┐
      * │ a      │ struct_a       │
@@ -504,35 +776,51 @@ export declare class ArrayExprNamespace {
      * │ [3, 4] │ { x: 3, y: 4 } │
      * └────────┴────────────────┘
      */
-    to_struct({ upper_bound, fields }?: ToStructOptions): any;
+    toStruct({ upperBound, fields }?: ToStructOptions): any;
     /**
      * Fills each list with unique elements only.
      * @param options Custom uniqueness matching configuration.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2, 2, 3], [4, 4, 5]] })
-     * >>> df.with_columns($df.col("a").arr.unique().alias("unique_a"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.unique().alias("unique_a"))
      * shape: (2, 2)
-     * ┌──────────────┬───────────┐
-     * │ a            │ unique_a  │
-     * ├──────────────┼───────────┤
-     * │ [1, 2, 2, 3] │ [1, 2, 3] │
-     * │ [4, 4, 5]    │ [4, 5]    │
-     * └──────────────┴───────────┘
+     * ┌───────────┬───────────┐
+     * │ a         │ unique_a  │
+     * ├───────────┼───────────┤
+     * │ [1, 2, 3] │ [1, 2, 3] │
+     * │ [4, 5]    │ [4, 5]    │
+     * └───────────┴───────────┘
      */
     unique(options?: UniqueArrayStatsOptions): any;
     /**
      * Returns sample variance of elements inside each list.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2, 3], [10, 20]] })
-     * >>> df.with_columns($df.col("a").arr.variance().alias("var_a"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.variance().alias("var_a"))
      * shape: (2, 2)
      * ┌───────────┬───────┐
      * │ a         │ var_a │
      * ├───────────┼───────┤
      * │ [1, 2, 3] │ 1     │
-     * │ [10, 20]  │ 50    │
+     * │ [4, 5]    │ 0.5   │
      * └───────────┴───────┘
      */
     variance(): any;
@@ -541,8 +829,16 @@ export declare class ArrayExprNamespace {
      * @param expr The sub-expression to evaluate inside each nested list.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [[1, 2], [3, 4]] })
-     * >>> df.with_columns($df.col("a").arr.eval($df.element().mul(10)).alias("multiplied"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").arr.eval($df.element().mul(10)).alias("multiplied"))
      * shape: (2, 2)
      * ┌────────┬────────────┐
      * │ a      │ multiplied │
@@ -561,7 +857,23 @@ export declare class ArrayExpr extends ExprBase {
      * @syntax $df.col(<column_name>).arr
      * @returns ArrayExprNamespace
      * @example
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
      * >>> df.select($df.col("a").arr.len())
+     * shape: (2, 1)
+     * ┌─────┐
+     * │ len │
+     * ├─────┤
+     * │ 3   │
+     * │ 2   │
+     * └─────┘
      */
     get arr(): ArrayExprNamespace;
 }