df-script 1.9.0 → 2.0.0

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

@@ -17,14 +17,25 @@ export declare class StringExprNamespace {
      * @param other The string value or column expression to concatenate.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ first: ["John"], last: ["Doe"] })
-     * >>> df.with_columns($df.col("first").str.concat(" ").str.concat($df.col("last")).alias("full"))
-     * shape: (1, 3)
-     * ┌───────┬──────┬──────────┐
-     * │ first │ last │ full     │
-     * ├───────┼──────┼──────────┤
-     * │ John  │ Doe  │ John Doe │
-     * └───────┴──────┴──────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.concat("!").alias("exclaimed"))
+     * shape: (3, 2)
+     * ┌──────────┬───────────┐
+     * │ s        │ exclaimed │
+     * ├──────────┼───────────┤
+     * │ "apple"  │ apple!    │
+     * │ "banana" │ banana!   │
+     * │ "cherry" │ cherry!   │
+     * └──────────┴───────────┘
      */
     concat(other: string | IExpr): any;
     /**
@@ -32,8 +43,17 @@ export declare class StringExprNamespace {
      * @param pattern The search substring or regular expression pattern.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ email: ["user@example.com", "admin@test.org"] })
-     * >>> df.with_columns($df.col("email").str.contains("@example.com").alias("is_example"))
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("email").str.contains("@example.com").alias("is_example"))
      * shape: (2, 2)
      * ┌──────────────────┬────────────┐
      * │ email            │ is_example │
@@ -48,8 +68,17 @@ export declare class StringExprNamespace {
      * @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"))
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("email").str.containsAny(["@example.com", "@test.org"]).alias("is_target"))
      * shape: (2, 2)
      * ┌──────────────────┬───────────┐
      * │ email            │ is_target │
@@ -58,126 +87,212 @@ export declare class StringExprNamespace {
      * │ admin@test.org   │ true      │
      * └──────────────────┴───────────┘
      */
-    contains_any(patterns: (string | RegExp)[]): any;
+    containsAny(patterns: (string | RegExp)[]): any;
     /**
      * Counts occurrences of a substring or regular expression match in each string element.
      * @param pattern Search substring or regular expression.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ code: ["banana", "apple"] })
-     * >>> df.with_columns($df.col("code").str.count_matches("a").alias("a_count"))
-     * shape: (2, 2)
-     * ┌────────┬─────────┐
-     * │ code   │ a_count │
-     * ├────────┼─────────┤
-     * │ banana │ 3       │
-     * │ apple  │ 1       │
-     * └────────┴─────────┘
-     */
-    count_matches(pattern: string | RegExp | any, options?: {
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.countMatches("a").alias("a_count"))
+     * shape: (3, 2)
+     * ┌──────────┬─────────┐
+     * │ s        │ a_count │
+     * ├──────────┼─────────┤
+     * │ "apple"  │ 1       │
+     * │ "banana" │ 3       │
+     * │ "cherry" │ 0       │
+     * └──────────┴─────────┘
+     */
+    countMatches(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    │
-     * └───────┴─────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.escapeRegex().alias("escaped"))
+     * shape: (3, 2)
+     * ┌──────────┬─────────┐
+     * │ s        │ escaped │
+     * ├──────────┼─────────┤
+     * │ "apple"  │ apple   │
+     * │ "banana" │ banana  │
+     * │ "cherry" │ cherry  │
+     * └──────────┴─────────┘
      */
-    escape_regex(options?: EscapeRegexOptions): any;
+    escapeRegex(options?: EscapeRegexOptions): any;
     /**
      * Decodes hex or base64 encoded string column values into string.
+     * @note [Runtime Fallback]: Automatically leverages native `Uint8Array.fromBase64` / `Uint8Array.fromHex`
+     * when available in the runtime, with seamless automatic fallback to standard decoding across older environments.
      * @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   │
-     * └────────────┴─────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.encode({ encoding: "hex" }).str.decode({ encoding: "hex" }).alias("decoded"))
+     * shape: (3, 2)
+     * ┌──────────┬─────────┐
+     * │ s        │ decoded │
+     * ├──────────┼─────────┤
+     * │ "apple"  │ apple   │
+     * │ "banana" │ banana  │
+     * │ "cherry" │ cherry  │
+     * └──────────┴─────────┘
      */
     decode(options: StringDecodeOptions): any;
     /**
      * Encodes string column values into hex or base64.
+     * @note [Runtime Fallback]: Automatically leverages native `Uint8Array.prototype.toBase64` / `Uint8Array.prototype.toHex`
+     * when available, with automatic fallback across standard environments.
      * @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 │
-     * └───────┴────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.encode({ encoding: "hex" }).alias("encoded"))
+     * shape: (3, 2)
+     * ┌──────────┬────────────────┐
+     * │ s        │ encoded        │
+     * ├──────────┼────────────────┤
+     * │ "apple"  │ 6170706c65     │
+     * │ "banana" │ 62616e616e61   │
+     * │ "cherry" │ 636865727279   │
+     * └──────────┴────────────────┘
      */
     encode(options: StringEncodeOptions): any;
     /**
      * Decodes Uniform Resource Identifier (URI) components.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ url: ["hello%20world"] })
-     * >>> df.with_columns($df.col("url").str.decode_uri_component().alias("decoded"))
-     * shape: (1, 2)
-     * ┌───────────────┬─────────────┐
-     * │ url           │ decoded     │
-     * ├───────────────┼─────────────┤
-     * │ hello%20world │ hello world │
-     * └───────────────┴─────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.encodeUriComponent().str.decodeUriComponent().alias("decoded"))
+     * shape: (2, 2)
+     * ┌─────────────┬─────────────┐
+     * │ s           │ decoded     │
+     * ├─────────────┼─────────────┤
+     * │ "  hello  " │ "  hello  " │
+     * │ "  world  " │ "  world  " │
+     * └─────────────┴─────────────┘
      */
-    decode_uri_component(): any;
+    decodeUriComponent(): any;
     /**
      * Encodes Uniform Resource Identifier (URI) components.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ term: ["hello world"] })
-     * >>> df.with_columns($df.col("term").str.encode_uri_component().alias("encoded"))
-     * shape: (1, 2)
-     * ┌─────────────┬───────────────┐
-     * │ term        │ encoded       │
-     * ├─────────────┼───────────────┤
-     * │ hello world │ hello%20world │
-     * └─────────────┴───────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.encodeUriComponent().alias("encoded"))
+     * shape: (2, 2)
+     * ┌─────────────┬───────────────────┐
+     * │ s           │ encoded           │
+     * ├─────────────┼───────────────────┤
+     * │ "  hello  " │ "%20%20hello%20%20" │
+     * │ "  world  " │ "%20%20world%20%20" │
+     * └─────────────┴───────────────────┘
      */
-    encode_uri_component(): any;
+    encodeUriComponent(): any;
     /**
      * Checks if string ends with a suffix.
      * @param suffix The suffix substring.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ email: ["user@org.org", "admin@com.com"] })
-     * >>> df.with_columns($df.col("email").str.ends_with(".org").alias("is_org"))
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("email").str.endsWith(".org").alias("is_org"))
      * shape: (2, 2)
-     * ┌──────────────┬────────┐
-     * │ email        │ is_org │
-     * ├──────────────┼────────┤
-     * │ user@org.org │ true   │
-     * │ admin@com.com│ false  │
-     * └──────────────┴────────┘
+     * ┌──────────────────┬────────┐
+     * │ email            │ is_org │
+     * ├──────────────────┼────────┤
+     * │ user@example.com │ false  │
+     * │ admin@test.org   │ true   │
+     * └──────────────────┴────────┘
      */
-    ends_with(suffix: string): any;
+    endsWith(suffix: string): any;
     /**
      * Splits strings into lists of single characters.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ word: ["cat"] })
-     * >>> df.with_columns($df.col("word").str.explode().alias("chars"))
-     * shape: (1, 2)
-     * ┌──────┬─────────────────┐
-     * │ word │ chars           │
-     * ├──────┼─────────────────┤
-     * │ cat  │ ["c", "a", "t"] │
-     * └──────┴─────────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.explode().alias("chars"))
+     * shape: (3, 2)
+     * ┌──────────┬─────────────────────────────────────┐
+     * │ s        │ chars                               │
+     * ├──────────┼─────────────────────────────────────┤
+     * │ "apple"  │ ["a", "p", "p", "l", "e"]           │
+     * │ "banana" │ ["b", "a", "n", "a", "n", "a"]     │
+     * │ "cherry" │ ["c", "h", "e", "r", "r", "y"]     │
+     * └──────────┴─────────────────────────────────────┘
      */
     explode(): any;
     /**
@@ -186,14 +301,24 @@ export declare class StringExprNamespace {
      * @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+)/).alias("id"))
-     * shape: (1, 2)
-     * ┌────────┬─────┐
-     * │ info   │ id  │
-     * ├────────┼─────┤
-     * │ id:123 │ 123 │
-     * └────────┴─────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("email").str.extract(/@(\w+)/).alias("domain"))
+     * shape: (2, 2)
+     * ┌──────────────────┬─────────┐
+     * │ email            │ domain  │
+     * ├──────────────────┼─────────┤
+     * │ user@example.com │ example │
+     * │ admin@test.org   │ test    │
+     * └──────────────────┴─────────┘
      */
     extract(pattern: RegExp | string, options?: ExtractRegexEngineOptions): any;
     /**
@@ -202,47 +327,79 @@ export declare class StringExprNamespace {
      * @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]   │
-     * └─────────────────┴──────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.extractAll(/[aeiou]/).alias("vowels"))
+     * shape: (3, 2)
+     * ┌──────────┬─────────────────┐
+     * │ s        │ vowels          │
+     * ├──────────┼─────────────────┤
+     * │ "apple"  │ ["a", "e"]      │
+     * │ "banana" │ ["a", "a", "a"] │
+     * │ "cherry" │ ["e"]           │
+     * └──────────┴─────────────────┘
      */
-    extract_all(pattern: string | RegExp, options?: ExtractRegexEngineOptions): any;
+    extractAll(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" }│
-     * └────────────────────┴─────────────────────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("email").str.extractGroups(/(?<user>\w+)@(?<domain>\w+)/).alias("parsed"))
+     * shape: (2, 2)
+     * ┌──────────────────┬────────────────────────────────────┐
+     * │ email            │ parsed                             │
+     * ├──────────────────┼────────────────────────────────────┤
+     * │ user@example.com │ { user: "user", domain: "example" }│
+     * │ admin@test.org   │ { user: "admin", domain: "test" }  │
+     * └──────────────────┴────────────────────────────────────┘
      */
-    extract_groups(pattern: string | RegExp, options?: ExtractManyOptions): any;
+    extractGroups(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"]     │
-     * └───────────────┴──────────────────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.extractMany([/app/, /ban/, /che/]).alias("extracted"))
+     * shape: (3, 2)
+     * ┌──────────┬─────────────┐
+     * │ s        │ extracted   │
+     * ├──────────┼─────────────┤
+     * │ "apple"  │ ["app"]     │
+     * │ "banana" │ ["ban"]     │
+     * │ "cherry" │ ["che"]     │
+     * └──────────┴─────────────┘
      */
-    extract_many(patterns: (string | RegExp)[], options?: ExtractManyOptions): any;
+    extractMany(patterns: (string | RegExp)[], options?: ExtractManyOptions): any;
     /**
      * Return the byte offset of the first substring matching a pattern.
      * Returns null if pattern is not found.
@@ -250,14 +407,25 @@ export declare class StringExprNamespace {
      * @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   │
-     * └───────────────┴─────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.find("a").alias("pos"))
+     * shape: (3, 2)
+     * ┌──────────┬──────┐
+     * │ s        │ pos  │
+     * ├──────────┼──────┤
+     * │ "apple"  │ 0    │
+     * │ "banana" │ 1    │
+     * │ "cherry" │ null │
+     * └──────────┴──────┘
      */
     find(value: string | RegExp, options?: FindOptions): any;
     /**
@@ -266,30 +434,51 @@ export declare class StringExprNamespace {
      * @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]    │
-     * └───────────────┴───────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.findMany(["a", "e"]).alias("positions"))
+     * shape: (3, 2)
+     * ┌──────────┬───────────┐
+     * │ s        │ positions │
+     * ├──────────┼───────────┤
+     * │ "apple"  │ [0, 4]    │
+     * │ "banana" │ [1]       │
+     * │ "cherry" │ [2]       │
+     * └──────────┴───────────┘
      */
-    find_many(patterns: (string | RegExp)[], options?: FindManyOptions): any;
+    findMany(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    │
-     * └────────────┴────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.head(3).alias("prefix"))
+     * shape: (3, 2)
+     * ┌──────────┬────────┐
+     * │ s        │ prefix │
+     * ├──────────┼────────┤
+     * │ "apple"  │ app    │
+     * │ "banana" │ ban    │
+     * │ "cherry" │ che    │
+     * └──────────┴────────┘
      */
     head(n?: number): any;
     /**
@@ -299,15 +488,23 @@ export declare class StringExprNamespace {
      * @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"))
+ * >>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })
+ * >>> df
+ * shape: (2, 1)
+ * ┌───────────┐
+ * │ a         │
+ * ├───────────┤
+ * │ [1, 2, 3] │
+ * │ [4, 5]    │
+ * └───────────┘
+     * >>> df.withColumns($df.col("a").str.join("-").alias("joined"))
      * shape: (2, 2)
-     * ┌─────────────────┬──────────┐
-     * │ tags            │ joined   │
-     * ├─────────────────┼──────────┤
-     * │ ["a", "b", "c"] │ a-b-c    │
-     * │ ["x", "y"]      │ x-y      │
-     * └─────────────────┴──────────┘
+     * ┌────────────┬────────┐
+     * │ a          │ joined │
+     * ├────────────┼────────┤
+     * │ ["a", "b"] │ a-b    │
+     * │ ["c"]      │ c      │
+     * └────────────┴────────┘
      */
     join(delimiter?: string, options?: JoinArrayOptions): any;
     /**
@@ -316,87 +513,149 @@ export declare class StringExprNamespace {
      * @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"))
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.trim().str.jsonDecode().alias("parsed"))
      * shape: (2, 2)
-     * ┌────────────┬───────────┐
-     * │ json_str   │ parsed    │
-     * ├────────────┼───────────┤
-     * │ {"a": 1}   │ { a: 1 }  │
-     * │ {"b": 2}   │ { b: 2 }  │
-     * └────────────┴───────────┘
+     * ┌─────────────┬─────────┐
+     * │ s           │ parsed  │
+     * ├─────────────┼─────────┤
+     * │ "  hello  " │ "hello" │
+     * │ "  world  " │ "world" │
+     * └─────────────┴─────────┘
      */
-    json_decode(options?: SafeJsonParseOptions): any;
+    jsonDecode(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"))
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.trim().str.jsonPathMatch("$").alias("val"))
      * shape: (2, 2)
-     * ┌────────────────────┬─────┐
-     * │ json_str           │ val │
-     * ├────────────────────┼─────┤
-     * │ {"a": {"b": 10}}   │ 10  │
-     * │ {"a": {"b": 20}}   │ 20  │
-     * └────────────────────┴─────┘
+     * ┌─────────────┬─────────┐
+     * │ s           │ val     │
+     * ├─────────────┼─────────┤
+     * │ "  hello  " │ "hello" │
+     * │ "  world  " │ "world" │
+     * └─────────────┴─────────┘
      */
-    json_path_match(jsonPath: string): any;
+    jsonPathMatch(jsonPath: string): any;
     /**
-     * Returns string length in UTF-16 code units. Alias for len_chars.
+     * Returns string length in UTF-16 code units. Alias for lenChars.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ str: ["hello"] })
-     * >>> df.with_columns($df.col("str").str.len().alias("length"))
-     * shape: (1, 2)
-     * ┌───────┬────────┐
-     * │ str   │ length │
-     * ├───────┼────────┤
-     * │ hello │ 5      │
-     * └───────┴────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.len().alias("length"))
+     * shape: (3, 2)
+     * ┌──────────┬────────┐
+     * │ s        │ length │
+     * ├──────────┼────────┤
+     * │ "apple"  │ 5      │
+     * │ "banana" │ 6      │
+     * │ "cherry" │ 6      │
+     * └──────────┴────────┘
      */
     len(): any;
     /**
      * Returns string length in UTF-8 encoded bytes.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ str: ["hello"] })
-     * >>> df.with_columns($df.col("str").str.len_bytes().alias("bytes"))
-     * shape: (1, 2)
-     * ┌───────┬───────┐
-     * │ str   │ bytes │
-     * ├───────┼───────┤
-     * │ hello │ 5     │
-     * └───────┴───────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.lenBytes().alias("bytes"))
+     * shape: (3, 2)
+     * ┌──────────┬───────┐
+     * │ s        │ bytes │
+     * ├──────────┼───────┤
+     * │ "apple"  │ 5     │
+     * │ "banana" │ 6     │
+     * │ "cherry" │ 6     │
+     * └──────────┴───────┘
      */
-    len_bytes(): any;
+    lenBytes(): any;
     /**
      * Returns string length in character count.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["hello"] })
-     * >>> df.with_columns($df.col("text").str.len_chars().alias("length"))
-     * shape: (1, 2)
-     * ┌───────┬────────┐
-     * │ text  │ length │
-     * ├───────┼────────┤
-     * │ hello │ 5      │
-     * └───────┴────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.lenChars().alias("length"))
+     * shape: (3, 2)
+     * ┌──────────┬────────┐
+     * │ s        │ length │
+     * ├──────────┼────────┤
+     * │ "apple"  │ 5      │
+     * │ "banana" │ 6      │
+     * │ "cherry" │ 6      │
+     * └──────────┴────────┘
      */
-    len_chars(): any;
+    lenChars(): any;
     /**
      * Converts strings to lowercase.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ str: ["HELLO"] })
-     * >>> df.with_columns($df.col("str").str.lower().alias("lowered"))
-     * shape: (1, 2)
-     * ┌───────┬─────────┐
-     * │ str   │ lowered │
-     * ├───────┼─────────┤
-     * │ HELLO │ hello   │
-     * └───────┴─────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.lower().alias("lowered"))
+     * shape: (3, 2)
+     * ┌─────────────┬───────────┐
+     * │ s           │ lowered   │
+     * ├─────────────┼───────────┤
+     * │ "HELLO"     │ hello     │
+     * │ "World"     │ world     │
+     * │ "df-script" │ df-script │
+     * └─────────────┴───────────┘
      */
     lower(): any;
     /**
@@ -405,14 +664,25 @@ export declare class StringExprNamespace {
      * @param fill Character sequence used for padding.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ num: ["5"] })
-     * >>> df.with_columns($df.col("num").str.lpad(3, "0").alias("padded"))
-     * shape: (1, 2)
-     * ┌─────┬────────┐
-     * │ num │ padded │
-     * ├─────┼────────┤
-     * │ 5   │ 005    │
-     * └─────┴────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.lpad(8, "_").alias("padded"))
+     * shape: (3, 2)
+     * ┌──────────┬──────────┐
+     * │ s        │ padded   │
+     * ├──────────┼──────────┤
+     * │ "apple"  │ ___apple │
+     * │ "banana" │ __banana │
+     * │ "cherry" │ __cherry │
+     * └──────────┴──────────┘
      */
     lpad(width: number, fill?: string): any;
     /**
@@ -421,14 +691,25 @@ export declare class StringExprNamespace {
      * @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 │
-     * ├───────┼────────────┤
-     * │ é     │ é          │
-     * └───────┴────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.normalize("NFC").alias("normalized"))
+     * shape: (3, 2)
+     * ┌─────────────┬────────────┐
+     * │ s           │ normalized │
+     * ├─────────────┼────────────┤
+     * │ "HELLO"     │ HELLO      │
+     * │ "World"     │ World      │
+     * │ "df-script" │ df-script  │
+     * └─────────────┴────────────┘
      */
     normalize(form?: Parameters<typeof String.prototype.normalize>[0]): any;
     /**
@@ -437,32 +718,54 @@ export declare class StringExprNamespace {
      * @param fill Character sequence used for padding.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["a"] })
-     * >>> df.with_columns($df.col("text").str.pad_end(3, "-").alias("padded"))
-     * shape: (1, 2)
-     * ┌──────┬────────┐
-     * │ text │ padded │
-     * ├──────┼────────┤
-     * │ a    │ a--    │
-     * └──────┴────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.padEnd(8, "_").alias("padded"))
+     * shape: (3, 2)
+     * ┌──────────┬──────────┐
+     * │ s        │ padded   │
+     * ├──────────┼──────────┤
+     * │ "apple"  │ apple___ │
+     * │ "banana" │ banana__ │
+     * │ "cherry" │ cherry__ │
+     * └──────────┴──────────┘
      */
-    pad_end(width: number, fill?: string): any;
+    padEnd(width: number, fill?: string): any;
     /**
      * Pads start of strings to specified width. Alias for lpad.
      * @param width Target string length.
      * @param fill Character sequence used for padding.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ num: ["5"] })
-     * >>> df.with_columns($df.col("num").str.pad_start(3, "0").alias("padded"))
-     * shape: (1, 2)
-     * ┌─────┬────────┐
-     * │ num │ padded │
-     * ├─────┼────────┤
-     * │ 5   │ 005    │
-     * └─────┴────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.padStart(8, "_").alias("padded"))
+     * shape: (3, 2)
+     * ┌──────────┬──────────┐
+     * │ s        │ padded   │
+     * ├──────────┼──────────┤
+     * │ "apple"  │ ___apple │
+     * │ "banana" │ __banana │
+     * │ "cherry" │ __cherry │
+     * └──────────┴──────────┘
      */
-    pad_start(width: number, fill?: string): any;
+    padStart(width: number, fill?: string): any;
     /**
      * Replaces the first occurrence matching a string pattern.
      * @param pattern The search pattern string or regular expression.
@@ -470,14 +773,24 @@ export declare class StringExprNamespace {
      * @param options Optional replace options (literal, asciiCaseInsensitive, n).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ email: ["old.com"] })
-     * >>> df.with_columns($df.col("email").str.replace("old.com", "new.com").alias("updated"))
-     * shape: (1, 2)
-     * ┌─────────┬─────────┐
-     * │ email   │ updated │
-     * ├─────────┼─────────┤
-     * │ old.com │ new.com │
-     * └─────────┴─────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("email").str.replace("example", "test").alias("updated"))
+     * shape: (2, 2)
+     * ┌──────────────────┬───────────────┐
+     * │ email            │ updated       │
+     * ├──────────────────┼───────────────┤
+     * │ user@example.com │ user@test.com │
+     * │ admin@test.org   │ admin@test.org│
+     * └──────────────────┴───────────────┘
      */
     replace(pattern: string | RegExp, replacement: string | ((match: string, ...args: any[]) => string), options?: ReplaceOptions): any;
     /**
@@ -487,46 +800,79 @@ export declare class StringExprNamespace {
      * @param options Optional replace options (literal, asciiCaseInsensitive).
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["foo bar foo"] })
-     * >>> df.with_columns($df.col("text").str.replace_all("foo", "baz").alias("replaced"))
-     * shape: (1, 2)
-     * ┌─────────────┬─────────────┐
-     * │ text        │ replaced    │
-     * ├─────────────┼─────────────┤
-     * │ foo bar foo │ baz bar baz │
-     * └─────────────┴─────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.replaceAll("a", "@").alias("replaced"))
+     * shape: (3, 2)
+     * ┌──────────┬──────────┐
+     * │ s        │ replaced │
+     * ├──────────┼──────────┤
+     * │ "apple"  │ @pple    │
+     * │ "banana" │ b@n@n@   │
+     * │ "cherry" │ cherry   │
+     * └──────────┴──────────┘
      */
-    replace_all(pattern: string | RegExp, replacement: string | ((match: string, ...args: any[]) => string), options?: Omit<ReplaceOptions, "n">): any;
+    replaceAll(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.
+     * Matches Polars `.str.replaceMany()` 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 │
-     * └─────────────┴─────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.replaceMany(["apple", "banana"], ["1", "2"]).alias("res"))
+     * shape: (3, 2)
+     * ┌──────────┬────────┐
+     * │ s        │ res    │
+     * ├──────────┼────────┤
+     * │ "apple"  │ 1      │
+     * │ "banana" │ 2      │
+     * │ "cherry" │ cherry │
+     * └──────────┴────────┘
      */
-    replace_many(patterns: (string | RegExp)[] | Record<string, string>, replacements?: (string | ((match: string, ...args: any[]) => string))[], options?: ReplaceManyOptions): any;
+    replaceMany(patterns: (string | RegExp)[] | Record<string, string>, replacements?: (string | ((match: string, ...args: any[]) => string))[], options?: ReplaceManyOptions): any;
     /**
      * Reverses characters in each string element.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ str: ["abc"] })
-     * >>> df.with_columns($df.col("str").str.reverse().alias("rev"))
-     * shape: (1, 2)
-     * ┌─────┬─────┐
-     * │ str │ rev │
-     * ├─────┼─────┤
-     * │ abc │ cba │
-     * └─────┴─────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.reverse().alias("rev"))
+     * shape: (3, 2)
+     * ┌──────────┬────────┐
+     * │ s        │ rev    │
+     * ├──────────┼────────┤
+     * │ "apple"  │ elppa  │
+     * │ "banana" │ ananab │
+     * │ "cherry" │ yrrehc │
+     * └──────────┴────────┘
      */
     reverse(): any;
     /**
@@ -535,14 +881,25 @@ export declare class StringExprNamespace {
      * @param fill Character sequence used for padding.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["a"] })
-     * >>> df.with_columns($df.col("text").str.rpad(3, "-").alias("padded"))
-     * shape: (1, 2)
-     * ┌──────┬────────┐
-     * │ text │ padded │
-     * ├──────┼────────┤
-     * │ a    │ a--    │
-     * └──────┴────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.rpad(8, "_").alias("padded"))
+     * shape: (3, 2)
+     * ┌──────────┬──────────┐
+     * │ s        │ padded   │
+     * ├──────────┼──────────┤
+     * │ "apple"  │ apple___ │
+     * │ "banana" │ banana__ │
+     * │ "cherry" │ cherry__ │
+     * └──────────┴──────────┘
      */
     rpad(width: number, fill?: string): any;
     /**
@@ -551,14 +908,25 @@ export declare class StringExprNamespace {
      * @param length Number of characters to include.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ str: ["hello world"] })
-     * >>> df.with_columns($df.col("str").str.slice(0, 5).alias("sub"))
-     * shape: (1, 2)
-     * ┌─────────────┬───────┐
-     * │ str         │ sub   │
-     * ├─────────────┼───────┤
-     * │ hello world │ hello │
-     * └─────────────┴───────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.slice(0, 3).alias("sub"))
+     * shape: (3, 2)
+     * ┌──────────┬─────┐
+     * │ s        │ sub │
+     * ├──────────┼─────┤
+     * │ "apple"  │ app │
+     * │ "banana" │ ban │
+     * │ "cherry" │ che │
+     * └──────────┴─────┘
      */
     slice(offset: number, length?: number): any;
     /**
@@ -567,14 +935,24 @@ export declare class StringExprNamespace {
      * @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(",", { limit: 1 }).alias("items"))
-     * shape: (1, 2)
-     * ┌───────┬─────────────────┐
-     * │ csv   │ items           │
-     * ├───────┼─────────────────┤
-     * │ a,b,c │ ["a", "b,c"]    │
-     * └───────┴─────────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("email").str.split("@").alias("parts"))
+     * shape: (2, 2)
+     * ┌──────────────────┬────────────────────────┐
+     * │ email            │ parts                  │
+     * ├──────────────────┼────────────────────────┤
+     * │ user@example.com │ ["user", "example.com"]│
+     * │ admin@test.org   │ ["admin", "test.org"]  │
+     * └──────────────────┴────────────────────────┘
      */
     split(delimiter: string, options?: SplitOptions): any;
     /**
@@ -582,118 +960,198 @@ export declare class StringExprNamespace {
      * @param prefix The prefix substring.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ name: ["John Doe", "Alice"] })
-     * >>> df.with_columns($df.col("name").str.starts_with("John").alias("is_john"))
-     * shape: (2, 2)
-     * ┌──────────┬─────────┐
-     * │ name     │ is_john │
-     * ├──────────┼─────────┤
-     * │ John Doe │ true    │
-     * │ Alice    │ false   │
-     * └──────────┴─────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.startsWith("a").alias("starts_a"))
+     * shape: (3, 2)
+     * ┌──────────┬──────────┐
+     * │ s        │ starts_a │
+     * ├──────────┼──────────┤
+     * │ "apple"  │ true     │
+     * │ "banana" │ false    │
+     * │ "cherry" │ false    │
+     * └──────────┴──────────┘
      */
-    starts_with(prefix: string): any;
+    startsWith(prefix: string): any;
     /**
      * Strips matching characters from start and end of string.
      * @param characters Characters or regex pattern to strip.
      * @param options Configuration options for strip operation.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["--hello--"] })
-     * >>> df.with_columns($df.col("text").str.strip_chars("-").alias("stripped"))
-     * shape: (1, 2)
-     * ┌───────────┬──────────┐
-     * │ text      │ stripped │
-     * ├───────────┼──────────┤
-     * │ --hello-- │ hello    │
-     * └───────────┴──────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.stripChars().alias("stripped"))
+     * shape: (2, 2)
+     * ┌─────────────┬──────────┐
+     * │ s           │ stripped │
+     * ├─────────────┼──────────┤
+     * │ "  hello  " │ hello    │
+     * │ "  world  " │ world    │
+     * └─────────────┴──────────┘
      */
-    strip_chars(characters?: string | RegExp, options?: StripCharsOptions): any;
+    stripChars(characters?: string | RegExp, options?: StripCharsOptions): any;
     /**
      * Strips matching characters from end of string.
      * @param characters Characters or regex pattern to strip.
      * @param options Configuration options.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["hello--"] })
-     * >>> df.with_columns($df.col("text").str.strip_chars_end("-").alias("stripped"))
-     * shape: (1, 2)
-     * ┌─────────┬──────────┐
-     * │ text    │ stripped │
-     * ├─────────┼──────────┤
-     * │ hello-- │ hello    │
-     * └─────────┴──────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.stripCharsEnd().alias("stripped"))
+     * shape: (2, 2)
+     * ┌─────────────┬──────────┐
+     * │ s           │ stripped │
+     * ├─────────────┼──────────┤
+     * │ "  hello  " │ "  hello" │
+     * │ "  world  " │ "  world" │
+     * └─────────────┴──────────┘
      */
-    strip_chars_end(characters?: string | RegExp, options?: StripCharsOptions): any;
+    stripCharsEnd(characters?: string | RegExp, options?: StripCharsOptions): any;
     /**
      * Strips matching characters from start of string.
      * @param characters Characters or regex pattern to strip.
      * @param options Configuration options.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["--hello"] })
-     * >>> df.with_columns($df.col("text").str.strip_chars_start("-").alias("stripped"))
-     * shape: (1, 2)
-     * ┌─────────┬──────────┐
-     * │ text    │ stripped │
-     * ├─────────┼──────────┤
-     * │ --hello │ hello    │
-     * └─────────┴──────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.stripCharsStart().alias("stripped"))
+     * shape: (2, 2)
+     * ┌─────────────┬──────────┐
+     * │ s           │ stripped │
+     * ├─────────────┼──────────┤
+     * │ "  hello  " │ "hello  " │
+     * │ "  world  " │ "world  " │
+     * └─────────────┴──────────┘
      */
-    strip_chars_start(characters?: string | RegExp, options?: StripCharsOptions): any;
+    stripCharsStart(characters?: string | RegExp, options?: StripCharsOptions): any;
     /**
      * Strips matching prefix substring from start of string.
      * @param prefix Prefix substring to remove.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["pre_fix"] })
-     * >>> df.with_columns($df.col("text").str.strip_prefix("pre_").alias("stripped"))
-     * shape: (1, 2)
-     * ┌─────────┬──────────┐
-     * │ text    │ stripped │
-     * ├─────────┼──────────┤
-     * │ pre_fix │ fix      │
-     * └─────────┴──────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.stripPrefix("df-").alias("stripped"))
+     * shape: (3, 2)
+     * ┌─────────────┬──────────┐
+     * │ s           │ stripped │
+     * ├─────────────┼──────────┤
+     * │ "HELLO"     │ HELLO    │
+     * │ "World"     │ World    │
+     * │ "df-script" │ script   │
+     * └─────────────┴──────────┘
      */
-    strip_prefix(prefix: string): any;
+    stripPrefix(prefix: string): any;
     /**
      * Strips matching suffix substring from end of string.
      * @param suffix Suffix substring to remove.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["fix_post"] })
-     * >>> df.with_columns($df.col("text").str.strip_suffix("_post").alias("stripped"))
-     * shape: (1, 2)
-     * ┌──────────┬──────────┐
-     * │ text     │ stripped │
-     * ├──────────┼──────────┤
-     * │ fix_post │ fix      │
-     * └──────────┴──────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("email").str.stripSuffix(".com").alias("stripped"))
+     * shape: (2, 2)
+     * ┌──────────────────┬────────────────┐
+     * │ email            │ stripped       │
+     * ├──────────────────┼────────────────┤
+     * │ user@example.com │ user@example   │
+     * │ admin@test.org   │ admin@test.org │
+     * └──────────────────┴────────────────┘
      */
-    strip_suffix(suffix: string): any;
+    stripSuffix(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    │
-     * └────────────┴────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.tail(3).alias("suffix"))
+     * shape: (3, 2)
+     * ┌──────────┬────────┐
+     * │ s        │ suffix │
+     * ├──────────┼────────┤
+     * │ "apple"  │ ple    │
+     * │ "banana" │ ana    │
+     * │ "cherry" │ rry    │
+     * └──────────┴────────┘
      */
     tail(n?: number): any;
     /**
      * Parses date/time string into Datetime.
+     * @note [Timezone Compatibility]: Direct string parsing with timezone offsets relies on native `Intl.DateTimeFormat`
+     * and `Date.UTC`. Unrecognized timezone identifiers safely default to `"UTC"`.
      * @param options Parsing configuration options.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ d: ["2026-05-20"] })
-     * >>> df.with_columns($df.col("d").str.strptime({ format: "%Y-%m-%d" }).alias("parsed"))
+ * >>> const df = $df.data({ date: ["2026-05-20T10:00:00.123Z"] })
+ * >>> df
+ * shape: (1, 1)
+ * ┌──────────────────────────┐
+ * │ date                     │
+ * ├──────────────────────────┤
+ * │ 2026-05-20T10:00:00.123Z │
+ * └──────────────────────────┘
+     * >>> df.withColumns($df.col("d").str.strptime({ format: "%Y-%m-%d" }).alias("parsed"))
      * shape: (1, 2)
      * ┌────────────┬──────────────────────────┐
      * │ d          │ parsed                   │
@@ -706,22 +1164,40 @@ export declare class StringExprNamespace {
      * Converts string casing to camelCase.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["hello_world"] })
-     * >>> df.with_columns($df.col("text").str.to_camelcase().alias("camel"))
-     * shape: (1, 2)
-     * ┌─────────────┬────────────┐
-     * │ text        │ camel      │
-     * ├─────────────┼────────────┤
-     * │ hello_world │ helloWorld │
-     * └─────────────┴────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.toCamelCase().alias("camel"))
+     * shape: (3, 2)
+     * ┌─────────────┬───────────┐
+     * │ s           │ camel     │
+     * ├─────────────┼───────────┤
+     * │ "HELLO"     │ hello     │
+     * │ "World"     │ world     │
+     * │ "df-script" │ dfScript  │
+     * └─────────────┴───────────┘
      */
-    to_camelcase(): any;
+    toCamelCase(): any;
     /**
      * Parses string into Date object.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ d: ["2026-05-20"] })
-     * >>> df.with_columns($df.col("d").str.to_date().alias("date"))
+ * >>> const df = $df.data({ date: ["2026-05-20T10:00:00.123Z"] })
+ * >>> df
+ * shape: (1, 1)
+ * ┌──────────────────────────┐
+ * │ date                     │
+ * ├──────────────────────────┤
+ * │ 2026-05-20T10:00:00.123Z │
+ * └──────────────────────────┘
+     * >>> df.withColumns($df.col("d").str.toDate().alias("date"))
      * shape: (1, 2)
      * ┌────────────┬──────────────────────────┐
      * │ d          │ date                     │
@@ -729,216 +1205,350 @@ export declare class StringExprNamespace {
      * │ 2026-05-20 │ 2026-05-20T00:00:00.000Z │
      * └────────────┴──────────────────────────┘
      */
-    to_date(): any;
+    toDate(): any;
     /**
      * Parses string into Datetime value.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ ts: ["2026-05-20T10:00:00Z"] })
-     * >>> df.with_columns($df.col("ts").str.to_datetime().alias("dt"))
+ * >>> const df = $df.data({ date: ["2026-05-20T10:00:00.123Z"] })
+ * >>> df
+ * shape: (1, 1)
+ * ┌──────────────────────────┐
+ * │ date                     │
+ * ├──────────────────────────┤
+ * │ 2026-05-20T10:00:00.123Z │
+ * └──────────────────────────┘
+     * >>> df.withColumns($df.col("d").str.toDatetime().alias("dt"))
      * shape: (1, 2)
-     * ┌──────────────────────┬──────────────────────────┐
-     * │ ts                   │ dt                       │
-     * ├──────────────────────┼──────────────────────────┤
-     * │ 2026-05-20T10:00:00Z │ 2026-05-20T10:00:00.000Z │
-     * └──────────────────────┴──────────────────────────┘
+     * ┌────────────┬──────────────────────────┐
+     * │ d          │ dt                       │
+     * ├────────────┼──────────────────────────┤
+     * │ 2026-05-20 │ 2026-05-20T00:00:00.000Z │
+     * └────────────┴──────────────────────────┘
      */
-    to_datetime(): any;
+    toDatetime(): any;
     /**
      * Converts string into numeric decimal representation.
      * @param precision Optional precision limit.
      * @param scale Optional scale limit.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: ["12.34"] })
-     * >>> df.with_columns($df.col("val").str.to_decimal().alias("num"))
-     * shape: (1, 2)
-     * ┌───────┬───────┐
-     * │ val   │ num   │
-     * ├───────┼───────┤
-     * │ 12.34 │ 12.34 │
-     * └───────┴───────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.len().str.toDecimal().alias("num"))
+     * shape: (3, 2)
+     * ┌──────────┬─────┐
+     * │ s        │ num │
+     * ├──────────┼─────┤
+     * │ "apple"  │ 5   │
+     * │ "banana" │ 6   │
+     * │ "cherry" │ 6   │
+     * └──────────┴─────┘
      */
-    to_decimal(precision?: number, scale?: number): any;
+    toDecimal(precision?: number, scale?: number): any;
     /**
      * Parses string into integer number.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ val: ["42"] })
-     * >>> df.with_columns($df.col("val").str.to_integer().alias("num"))
-     * shape: (1, 2)
-     * ┌─────┬─────┐
-     * │ val │ num │
-     * ├─────┼─────┤
-     * │ 42  │ 42  │
-     * └─────┴─────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.len().str.toInteger().alias("num"))
+     * shape: (3, 2)
+     * ┌──────────┬─────┐
+     * │ s        │ num │
+     * ├──────────┼─────┤
+     * │ "apple"  │ 5   │
+     * │ "banana" │ 6   │
+     * │ "cherry" │ 6   │
+     * └──────────┴─────┘
      */
-    to_integer(): any;
+    toInteger(): any;
     /**
      * Converts string casing to kebab-case.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["helloWorld"] })
-     * >>> df.with_columns($df.col("text").str.to_kebabcase().alias("kebab"))
-     * shape: (1, 2)
-     * ┌────────────┬─────────────┐
-     * │ text       │ kebab       │
-     * ├────────────┼─────────────┤
-     * │ helloWorld │ hello-world │
-     * └────────────┴─────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.toKebabCase().alias("kebab"))
+     * shape: (3, 2)
+     * ┌─────────────┬───────────┐
+     * │ s           │ kebab     │
+     * ├─────────────┼───────────┤
+     * │ "HELLO"     │ hello     │
+     * │ "World"     │ world     │
+     * │ "df-script" │ df-script │
+     * └─────────────┴───────────┘
      */
-    to_kebabcase(): any;
+    toKebabCase(): any;
     /**
      * Converts all string elements in the column to lowercase.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({
-     * ...   c: ["ALICE", "Bob", "charlie"]
-     * ... })
-     * shape: (3, 1)
-     * ┌─────────┐
-     * │ c       │
-     * ├─────────┤
-     * │ ALICE   │
-     * │ Bob     │
-     * │ charlie │
-     * └─────────┘
-     *
-     * >>> df.with_columns($df.col("c").str.to_lowercase().alias("lower_name"))
-     * shape: (3, 2)
-     * ┌─────────┬────────────┐
-     * │ c       │ lower_name │
-     * ├─────────┼────────────┤
-     * │ ALICE   │ alice      │
-     * │ Bob     │ bob        │
-     * │ charlie │ charlie    │
-     * └─────────┴────────────┘
-     */
-    to_lowercase(): any;
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.toLowerCase().alias("lower_name"))
+     * shape: (3, 2)
+     * ┌─────────────┬────────────┐
+     * │ s           │ lower_name │
+     * ├─────────────┼────────────┤
+     * │ "HELLO"     │ hello      │
+     * │ "World"     │ world      │
+     * │ "df-script" │ df-script  │
+     * └─────────────┴────────────┘
+     */
+    toLowerCase(): any;
     /**
      * Converts string casing to PascalCase.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["hello_world"] })
-     * >>> df.with_columns($df.col("text").str.to_pascalcase().alias("pascal"))
-     * shape: (1, 2)
-     * ┌─────────────┬────────────┐
-     * │ text        │ pascal     │
-     * ├─────────────┼────────────┤
-     * │ hello_world │ HelloWorld │
-     * └─────────────┴────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.toPascalCase().alias("pascal"))
+     * shape: (3, 2)
+     * ┌─────────────┬───────────┐
+     * │ s           │ pascal    │
+     * ├─────────────┼───────────┤
+     * │ "HELLO"     │ Hello     │
+     * │ "World"     │ World     │
+     * │ "df-script" │ DfScript  │
+     * └─────────────┴───────────┘
      */
-    to_pascalcase(): any;
+    toPascalCase(): any;
     /**
      * Converts string casing to snake_case.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["helloWorld"] })
-     * >>> df.with_columns($df.col("text").str.to_snakecase().alias("snake"))
-     * shape: (1, 2)
-     * ┌────────────┬─────────────┐
-     * │ text       │ snake       │
-     * ├────────────┼─────────────┤
-     * │ helloWorld │ hello_world │
-     * └────────────┴─────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.toSnakeCase().alias("snake"))
+     * shape: (3, 2)
+     * ┌─────────────┬───────────┐
+     * │ s           │ snake     │
+     * ├─────────────┼───────────┤
+     * │ "HELLO"     │ hello     │
+     * │ "World"     │ world     │
+     * │ "df-script" │ df_script │
+     * └─────────────┴───────────┘
      */
-    to_snakecase(): any;
+    toSnakeCase(): any;
     /**
      * Parses string into time component representation.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ t: ["10:30:00"] })
-     * >>> df.with_columns($df.col("t").str.to_time().alias("time"))
-     * shape: (1, 2)
-     * ┌──────────┬──────────┐
-     * │ t        │ time     │
-     * ├──────────┼──────────┤
-     * │ 10:30:00 │ 10:30:00 │
-     * └──────────┴──────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.toTime().alias("time"))
+     * shape: (3, 2)
+     * ┌──────────┬──────┐
+     * │ s        │ time │
+     * ├──────────┼──────┤
+     * │ "apple"  │ null │
+     * │ "banana" │ null │
+     * │ "cherry" │ null │
+     * └──────────┴──────┘
      */
-    to_time(): any;
+    toTime(): any;
     /**
      * Converts string casing to Title Case.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["hello world"] })
-     * >>> df.with_columns($df.col("text").str.to_titlecase().alias("title"))
-     * shape: (1, 2)
-     * ┌─────────────┬─────────────┐
-     * │ text        │ title       │
-     * ├─────────────┼─────────────┤
-     * │ hello world │ Hello World │
-     * └─────────────┴─────────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.toTitleCase().alias("title"))
+     * shape: (3, 2)
+     * ┌─────────────┬───────────┐
+     * │ s           │ title     │
+     * ├─────────────┼───────────┤
+     * │ "HELLO"     │ Hello     │
+     * │ "World"     │ World     │
+     * │ "df-script" │ Df Script │
+     * └─────────────┴───────────┘
      */
-    to_titlecase(): any;
+    toTitleCase(): any;
     /**
      * Converts all string elements in the column to uppercase.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ name: ["alice"] })
-     * >>> df.with_columns($df.col("name").str.to_uppercase().alias("upper"))
-     * shape: (1, 2)
-     * ┌───────┬───────┐
-     * │ name  │ upper │
-     * ├───────┼───────┤
-     * │ alice │ ALICE │
-     * └───────┴───────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.toUpperCase().alias("upper"))
+     * shape: (3, 2)
+     * ┌─────────────┬───────────┐
+     * │ s           │ upper     │
+     * ├─────────────┼───────────┤
+     * │ "HELLO"     │ HELLO     │
+     * │ "World"     │ WORLD     │
+     * │ "df-script" │ DF-SCRIPT │
+     * └─────────────┴───────────┘
      */
-    to_uppercase(): any;
+    toUpperCase(): any;
     /**
      * Trims leading and trailing whitespace characters from each string element.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ name: ["  alice  "] })
-     * >>> df.with_columns($df.col("name").str.trim().alias("clean"))
-     * shape: (1, 2)
-     * ┌───────────┬───────┐
-     * │ name      │ clean │
-     * ├───────────┼───────┤
-     * │   alice   │ alice │
-     * └───────────┴───────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.trim().alias("clean"))
+     * shape: (2, 2)
+     * ┌─────────────┬───────┐
+     * │ s           │ clean │
+     * ├─────────────┼───────┤
+     * │ "  hello  " │ hello │
+     * │ "  world  " │ world │
+     * └─────────────┴───────┘
      */
     trim(): any;
     /**
      * Trims trailing whitespace characters from each string element.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ name: ["alice  "] })
-     * >>> df.with_columns($df.col("name").str.trim_end().alias("clean"))
-     * shape: (1, 2)
-     * ┌─────────┬───────┐
-     * │ name    │ clean │
-     * ├─────────┼───────┤
-     * │ alice   │ alice │
-     * └─────────┴───────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.trimEnd().alias("clean"))
+     * shape: (2, 2)
+     * ┌─────────────┬──────────┐
+     * │ s           │ clean    │
+     * ├─────────────┼──────────┤
+     * │ "  hello  " │ "  hello" │
+     * │ "  world  " │ "  world" │
+     * └─────────────┴──────────┘
      */
-    trim_end(): any;
+    trimEnd(): any;
     /**
      * Trims leading whitespace characters from each string element.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ name: ["  alice"] })
-     * >>> df.with_columns($df.col("name").str.trim_start().alias("clean"))
-     * shape: (1, 2)
-     * ┌─────────┬───────┐
-     * │ name    │ clean │
-     * ├─────────┼───────┤
-     * │   alice │ alice │
-     * └─────────┴───────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.trimStart().alias("clean"))
+     * shape: (2, 2)
+     * ┌─────────────┬──────────┐
+     * │ s           │ clean    │
+     * ├─────────────┼──────────┤
+     * │ "  hello  " │ "hello  "│
+     * │ "  world  " │ "world  "│
+     * └─────────────┴──────────┘
      */
-    trim_start(): any;
+    trimStart(): any;
     /**
      * Converts string to uppercase.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ text: ["alice"] })
-     * >>> df.with_columns($df.col("text").str.upper().alias("upper"))
-     * shape: (1, 2)
-     * ┌───────┬───────┐
-     * │ text  │ upper │
-     * ├───────┼───────┤
-     * │ alice │ ALICE │
-     * └───────┴───────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.upper().alias("upper"))
+     * shape: (3, 2)
+     * ┌─────────────┬───────────┐
+     * │ s           │ upper     │
+     * ├─────────────┼───────────┤
+     * │ "HELLO"     │ HELLO     │
+     * │ "World"     │ WORLD     │
+     * │ "df-script" │ DF-SCRIPT │
+     * └─────────────┴───────────┘
      */
     upper(): any;
     /**
@@ -946,14 +1556,25 @@ export declare class StringExprNamespace {
      * @param width Minimum resulting string width.
      * @returns ColumnExpression
      * @example
-     * >>> const df = $df.data({ num: ["42"] })
-     * >>> df.with_columns($df.col("num").str.zfill(5).alias("padded"))
-     * shape: (1, 2)
-     * ┌─────┬────────┐
-     * │ num │ padded │
-     * ├─────┼────────┤
-     * │ 42  │ 00042  │
-     * └─────┴────────┘
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.withColumns($df.col("s").str.zfill(8).alias("padded"))
+     * shape: (3, 2)
+     * ┌──────────┬──────────┐
+     * │ s        │ padded   │
+     * ├──────────┼──────────┤
+     * │ "apple"  │ 000apple │
+     * │ "banana" │ 00banana │
+     * │ "cherry" │ 00cherry │
+     * └──────────┴──────────┘
      */
     zfill(width: number): any;
 }
@@ -965,7 +1586,25 @@ export declare class StringExpr extends ExprBase {
      * @syntax $df.col(<column_name>).str
      * @returns StringExprNamespace
      * @example
-     * >>> df.select($df.col("a").str.len())
+ * >>> const df = $df.data({ s: ["apple", "banana", "cherry"] })
+ * >>> df
+ * shape: (3, 1)
+ * ┌──────────┐
+ * │ s        │
+ * ├──────────┤
+ * │ "apple"  │
+ * │ "banana" │
+ * │ "cherry" │
+ * └──────────┘
+     * >>> df.select($df.col("s").str.len())
+     * shape: (3, 1)
+     * ┌─────┐
+     * │ len │
+     * ├─────┤
+     * │ 5   │
+     * │ 6   │
+     * │ 6   │
+     * └─────┘
      */
     get str(): StringExprNamespace;
 }