df-script 1.9.0 → 2.0.0

package/dist/dataframe/dataframe.d.ts

@@ -1,6 +1,6 @@
-import { GroupedData } from "./grouped/grouped";
+import { GroupedData } from "./grouped";
 import type { IExpr, ColumnData, ColumnDict, DataFrameColumns, ConcatOptions, ConcatItem, HorizontalConcatOptions, RowRecord, DataFrameSchema, RegisteredDataType, ExplodeOptions, IntoExpr, FillNullOptions } from "../types";
-import type { LimitOptions, SortOptions, PivotOptions, JoinOptions, AsofJoinOptions, UnpivotOptions, TransposeOptions, WriteJSONOptions, WriteCSVOptions } from "./types";
+import type { LimitOptions, SortOptions, PivotOptions, JoinOptions, JoinAsofOptions, JoinWhereOptions, GroupByDynamicOptions, UnpivotOptions, TransposeOptions, WriteJSONOptions, WriteCSVOptions } from "./types";
 /**
  * Two-dimensional columnar tabular data structure supporting expression execution and reshaping.
  */
@@ -29,20 +29,47 @@ export declare class DataFrame<T extends RowRecord = any> {
      * └─────┴─────┘
      */
     constructor(data: T[] | ColumnDict, schema?: DataFrameSchema, height?: number);
-    private _inferSchema;
     private _applySchema;
+    private _inferSchema;
+    private _normalizeArgs;
     /**
-     * Gets array of column names in the DataFrame.
-     * @returns Array of column name strings.
+     * Creates a deep copy of the current DataFrame instance, duplicating all underlying column data arrays and schema metadata.
+     * Modifying columns or values in the cloned DataFrame will not mutate the original.
+     * @returns {DataFrame<T>}
      * @example
-     * >>> const df = $df.data({ a: [1], b: [2] })
-     * >>> df
-     * shape: (1, 2)
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
+     * >>> const cloned = df.clone()
+     * >>> cloned
+     * shape: (2, 2)
      * ┌───┬───┐
      * │ a │ b │
      * ├───┼───┤
-     * │ 1 │ 2 │
+     * │ 1 │ x │
+     * │ 2 │ y │
      * └───┴───┘
+     */
+    clone(): DataFrame<T>;
+    /**
+     * Gets array of column names in the DataFrame.
+     * @returns Array of column name strings.
+     * @example
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
      * >>> df.columns
      * ["a", "b"]
      */
@@ -58,49 +85,94 @@ export declare class DataFrame<T extends RowRecord = any> {
      *
      * @example
      * // 1. Vertical Concatenation (default):
-     * >>> const df1 = $df.data({ a: [1] })
-     * >>> df1
-     * shape: (1, 1)
-     * ┌───┐
-     * │ a │
-     * ├───┤
-     * │ 1 │
-     * └───┘
-     * >>> const df2 = $df.data({ a: [2] })
+ * >>> const df1 = $df.data({ a: [1, 2] })
+ * >>> const df2 = $df.data({ b: [10, 20] })
+ * >>> df1
+ * shape: (2, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * └───┘
+ * >>> df2
+ * shape: (2, 1)
+ * ┌────┐
+ * │ b  │
+ * ├────┤
+ * │ 10 │
+ * │ 20 │
+ * └────┘
      * >>> df1.concat(df2, { how: "vertical" })
-     * shape: (2, 1)
-     * ┌───┐
-     * │ a │
-     * ├───┤
-     * │ 1 │
-     * │ 2 │
-     * └───┘
+     * shape: (4, 1)
+     * ┌──────┐
+     * │ a    │
+     * ├──────┤
+     * │ 1    │
+     * │ 2    │
+     * │ null │
+     * │ null │
+     * └──────┘
      *
      * @example
      * // 2. Horizontal Concatenation:
-     * >>> const df1 = $df.data({ a: [1] })
-     * >>> const df2 = $df.data({ b: [2] })
+ * >>> const df1 = $df.data({ a: [1, 2] })
+ * >>> const df2 = $df.data({ b: [10, 20] })
+ * >>> df1
+ * shape: (2, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * └───┘
+ * >>> df2
+ * shape: (2, 1)
+ * ┌────┐
+ * │ b  │
+ * ├────┤
+ * │ 10 │
+ * │ 20 │
+ * └────┘
      * >>> df1.concat(df2, { how: "horizontal" })
-     * shape: (1, 2)
-     * ┌───┬───┐
-     * │ a │ b │
-     * ├───┼───┤
-     * │ 1 │ 2 │
-     * └───┴───┘
+     * shape: (2, 2)
+     * ┌───┬────┐
+     * │ a │ b  │
+     * ├───┼────┤
+     * │ 1 │ 10 │
+     * │ 2 │ 20 │
+     * └───┴────┘
      *
      * @example
      * // 3. Diagonal Concatenation (mismatched columns):
-     * >>> const df1 = $df.data({ a: [1] })
-     * >>> const df2 = $df.data({ b: [2] })
+ * >>> const df1 = $df.data({ a: [1, 2] })
+ * >>> const df2 = $df.data({ b: [10, 20] })
+ * >>> df1
+ * shape: (2, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * └───┘
+ * >>> df2
+ * shape: (2, 1)
+ * ┌────┐
+ * │ b  │
+ * ├────┤
+ * │ 10 │
+ * │ 20 │
+ * └────┘
      * >>> df1.concat(df2, { how: "diagonal" })
-     * shape: (2, 2)
+     * shape: (4, 2)
      * ┌──────┬──────┐
      * │ a    │ b    │
      * ├──────┼──────┤
      * │ 1    │ null │
-     * │ null │ 2    │
+     * │ 2    │ null │
+     * │ null │ 10   │
+     * │ null │ 20   │
      * └──────┴──────┘
-     *
      */
     concat<U extends RowRecord = any>(items: ConcatItem | ConcatItem[], options?: ConcatOptions): DataFrame<U>;
     /**
@@ -108,39 +180,41 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param {(K | K[])[]} args Column names or arrays of column names to remove.
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ a: [1], b: [2] })
-     * >>> df
-     * shape: (1, 2)
-     * ┌───┬───┐
-     * │ a │ b │
-     * ├───┼───┤
-     * │ 1 │ 2 │
-     * └───┴───┘
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
      * >>> df.drop("b")
-     * shape: (1, 1)
+     * shape: (2, 1)
      * ┌───┐
      * │ a │
      * ├───┤
      * │ 1 │
+     * │ 2 │
      * └───┘
      */
     drop<K extends keyof T>(...args: (K | K[])[]): DataFrame<Omit<T, K>>;
     /**
-     * Drops rows containing null or undefined values in specified subset columns.
+     * Drops rows with null or undefined values.
      * @param {string | string[]} [subset] Column name or array of column names to check for nulls.
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ a: [1, null, 3] })
-     * >>> df
-     * shape: (3, 1)
-     * ┌──────┐
-     * │ a    │
-     * ├──────┤
-     * │ 1    │
-     * │ null │
-     * │ 3    │
-     * └──────┘
-     * >>> df.drop_nulls()
+ * >>> 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.dropNulls()
      * shape: (2, 1)
      * ┌───┐
      * │ a │
@@ -149,19 +223,20 @@ export declare class DataFrame<T extends RowRecord = any> {
      * │ 3 │
      * └───┘
      */
-    drop_nulls(subset?: string | string[]): DataFrame<T>;
+    dropNulls(subset?: string | string[]): DataFrame<T>;
     /**
      * Gets array of registered column DataTypes matching current schema order.
      * @returns Array of RegisteredDataType definitions.
      * @example
-     * >>> const df = $df.data({ a: [1], b: ["text"] })
-     * >>> df
-     * shape: (1, 2)
-     * ┌───┬──────┐
-     * │ a │ b    │
-     * ├───┼──────┤
-     * │ 1 │ text │
-     * └───┴──────┘
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
      * >>> df.dtypes
      * [Float64, Utf8]
      */
@@ -170,18 +245,19 @@ export declare class DataFrame<T extends RowRecord = any> {
      * Explodes an array column into multiple rows, replicating non-target row attributes.
      * @param {IntoExpr | IntoExpr[]} columns Target column expression or array column name to explode.
      * @param {ExplodeOptions} [options] Configuration options for empty array and null handling.
-     * @param {boolean} [options.empty_as_null] When `true`, converts empty arrays to `null` rows.
-     * @param {boolean} [options.keep_nulls] When `true`, retains `null` array values during explosion.
+     * @param {boolean} [options.emptyAsNull] When `true`, converts empty arrays to `null` rows.
+     * @param {boolean} [options.keepNulls] When `true`, retains `null` array values during explosion.
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ group: ["A"], values: [[1, 2]] })
-     * >>> df
-     * shape: (1, 2)
-     * ┌───────┬────────┐
-     * │ group │ values │
-     * ├───────┼────────┤
-     * │ A     │ [1, 2] │
-     * └───────┴────────┘
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
      * >>> df.explode("values")
      * shape: (2, 2)
      * ┌───────┬────────┐
@@ -200,17 +276,17 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param {number} [options.limit] Maximum consecutive nulls to fill when using propagation strategies.
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ a: [1, null, 3] })
-     * >>> df
-     * shape: (3, 1)
-     * ┌──────┐
-     * │ a    │
-     * ├──────┤
-     * │ 1    │
-     * │ null │
-     * │ 3    │
-     * └──────┘
-     * >>> df.fill_null({ value: 0 })
+ * >>> 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.fillNull({ value: 0 })
      * shape: (3, 1)
      * ┌───┐
      * │ a │
@@ -220,22 +296,22 @@ export declare class DataFrame<T extends RowRecord = any> {
      * │ 3 │
      * └───┘
      */
-    fill_null(options?: FillNullOptions): DataFrame<T>;
+    fillNull(options?: FillNullOptions): DataFrame<T>;
     /**
      * Filters rows matching boolean column expressions or predicate callbacks.
      * @param {(IExpr | ((row: T) => any))[]} exprs Expressions or predicate functions evaluated per row.
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ a: [1, 2, 3] })
-     * >>> df
-     * shape: (3, 1)
-     * ┌───┐
-     * │ a │
-     * ├───┤
-     * │ 1 │
-     * │ 2 │
-     * │ 3 │
-     * └───┘
+ * >>> 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.filter($df.col("a").gt(1))
      * shape: (2, 1)
      * ┌───┐
@@ -251,17 +327,17 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param {K | K[]} keys Column name or array of key column names.
      * @returns {GroupedData}
      * @example
-     * >>> const df = $df.data({ cat: ["A", "A", "B"], val: [10, 20, 30] })
-     * >>> df
-     * shape: (3, 2)
-     * ┌─────┬─────┐
-     * │ cat │ val │
-     * ├─────┼─────┤
-     * │ A   │ 10  │
-     * │ A   │ 20  │
-     * │ B   │ 30  │
-     * └─────┴─────┘
-     * >>> df.groupby("cat").agg($df.col("val").sum().alias("sum"))
+ * >>> 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("sum"))
      * shape: (2, 2)
      * ┌─────┬─────┐
      * │ cat │ sum │
@@ -270,23 +346,53 @@ export declare class DataFrame<T extends RowRecord = any> {
      * │ B   │ 30  │
      * └─────┴─────┘
      */
-    groupby<K extends keyof T>(keys: K | K[]): GroupedData<T, K>;
+    groupBy<K extends keyof T>(keys: K | K[]): GroupedData<T, K>;
+    /**
+     * Groups dynamically based on a time or integer index column over sliding / stepping windows.
+     *
+     * @param indexColumn The time/integer column or column expression to group on.
+     * @param options Dynamic grouping configuration options (`every`, `period`, `offset`, `truncate`, `includeBoundaries`, `closed`, `label`, `by`, `startBy`, `checkSorted`).
+     * @returns GroupedData
+     * @example
+ * >>> const df = $df.data([
+ * ...   { time: new Date("2024-01-01T00:00:00Z"), val: 10 },
+ * ...   { time: new Date("2024-01-01T12:00:00Z"), val: 20 },
+ * ...   { time: new Date("2024-01-02T00:00:00Z"), val: 30 }
+ * ... ])
+ * >>> df
+ * shape: (3, 2)
+ * ┌──────────────────────────┬─────┐
+ * │ time                     │ val │
+ * ├──────────────────────────┼─────┤
+ * │ 2024-01-01T00:00:00.000Z │ 10  │
+ * │ 2024-01-01T12:00:00.000Z │ 20  │
+ * │ 2024-01-02T00:00:00.000Z │ 30  │
+ * └──────────────────────────┴─────┘
+     * >>> df.groupByDynamic("time", { every: "1d", period: "1d" }).agg($df.col("val").sum().alias("daily_sum"))
+     * shape: (2, 2)
+     * ┌──────────────────────────┬───────────┐
+     * │ time                     │ daily_sum │
+     * ├──────────────────────────┼───────────┤
+     * │ 2024-01-01T00:00:00.000Z │ 30        │
+     * │ 2024-01-02T00:00:00.000Z │ 30        │
+     * └──────────────────────────┴───────────┘
+     */
+    groupByDynamic<K extends keyof T & string>(indexColumn: K | IntoExpr, options: GroupByDynamicOptions<T>): GroupedData<T, K>;
     /**
      * Returns the first N rows as a new DataFrame.
      * @param n Number of leading rows to slice (default 10).
      * @returns DataFrame
      * @example
-     * >>> const df = $df.data({ a: [1, 2, 3, 4] })
-     * >>> df
-     * shape: (4, 1)
-     * ┌───┐
-     * │ a │
-     * ├───┤
-     * │ 1 │
-     * │ 2 │
-     * │ 3 │
-     * │ 4 │
-     * └───┘
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
      * >>> df.head(2)
      * shape: (2, 1)
      * ┌───┐
@@ -297,49 +403,19 @@ export declare class DataFrame<T extends RowRecord = any> {
      * └───┘
      */
     head(n?: number): DataFrame<T>;
-    /**
-     * Creates a deep copy of the current DataFrame instance, duplicating all underlying column data arrays and schema metadata.
-     * Modifying columns or values in the cloned DataFrame will not mutate the original.
-     * @returns {DataFrame<T>}
-     * @example
-     * >>> // Example 1: Basic cloning and independence
-     * >>> const df1 = $df.data({ a: [10, 20], b: ["x", "y"] })
-     * >>> const copy1 = df1.clone()
-     * >>> copy1
-     * shape: (2, 2)
-     * ┌────┬───┐
-     * │ a  │ b │
-     * ├────┼───┤
-     * │ 10 │ x │
-     * │ 20 │ y │
-     * └────┴───┘
-     *
-     * >>> // Example 2: Verifying mutation isolation
-     * >>> copy1._columns.a[0] = 999
-     * >>> df1.to_dicts()[0].a
-     * 10
-     *
-     * >>> // Example 3: Cloning empty DataFrames
-     * >>> const emptyDf = $df.data({ x: [], y: [] })
-     * >>> const emptyCopy = emptyDf.clone()
-     * >>> emptyCopy.height
-     * 0
-     */
-    clone(): DataFrame<T>;
     /**
      * Gets height (total row count) of the DataFrame.
      * @returns Number of rows.
      * @example
-     * >>> const df = $df.data({ a: [10, 20, 30] })
-     * >>> df
-     * shape: (3, 1)
-     * ┌────┐
-     * │ a  │
-     * ├────┤
-     * │ 10 │
-     * │ 20 │
-     * │ 30 │
-     * └────┘
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
      * >>> df.height
      * 3
      */
@@ -351,16 +427,24 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param {boolean} [options.strict] When `true` (default), throws an error if row counts mismatch. Set `false` to allow null padding.
      * @returns {DataFrame}
      * @example
-     * >>> const df1 = $df.data({ a: [1, 2] })
-     * >>> df1
-     * shape: (2, 1)
-     * ┌───┐
-     * │ a │
-     * ├───┤
-     * │ 1 │
-     * │ 2 │
-     * └───┘
-     * >>> const df2 = $df.data({ b: [10, 20] })
+ * >>> const df1 = $df.data({ a: [1, 2] })
+ * >>> const df2 = $df.data({ b: [10, 20] })
+ * >>> df1
+ * shape: (2, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * └───┘
+ * >>> df2
+ * shape: (2, 1)
+ * ┌────┐
+ * │ b  │
+ * ├────┤
+ * │ 10 │
+ * │ 20 │
+ * └────┘
      * >>> df1.hstack(df2)
      * shape: (2, 2)
      * ┌───┬────┐
@@ -378,23 +462,25 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param {IntoExpr} expr Value expression or column definition.
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ a: [1], c: [3] })
-     * >>> df
-     * shape: (1, 2)
-     * ┌───┬───┐
-     * │ a │ c │
-     * ├───┼───┤
-     * │ 1 │ 3 │
-     * └───┴───┘
-     * >>> df.insert_column(1, "b", 2)
-     * shape: (1, 3)
-     * ┌───┬───┬───┐
-     * │ a │ b │ c │
-     * ├───┼───┼───┤
-     * │ 1 │ 2 │ 3 │
-     * └───┴───┴───┘
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
+     * >>> df.insertColumn(1, "c", [10, 20])
+     * shape: (2, 3)
+     * ┌───┬────┬───┐
+     * │ a │ c  │ b │
+     * ├───┼────┼───┤
+     * │ 1 │ 10 │ x │
+     * │ 2 │ 20 │ y │
+     * └───┴────┴───┘
      */
-    insert_column(index: number, name: string, expr: IntoExpr): DataFrame<any>;
+    insertColumn(index: number, name: string, expr: IntoExpr): DataFrame<any>;
     /**
      * Retrieves a single scalar cell value by row and column position or name.
      * @param {number} [row] Row index position.
@@ -403,14 +489,15 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @throws {DataFrameError} If shape is not (1, 1) when called without arguments.
      * @throws {ShapeError} If row or column index is out of bounds.
      * @example
-     * >>> const df = $df.data({ val: [42] })
-     * >>> df
-     * shape: (1, 1)
-     * ┌─────┐
-     * │ val │
-     * ├─────┤
-     * │ 42  │
-     * └─────┘
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
      * >>> df.item(0, "val")
      * 42
      */
@@ -419,50 +506,48 @@ export declare class DataFrame<T extends RowRecord = any> {
      * Yields a generator iterating over raw column arrays.
      * @returns Generator of ColumnData arrays.
      * @example
-     * >>> const df = $df.data({ a: [1, 2], b: [3, 4] })
-     * >>> df
-     * shape: (2, 2)
-     * ┌───┬───┐
-     * │ a │ b │
-     * ├───┼───┤
-     * │ 1 │ 3 │
-     * │ 2 │ 4 │
-     * └───┴───┘
-     * >>> for (const col of df.iter_columns()) { console.log(col); }
-     * Float64Array([1, 2])
-     * Float64Array([3, 4])
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
+     * >>> Array.from(df.iterColumns())
+     * [ Float64Array([1, 2]), ["x", "y"] ]
      */
-    iter_columns(): Generator<ColumnData>;
+    iterColumns(): Generator<ColumnData>;
     /**
      * Yields a generator iterating over rows as tuples or named objects.
      * @param [config] Iteration format configuration.
      * @param [config.named] When `true`, yields row objects with column keys (`{ col: val }`). When `false` (default), yields positional arrays (`[val1, val2]`).
      * @returns Generator of rows.
      * @example
-     * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
-     * >>> df
-     * shape: (2, 2)
-     * ┌───┬───┐
-     * │ a │ b │
-     * ├───┼───┤
-     * │ 1 │ x │
-     * │ 2 │ y │
-     * └───┴───┘
-     * >>> for (const row of df.iter_rows({ named: true })) { console.log(row); }
-     * { a: 1, b: "x" }
-     * { a: 2, b: "y" }
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
+     * >>> Array.from(df.iterRows({ named: true }))
+     * [ { a: 1, b: "x" }, { a: 2, b: "y" } ]
      */
-    iter_rows({ named }?: {
+    iterRows({ named }?: {
         named?: boolean;
     }): Generator<any[] | Record<string, any>>;
     /**
      * Joins two DataFrames on key columns using a specified join strategy.
-     * @param {JoinOptions} config Join configuration object.
-     * @param {DataFrame} config.other Right DataFrame to join with.
-     * @param {string | string[]} [config.on] Join key column name or array of key column names that exist in both DataFrames.
-     * @param {string | string[]} [config.leftOn] Join key column(s) in the left DataFrame when key names differ.
-     * @param {string | string[]} [config.rightOn] Join key column(s) in the right DataFrame when key names differ.
-     * @param {JoinType} [config.how] Join strategy. Default `"inner"`.
+     * @param {DataFrame} other Right DataFrame to join with.
+     * @param {JoinOptions} [options={}] Join configuration object.
+     * @param {string | string[]} [options.on] Join key column name or array of key column names that exist in both DataFrames.
+     * @param {string | string[]} [options.leftOn] Join key column(s) in the left DataFrame when key names differ.
+     * @param {string | string[]} [options.rightOn] Join key column(s) in the right DataFrame when key names differ.
+     * @param {JoinType} [options.how] Join strategy. Default `"inner"`.
      *   - `"inner"` — Only rows with matching keys in both DataFrames.
      *   - `"left"` — All left rows; unmatched right values are `null`.
      *   - `"right"` — All right rows; unmatched left values are `null`.
@@ -470,12 +555,12 @@ export declare class DataFrame<T extends RowRecord = any> {
      *   - `"semi"` — Left rows that have a match in the right DataFrame (only left columns retained).
      *   - `"anti"` — Left rows that have **no** match in the right DataFrame (only left columns retained).
      *   - `"cross"` — Cartesian product pairing every left row with every right row (keyless).
-     * @param {[string, string]} [config.suffixes] Suffix tuple `[leftSuffix, rightSuffix]` appended to overlapping
+     * @param {[string, string]} [options.suffixes] Suffix tuple `[leftSuffix, rightSuffix]` appended to overlapping
      *   non-key column names (default `["", "_right"]`). Ignored for `"semi"` and `"anti"` joins.
-     * @param {boolean} [config.join_nulls] If `true`, null key values are treated as equal and will match each other
+     * @param {boolean} [options.joinNulls] If `true`, null key values are treated as equal and will match each other
      *   across DataFrames. Default `false` (SQL-standard: `NULL != NULL`).
-     * @param {boolean} [config.coalesce] Coalescing behavior for join key columns. Default `true`. If `true`, coalesces join key values into left key columns and drops right key columns. If `false`, keeps join key columns separate.
-     * @param {JoinMaintainOrder | boolean} [config.maintain_order] Row order preservation strategy. Default `"none"`.
+     * @param {boolean} [options.coalesce] Coalescing behavior for join key columns. Default `true`. If `true`, coalesces join key values into left key columns and drops right key columns. If `false`, keeps join key columns separate.
+     * @param {JoinMaintainOrder | boolean} [options.maintainOrder] Row order preservation strategy. Default `"none"`.
      *   - `"none"` (or `false`) — No specific ordering is desired.
      *   - `"left"` (or `true`) — Preserves the order of the left DataFrame.
      *   - `"right"` — Preserves the order of the right DataFrame.
@@ -483,17 +568,25 @@ export declare class DataFrame<T extends RowRecord = any> {
      *   - `"right_left"` — Preserves the order of the right DataFrame first, then the left.
      * @returns {DataFrame}
      * @example
-     * >>> const df1 = $df.data({ id: [1, 2], val: ["a", "b"] })
-     * >>> df1
-     * shape: (2, 2)
-     * ┌────┬─────┐
-     * │ id │ val │
-     * ├────┼─────┤
-     * │ 1  │ a   │
-     * │ 2  │ b   │
-     * └────┴─────┘
-     * >>> const df2 = $df.data({ id: [1, 2], num: [100, 200] })
-     * >>> df1.join({ other: df2, on: "id" })
+ * >>> const df1 = $df.data({ id: [1, 2], val: ["a", "b"] })
+ * >>> const df2 = $df.data({ id: [1, 2], num: [100, 200] })
+ * >>> df1
+ * shape: (2, 2)
+ * ┌────┬─────┐
+ * │ id │ val │
+ * ├────┼─────┤
+ * │ 1  │ a   │
+ * │ 2  │ b   │
+ * └────┴─────┘
+ * >>> df2
+ * shape: (2, 2)
+ * ┌────┬─────┐
+ * │ id │ num │
+ * ├────┼─────┤
+ * │ 1  │ 100 │
+ * │ 2  │ 200 │
+ * └────┴─────┘
+     * >>> df1.join(df2, { on: "id" })
      * shape: (2, 3)
      * ┌────┬─────┬─────┐
      * │ id │ val │ num │
@@ -502,7 +595,7 @@ export declare class DataFrame<T extends RowRecord = any> {
      * │ 2  │ b   │ 200 │
      * └────┴─────┴─────┘
      */
-    join<U extends RowRecord = any, R extends RowRecord = any>(config: JoinOptions<T, U>): DataFrame<R>;
+    join<U extends RowRecord = any, R extends RowRecord = any>(other: DataFrame<U>, options?: JoinOptions<T, U>): DataFrame<R>;
     /**
      * Performs an asof (as-of) join for inexact matching on ordered numeric or temporal key columns.
      *
@@ -510,71 +603,123 @@ export declare class DataFrame<T extends RowRecord = any> {
      * DataFrame according to the selected `strategy` ("backward", "forward", or "nearest") and optional `tolerance`.
      * Both DataFrames must be sorted in ascending order on their respective `on` / `leftOn` / `rightOn` join keys.
      *
-     * @param {AsofJoinOptions} options Asof join configuration options.
-     * @param {DataFrame} options.other The right DataFrame to join with.
+     * @param {DataFrame} other The right DataFrame to join with.
+     * @param {JoinAsofOptions} options Asof join configuration options.
      * @param {string} [options.on] Column name to join on (must exist in both DataFrames and be sorted ascending).
      * @param {string} [options.leftOn] Left DataFrame join key column name.
      * @param {string} [options.rightOn] Right DataFrame join key column name.
      * @param {string | string[]} [options.by] Optional exact-match group column(s) present in both DataFrames.
      * @param {string | string[]} [options.leftBy] Group column(s) for exact key matching in left DataFrame.
      * @param {string | string[]} [options.rightBy] Group column(s) for exact key matching in right DataFrame.
-     * @param {AsofJoinStrategy} [options.strategy] Match search strategy. Default `"backward"`.
+     * @param {JoinAsofStrategy} [options.strategy] Match search strategy. Default `"backward"`.
      *   - `"backward"` — Matches the latest right row where `rightKey <= leftKey`.
      *   - `"forward"` — Matches the earliest right row where `rightKey >= leftKey`.
      *   - `"nearest"` — Matches the right row with the absolute nearest key value to `leftKey`.
      * @param {number | string} [options.tolerance] Maximum allowed distance between left key and right key.
-     * @param {boolean} [options.allow_exact_matches] Whether exact key matches are permitted. Default `true`.
+     * @param {boolean} [options.allowExactMatches] Whether exact key matches are permitted. Default `true`.
      * @param {[string, string]} [options.suffixes] Column name suffixes `[leftSuffix, rightSuffix]` to resolve name collisions. Default `["", "_right"]`.
      * @param {boolean} [options.coalesce] Coalescing behavior for join key columns. Default `true`.
-     * @param {boolean} [options.check_sorted] Whether to verify that join keys are sorted ascending prior to matching. Default `true`.
+     * @param {boolean} [options.checkSorted] Whether to verify that join keys are sorted ascending prior to matching. Default `true`.
      * @returns A new DataFrame containing the joined results.
-     *
-     * @namespace df
-     * @category DataFrame
-     * @syntax
-     * df.join_asof({
-     *   other,
-     *   on,
-     *   leftOn,
-     *   rightOn,
-     *   by,
-     *   leftBy,
-     *   rightBy,
-     *   strategy,
-     *   tolerance,
-     *   allow_exact_matches,
-     *   suffixes,
-     *   coalesce,
-     *   check_sorted
-     * })
      * @example
-     * >>> const trades = new DataFrame([
-     * ...   { time: 1000, ticker: "AAPL", price: 150.0 },
-     * ...   { time: 1005, ticker: "AAPL", price: 150.5 },
-     * ...   { time: 1015, ticker: "AAPL", price: 151.0 }
-     * ... ]);
-     * >>> const quotes = new DataFrame([
-     * ...   { time: 998, ticker: "AAPL", bid: 149.9 },
-     * ...   { time: 1004, ticker: "AAPL", bid: 150.4 },
-     * ...   { time: 1010, ticker: "AAPL", bid: 150.8 }
-     * ... ]);
-     * >>> const joined = trades.join_asof({
-     * ...   other: quotes,
-     * ...   on: "time",
-     * ...   by: "ticker",
-     * ...   strategy: "backward"
-     * ... });
-     * >>> joined
+ * >>> const trades = $df.data([
+ * ...   { time: 1000, ticker: "AAPL", price: 150.0 },
+ * ...   { time: 1005, ticker: "AAPL", price: 150.5 },
+ * ...   { time: 1015, ticker: "AAPL", price: 151.0 }
+ * ... ])
+ * >>> const quotes = $df.data([
+ * ...   { time: 998, ticker: "AAPL", bid: 149.9 },
+ * ...   { time: 1004, ticker: "AAPL", bid: 150.4 },
+ * ...   { time: 1010, ticker: "AAPL", bid: 150.8 }
+ * ... ])
+ * >>> trades
+ * shape: (3, 3)
+ * ┌──────┬────────┬───────┐
+ * │ time │ ticker │ price │
+ * ├──────┼────────┼───────┤
+ * │ 1000 │ AAPL   │ 150.0 │
+ * │ 1005 │ AAPL   │ 150.5 │
+ * │ 1015 │ AAPL   │ 151.0 │
+ * └──────┴────────┴───────┘
+ * >>> quotes
+ * shape: (3, 3)
+ * ┌──────┬────────┬───────┐
+ * │ time │ ticker │ bid   │
+ * ├──────┼────────┼───────┤
+ * │ 998  │ AAPL   │ 149.9 │
+ * │ 1004 │ AAPL   │ 150.4 │
+ * │ 1010 │ AAPL   │ 150.8 │
+ * └──────┴────────┴───────┘
+     * >>> trades.joinAsof(quotes, { on: "time", by: "ticker" })
      * shape: (3, 4)
-     * ┌──────┬────────┬───────┬──────┐
-     * │ time │ ticker │ price │ bid  │
-     * ├──────┼────────┼───────┼──────┤
-     * │ 1000 │ AAPL   │ 150.0 │ 149.9│
-     * │ 1005 │ AAPL   │ 150.5 │ 150.4│
-     * │ 1015 │ AAPL   │ 151.0 │ 150.8│
-     * └──────┴────────┴───────┴──────┘
+     * ┌──────┬────────┬───────┬───────┐
+     * │ time │ ticker │ price │ bid   │
+     * ├──────┼────────┼───────┼───────┤
+     * │ 1000 │ AAPL   │ 150.0 │ 149.9 │
+     * │ 1005 │ AAPL   │ 150.5 │ 150.4 │
+     * │ 1015 │ AAPL   │ 151.0 │ 150.8 │
+     * └──────┴────────┴───────┴───────┘
+     */
+    joinAsof<U extends RowRecord = any, R extends RowRecord = any>(other: DataFrame<U>, options: JoinAsofOptions<T, U>): DataFrame<R>;
+    /**
+     * Joins two DataFrames based on arbitrary expression predicates (non-equi joins).
+     *
+     * Evaluates one or more boolean expressions across combined rows from both DataFrames.
+     * When column names collide between the two DataFrames, columns are suffixed according to
+     * `options.suffixes` (default `["", "_right"]`).
+     *
+     * @param {DataFrame} other The right DataFrame to join with.
+     * @param {...(IntoExpr | IntoExpr[] | JoinWhereOptions)} args Predicate expression(s), arrays of expressions,
+     *   and an optional configuration options object (`{ how, suffixes }`).
+     * @returns {DataFrame} A new DataFrame containing the joined results.
+     * @example
+ * >>> const east = $df.data([
+ * ...   { id: 100, dur: 120, rev: 12, cores: 2 },
+ * ...   { id: 101, dur: 140, rev: 14, cores: 8 },
+ * ...   { id: 102, dur: 160, rev: 16, cores: 4 }
+ * ... ])
+ * >>> const west = $df.data([
+ * ...   { t_id: 404, time: 90, cost: 9, cores: 4 },
+ * ...   { t_id: 498, time: 130, cost: 13, cores: 2 },
+ * ...   { t_id: 676, time: 150, cost: 15, cores: 1 },
+ * ...   { t_id: 742, time: 170, cost: 16, cores: 4 }
+ * ... ])
+ * >>> east
+ * shape: (3, 4)
+ * ┌─────┬─────┬─────┬───────┐
+ * │ id  │ dur │ rev │ cores │
+ * ├─────┼─────┼─────┼───────┤
+ * │ 100 │ 120 │ 12  │ 2     │
+ * │ 101 │ 140 │ 14  │ 8     │
+ * │ 102 │ 160 │ 16  │ 4     │
+ * └─────┴─────┴─────┴───────┘
+ * >>> west
+ * shape: (4, 4)
+ * ┌──────┬──────┬──────┬───────┐
+ * │ t_id │ time │ cost │ cores │
+ * ├──────┼──────┼──────┼───────┤
+ * │ 404  │ 90   │ 9    │ 4     │
+ * │ 498  │ 130  │ 13   │ 2     │
+ * │ 676  │ 150  │ 15   │ 1     │
+ * │ 742  │ 170  │ 16   │ 4     │
+ * └──────┴──────┴──────┴───────┘
+     * >>> east.joinWhere(
+     * ...     west,
+     * ...     $df.col("dur").lt($df.col("time")),
+     * ...     $df.col("rev").lt($df.col("cost"))
+     * ... )
+     * shape: (5, 8)
+     * ┌─────┬─────┬─────┬───────┬──────┬──────┬──────┬─────────────┐
+     * │ id  │ dur │ rev │ cores │ t_id │ time │ cost │ cores_right │
+     * ├─────┼─────┼─────┼───────┼──────┼──────┼──────┼─────────────┤
+     * │ 100 │ 120 │ 12  │ 2     │ 498  │ 130  │ 13   │ 2           │
+     * │ 100 │ 120 │ 12  │ 2     │ 676  │ 150  │ 15   │ 1           │
+     * │ 100 │ 120 │ 12  │ 2     │ 742  │ 170  │ 16   │ 4           │
+     * │ 101 │ 140 │ 14  │ 8     │ 676  │ 150  │ 15   │ 1           │
+     * │ 101 │ 140 │ 14  │ 8     │ 742  │ 170  │ 16   │ 4           │
+     * └─────┴─────┴─────┴───────┴──────┴──────┴──────┴─────────────┘
      */
-    join_asof<U extends RowRecord = any, R extends RowRecord = any>(options: AsofJoinOptions<T, U>): DataFrame<R>;
+    joinWhere<U extends RowRecord = any, R extends RowRecord = any>(other: DataFrame<U>, ...args: (IntoExpr | IntoExpr[] | JoinWhereOptions)[]): DataFrame<R>;
     /**
      * Limits the output to N rows starting from offset.
      * @param {number} n Maximum number of rows to take.
@@ -583,17 +728,16 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param {LimitPosition} [options.from] Slice direction starting point (`"start"` or `"end"`). Default `"start"`.
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ a: [10, 20, 30, 40] })
-     * >>> df
-     * shape: (4, 1)
-     * ┌────┐
-     * │ a  │
-     * ├────┤
-     * │ 10 │
-     * │ 20 │
-     * │ 30 │
-     * │ 40 │
-     * └────┘
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
      * >>> df.limit(2, { offset: 1 })
      * shape: (2, 1)
      * ┌────┐
@@ -613,21 +757,17 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param {AggFn | string} [config.agg] Aggregation function to apply when multiple values exist for a cell.
      * @returns DataFrame
      * @example
-     * >>> const df = $df.data({
-     * ...   year: [2020, 2020, 2021, 2021],
-     * ...   month: ["Jan", "Feb", "Jan", "Feb"],
-     * ...   revenue: [100, 150, 120, 180]
-     * ... })
-     * >>> df
-     * shape: (4, 3)
-     * ┌──────┬───────┬─────────┐
-     * │ year │ month │ revenue │
-     * ├──────┼───────┼─────────┤
-     * │ 2020 │ Jan   │ 100     │
-     * │ 2020 │ Feb   │ 150     │
-     * │ 2021 │ Jan   │ 120     │
-     * │ 2021 │ Feb   │ 180     │
-     * └──────┴───────┴─────────┘
+ * >>> const df = $df.data({ year: [2020, 2020, 2021, 2021], month: ["Jan", "Feb", "Jan", "Feb"], revenue: [100, 150, 120, 180] })
+ * >>> df
+ * shape: (4, 3)
+ * ┌──────┬───────┬─────────┐
+ * │ year │ month │ revenue │
+ * ├──────┼───────┼─────────┤
+ * │ 2020 │ Jan   │ 100     │
+ * │ 2020 │ Feb   │ 150     │
+ * │ 2021 │ Jan   │ 120     │
+ * │ 2021 │ Feb   │ 180     │
+ * └──────┴───────┴─────────┘
      * >>> df.pivot({ index: "year", columns: "month", values: "revenue" })
      * shape: (2, 3)
      * ┌──────┬─────┬─────┐
@@ -643,60 +783,61 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param {Partial<Record<keyof T, string>>} [mapping] Dictionary mapping old column names to new names.
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ old_name: [1] })
-     * >>> df
-     * shape: (1, 1)
-     * ┌──────────┐
-     * │ old_name │
-     * ├──────────┤
-     * │ 1        │
-     * └──────────┘
-     * >>> df.rename({ old_name: "new_name" })
-     * shape: (1, 1)
-     * ┌──────────┐
-     * │ new_name │
-     * ├──────────┤
-     * │ 1        │
-     * └──────────┘
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
+     * >>> df.rename({ a: "id", b: "label" })
+     * shape: (2, 2)
+     * ┌────┬───────┐
+     * │ id │ label │
+     * ├────┼───────┤
+     * │ 1  │ x     │
+     * │ 2  │ y     │
+     * └────┴───────┘
      */
     rename(mapping?: Partial<Record<keyof T, string>>): DataFrame<any>;
     /**
      * Reverses the row ordering of the DataFrame.
      * @returns DataFrame
      * @example
-     * >>> const df = $df.data({ a: [1, 2, 3] })
-     * >>> df
-     * shape: (3, 1)
-     * ┌───┐
-     * │ a │
-     * ├───┤
-     * │ 1 │
-     * │ 2 │
-     * │ 3 │
-     * └───┘
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
      * >>> df.reverse()
-     * shape: (3, 1)
-     * ┌───┐
-     * │ a │
-     * ├───┤
-     * │ 3 │
-     * │ 2 │
-     * │ 1 │
-     * └───┘
+     * shape: (2, 2)
+     * ┌───┬───┐
+     * │ a │ b │
+     * ├───┼───┤
+     * │ 2 │ y │
+     * │ 1 │ x │
+     * └───┴───┘
      */
     reverse(): DataFrame<T>;
     /**
      * Gets current DataFrameSchema dictionary mapping column names to DataType.
      * @returns DataFrameSchema mapping.
      * @example
-     * >>> const df = $df.data({ a: [1], b: ["text"] })
-     * >>> df
-     * shape: (1, 2)
-     * ┌───┬──────┐
-     * │ a │ b    │
-     * ├───┼──────┤
-     * │ 1 │ text │
-     * └───┴──────┘
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
      * >>> df.schema
      * { a: Float64, b: Utf8 }
      */
@@ -706,15 +847,15 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param {(string | IExpr | Record<string, any> | (string | IExpr | Record<string, any>)[])[]} args Column names, column expressions, or object maps to evaluate.
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ a: [1, 2], b: [10, 20] })
-     * >>> df
-     * shape: (2, 2)
-     * ┌───┬────┐
-     * │ a │ b  │
-     * ├───┼────┤
-     * │ 1 │ 10 │
-     * │ 2 │ 20 │
-     * └───┴────┘
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
      * >>> df.select("a", $df.col("b").add(100).alias("b_plus"))
      * shape: (2, 2)
      * ┌───┬────────┐
@@ -729,15 +870,15 @@ export declare class DataFrame<T extends RowRecord = any> {
      * Gets DataFrame dimensions as [height, width] tuple.
      * @returns Tuple [height, width].
      * @example
-     * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
-     * >>> df
-     * shape: (2, 2)
-     * ┌───┬───┐
-     * │ a │ b │
-     * ├───┼───┤
-     * │ 1 │ x │
-     * │ 2 │ y │
-     * └───┴───┘
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
      * >>> df.shape
      * [2, 2]
      */
@@ -748,17 +889,16 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param {number} [end] Optional ending row index (exclusive).
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ a: [10, 20, 30, 40] })
-     * >>> df
-     * shape: (4, 1)
-     * ┌────┐
-     * │ a  │
-     * ├────┤
-     * │ 10 │
-     * │ 20 │
-     * │ 30 │
-     * │ 40 │
-     * └────┘
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
      * >>> df.slice(1, 3)
      * shape: (2, 1)
      * ┌────┐
@@ -778,25 +918,25 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param {Partial<Record<keyof T, (a: any, b: any) => number>>} [config.custom] Optional dictionary mapping column names to custom comparator functions.
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ val: [3, 1, 2] })
-     * >>> df
-     * shape: (3, 1)
-     * ┌─────┐
-     * │ val │
-     * ├─────┤
-     * │ 3   │
-     * │ 1   │
-     * │ 2   │
-     * └─────┘
-     * >>> df.sort({ by: "val" })
-     * shape: (3, 1)
-     * ┌─────┐
-     * │ val │
-     * ├─────┤
-     * │ 1   │
-     * │ 2   │
-     * │ 3   │
-     * └─────┘
+ * >>> 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.sort({ by: "a", descending: true })
+     * shape: (3, 2)
+     * ┌───┬────┐
+     * │ a │ b  │
+     * ├───┼────┤
+     * │ 3 │ 30 │
+     * │ 2 │ 20 │
+     * │ 1 │ 10 │
+     * └───┴────┘
      */
     sort(config?: SortOptions<T>): DataFrame<T>;
     /**
@@ -804,17 +944,16 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param n Number of trailing rows to take (default 10).
      * @returns DataFrame
      * @example
-     * >>> const df = $df.data({ a: [1, 2, 3, 4] })
-     * >>> df
-     * shape: (4, 1)
-     * ┌───┐
-     * │ a │
-     * ├───┤
-     * │ 1 │
-     * │ 2 │
-     * │ 3 │
-     * │ 4 │
-     * └───┘
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
      * >>> df.tail(2)
      * shape: (2, 1)
      * ┌───┐
@@ -825,75 +964,78 @@ export declare class DataFrame<T extends RowRecord = any> {
      * └───┘
      */
     tail(n?: number): DataFrame<T>;
+    /**
+     * Evaluates a column expression or retrieves column values as a raw JavaScript array.
+     * @param {K | IExpr} nameOrExpr Target column name or column expression.
+     * @returns {any[]} Array of column scalar values.
+     * @example
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
+     * >>> df.toArray("a")
+     * [10, 20]
+     */
+    toArray<K extends keyof T>(nameOrExpr: K | IExpr): any[];
     /**
      * Converts columns into a JavaScript dictionary mapping column keys to raw arrays.
      * @returns Column dictionary map.
      * @example
-     * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
-     * >>> df
-     * shape: (2, 2)
-     * ┌───┬───┐
-     * │ a │ b │
-     * ├───┼───┤
-     * │ 1 │ x │
-     * │ 2 │ y │
-     * └───┴───┘
-     * >>> df.to_dict()
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
+     * >>> df.toDict()
      * { a: Float64Array([1, 2]), b: ["x", "y"] }
      */
-    to_dict(): DataFrameColumns<T>;
+    toDict(): DataFrameColumns<T>;
     /**
      * Converts rows into an array of JavaScript objects.
      * @returns Array of row record objects.
      * @example
-     * >>> const df = $df.data({ a: [1], b: ["x"] })
-     * >>> df
-     * shape: (1, 2)
-     * ┌───┬───┐
-     * │ a │ b │
-     * ├───┼───┤
-     * │ 1 │ x │
-     * └───┴───┘
-     * >>> df.to_dicts()
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
+     * >>> df.toDicts()
      * [{ a: 1, b: "x" }]
      */
-    to_dicts(): T[];
-    /**
-     * Evaluates a column expression or retrieves column values as a raw JavaScript array.
-     * @param {K | IExpr} nameOrExpr Target column name or column expression.
-     * @returns {any[]} Array of column scalar values.
-     * @example
-     * >>> const df = $df.data({ a: [10, 20] })
-     * >>> df
-     * shape: (2, 1)
-     * ┌────┐
-     * │ a  │
-     * ├────┤
-     * │ 10 │
-     * │ 20 │
-     * └────┘
-     * >>> df.to_array("a")
-     * [10, 20]
-     */
-    to_array<K extends keyof T>(nameOrExpr: K | IExpr): any[];
+    toDicts(): T[];
     /**
      * Transposes rows into columns and columns into rows.
      * @param {TransposeOptions} [options] Transpose layout options.
-     * @param {boolean} [options.include_header] When `true`, includes original column names as a new header column (default `false`).
-     * @param {string} [options.header_name] Name of the header column when `include_header` is `true` (default `"column"`).
-     * @param {string | Iterable<string>} [options.column_names] Column name or iterable of strings to use as transposed column headers.
+     * @param {boolean} [options.includeHeader] When `true`, includes original column names as a new header column (default `false`).
+     * @param {string} [options.headerName] Name of the header column when `includeHeader` is `true` (default `"column"`).
+     * @param {string | Iterable<string>} [options.columnNames] Column name or iterable of strings to use as transposed column headers.
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ metric: ["sales", "clicks"], q1: [100, 500], q2: [120, 600] })
-     * >>> df
-     * shape: (2, 3)
-     * ┌────────┬─────┬─────┐
-     * │ metric │ q1  │ q2  │
-     * ├────────┼─────┼─────┤
-     * │ sales  │ 100 │ 120 │
-     * │ clicks │ 500 │ 600 │
-     * └────────┴─────┴─────┘
-     * >>> df.transpose({ include_header: true, header_name: "metric" })
+ * >>> const df = $df.data({ year: [2020, 2020, 2021, 2021], month: ["Jan", "Feb", "Jan", "Feb"], revenue: [100, 150, 120, 180] })
+ * >>> df
+ * shape: (4, 3)
+ * ┌──────┬───────┬─────────┐
+ * │ year │ month │ revenue │
+ * ├──────┼───────┼─────────┤
+ * │ 2020 │ Jan   │ 100     │
+ * │ 2020 │ Feb   │ 150     │
+ * │ 2021 │ Jan   │ 120     │
+ * │ 2021 │ Feb   │ 180     │
+ * └──────┴───────┴─────────┘
+     * >>> df.transpose({ includeHeader: true, headerName: "metric" })
      * shape: (2, 3)
      * ┌────────┬──────────┬──────────┐
      * │ metric │ column_0 │ column_1 │
@@ -902,22 +1044,21 @@ export declare class DataFrame<T extends RowRecord = any> {
      * │ q2     │ 120      │ 600      │
      * └────────┴──────────┴──────────┘
      */
-    transpose({ include_header: includeHeader, header_name: headerName, column_names: colNamesOpt }?: TransposeOptions): DataFrame<any>;
+    transpose({ includeHeader: includeHeader, headerName: headerName, columnNames: colNamesOpt }?: TransposeOptions): DataFrame<any>;
     /**
      * Filters distinct unique rows matching target key columns.
      * @param {K | K[]} [columns] Target column or array of column names to evaluate uniqueness.
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ a: [1, 2, 2], b: ["x", "y", "y"] })
-     * >>> df
-     * shape: (3, 2)
-     * ┌───┬───┐
-     * │ a │ b │
-     * ├───┼───┤
-     * │ 1 │ x │
-     * │ 2 │ y │
-     * │ 2 │ y │
-     * └───┴───┘
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
      * >>> df.unique()
      * shape: (2, 2)
      * ┌───┬───┐
@@ -937,22 +1078,27 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param {string} [config.valueName] Name for the new value column holding cell values (default `"value"`).
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ year: [2020], Jan: [100], Feb: [150] })
-     * >>> df
-     * shape: (1, 3)
-     * ┌──────┬─────┬─────┐
-     * │ year │ Jan │ Feb │
-     * ├──────┼─────┼─────┤
-     * │ 2020 │ 100 │ 150 │
-     * └──────┴─────┴─────┘
-     * >>> df.unpivot({ idVars: "year", valueVars: ["Jan", "Feb"], varName: "month", valueName: "revenue" })
-     * shape: (2, 3)
-     * ┌──────┬───────┬─────────┐
-     * │ year │ month │ revenue │
-     * ├──────┼───────┼─────────┤
-     * │ 2020 │ Jan   │ 100     │
-     * │ 2020 │ Feb   │ 150     │
-     * └──────┴───────┴─────────┘
+ * >>> const df = $df.data({ year: [2020, 2020, 2021, 2021], month: ["Jan", "Feb", "Jan", "Feb"], revenue: [100, 150, 120, 180] })
+ * >>> df
+ * shape: (4, 3)
+ * ┌──────┬───────┬─────────┐
+ * │ year │ month │ revenue │
+ * ├──────┼───────┼─────────┤
+ * │ 2020 │ Jan   │ 100     │
+ * │ 2020 │ Feb   │ 150     │
+ * │ 2021 │ Jan   │ 120     │
+ * │ 2021 │ Feb   │ 180     │
+ * └──────┴───────┴─────────┘
+     * >>> df.unpivot({ idVars: "metric", valueVars: ["q1", "q2"], varName: "quarter", valueName: "val" })
+     * shape: (4, 3)
+     * ┌────────┬─────────┬─────┐
+     * │ metric │ quarter │ val │
+     * ├────────┼─────────┼─────┤
+     * │ sales  │ q1      │ 100 │
+     * │ sales  │ q2      │ 120 │
+     * │ clicks │ q1      │ 500 │
+     * │ clicks │ q2      │ 600 │
+     * └────────┴─────────┴─────┘
      */
     unpivot<U extends RowRecord = any>(config: UnpivotOptions<T>): DataFrame<U>;
     /**
@@ -960,93 +1106,132 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param {ConcatItem | ConcatItem[]} other Single DataFrame or array of DataFrames to append vertically.
      * @returns {DataFrame}
      * @example
-     * >>> const df1 = $df.data({ a: [1] })
-     * >>> df1
-     * shape: (1, 1)
-     * ┌───┐
-     * │ a │
-     * ├───┤
-     * │ 1 │
-     * └───┘
-     * >>> const df2 = $df.data({ a: [2] })
+ * >>> const df1 = $df.data({ a: [1, 2] })
+ * >>> const df2 = $df.data({ b: [10, 20] })
+ * >>> df1
+ * shape: (2, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * └───┘
+ * >>> df2
+ * shape: (2, 1)
+ * ┌────┐
+ * │ b  │
+ * ├────┤
+ * │ 10 │
+ * │ 20 │
+ * └────┘
      * >>> df1.vstack(df2)
-     * shape: (2, 1)
-     * ┌───┐
-     * │ a │
-     * ├───┤
-     * │ 1 │
-     * │ 2 │
-     * └───┘
+     * shape: (4, 1)
+     * ┌──────┐
+     * │ a    │
+     * ├──────┤
+     * │ 1    │
+     * │ 2    │
+     * │ null │
+     * │ null │
+     * └──────┘
      */
     vstack<U extends RowRecord = any>(other: ConcatItem | ConcatItem[]): DataFrame<U>;
     /**
      * Gets width (total column count) of the DataFrame.
      * @returns Number of columns.
      * @example
-     * >>> const df = $df.data({ a: [1], b: [2] })
-     * >>> df
-     * shape: (1, 2)
-     * ┌───┬───┐
-     * │ a │ b │
-     * ├───┼───┤
-     * │ 1 │ 2 │
-     * └───┴───┘
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
      * >>> df.width
      * 2
      */
     get width(): number;
-    private _normalizeArgs;
     /**
      * Adds new columns or updates existing ones using column expressions.
      * @param {(string | IExpr | Record<string, any> | (string | IExpr | Record<string, any>)[])[]} args Expressions or field objects defining column calculations.
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ a: [1, 2] })
-     * >>> df
-     * shape: (2, 1)
-     * ┌───┐
-     * │ a │
-     * ├───┤
-     * │ 1 │
-     * │ 2 │
-     * └───┘
-     * >>> df.with_columns($df.col("a").add(10).alias("b"))
-     * shape: (2, 2)
-     * ┌───┬────┐
-     * │ a │ b  │
-     * ├───┼────┤
-     * │ 1 │ 11 │
-     * │ 2 │ 12 │
-     * └───┴────┘
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
+     * >>> df.withColumns($df.col("a").mul(10).alias("a_x10"))
+     * shape: (2, 3)
+     * ┌───┬───┬───────┐
+     * │ a │ b │ a_x10 │
+     * ├───┼───┼───────┤
+     * │ 1 │ x │ 10    │
+     * │ 2 │ y │ 20    │
+     * └───┴───┴───────┘
      */
-    with_columns(...args: (string | IExpr | Record<string, any> | (string | IExpr | Record<string, any>)[])[]): DataFrame<any>;
+    withColumns(...args: (string | IExpr | Record<string, any> | (string | IExpr | Record<string, any>)[])[]): DataFrame<any>;
     /**
      * Appends an incremental index column.
      * @param {string} [name] Name of index column (default "index").
      * @param {number} [offset] Starting numeric index offset (default 0).
      * @returns {DataFrame}
      * @example
-     * >>> const df = $df.data({ val: ["a", "b"] })
-     * >>> df
-     * shape: (2, 1)
-     * ┌─────┐
-     * │ val │
-     * ├─────┤
-     * │ a   │
-     * │ b   │
-     * └─────┘
-     * >>> df.with_row_index("idx")
-     * shape: (2, 2)
-     * ┌─────┬─────┐
-     * │ idx │ val │
-     * ├─────┼─────┤
-     * │ 0   │ a   │
-     * │ 1   │ b   │
-     * └─────┴─────┘
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
+     * >>> df.withRowIndex("idx")
+     * shape: (2, 3)
+     * ┌─────┬───┬───┐
+     * │ idx │ a │ b │
+     * ├─────┼───┼───┤
+     * │ 0   │ 1 │ x │
+     * │ 1   │ 2 │ y │
+     * └─────┴───┴───┘
+     */
+    withRowIndex(name?: string, offset?: number): DataFrame<any>;
+    /**
+     * Writes DataFrame to CSV format string or file/stream target.
+     * @note [Environment]: When `file` is provided as a string file path, execution requires a Node.js-compatible
+     * environment with `fs` access. In browser environments, omit `file` to receive a string or supply a custom writable stream object.
+     * @param {string | { write: (str: string) => void }} [file] Target file path or writable stream target (optional).
+     * @param {WriteCSVOptions} [options] CSV formatting options.
+     * @param {string} [options.delimiter] Column delimiter character (default `","`).
+     * @param {boolean} [options.header] When `true` (default), includes column header row.
+     * @param {string} [options.quoteChar] Character used to enclose fields containing special characters (default `'"'`).
+     * @returns {string} CSV string output.
+     * @example
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
+     * >>> df.writeCsv()
+     * "a,b\n1,x"
      */
-    with_row_index(name?: string, offset?: number): DataFrame<any>;
+    writeCsv(file?: string | {
+        write: (str: string) => void;
+    }, options?: WriteCSVOptions): string;
     /**
      * Writes DataFrame rows to JSON format string or file/stream target.
+     * @note [Environment]: When `file` is provided as a string file path, execution requires a Node.js-compatible
+     * environment with `fs` access. In browser environments, omit `file` to receive a string or supply a custom writable stream object.
      * @param {string | { write: (str: string) => void }} [file] Target file path or writable stream target (optional).
      * @param {WriteJSONOptions} [options] JSON formatting and replacer options.
      * @param {JSONFormat} [options.format] JSON output format structure (`"json"` or `"ndjson"`). Default `"json"`.
@@ -1073,41 +1258,19 @@ export declare class DataFrame<T extends RowRecord = any> {
      * @param {((this: any, k: string, v: any) => any) | (string | number)[] | null} [options.replacerOptions.replacer] Custom replacer function or array whitelist that runs first for pre-processing.
      * @returns {string} JSON string representation.
      * @example
-     * >>> const df = $df.data({ a: [1], b: ["x"] })
-     * >>> df
-     * shape: (1, 2)
-     * ┌───┬───┐
-     * │ a │ b │
-     * ├───┼───┤
-     * │ 1 │ x │
-     * └───┴───┘
-     * >>> df.write_json()
+ * >>> const df = $df.data({ a: [1, 2], b: ["x", "y"] })
+ * >>> df
+ * shape: (2, 2)
+ * ┌───┬───┐
+ * │ a │ b │
+ * ├───┼───┤
+ * │ 1 │ x │
+ * │ 2 │ y │
+ * └───┴───┘
+     * >>> df.writeJson()
      * '[{"a":1,"b":"x"}]'
      */
-    write_json(file?: string | {
+    writeJson(file?: string | {
         write: (str: string) => void;
     }, { format, replacerOptions }?: WriteJSONOptions): string;
-    /**
-     * Writes DataFrame to CSV format string or file/stream target.
-     * @param {string | { write: (str: string) => void }} [file] Target file path or writable stream target (optional).
-     * @param {WriteCSVOptions} [options] CSV formatting options.
-     * @param {string} [options.delimiter] Column delimiter character (default `","`).
-     * @param {boolean} [options.header] When `true` (default), includes column header row.
-     * @param {string} [options.quoteChar] Character used to enclose fields containing special characters (default `'"'`).
-     * @returns {string} CSV string output.
-     * @example
-     * >>> const df = $df.data({ a: [1], b: ["x"] })
-     * >>> df
-     * shape: (1, 2)
-     * ┌───┬───┐
-     * │ a │ b │
-     * ├───┼───┤
-     * │ 1 │ x │
-     * └───┴───┘
-     * >>> df.write_csv()
-     * "a,b\n1,x"
-     */
-    write_csv(file?: string | {
-        write: (str: string) => void;
-    }, options?: WriteCSVOptions): string;
 }