df-script 1.9.0 → 2.0.0

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

@@ -12,35 +12,43 @@ export declare class ComparisonExpr extends ExprBase {
      * @param closed Control boundary inclusivity: "both", "left", "right", or "none" (default: "both").
      * @returns ColumnExpression
      * @example
-     * >>> df.with_columns($df.col("a").between(1, 2).alias("in_range"))
+ * >>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───┬────┐
+ * │ a │ b  │
+ * ├───┼────┤
+ * │ 1 │ 10 │
+ * │ 2 │ 20 │
+ * │ 3 │ 30 │
+ * └───┴────┘
+     * >>> df.withColumns($df.col("a").between(1, 2).alias("in_range"))
      * shape: (3, 3)
-     * ┌───┬───┬──────────┐
-     * │ a │ b │ in_range │
-     * ├───┼───┼──────────┤
-     * │ 1 │ x │ true     │
-     * │ 2 │ y │ true     │
-     * │ 3 │ z │ false    │
-     * └───┴───┴──────────┘
+     * ┌───┬────┬──────────┐
+     * │ a │ b  │ in_range │
+     * ├───┼────┼──────────┤
+     * │ 1 │ 10 │ true     │
+     * │ 2 │ 20 │ true     │
+     * │ 3 │ 30 │ false    │
+     * └───┴────┴──────────┘
      */
-    between(lower: any, upper: any, closed?: "both" | "left" | "right" | "none"): this;
+    between(lower: any, upper: any, closed?: "both" | "left" | "right" | "none"): any;
     /**
      * Boolean comparison: Returns true if column values match the specified value exactly.
      * @param val The value or column expression to compare against.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({
-     * ...   a: [1, 2, 3]
-     * ... })
-     * shape: (3, 1)
-     * ┌───┐
-     * │ a │
-     * ├───┤
-     * │ 1 │
-     * │ 2 │
-     * │ 3 │
-     * └───┘
-     *
-     * >>> df.with_columns($df.col("a").eq(2).alias("is_two"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").eq(2).alias("is_two"))
      * shape: (3, 2)
      * ┌───┬────────┐
      * │ a │ is_two │
@@ -56,8 +64,17 @@ export declare class ComparisonExpr extends ExprBase {
      * @param val The value or column expression to compare against.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [1, null, 3] })
-     * >>> df.with_columns($df.col("a").eq_missing(null).alias("is_missing"))
+ * >>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌──────┬──────┐
+ * │ a    │ b    │
+ * ├──────┼──────┤
+ * │ 1    │ null │
+ * │ null │ 2    │
+ * │ 3    │ null │
+ * └──────┴──────┘
+     * >>> df.withColumns($df.col("a").eqMissing(null).alias("is_missing"))
      * shape: (3, 2)
      * ┌──────┬────────────┐
      * │ a    │ is_missing │
@@ -67,22 +84,31 @@ export declare class ComparisonExpr extends ExprBase {
      * │ 3    │ false      │
      * └──────┴────────────┘
      */
-    eq_missing(val: any): this;
+    eqMissing(val: any): this;
     /**
      * Boolean comparison: Returns true if greater than or equal to argument.
      * @param val The value or column expression to compare against.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ price: [90, 100, 110] })
-     * >>> df.with_columns($df.col("price").ge(100).alias("ge_100"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").ge(2).alias("ge_two"))
      * shape: (3, 2)
-     * ┌───────┬────────┐
-     * │ price │ ge_100 │
-     * ├───────┼────────┤
-     * │ 90    │ false  │
-     * │ 100   │ true   │
-     * │ 110   │ true   │
-     * └───────┴────────┘
+     * ┌───┬────────┐
+     * │ a │ ge_two │
+     * ├───┼────────┤
+     * │ 1 │ false  │
+     * │ 2 │ true   │
+     * │ 3 │ true   │
+     * └───┴────────┘
      */
     ge(val: any): this;
     /**
@@ -90,228 +116,362 @@ export declare class ComparisonExpr extends ExprBase {
      * @param val The value or column expression to compare against.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ price: [90, 100, 110] })
-     * >>> df.with_columns($df.col("price").gt(100).alias("gt_100"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").gt(2).alias("gt_two"))
      * shape: (3, 2)
-     * ┌───────┬────────┐
-     * │ price │ gt_100 │
-     * ├───────┼────────┤
-     * │ 90    │ false  │
-     * │ 100   │ false  │
-     * │ 110   │ true   │
-     * └───────┴────────┘
+     * ┌───┬────────┐
+     * │ a │ gt_two │
+     * ├───┼────────┤
+     * │ 1 │ false  │
+     * │ 2 │ false  │
+     * │ 3 │ true   │
+     * └───┴────────┘
      */
     gt(val: any): this;
-    /**
-     * Aggregation: Checks if any value in the group is null.
-     * @returns ColumnExpression
-     * @example
-     * >>> const df = $df.data({ group: ["A", "A"], val: [10, null] })
-     * >>> df.group_by("group").agg($df.col("val").has_nulls().alias("has_nulls"))
-     * shape: (1, 2)
-     * ┌───────┬───────────┐
-     * │ group │ has_nulls │
-     * ├───────┼───────────┤
-     * │ "A"   │ true      │
-     * └───────┴───────────┘
-     */
-    has_nulls(): any;
     /**
      * Determines if floating-point values are approximately equal within tolerances.
      * @param other The value or expression to compare against.
-     * @param options Tolerance values absolute (abs_tol) and relative (rel_tol), and NaN options.
+     * @param options Tolerance values absolute (absTol) and relative (relTol), and NaN options.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [1.000000001, 2.0] })
-     * >>> df.with_columns($df.col("a").is_close(1.0).alias("close"))
-     * shape: (2, 2)
-     * ┌─────────────┬───────┐
-     * │ a           │ close │
-     * ├─────────────┼───────┤
-     * │ 1.000000001 │ true  │
-     * │ 2.0         │ false │
-     * └─────────────┴───────┘
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").isClose(1.0).alias("close"))
+     * shape: (3, 2)
+     * ┌───┬───────┐
+     * │ a │ close │
+     * ├───┼───────┤
+     * │ 1 │ true  │
+     * │ 2 │ false │
+     * │ 3 │ false │
+     * └───┴───────┘
      */
-    is_close(other: any, { abs_tol, rel_tol, nans_equal }?: {
-        abs_tol?: number;
-        rel_tol?: number;
-        nans_equal?: boolean;
+    isClose(other: any, { absTol, relTol, nansEqual }?: {
+        absTol?: number;
+        relTol?: number;
+        nansEqual?: boolean;
     }): this;
     /**
      * Checks if values occur more than once in the column.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [1, 2, 2] })
-     * >>> df.with_columns($df.col("a").is_duplicated().alias("dup"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").isDuplicated().alias("dup"))
      * shape: (3, 2)
      * ┌───┬───────┐
      * │ a │ dup   │
      * ├───┼───────┤
      * │ 1 │ false │
-     * │ 2 │ true  │
-     * │ 2 │ true  │
+     * │ 2 │ false │
+     * │ 3 │ false │
      * └───┴───────┘
      */
-    is_duplicated(): this;
+    isDuplicated(): this;
     /**
      * Checks if strings or nested arrays have length 0.
      * @param options Config options including whether to ignore nulls inside arrays.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: ["", "hello", []] })
-     * >>> df.with_columns($df.col("a").is_empty().alias("empty"))
-     * shape: (3, 2)
-     * ┌─────────┬───────┐
-     * │ a       │ empty │
-     * ├─────────┼───────┤
-     * │ ""      │ true  │
-     * │ "hello" │ false │
-     * │ []      │ true  │
-     * └─────────┴───────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").isEmpty().alias("empty"))
+     * shape: (2, 2)
+     * ┌─────────────┬───────┐
+     * │ s           │ empty │
+     * ├─────────────┼───────┤
+     * │ "  hello  " │ false │
+     * │ "  world  " │ false │
+     * └─────────────┴───────┘
      */
-    is_empty({ ignoreNulls }?: {
+    isEmpty({ ignoreNulls }?: {
         ignoreNulls?: boolean;
     }): this;
     /**
      * Checks if values are finite numbers (not NaN or Infinity).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [1.5, Infinity, NaN] })
-     * >>> df.with_columns($df.col("a").is_finite().alias("finite"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").isFinite().alias("finite"))
      * shape: (3, 2)
-     * ┌──────────┬────────┐
-     * │ a        │ finite │
-     * ├──────────┼────────┤
-     * │ 1.5      │ true   │
-     * │ Infinity │ false  │
-     * │ NaN      │ false  │
-     * └──────────┴────────┘
+     * ┌───┬────────┐
+     * │ a │ finite │
+     * ├───┼────────┤
+     * │ 1 │ true   │
+     * │ 2 │ true   │
+     * │ 3 │ true   │
+     * └───┴────────┘
      */
-    is_finite(): this;
+    isFinite(): this;
     /**
      * Checks if column values are members of a specified array or list.
      * @param values An array of candidate values or a single value to match against.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ category: ["toys", "books", "food"] })
-     * >>> df.with_columns($df.col("category").is_in(["toys", "books"]).alias("in_list"))
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").isIn(["apple", "banana"]).alias("in_list"))
      * shape: (3, 2)
      * ┌──────────┬─────────┐
-     * │ category │ in_list │
+     * │ s        │ in_list │
      * ├──────────┼─────────┤
-     * │ "toys"   │ true    │
-     * │ "books"  │ true    │
-     * │ "food"   │ false   │
+     * │ "apple"  │ true    │
+     * │ "banana" │ true    │
+     * │ "cherry" │ false   │
      * └──────────┴─────────┘
      */
-    is_in(values: any[] | any): this;
+    isIn(values: any[] | any): this;
     /**
      * Checks if values are positive or negative Infinity.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [1.5, Infinity, -Infinity] })
-     * >>> df.with_columns($df.col("a").is_infinite().alias("inf"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").isInfinite().alias("inf"))
      * shape: (3, 2)
-     * ┌───────────┬───────┐
-     * │ a         │ inf   │
-     * ├───────────┼───────┤
-     * │ 1.5       │ false │
-     * │ Infinity  │ true  │
-     * │ -Infinity │ true  │
-     * └───────────┴───────┘
+     * ┌───┬───────┐
+     * │ a │ inf   │
+     * ├───┼───────┤
+     * │ 1 │ false │
+     * │ 2 │ false │
+     * │ 3 │ false │
+     * └───┴───────┘
      */
-    is_infinite(): this;
+    isInfinite(): this;
     /**
      * Checks if values are NaN.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [1.5, NaN] })
-     * >>> df.with_columns($df.col("a").is_nan().alias("nan"))
-     * shape: (2, 2)
-     * ┌─────┬───────┐
-     * │ a   │ nan   │
-     * ├─────┼───────┤
-     * │ 1.5 │ false │
-     * │ NaN │ true  │
-     * └─────┴───────┘
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").isNan().alias("nan"))
+     * shape: (3, 2)
+     * ┌───┬───────┐
+     * │ a │ nan   │
+     * ├───┼───────┤
+     * │ 1 │ false │
+     * │ 2 │ false │
+     * │ 3 │ false │
+     * └───┴───────┘
      */
-    is_nan(): this;
+    isNan(): this;
     /**
      * Checks if values are not NaN.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [1.5, NaN] })
-     * >>> df.with_columns($df.col("a").is_not_nan().alias("not_nan"))
-     * shape: (2, 2)
-     * ┌─────┬─────────┐
-     * │ a   │ not_nan │
-     * ├─────┼─────────┤
-     * │ 1.5 │ true    │
-     * │ NaN │ false   │
-     * └─────┴─────────┘
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").isNotNan().alias("not_nan"))
+     * shape: (3, 2)
+     * ┌───┬─────────┐
+     * │ a │ not_nan │
+     * ├───┼─────────┤
+     * │ 1 │ true    │
+     * │ 2 │ true    │
+     * │ 3 │ true    │
+     * └───┴─────────┘
      */
-    is_not_nan(): this;
+    isNotNan(): any;
+    /**
+     * Checks if column values match the N-th distinct value by positive or negative index position.
+     * @param index The 0-based or negative index position into the ordered distinct values (e.g. 0 for first distinct, -1 for last distinct).
+     * @param nullOnOob If true, returns null if index is out of bounds (default: true).
+     * @returns ColumnExpression
+     * @example
+ * >>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌───┬────┐
+ * │ a │ b  │
+ * ├───┼────┤
+ * │ 1 │ 10 │
+ * │ 2 │ 20 │
+ * │ 3 │ 30 │
+ * └───┴────┘
+     * >>> df.withColumns($df.col("a").isNDistinct(0).alias("is_first"))
+     * shape: (3, 3)
+     * ┌───┬────┬──────────┐
+     * │ a │ b  │ is_first │
+     * ├───┼────┼──────────┤
+     * │ 1 │ 10 │ true     │
+     * │ 2 │ 20 │ false    │
+     * │ 3 │ 30 │ false    │
+     * └───┴────┴──────────┘
+     */
+    isNDistinct(index: number, nullOnOob?: boolean): this;
     /**
      * Checks if column values are non-null and valid (not null, undefined, or missing).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ email: ["alice@example.com", null] })
-     * >>> df.with_columns($df.col("email").is_not_null().alias("valid"))
-     * shape: (2, 2)
-     * ┌───────────────────┬───────┐
-     * │ email             │ valid │
-     * ├───────────────────┼───────┤
-     * │ alice@example.com │ true  │
-     * │ null              │ false │
-     * └───────────────────┴───────┘
+ * >>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌──────┬──────┐
+ * │ a    │ b    │
+ * ├──────┼──────┤
+ * │ 1    │ null │
+ * │ null │ 2    │
+ * │ 3    │ null │
+ * └──────┴──────┘
+     * >>> df.withColumns($df.col("a").isNotNull().alias("valid"))
+     * shape: (3, 2)
+     * ┌──────┬───────┐
+     * │ a    │ valid │
+     * ├──────┼───────┤
+     * │ 1    │ true  │
+     * │ null │ false │
+     * │ 3    │ true  │
+     * └──────┴───────┘
      */
-    is_not_null(): this;
+    isNotNull(): any;
     /**
      * Checks if column values are null, undefined, or missing.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ email: ["alice@example.com", null] })
-     * >>> df.with_columns($df.col("email").is_null().alias("missing"))
-     * shape: (2, 2)
-     * ┌───────────────────┬─────────┐
-     * │ email             │ missing │
-     * ├───────────────────┼─────────┤
-     * │ alice@example.com │ false   │
-     * │ null              │ true    │
-     * └───────────────────┴─────────┘
+ * >>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌──────┬──────┐
+ * │ a    │ b    │
+ * ├──────┼──────┤
+ * │ 1    │ null │
+ * │ null │ 2    │
+ * │ 3    │ null │
+ * └──────┴──────┘
+     * >>> df.withColumns($df.col("a").isNull().alias("missing"))
+     * shape: (3, 2)
+     * ┌──────┬─────────┐
+     * │ a    │ missing │
+     * ├──────┼─────────┤
+     * │ 1    │ false   │
+     * │ null │ true    │
+     * │ 3    │ false   │
+     * └──────┴─────────┘
      */
-    is_null(): this;
+    isNull(): this;
     /**
      * Checks if values occur exactly once in the column.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [1, 2, 2] })
-     * >>> df.with_columns($df.col("a").is_unique().alias("uniq"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").isUnique().alias("uniq"))
      * shape: (3, 2)
-     * ┌───┬───────┐
-     * │ a │ uniq  │
-     * ├───┼───────┤
-     * │ 1 │ true  │
-     * │ 2 │ false │
-     * │ 2 │ false │
-     * └───┴───────┘
+     * ┌───┬──────┐
+     * │ a │ uniq │
+     * ├───┼──────┤
+     * │ 1 │ true │
+     * │ 2 │ true │
+     * │ 3 │ true │
+     * └───┴──────┘
      */
-    is_unique(): this;
+    isUnique(): any;
     /**
      * Boolean comparison: Returns true if less than or equal to argument.
      * @param val The value or column expression to compare against.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ price: [40, 50, 60] })
-     * >>> df.with_columns($df.col("price").le(50).alias("le_50"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").le(2).alias("le_two"))
      * shape: (3, 2)
-     * ┌───────┬───────┐
-     * │ price │ le_50 │
-     * ├───────┼───────┤
-     * │ 40    │ true  │
-     * │ 50    │ true  │
-     * │ 60    │ false │
-     * └───────┴───────┘
+     * ┌───┬────────┐
+     * │ a │ le_two │
+     * ├───┼────────┤
+     * │ 1 │ true   │
+     * │ 2 │ true   │
+     * │ 3 │ false  │
+     * └───┴────────┘
      */
     le(val: any): this;
     /**
@@ -319,16 +479,25 @@ export declare class ComparisonExpr extends ExprBase {
      * @param val The value or column expression to compare against.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ price: [40, 50, 60] })
-     * >>> df.with_columns($df.col("price").lt(50).alias("lt_50"))
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").lt(2).alias("lt_two"))
      * shape: (3, 2)
-     * ┌───────┬───────┐
-     * │ price │ lt_50 │
-     * ├───────┼───────┤
-     * │ 40    │ true  │
-     * │ 50    │ false │
-     * │ 60    │ false │
-     * └───────┴───────┘
+     * ┌───┬────────┐
+     * │ a │ lt_two │
+     * ├───┼────────┤
+     * │ 1 │ true   │
+     * │ 2 │ false  │
+     * │ 3 │ false  │
+     * └───┴────────┘
      */
     lt(val: any): this;
     /**
@@ -336,15 +505,25 @@ export declare class ComparisonExpr extends ExprBase {
      * @param val The value or column expression to compare against.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ category: ["electronics", "toys"] })
-     * >>> df.with_columns($df.col("category").ne("electronics").alias("not_elec"))
-     * shape: (2, 2)
-     * ┌─────────────┬──────────┐
-     * │ category    │ not_elec │
-     * ├─────────────┼──────────┤
-     * │ electronics │ false    │
-     * │ toys        │ true     │
-     * └─────────────┴──────────┘
+ * >>> const df = $df.data({ a: [1, 2, 3] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌───┐
+ * │ a │
+ * ├───┤
+ * │ 1 │
+ * │ 2 │
+ * │ 3 │
+ * └───┘
+     * >>> df.withColumns($df.col("a").ne(2).alias("not_two"))
+     * shape: (3, 2)
+     * ┌───┬─────────┐
+     * │ a │ not_two │
+     * ├───┼─────────┤
+     * │ 1 │ true    │
+     * │ 2 │ false   │
+     * │ 3 │ true    │
+     * └───┴─────────┘
      */
     ne(val: any): this;
     /**
@@ -352,8 +531,17 @@ export declare class ComparisonExpr extends ExprBase {
      * @param val The value or column expression to compare against.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ a: [1, null, 3] })
-     * >>> df.with_columns($df.col("a").ne_missing(null).alias("not_missing"))
+ * >>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })
+ * >>> df
+ * shape: (3, 2)
+ * ┌──────┬──────┐
+ * │ a    │ b    │
+ * ├──────┼──────┤
+ * │ 1    │ null │
+ * │ null │ 2    │
+ * │ 3    │ null │
+ * └──────┴──────┘
+     * >>> df.withColumns($df.col("a").neMissing(null).alias("not_missing"))
      * shape: (3, 2)
      * ┌──────┬─────────────┐
      * │ a    │ not_missing │
@@ -363,22 +551,31 @@ export declare class ComparisonExpr extends ExprBase {
      * │ 3    │ true        │
      * └──────┴─────────────┘
      */
-    ne_missing(val: any): this;
+    neMissing(val: any): any;
     /**
      * Checks if values are not elements of a specific array or set list.
      * @param values An array of candidate values or a single value to match against.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ category: ["toys", "books", "food"] })
-     * >>> df.with_columns($df.col("category").not_in(["toys", "books"]).alias("not_in"))
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").notIn(["apple", "banana"]).alias("not_in"))
      * shape: (3, 2)
      * ┌──────────┬────────┐
-     * │ category │ not_in │
+     * │ s        │ not_in │
      * ├──────────┼────────┤
-     * │ toys     │ false  │
-     * │ books    │ false  │
-     * │ food     │ true   │
+     * │ "apple"  │ false  │
+     * │ "banana" │ false  │
+     * │ "cherry" │ true   │
      * └──────────┴────────┘
      */
-    not_in(values: any[] | any): this;
+    notIn(values: any[] | any): any;
 }