df-script 1.7.0 → 1.9.0

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

@@ -10,6 +10,22 @@ export declare class ArrayExprNamespace {
     expr: any;
     constructor(expr: any);
     _deriveArray(fn: (arr: any[] | AnyTypedArray) => 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.with_columns($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
@@ -40,6 +56,36 @@ export declare class ArrayExprNamespace {
      * └────────────────┴──────────┘
      */
     any(): any;
+    /**
+     * Finds the index of the maximum value in each array.
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ a: [[1, 5, 2], [10, 4]] })
+     * >>> df.with_columns($df.col("a").arr.arg_max().alias("max_idx"))
+     * shape: (2, 2)
+     * ┌───────────┬─────────┐
+     * │ a         │ max_idx │
+     * ├───────────┼─────────┤
+     * │ [1, 5, 2] │ 1       │
+     * │ [10, 4]   │ 0       │
+     * └───────────┴─────────┘
+     */
+    arg_max(): any;
+    /**
+     * Finds the index of the minimum value in each array.
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ a: [[5, 1, 2], [10, 4]] })
+     * >>> df.with_columns($df.col("a").arr.arg_min().alias("min_idx"))
+     * shape: (2, 2)
+     * ┌───────────┬─────────┐
+     * │ a         │ min_idx │
+     * ├───────────┼─────────┤
+     * │ [5, 1, 2] │ 1       │
+     * │ [10, 4]   │ 1       │
+     * └───────────┴─────────┘
+     */
+    arg_min(): any;
     /**
      * Checks if nested lists contain item.
      * @param item The element to search for.
@@ -122,20 +168,20 @@ export declare class ArrayExprNamespace {
      */
     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({ id: [1, 2], values: [[10, 20], [30]] })
+     * >>> df.select([$df.col("id"), $df.col("values").arr.explode()])
+     * shape: (3, 2)
+     * ┌─────┬────────┐
+     * │ id  │ values │
+     * ├─────┼────────┤
+     * │ 1   │ 10     │
+     * │ 1   │ 20     │
+     * │ 2   │ 30     │
+     * └─────┴────────┘
      */
     explode({ empty_as_null, keep_nulls }?: ExplodeOptions): any;
     /**
@@ -271,21 +317,6 @@ export declare class ArrayExprNamespace {
      * └───────────┴───────┘
      */
     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
@@ -331,21 +362,6 @@ export declare class ArrayExprNamespace {
      * └───────────┴───────┘
      */
     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

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

@@ -1,6 +1,6 @@
-import type { IExpr, StrptimeOptions } from "../../types";
+import type { IExpr, StrptimeOptions, StringDecodeOptions, StringEncodeOptions, EscapeRegexOptions, ExtractManyOptions, ExtractRegexEngineOptions, FindOptions, FindManyOptions, SplitOptions, ReplaceOptions, ReplaceManyOptions } from "../../types";
 import { ExprBase } from "../ExprBase";
-import { StripCharsOptions } from "../../utils";
+import { StripCharsOptions, JoinArrayOptions, SafeJsonParseOptions } from "../../utils";
 /**
  * @namespace $df.col.str
  * @category ColumnExpression
@@ -11,6 +11,7 @@ export declare class StringExprNamespace {
     constructor(expr: any);
     _deriveString(fn: (v: string) => any): any;
     _patternGuard(pattern: any, fn: () => any): any;
+    _matchPattern(str: string, pattern: string | RegExp): boolean;
     /**
      * Concatenates string elements with another string value or expression.
      * @param other The string value or column expression to concatenate.
@@ -42,6 +43,22 @@ export declare class StringExprNamespace {
      * └──────────────────┴────────────┘
      */
     contains(pattern: string | RegExp): any;
+    /**
+     * Checks if a string contains any of the search patterns.
+     * @param patterns Array of substring or regular expression search patterns.
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ email: ["user@example.com", "admin@test.org"] })
+     * >>> df.with_columns($df.col("email").str.contains_any(["@example.com", "@test.org"]).alias("is_target"))
+     * shape: (2, 2)
+     * ┌──────────────────┬───────────┐
+     * │ email            │ is_target │
+     * ├──────────────────┼───────────┤
+     * │ user@example.com │ true      │
+     * │ admin@test.org   │ true      │
+     * └──────────────────┴───────────┘
+     */
+    contains_any(patterns: (string | RegExp)[]): any;
     /**
      * Counts occurrences of a substring or regular expression match in each string element.
      * @param pattern Search substring or regular expression.
@@ -57,7 +74,54 @@ export declare class StringExprNamespace {
      * │ apple  │ 1       │
      * └────────┴─────────┘
      */
-    count_matches(pattern: string | RegExp): any;
+    count_matches(pattern: string | RegExp | any, options?: {
+        literal?: boolean;
+    } | boolean): any;
+    /**
+     * Escapes special regular expression characters in string elements.
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ pat: ["a.b", "c$d"] })
+     * >>> df.with_columns($df.col("pat").str.escape_regex().alias("escaped"))
+     * shape: (2, 2)
+     * ┌───────┬─────────┐
+     * │ pat   │ escaped │
+     * ├───────┼─────────┤
+     * │ a.b   │ a\.b    │
+     * │ c$d   │ c\$d    │
+     * └───────┴─────────┘
+     */
+    escape_regex(options?: EscapeRegexOptions): any;
+    /**
+     * Decodes hex or base64 encoded string column values into string.
+     * @param options Object containing encoding ("hex" | "base64") and optional strict flag
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ encoded: ["68656c6c6f"] })
+     * >>> df.with_columns($df.col("encoded").str.decode({ encoding: "hex" }).alias("decoded"))
+     * shape: (1, 2)
+     * ┌────────────┬─────────┐
+     * │ encoded    │ decoded │
+     * ├────────────┼─────────┤
+     * │ 68656c6c6f │ hello   │
+     * └────────────┴─────────┘
+     */
+    decode(options: StringDecodeOptions): any;
+    /**
+     * Encodes string column values into hex or base64.
+     * @param options Object containing encoding ("hex" | "base64")
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ text: ["hello"] })
+     * >>> df.with_columns($df.col("text").str.encode({ encoding: "hex" }).alias("encoded"))
+     * shape: (1, 2)
+     * ┌───────┬────────────┐
+     * │ text  │ encoded    │
+     * ├───────┼────────────┤
+     * │ hello │ 68656c6c6f │
+     * └───────┴────────────┘
+     */
+    encode(options: StringEncodeOptions): any;
     /**
      * Decodes Uniform Resource Identifier (URI) components.
      * @returns ColumnExpression
@@ -117,13 +181,13 @@ export declare class StringExprNamespace {
      */
     explode(): any;
     /**
-     * Extracts captured group matching a regular expression pattern.
+     * Extracts a captured group from the first regex match.
      * @param pattern The regex pattern containing capture groups.
-     * @param group Group index to extract (default 0 for whole match).
+     * @param options Options object. Use `groupIndex` to select the group (default 1).
      * @returns ColumnExpression
      * @example
      * >>> const df = $df.data({ info: ["id:123"] })
-     * >>> df.with_columns($df.col("info").str.extract(/id:(\d+)/, 1).alias("id"))
+     * >>> df.with_columns($df.col("info").str.extract(/id:(\d+)/).alias("id"))
      * shape: (1, 2)
      * ┌────────┬─────┐
      * │ info   │ id  │
@@ -131,7 +195,154 @@ export declare class StringExprNamespace {
      * │ id:123 │ 123 │
      * └────────┴─────┘
      */
-    extract(pattern: RegExp, group?: number): any;
+    extract(pattern: RegExp | string, options?: ExtractRegexEngineOptions): any;
+    /**
+     * Extracts all occurrences matching a regular expression pattern.
+     * @param pattern Search pattern (string or RegExp).
+     * @param options Options object. Use `groupIndex` to select the group (default 0).
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ text: ["foo 123 bar 456"] })
+     * >>> df.with_columns($df.col("text").str.extract_all(/\d+/).alias("nums"))
+     * shape: (1, 2)
+     * ┌─────────────────┬──────────────┐
+     * │ text            │ nums         │
+     * ├─────────────────┼──────────────┤
+     * │ foo 123 bar 456 │ [123, 456]   │
+     * └─────────────────┴──────────────┘
+     */
+    extract_all(pattern: string | RegExp, options?: ExtractRegexEngineOptions): any;
+    /**
+     * Extracts all captured groups from the first regex match into a structured object (struct).
+     * @param pattern Search pattern containing capture groups.
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ info: ["id:123-name:alice"] })
+     * >>> df.with_columns($df.col("info").str.extract_groups(/(?<id>\d+)-(?<name>\w+)/).alias("parsed"))
+     * shape: (1, 2)
+     * ┌────────────────────┬─────────────────────────────┐
+     * │ info               │ parsed                      │
+     * ├────────────────────┼─────────────────────────────┤
+     * │ id:123-name:alice  │ { id: "123", name: "alice" }│
+     * └────────────────────┴─────────────────────────────┘
+     */
+    extract_groups(pattern: string | RegExp, options?: ExtractManyOptions): any;
+    /**
+     * Extracts the first regex match for each pattern in a list of patterns.
+     * @param patterns Array of regular expression patterns or strings.
+     * @param options Named options object ({ asciiCaseInsensitive, overlapping }).
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ text: ["user_123_PROD"] })
+     * >>> df.with_columns($df.col("text").str.extract_many([/user_\d+/, /prod/], { asciiCaseInsensitive: true }).alias("extracted"))
+     * shape: (1, 2)
+     * ┌───────────────┬──────────────────────────┐
+     * │ text          │ extracted                │
+     * ├───────────────┼──────────────────────────┤
+     * │ user_123_PROD │ ["user_123", "PROD"]     │
+     * └───────────────┴──────────────────────────┘
+     */
+    extract_many(patterns: (string | RegExp)[], options?: ExtractManyOptions): any;
+    /**
+     * Return the byte offset of the first substring matching a pattern.
+     * Returns null if pattern is not found.
+     * @param value Search string or regular expression.
+     * @param options Configuration options ({ literal, asciiCaseInsensitive }).
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ text: ["user_123_PROD"] })
+     * >>> df.with_columns($df.col("text").str.find(/\d+/).alias("pos"))
+     * shape: (1, 2)
+     * ┌───────────────┬─────┐
+     * │ text          │ pos │
+     * ├───────────────┼─────┤
+     * │ user_123_PROD │ 5   │
+     * └───────────────┴─────┘
+     */
+    find(value: string | RegExp, options?: FindOptions): any;
+    /**
+     * Return the starting byte offset of each match for multiple patterns.
+     * @param patterns Array of regular expressions or literal search strings.
+     * @param options Configuration options ({ literal, asciiCaseInsensitive, overlapping, leftmost }).
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ text: ["user_123_PROD"] })
+     * >>> df.with_columns($df.col("text").str.find_many([/user_\d+/, /PROD/]).alias("positions"))
+     * shape: (1, 2)
+     * ┌───────────────┬───────────┐
+     * │ text          │ positions │
+     * ├───────────────┼───────────┤
+     * │ user_123_PROD │ [0, 9]    │
+     * └───────────────┴───────────┘
+     */
+    find_many(patterns: (string | RegExp)[], options?: FindManyOptions): any;
+    /**
+     * Extracts the first n characters of each string element.
+     * @param n Number of characters to extract from the start of the string (default 1).
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ name: ["polars", "javascript"] })
+     * >>> df.with_columns($df.col("name").str.head(3).alias("prefix"))
+     * shape: (2, 2)
+     * ┌────────────┬────────┐
+     * │ name       │ prefix │
+     * ├────────────┼────────┤
+     * │ polars     │ pol    │
+     * │ javascript │ jav    │
+     * └────────────┴────────┘
+     */
+    head(n?: number): any;
+    /**
+     * Joins a list of string elements into a single string using a delimiter.
+     * Accepts `JoinArrayOptions` (`{ ignoreNulls, nullValue, prefix, suffix, limit, truncationMarker, valueFormatter }`).
+     * @param delimiter The string delimiter to join elements with.
+     * @param options Formatting configuration options (`JoinArrayOptions`).
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ tags: [["a", "b", "c"], ["x", "y"]] })
+     * >>> df.with_columns($df.col("tags").str.join("-").alias("joined"))
+     * shape: (2, 2)
+     * ┌─────────────────┬──────────┐
+     * │ tags            │ joined   │
+     * ├─────────────────┼──────────┤
+     * │ ["a", "b", "c"] │ a-b-c    │
+     * │ ["x", "y"]      │ x-y      │
+     * └─────────────────┴──────────┘
+     */
+    join(delimiter?: string, options?: JoinArrayOptions): any;
+    /**
+     * Decodes JSON string elements into parsed objects or arrays.
+     * Reuses safeJsonParse utility.
+     * @param options Configuration options for parsing (`SafeJsonParseOptions`).
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ json_str: ['{"a": 1}', '{"b": 2}'] })
+     * >>> df.with_columns($df.col("json_str").str.json_decode().alias("parsed"))
+     * shape: (2, 2)
+     * ┌────────────┬───────────┐
+     * │ json_str   │ parsed    │
+     * ├────────────┼───────────┤
+     * │ {"a": 1}   │ { a: 1 }  │
+     * │ {"b": 2}   │ { b: 2 }  │
+     * └────────────┴───────────┘
+     */
+    json_decode(options?: SafeJsonParseOptions): any;
+    /**
+     * Extracts fields or array elements from JSON strings using JSONPath syntax.
+     * @param jsonPath The JSONPath expression (e.g. `"$.store.book[0].title"` or `"$.a.b"`).
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ json_str: ['{"a": {"b": 10}}', '{"a": {"b": 20}}'] })
+     * >>> df.with_columns($df.col("json_str").str.json_path_match("$.a.b").alias("val"))
+     * shape: (2, 2)
+     * ┌────────────────────┬─────┐
+     * │ json_str           │ val │
+     * ├────────────────────┼─────┤
+     * │ {"a": {"b": 10}}   │ 10  │
+     * │ {"a": {"b": 20}}   │ 20  │
+     * └────────────────────┴─────┘
+     */
+    json_path_match(jsonPath: string): any;
     /**
      * Returns string length in UTF-16 code units. Alias for len_chars.
      * @returns ColumnExpression
@@ -204,6 +415,22 @@ export declare class StringExprNamespace {
      * └─────┴────────┘
      */
     lpad(width: number, fill?: string): any;
+    /**
+     * Normalizes Unicode strings using standard normalization forms (NFC, NFD, NFKC, NFKD).
+     * @param form The Unicode normalization form to apply ("NFC", "NFD", "NFKC", or "NFKD"). Default is "NFC".
+     * @returns ColumnExpression
+     * @throws InvalidArgumentError If an invalid normalization form is provided.
+     * @example
+     * >>> const df = $df.data({ str: ["e\u0301"] })
+     * >>> df.with_columns($df.col("str").str.normalize("NFC").alias("normalized"))
+     * shape: (1, 2)
+     * ┌───────┬────────────┐
+     * │ str   │ normalized │
+     * ├───────┼────────────┤
+     * │ é     │ é          │
+     * └───────┴────────────┘
+     */
+    normalize(form?: Parameters<typeof String.prototype.normalize>[0]): any;
     /**
      * Pads end of strings to specified width. Alias for rpad.
      * @param width Target string length.
@@ -240,6 +467,7 @@ export declare class StringExprNamespace {
      * Replaces the first occurrence matching a string pattern.
      * @param pattern The search pattern string or regular expression.
      * @param replacement The string value or match replacement function.
+     * @param options Optional replace options (literal, asciiCaseInsensitive, n).
      * @returns ColumnExpression
      * @example
      * >>> const df = $df.data({ email: ["old.com"] })
@@ -251,11 +479,12 @@ export declare class StringExprNamespace {
      * │ old.com │ new.com │
      * └─────────┴─────────┘
      */
-    replace(pattern: string | RegExp, replacement: string | ((match: string, ...args: any[]) => string)): any;
+    replace(pattern: string | RegExp, replacement: string | ((match: string, ...args: any[]) => string), options?: ReplaceOptions): any;
     /**
      * Replaces all occurrences matching a string pattern or global regular expression.
      * @param pattern The search pattern string or regular expression.
      * @param replacement The replacement value.
+     * @param options Optional replace options (literal, asciiCaseInsensitive).
      * @returns ColumnExpression
      * @example
      * >>> const df = $df.data({ text: ["foo bar foo"] })
@@ -267,7 +496,25 @@ export declare class StringExprNamespace {
      * │ foo bar foo │ baz bar baz │
      * └─────────────┴─────────────┘
      */
-    replace_all(pattern: string | RegExp, replacement: string | ((match: string, ...args: any[]) => string)): any;
+    replace_all(pattern: string | RegExp, replacement: string | ((match: string, ...args: any[]) => string), options?: Omit<ReplaceOptions, "n">): any;
+    /**
+     * Replaces multiple string patterns simultaneously or sequentially with their respective replacements.
+     * Matches Polars `.str.replace_many()` behavior, accepting pattern/replacement arrays or a pattern-to-replacement map dictionary.
+     * @param patterns Array of patterns or an object mapping target patterns to replacements.
+     * @param replacements Array of replacement strings/callbacks (when patterns is an array).
+     * @param options Configuration options ({ literal, asciiCaseInsensitive, mode }).
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ text: ["foo bar baz"] })
+     * >>> df.with_columns($df.col("text").str.replace_many(["foo", "bar"], ["1", "2"]).alias("res"))
+     * shape: (1, 2)
+     * ┌─────────────┬─────────┐
+     * │ text        │ res     │
+     * ├─────────────┼─────────┤
+     * │ foo bar baz │ 1 2 baz │
+     * └─────────────┴─────────┘
+     */
+    replace_many(patterns: (string | RegExp)[] | Record<string, string>, replacements?: (string | ((match: string, ...args: any[]) => string))[], options?: ReplaceManyOptions): any;
     /**
      * Reverses characters in each string element.
      * @returns ColumnExpression
@@ -315,20 +562,21 @@ export declare class StringExprNamespace {
      */
     slice(offset: number, length?: number): any;
     /**
-     * Splits strings into lists by delimiter.
+     * Splits strings into lists by delimiter with optional limit and exact padding.
      * @param delimiter Substring delimiter.
+     * @param options Options for controlling limit and exact padding.
      * @returns ColumnExpression
      * @example
      * >>> const df = $df.data({ csv: ["a,b,c"] })
-     * >>> df.with_columns($df.col("csv").str.split(",").alias("items"))
+     * >>> df.with_columns($df.col("csv").str.split(",", { limit: 1 }).alias("items"))
      * shape: (1, 2)
      * ┌───────┬─────────────────┐
      * │ csv   │ items           │
      * ├───────┼─────────────────┤
-     * │ a,b,c │ ["a", "b", "c"] │
+     * │ a,b,c │ ["a", "b,c"]    │
      * └───────┴─────────────────┘
      */
-    split(delimiter: string): any;
+    split(delimiter: string, options?: SplitOptions): any;
     /**
      * Checks if string starts with a prefix.
      * @param prefix The prefix substring.
@@ -423,6 +671,22 @@ export declare class StringExprNamespace {
      * └──────────┴──────────┘
      */
     strip_suffix(suffix: string): any;
+    /**
+     * Extracts the last n characters of each string element.
+     * @param n Number of characters to extract from the end of the string (default 1).
+     * @returns ColumnExpression
+     * @example
+     * >>> const df = $df.data({ name: ["polars", "javascript"] })
+     * >>> df.with_columns($df.col("name").str.tail(3).alias("suffix"))
+     * shape: (2, 2)
+     * ┌────────────┬────────┐
+     * │ name       │ suffix │
+     * ├────────────┼────────┤
+     * │ polars     │ ars    │
+     * │ javascript │ ipt    │
+     * └────────────┴────────┘
+     */
+    tail(n?: number): any;
     /**
      * Parses date/time string into Datetime.
      * @param options Parsing configuration options.

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

@@ -1,13 +1,13 @@
 import { ExprBase } from "../ExprBase";
-import type { IntoExpr, IExpr } from "../../types";
+import type { IntoExpr } from "../../types";
 /**
  * @namespace $df.col.struct
  * @category ColumnExpression
  * @syntax $df.col(<column_name>).struct.{symbol}(...)
  */
 export declare class StructExprNamespace {
-    expr: IExpr;
-    constructor(expr: IExpr);
+    expr: any;
+    constructor(expr: any);
     /**
      * Extracts a sub-field property value from nested objects/struct columns.
      * @param name Name of the field key to extract.
@@ -22,7 +22,7 @@ export declare class StructExprNamespace {
      * │ { name: "Alice", id: 1 }│ Alice     │
      * └─────────────────────────┴───────────┘
      */
-    field(name: string): IExpr;
+    field(name: string): any;
     /**
      * Renames existing field keys inside structured object columns.
      * @param mapping Key-value map of current field names to new field names.
@@ -37,7 +37,7 @@ export declare class StructExprNamespace {
      * │ { first: "Alice" }│ { first_name: "Alice" } │
      * └───────────────────┴─────────────────────────┘
      */
-    rename_fields(mapping: Record<string, string>): IExpr;
+    rename_fields(mapping: Record<string, string>): any;
     /**
      * Inserts or updates fields inside structured object columns.
      * @param fields Expressions or field map defining new or updated fields.
@@ -53,7 +53,7 @@ export declare class StructExprNamespace {
      * │ { name: "Alice"}│ 30  │ { name: "Alice", user_age: 30}│
      * └─────────────────┴─────┴───────────────────────────────┘
      */
-    with_fields(fields: IntoExpr[] | Record<string, IntoExpr>): IExpr;
+    with_fields(fields: IntoExpr[] | Record<string, IntoExpr>): any;
     /**
      * Expands nested struct attributes into distinct columns in the DataFrame schema.
      * @returns ColumnExpression
@@ -67,7 +67,7 @@ export declare class StructExprNamespace {
      * │ Alice │ 30  │
      * └───────┴─────┘
      */
-    unnest(): IExpr;
+    unnest(): any;
 }
 export interface StructExprNamespace {
     [key: string]: any;