{
  "columnExpressions": {
    "arrayExpr": {
      "agg": {
        "desc": "Applies an aggregation expression or element-wise calculation over each array cell.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.agg($df.element().sum()).alias(\"sum_a\"))\nshape: (2, 2)\n+-----------+-------+\n| a         | sum_a |\n+-----------+-------+\n| [1, 2, 3] | 6     |\n| [4, 5]    | 9     |\n+-----------+-------+"
        ],
        "params": [
          {
            "name": "expr",
            "desc": "Aggregation expression (e.g. $df.element().sum() or $df.element().max())"
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "agg",
        "callExpression": ".arr.agg()",
        "signature": "$df.col(<column_name>).arr.agg(expr: IExpr)",
        "signatureDetailed": "$df.col(<column_name>).arr.agg(expr: IExpr)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 99,
        "lineEnd": 101,
        "typeTree": {
          "expr": {
            "type": "IExpr",
            "optional": false,
            "desc": "Aggregation expression (e.g. $df.element().sum() or $df.element().max())"
          }
        }
      },
      "all": {
        "desc": "Returns true if all items in nested list cells are truthy.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.all().alias(\"all_true\"))\nshape: (2, 2)\n+---------------+----------+\n| a             | all_true |\n+---------------+----------+\n| [true, true]  | true     |\n| [true, false] | false    |\n+---------------+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "all",
        "callExpression": ".arr.all()",
        "signature": "$df.col(<column_name>).arr.all()",
        "signatureDetailed": "$df.col(<column_name>).arr.all()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 117,
        "lineEnd": 119
      },
      "any": {
        "desc": "Returns true if any item in nested list cells is truthy.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.any().alias(\"any_true\"))\nshape: (2, 2)\n+---------------+----------+\n| a             | any_true |\n+---------------+----------+\n| [true, true]  | true     |\n| [true, false] | true     |\n+---------------+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "any",
        "callExpression": ".arr.any()",
        "signature": "$df.col(<column_name>).arr.any()",
        "signatureDetailed": "$df.col(<column_name>).arr.any()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 135,
        "lineEnd": 137
      },
      "argMax": {
        "desc": "Finds the index of the maximum value in each array.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.argMax().alias(\"max_idx\"))\nshape: (2, 2)\n+-----------+---------+\n| a         | max_idx |\n+-----------+---------+\n| [1, 2, 3] | 2       |\n| [4, 5]    | 1       |\n+-----------+---------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "argMax",
        "callExpression": ".arr.argMax()",
        "signature": "$df.col(<column_name>).arr.argMax()",
        "signatureDetailed": "$df.col(<column_name>).arr.argMax()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 153,
        "lineEnd": 155
      },
      "argMin": {
        "desc": "Finds the index of the minimum value in each array.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.argMin().alias(\"min_idx\"))\nshape: (2, 2)\n+-----------+---------+\n| a         | min_idx |\n+-----------+---------+\n| [1, 2, 3] | 0       |\n| [4, 5]    | 0       |\n+-----------+---------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "argMin",
        "callExpression": ".arr.argMin()",
        "signature": "$df.col(<column_name>).arr.argMin()",
        "signatureDetailed": "$df.col(<column_name>).arr.argMin()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 171,
        "lineEnd": 173
      },
      "contains": {
        "desc": "Checks if nested lists contain item.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.contains(3).alias(\"has_three\"))\nshape: (2, 2)\n+-----------+-----------+\n| a         | has_three |\n+-----------+-----------+\n| [1, 2, 3] | true      |\n| [4, 5]    | false     |\n+-----------+-----------+"
        ],
        "params": [
          {
            "name": "item",
            "desc": "The element to search for."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "contains",
        "callExpression": ".arr.contains()",
        "signature": "$df.col(<column_name>).arr.contains(item: ScalarArg)",
        "signatureDetailed": "$df.col(<column_name>).arr.contains(item: IExpr | ValidScalarTypes)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 190,
        "lineEnd": 192,
        "typeTree": {
          "item": {
            "type": "ScalarArg",
            "optional": false,
            "desc": "The element to search for.",
            "resolvedType": "IExpr | ValidScalarTypes"
          }
        }
      },
      "containsAll": {
        "desc": "Checks if nested lists contain all elements in items.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.containsAll([1, 2]).alias(\"has_all\"))\nshape: (2, 2)\n+-----------+---------+\n| a         | has_all |\n+-----------+---------+\n| [1, 2, 3] | true    |\n| [4, 5]    | false   |\n+-----------+---------+"
        ],
        "params": [
          {
            "name": "items",
            "desc": "Array of elements or column expression that must all be present."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "containsAll",
        "callExpression": ".arr.containsAll()",
        "signature": "$df.col(<column_name>).arr.containsAll(items: ArrayArg)",
        "signatureDetailed": "$df.col(<column_name>).arr.containsAll(items: IExpr | ValidScalarTypes[] | AnyTypedArray)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 209,
        "lineEnd": 214,
        "typeTree": {
          "items": {
            "type": "ArrayArg",
            "optional": false,
            "desc": "Array of elements or column expression that must all be present.",
            "resolvedType": "IExpr | ValidScalarTypes[] | AnyTypedArray"
          }
        }
      },
      "containsAny": {
        "desc": "Checks if nested lists contain any element in items.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.containsAny([2, 3]).alias(\"has_any\"))\nshape: (2, 2)\n+--------+---------+\n| a      | has_any |\n+--------+---------+\n| [1, 2] | true    |\n| [3, 4] | true    |\n+--------+---------+"
        ],
        "params": [
          {
            "name": "items",
            "desc": "Array of elements or column expression where at least one must be present."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "containsAny",
        "callExpression": ".arr.containsAny()",
        "signature": "$df.col(<column_name>).arr.containsAny(items: ArrayArg)",
        "signatureDetailed": "$df.col(<column_name>).arr.containsAny(items: IExpr | ValidScalarTypes[] | AnyTypedArray)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 231,
        "lineEnd": 236,
        "typeTree": {
          "items": {
            "type": "ArrayArg",
            "optional": false,
            "desc": "Array of elements or column expression where at least one must be present.",
            "resolvedType": "IExpr | ValidScalarTypes[] | AnyTypedArray"
          }
        }
      },
      "countMatches": {
        "desc": "Counts occurrence frequency of item inside nested lists.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.countMatches(2).alias(\"twos\"))\nshape: (2, 2)\n+-----------+------+\n| a         | twos |\n+-----------+------+\n| [1, 2, 3] | 1    |\n| [4, 5]    | 0    |\n+-----------+------+"
        ],
        "params": [
          {
            "name": "item",
            "desc": "The value to count occurrences of."
          },
          {
            "name": "options",
            "desc": "Statistics and matching options."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "countMatches",
        "callExpression": ".arr.countMatches()",
        "signature": "$df.col(<column_name>).arr.countMatches(\n  item: ScalarArg,\n  options: UniqueArrayStatsOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).arr.countMatches(\n  item: IExpr | ValidScalarTypes,\n  options: {\n    keySelector?: (val: any) => any,\n    strict?: boolean = false\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 254,
        "lineEnd": 256,
        "typeTree": {
          "item": {
            "type": "ScalarArg",
            "optional": false,
            "desc": "The value to count occurrences of.",
            "resolvedType": "IExpr | ValidScalarTypes"
          },
          "options": {
            "type": "UniqueArrayStatsOptions",
            "optional": true,
            "default": "{}",
            "desc": "Statistics and matching options.",
            "properties": {
              "keySelector": {
                "type": "(val: any) => any",
                "optional": true,
                "desc": "Custom function to extract a unique comparison key from each element."
              },
              "strict": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, uses canonical serialization to group nested structures (Arrays, Sets, Maps, Dates) by value instead of reference.",
                "default": "false"
              }
            }
          }
        }
      },
      "eval": {
        "desc": "Evaluates subExpr element-wise across array lists.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.eval($df.element().mul(10)).alias(\"multiplied\"))\nshape: (2, 2)\n+--------+------------+\n| a      | multiplied |\n+--------+------------+\n| [1, 2] | [10, 20]   |\n| [3, 4] | [30, 40]   |\n+--------+------------+"
        ],
        "params": [
          {
            "name": "expr",
            "desc": "The sub-expression to evaluate inside each nested list."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "eval",
        "callExpression": ".arr.eval()",
        "signature": "$df.col(<column_name>).arr.eval(expr: IExpr)",
        "signatureDetailed": "$df.col(<column_name>).arr.eval(expr: IExpr)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 273,
        "lineEnd": 283,
        "typeTree": {
          "expr": {
            "type": "IExpr",
            "optional": false,
            "desc": "The sub-expression to evaluate inside each nested list."
          }
        }
      },
      "explode": {
        "desc": "Expands lists into row-wise elements and produces an index mapping for DataFrame unnesting.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.select([$df.col(\"group\"), $df.col(\"values\").arr.explode()])\nshape: (2, 2)\n+-------+--------+\n| group | values |\n+-------+--------+\n| A     | 1      |\n| A     | 2      |\n+-------+--------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Config options including handling of empty arrays and nulls."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "explode",
        "callExpression": ".arr.explode()",
        "signature": "$df.col(<column_name>).arr.explode(\n  {\n    emptyAsNull = true,\n    keepNulls = true\n  }: ExplodeOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).arr.explode(\n  options: {\n    emptyAsNull?: boolean = true,\n    keepNulls?: boolean = true\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 300,
        "lineEnd": 356,
        "typeTree": {
          "options": {
            "type": "ExplodeOptions",
            "optional": true,
            "default": "{}",
            "desc": "Config options including handling of empty arrays and nulls.",
            "properties": {
              "emptyAsNull": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, converts empty arrays to `null` rows.",
                "default": "true"
              },
              "keepNulls": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, retains `null` array values during explosion.",
                "default": "true"
              }
            }
          }
        }
      },
      "filter": {
        "desc": "Filters elements of list columns matching a boolean sub-expression.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.filter($df.element().gt(2)).alias(\"filtered\"))\nshape: (2, 2)\n+-----------+----------+\n| a         | filtered |\n+-----------+----------+\n| [1, 2, 3] | [3]      |\n| [4, 5]    | [4, 5]   |\n+-----------+----------+"
        ],
        "params": [
          {
            "name": "expr",
            "desc": "The boolean column expression to filter by."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "filter",
        "callExpression": ".arr.filter()",
        "signature": "$df.col(<column_name>).arr.filter(expr: IExpr)",
        "signatureDetailed": "$df.col(<column_name>).arr.filter(expr: IExpr)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 373,
        "lineEnd": 375,
        "typeTree": {
          "expr": {
            "type": "IExpr",
            "optional": false,
            "desc": "The boolean column expression to filter by."
          }
        }
      },
      "first": {
        "desc": "Returns the first element of each list.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.first().alias(\"first_a\"))\nshape: (2, 2)\n+-----------+---------+\n| a         | first_a |\n+-----------+---------+\n| [1, 2, 3] | 1       |\n| [4, 5]    | 4       |\n+-----------+---------+"
        ],
        "params": [
          {
            "name": "nullOnOob",
            "desc": "If true, returns null if the list is empty (default: true)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "first",
        "callExpression": ".arr.first()",
        "signature": "$df.col(<column_name>).arr.first(nullOnOob: boolean = true)",
        "signatureDetailed": "$df.col(<column_name>).arr.first(nullOnOob: boolean = true)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 392,
        "lineEnd": 394,
        "typeTree": {
          "nullOnOob": {
            "type": "boolean",
            "optional": true,
            "default": "true",
            "desc": "If true, returns null if the list is empty (default: true)."
          }
        }
      },
      "gather": {
        "desc": "Gathers specific indices from each nested list.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.gather([0, 2]).alias(\"g\"))\nshape: (2, 2)\n+-----------+----------+\n| a         | g        |\n+-----------+----------+\n| [1, 2, 3] | [1, 3]   |\n| [4, 5]    | [4, null]|\n+-----------+----------+"
        ],
        "params": [
          {
            "name": "indices",
            "desc": "Index or array of indices to extract."
          },
          {
            "name": "nullOnOob",
            "desc": "If true, returns null for indices out of bounds (default: true)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "gather",
        "callExpression": ".arr.gather()",
        "signature": "$df.col(<column_name>).arr.gather(\n  indices: NumericSeriesArg,\n  nullOnOob: boolean = true\n)",
        "signatureDetailed": "$df.col(<column_name>).arr.gather(\n  indices: NumericArg | number[] | AnyTypedArray,\n  nullOnOob: boolean = true\n)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 412,
        "lineEnd": 427,
        "typeTree": {
          "indices": {
            "type": "NumericSeriesArg",
            "optional": false,
            "desc": "Index or array of indices to extract.",
            "resolvedType": "NumericArg | number[] | AnyTypedArray"
          },
          "nullOnOob": {
            "type": "boolean",
            "optional": true,
            "default": "true",
            "desc": "If true, returns null for indices out of bounds (default: true)."
          }
        }
      },
      "gatherEvery": {
        "desc": "Gather element slices with custom steps.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.gatherEvery({ step: 2 }).alias(\"ge\"))\nshape: (2, 2)\n+-----------+--------+\n| a         | ge     |\n+-----------+--------+\n| [1, 2, 3] | [1, 3] |\n| [4, 5]    | [4]    |\n+-----------+--------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Config options including offset, limit, and step size."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "gatherEvery",
        "callExpression": ".arr.gatherEvery()",
        "signature": "$df.col(<column_name>).arr.gatherEvery(options: StepSliceArrayOptions = {})",
        "signatureDetailed": "$df.col(<column_name>).arr.gatherEvery(\n  options: {\n    maxItemsGathered?: number,\n    nullOnOob?: boolean = true,\n    offsetEnd?: number,\n    offsetStart?: number = 0,\n    step?: number = 1\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 444,
        "lineEnd": 446,
        "typeTree": {
          "options": {
            "type": "StepSliceArrayOptions",
            "optional": true,
            "default": "{}",
            "desc": "Config options including offset, limit, and step size.",
            "properties": {
              "maxItemsGathered": {
                "type": "number",
                "optional": true,
                "desc": "Maximum number of items to gather in the sliced result array."
              },
              "nullOnOob": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, returns `null` when the starting offset is out of bounds; if `false`, throws an error.",
                "default": "true"
              },
              "offsetEnd": {
                "type": "number",
                "optional": true,
                "desc": "Ending index (exclusive). Supports negative indices relative to array length."
              },
              "offsetStart": {
                "type": "number",
                "optional": true,
                "desc": "Starting index (inclusive). Supports negative indices relative to array length.",
                "default": "0"
              },
              "step": {
                "type": "number",
                "optional": true,
                "desc": "Step size to slice the array by (non-zero). Positive slices forward; negative slices backward.",
                "default": "1"
              }
            }
          }
        }
      },
      "get": {
        "desc": "Extracts a single list element by its index position.",
        "examples": [
          "// 1. Positive 0-based index:\n>>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.get(1).alias(\"second\"))\nshape: (2, 2)\n+-----------+--------+\n| a         | second |\n+-----------+--------+\n| [1, 2, 3] | 2      |\n| [4, 5]    | 5      |\n+-----------+--------+",
          "// 2. Negative index (from the end):\n>>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.get(-1).alias(\"last_val\"))\nshape: (2, 2)\n+-----------+----------+\n| a         | last_val |\n+-----------+----------+\n| [1, 2, 3] | 3        |\n| [4, 5]    | 5        |\n+-----------+----------+"
        ],
        "params": [
          {
            "name": "index",
            "desc": "The 0-based or negative index position to extract."
          },
          {
            "name": "nullOnOob",
            "desc": "If true, returns null if index is out of bounds (default: true)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "get",
        "callExpression": ".arr.get()",
        "signature": "$df.col(<column_name>).arr.get(\n  index: NumericArg,\n  nullOnOob: boolean = true\n)",
        "signatureDetailed": "$df.col(<column_name>).arr.get(\n  index: number | bigint | IExpr | null,\n  nullOnOob: boolean = true\n)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 477,
        "lineEnd": 482,
        "typeTree": {
          "index": {
            "type": "NumericArg",
            "optional": false,
            "desc": "The 0-based or negative index position to extract.",
            "resolvedType": "number | bigint | IExpr | null"
          },
          "nullOnOob": {
            "type": "boolean",
            "optional": true,
            "default": "true",
            "desc": "If true, returns null if index is out of bounds (default: true)."
          }
        }
      },
      "join": {
        "desc": "Joins elements of list columns into a single string column.",
        "examples": [
          "// 1. Default delimiter join:\n>>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.join(\"-\").alias(\"joined\"))\nshape: (2, 2)\n+-----------+---------+\n| a         | joined  |\n+-----------+---------+\n| [1, 2, 3] | \"1-2-3\" |\n| [4, 5]    | \"4-5\"   |\n+-----------+---------+",
          "// 2. Custom delimiter with prefix and suffix options:\n>>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.join(\" | \", { prefix: \"<\", suffix: \">\" }).alias(\"joined\"))\nshape: (2, 2)\n+-----------+---------------+\n| a         | joined        |\n+-----------+---------------+\n| [1, 2, 3] | \"<1 | 2 | 3>\" |\n| [4, 5]    | \"<4 | 5>\"     |\n+-----------+---------------+"
        ],
        "params": [
          {
            "name": "separator",
            "desc": "The character sequence separating list elements."
          },
          {
            "name": "options",
            "desc": "String conversion options."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "join",
        "callExpression": ".arr.join()",
        "signature": "$df.col(<column_name>).arr.join(\n  separator: string = \",\",\n  options: JoinArrayOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).arr.join(\n  separator: string = \",\",\n  options: {\n    ignoreNulls?: boolean = false,\n    limit?: number,\n    nullValue?: string = \"\",\n    prefix?: string = \"\",\n    suffix?: string = \"\",\n    truncationMarker?: string = \"...\",\n    valueFormatter?: (val: any, index: number) => string\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 513,
        "lineEnd": 515,
        "typeTree": {
          "separator": {
            "type": "string",
            "optional": true,
            "default": "\",\"",
            "desc": "The character sequence separating list elements."
          },
          "options": {
            "type": "JoinArrayOptions",
            "optional": true,
            "default": "{}",
            "desc": "String conversion options.",
            "properties": {
              "ignoreNulls": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, `null` and `undefined` elements are skipped during joining.",
                "default": "false"
              },
              "limit": {
                "type": "number",
                "optional": true,
                "desc": "Maximum number of array elements to join before truncating with `truncationMarker`."
              },
              "nullValue": {
                "type": "string",
                "optional": true,
                "desc": "Custom string representation for `null` and `undefined` elements when `ignoreNulls` is `false`.",
                "default": "\"\""
              },
              "prefix": {
                "type": "string",
                "optional": true,
                "desc": "Prefix string prepended to the joined result.",
                "default": "\"\""
              },
              "suffix": {
                "type": "string",
                "optional": true,
                "desc": "Suffix string appended to the joined result.",
                "default": "\"\""
              },
              "truncationMarker": {
                "type": "string",
                "optional": true,
                "desc": "Placeholder string appended when `limit` truncation occurs.",
                "default": "\"...\""
              },
              "valueFormatter": {
                "type": "(val: any, index: number) => string",
                "optional": true,
                "desc": "Callback function used to format each non-null element to a string."
              }
            }
          }
        }
      },
      "last": {
        "desc": "Returns the last element of each list.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.last().alias(\"last_a\"))\nshape: (2, 2)\n+-----------+--------+\n| a         | last_a |\n+-----------+--------+\n| [1, 2, 3] | 3      |\n| [4, 5]    | 5      |\n+-----------+--------+"
        ],
        "params": [
          {
            "name": "nullOnOob",
            "desc": "If true, returns null if the list is empty (default: true)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "last",
        "callExpression": ".arr.last()",
        "signature": "$df.col(<column_name>).arr.last(nullOnOob: boolean = true)",
        "signatureDetailed": "$df.col(<column_name>).arr.last(nullOnOob: boolean = true)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 532,
        "lineEnd": 534,
        "typeTree": {
          "nullOnOob": {
            "type": "boolean",
            "optional": true,
            "default": "true",
            "desc": "If true, returns null if the list is empty (default: true)."
          }
        }
      },
      "len": {
        "desc": "Returns the length of each list inside the column cell.",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "len",
        "callExpression": ".arr.len()",
        "signature": "$df.col(<column_name>).arr.len()",
        "signatureDetailed": "$df.col(<column_name>).arr.len()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 539,
        "lineEnd": 541
      },
      "lengths": {
        "desc": "Returns the length of each list inside the column cell.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.lengths().alias(\"len_a\"))\nshape: (2, 2)\n+-----------+-------+\n| a         | len_a |\n+-----------+-------+\n| [1, 2, 3] | 3     |\n| [4, 5]    | 2     |\n+-----------+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "lengths",
        "callExpression": ".arr.lengths()",
        "signature": "$df.col(<column_name>).arr.lengths()",
        "signatureDetailed": "$df.col(<column_name>).arr.lengths()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 557,
        "lineEnd": 559
      },
      "max": {
        "desc": "Returns the maximum value of elements inside each list.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.max().alias(\"max_a\"))\nshape: (2, 2)\n+-----------+-------+\n| a         | max_a |\n+-----------+-------+\n| [1, 2, 3] | 3     |\n| [4, 5]    | 5     |\n+-----------+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "max",
        "callExpression": ".arr.max()",
        "signature": "$df.col(<column_name>).arr.max()",
        "signatureDetailed": "$df.col(<column_name>).arr.max()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 575,
        "lineEnd": 577
      },
      "mean": {
        "desc": "Returns average of elements inside each list.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.mean().alias(\"mean_a\"))\nshape: (2, 2)\n+-----------+--------+\n| a         | mean_a |\n+-----------+--------+\n| [1, 2, 3] | 2      |\n| [4, 5]    | 4.5    |\n+-----------+--------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "mean",
        "callExpression": ".arr.mean()",
        "signature": "$df.col(<column_name>).arr.mean()",
        "signatureDetailed": "$df.col(<column_name>).arr.mean()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 593,
        "lineEnd": 595
      },
      "median": {
        "desc": "Returns statistical median inside each list.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.median().alias(\"med\"))\nshape: (2, 2)\n+-----------+------+\n| a         | med  |\n+-----------+------+\n| [1, 2, 3] | 2    |\n| [4, 5]    | 4.5  |\n+-----------+------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "median",
        "callExpression": ".arr.median()",
        "signature": "$df.col(<column_name>).arr.median()",
        "signatureDetailed": "$df.col(<column_name>).arr.median()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 611,
        "lineEnd": 613
      },
      "min": {
        "desc": "Returns minimum of elements inside each list.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.min().alias(\"min_a\"))\nshape: (2, 2)\n+-----------+-------+\n| a         | min_a |\n+-----------+-------+\n| [1, 2, 3] | 1     |\n| [4, 5]    | 4     |\n+-----------+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "min",
        "callExpression": ".arr.min()",
        "signature": "$df.col(<column_name>).arr.min()",
        "signatureDetailed": "$df.col(<column_name>).arr.min()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 629,
        "lineEnd": 631
      },
      "mode": {
        "desc": "Returns the mode value inside each list.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.mode().alias(\"mode_a\"))\nshape: (2, 2)\n+-----------+-----------+\n| a         | mode_a    |\n+-----------+-----------+\n| [1, 2, 3] | [1, 2, 3] |\n| [4, 5]    | [4, 5]    |\n+-----------+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "mode",
        "callExpression": ".arr.mode()",
        "signature": "$df.col(<column_name>).arr.mode()",
        "signatureDetailed": "$df.col(<column_name>).arr.mode()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 647,
        "lineEnd": 649
      },
      "nUnique": {
        "desc": "Returns the unique count of elements inside each list.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.nUnique().alias(\"unique_len\"))\nshape: (2, 2)\n+-----------+------------+\n| a         | unique_len |\n+-----------+------------+\n| [1, 2, 3] | 3          |\n| [4, 5]    | 2          |\n+-----------+------------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Formatting/statistics parameters."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "nUnique",
        "callExpression": ".arr.nUnique()",
        "signature": "$df.col(<column_name>).arr.nUnique(options: UniqueArrayStatsOptions = {})",
        "signatureDetailed": "$df.col(<column_name>).arr.nUnique(\n  options: {\n    keySelector?: (val: any) => any,\n    strict?: boolean = false\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 666,
        "lineEnd": 668,
        "typeTree": {
          "options": {
            "type": "UniqueArrayStatsOptions",
            "optional": true,
            "default": "{}",
            "desc": "Formatting/statistics parameters.",
            "properties": {
              "keySelector": {
                "type": "(val: any) => any",
                "optional": true,
                "desc": "Custom function to extract a unique comparison key from each element."
              },
              "strict": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, uses canonical serialization to group nested structures (Arrays, Sets, Maps, Dates) by value instead of reference.",
                "default": "false"
              }
            }
          }
        }
      },
      "reverse": {
        "desc": "Reverses elements of list columns.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.reverse().alias(\"reversed\"))\nshape: (2, 2)\n+-----------+-----------+\n| a         | reversed  |\n+-----------+-----------+\n| [1, 2, 3] | [3, 2, 1] |\n| [4, 5]    | [5, 4]    |\n+-----------+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "reverse",
        "callExpression": ".arr.reverse()",
        "signature": "$df.col(<column_name>).arr.reverse()",
        "signatureDetailed": "$df.col(<column_name>).arr.reverse()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 684,
        "lineEnd": 686
      },
      "shift": {
        "desc": "Shifts elements of list columns by N offsets.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.shift(1).alias(\"shifted\"))\nshape: (2, 2)\n+-----------+------------------+\n| a         | shifted          |\n+-----------+------------------+\n| [1, 2, 3] | [null, 1, 2]     |\n| [4, 5]    | [null, 4]        |\n+-----------+------------------+"
        ],
        "params": [
          {
            "name": "n",
            "desc": "Positive or negative offsets shift amount (default: 1)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "shift",
        "callExpression": ".arr.shift()",
        "signature": "$df.col(<column_name>).arr.shift(\n  n: number = 1,\n  options: ShiftOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).arr.shift(\n  n: number = 1,\n  options: {\n    fillValue?: any = null\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 703,
        "lineEnd": 705,
        "typeTree": {
          "n": {
            "type": "number",
            "optional": true,
            "default": "1",
            "desc": "Positive or negative offsets shift amount (default: 1)."
          },
          "options": {
            "type": "ShiftOptions",
            "optional": true,
            "default": "{}",
            "desc": "Configuration options for shifting column or array elements (`shift`, `lag`, `lead`).",
            "properties": {
              "fillValue": {
                "type": "any",
                "optional": true,
                "desc": "Fallback fill value for empty slots introduced by shift/lag/lead.",
                "default": "null"
              }
            }
          }
        }
      },
      "slice": {
        "desc": "Slices nested list arrays.",
        "examples": [
          "// 1. Positive slice with start and end offsets:\n>>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.slice(1, 3).alias(\"sliced\"))\nshape: (2, 2)\n+-----------+--------+\n| a         | sliced |\n+-----------+--------+\n| [1, 2, 3] | [2, 3] |\n| [4, 5]    | [5]    |\n+-----------+--------+",
          "// 2. Negative slice offset from the end:\n>>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.slice(-2).alias(\"tail2\"))\nshape: (2, 2)\n+-----------+--------+\n| a         | tail2  |\n+-----------+--------+\n| [1, 2, 3] | [2, 3] |\n| [4, 5]    | [4, 5] |\n+-----------+--------+"
        ],
        "params": [
          {
            "name": "start",
            "desc": "The slice starting index."
          },
          {
            "name": "end",
            "desc": "The slice ending index."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "slice",
        "callExpression": ".arr.slice()",
        "signature": "$df.col(<column_name>).arr.slice(\n  start?: number,\n  end?: number\n)",
        "signatureDetailed": "$df.col(<column_name>).arr.slice(\n  start?: number,\n  end?: number\n)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 736,
        "lineEnd": 738,
        "typeTree": {
          "start": {
            "type": "number",
            "optional": true,
            "desc": "The slice starting index."
          },
          "end": {
            "type": "number",
            "optional": true,
            "desc": "The slice ending index."
          }
        }
      },
      "sort": {
        "desc": "Sorts elements inside each list.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.sort().alias(\"sorted\"))\nshape: (2, 2)\n+-----------+-----------+\n| a         | sorted    |\n+-----------+-----------+\n| [1, 2, 3] | [1, 2, 3] |\n| [4, 5]    | [4, 5]    |\n+-----------+-----------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Sort customization parameters (e.g. descending flag)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "sort",
        "callExpression": ".arr.sort()",
        "signature": "$df.col(<column_name>).arr.sort(options?: SortArrayOptions)",
        "signatureDetailed": "$df.col(<column_name>).arr.sort(\n  options?: {\n    customComp?: ((a: any, b: any) => number) | Partial<Record<keyof any, (a: any, b: any) => number>> | null,\n    descending?: boolean | boolean[] = false,\n    nullsLast?: boolean = true\n  }\n)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 755,
        "lineEnd": 757,
        "typeTree": {
          "options": {
            "type": "SortArrayOptions",
            "optional": true,
            "desc": "Sort customization parameters (e.g. descending flag).",
            "properties": {
              "customComp": {
                "type": "((a: any, b: any) => number) | Partial<Record<keyof any, (a: any, b: any) => number>> | null",
                "optional": true,
                "desc": "Optional comparator function or dictionary mapping column names to custom comparator functions."
              },
              "descending": {
                "type": "ColumnKeyArg<boolean>",
                "optional": true,
                "desc": "Sort order boolean or array of booleans per key.",
                "default": "false",
                "resolvedType": "boolean | boolean[]"
              },
              "nullsLast": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, places nulls at the end of sorted output.",
                "default": "true"
              }
            }
          }
        }
      },
      "splice": {
        "desc": "Splices elements in list cells.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.splice(1, 1, 10, 20).alias(\"spliced\"))\nshape: (2, 2)\n+-----------+-----------------+\n| a         | spliced         |\n+-----------+-----------------+\n| [1, 2, 3] | [1, 10, 20, 3]  |\n| [4, 5]    | [4, 10, 20]     |\n+-----------+-----------------+"
        ],
        "params": [
          {
            "name": "start",
            "desc": "The index where array modifications begin."
          },
          {
            "name": "deleteCount",
            "desc": "The number of elements to remove."
          },
          {
            "name": "items",
            "desc": "The elements to insert."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "splice",
        "callExpression": ".arr.splice()",
        "signature": "$df.col(<column_name>).arr.splice(\n  start: number,\n  deleteCount?: number,\n  ...items: ValidScalarTypes[]\n)",
        "signatureDetailed": "$df.col(<column_name>).arr.splice(\n  start: number,\n  deleteCount?: number,\n  ...items: (Exclude<ValidPrimitiveTypes, symbol> | Date | AnyTypedArray)[]\n)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 776,
        "lineEnd": 783,
        "typeTree": {
          "start": {
            "type": "number",
            "optional": false,
            "desc": "The index where array modifications begin."
          },
          "deleteCount": {
            "type": "number",
            "optional": true,
            "desc": "The number of elements to remove."
          },
          "items": {
            "type": "ValidScalarTypes[]",
            "optional": false,
            "variadic": true,
            "desc": "The elements to insert.",
            "resolvedType": "(Exclude<ValidPrimitiveTypes, symbol> | Date | AnyTypedArray)[]"
          }
        }
      },
      "std": {
        "desc": "Returns sample standard deviation of elements inside each list.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.std().alias(\"std_dev\"))\nshape: (2, 2)\n+-----------+----------+\n| a         | std_dev  |\n+-----------+----------+\n| [1, 2, 3] | 1        |\n| [4, 5]    | 0.707107 |\n+-----------+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "std",
        "callExpression": ".arr.std()",
        "signature": "$df.col(<column_name>).arr.std()",
        "signatureDetailed": "$df.col(<column_name>).arr.std()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 799,
        "lineEnd": 801
      },
      "sum": {
        "desc": "Returns sum of elements inside each list.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.sum().alias(\"sum_a\"))\nshape: (2, 2)\n+-----------+-------+\n| a         | sum_a |\n+-----------+-------+\n| [1, 2, 3] | 6     |\n| [4, 5]    | 9     |\n+-----------+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "sum",
        "callExpression": ".arr.sum()",
        "signature": "$df.col(<column_name>).arr.sum()",
        "signatureDetailed": "$df.col(<column_name>).arr.sum()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 817,
        "lineEnd": 819
      },
      "toStruct": {
        "desc": "Converts list column elements to struct columns.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.toStruct({ fields: [\"x\", \"y\"] }).alias(\"struct_a\"))\nshape: (2, 2)\n+--------+----------------+\n| a      | struct_a       |\n+--------+----------------+\n| [1, 2] | { x: 1, y: 2 } |\n| [3, 4] | { x: 3, y: 4 } |\n+--------+----------------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Config flags including custom field names or upper bound size."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "toStruct",
        "callExpression": ".arr.toStruct()",
        "signature": "$df.col(<column_name>).arr.toStruct(\n  {\n    upperBound,\n    fields\n  }: ToStructOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).arr.toStruct(\n  options: {\n    fields?: string[] | ((idx: number) => string) = `\"field_0\"`, `\"field_1\"`, etc,\n    upperBound?: number = the maximum array length in the column\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 836,
        "lineEnd": 882,
        "typeTree": {
          "options": {
            "type": "ToStructOptions",
            "optional": true,
            "default": "{}",
            "desc": "Config flags including custom field names or upper bound size.",
            "properties": {
              "fields": {
                "type": "string[] | ((idx: number) => string)",
                "optional": true,
                "desc": "Explicit array of struct field names or a callback `(idx: number) => string` generating field names by element index. Defaults to `\"field_0\"`, `\"field_1\"`, etc.",
                "default": "`\"field_0\"`, `\"field_1\"`, etc"
              },
              "upperBound": {
                "type": "number",
                "optional": true,
                "desc": "Maximum number of array elements to extract into struct fields when `fields` is not an array. Defaults to the maximum array length in the column.",
                "default": "the maximum array length in the column"
              }
            }
          }
        }
      },
      "unique": {
        "desc": "Fills each list with unique elements only.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.unique().alias(\"unique_a\"))\nshape: (2, 2)\n+-----------+-----------+\n| a         | unique_a  |\n+-----------+-----------+\n| [1, 2, 3] | [1, 2, 3] |\n| [4, 5]    | [4, 5]    |\n+-----------+-----------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Custom uniqueness matching configuration."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "unique",
        "callExpression": ".arr.unique()",
        "signature": "$df.col(<column_name>).arr.unique(options: UniqueArrayStatsOptions = {})",
        "signatureDetailed": "$df.col(<column_name>).arr.unique(\n  options: {\n    keySelector?: (val: any) => any,\n    strict?: boolean = false\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 899,
        "lineEnd": 901,
        "typeTree": {
          "options": {
            "type": "UniqueArrayStatsOptions",
            "optional": true,
            "default": "{}",
            "desc": "Custom uniqueness matching configuration.",
            "properties": {
              "keySelector": {
                "type": "(val: any) => any",
                "optional": true,
                "desc": "Custom function to extract a unique comparison key from each element."
              },
              "strict": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, uses canonical serialization to group nested structures (Arrays, Sets, Maps, Dates) by value instead of reference.",
                "default": "false"
              }
            }
          }
        }
      },
      "variance": {
        "desc": "Returns sample variance of elements inside each list.",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").arr.variance().alias(\"var_a\"))\nshape: (2, 2)\n+-----------+-------+\n| a         | var_a |\n+-----------+-------+\n| [1, 2, 3] | 1     |\n| [4, 5]    | 0.5   |\n+-----------+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "arr",
        "category": "ColumnExpression",
        "propertyAccess": "variance",
        "callExpression": ".arr.variance()",
        "signature": "$df.col(<column_name>).arr.variance()",
        "signatureDetailed": "$df.col(<column_name>).arr.variance()",
        "filePath": "columnExpressions/mixins/arrayExpr.ts",
        "lineStart": 917,
        "lineEnd": 919
      }
    },
    "standardExpr": {
      "abs": {
        "desc": "Computes the absolute value of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").abs().alias(\"abs_a\"))\nshape: (3, 2)\n+---+-------+\n| a | abs_a |\n+---+-------+\n| 1 | 1     |\n| 2 | 2     |\n| 3 | 3     |\n+---+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "abs",
        "callExpression": ".abs()",
        "signature": "$df.col(<column_name>).abs()",
        "signatureDetailed": "$df.col(<column_name>).abs()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 182,
        "lineEnd": 184
      },
      "add": {
        "desc": "Adds a scalar value or another column expression.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").add(10).alias(\"added\"))\nshape: (3, 2)\n+---+-------+\n| a | added |\n+---+-------+\n| 1 | 11    |\n| 2 | 12    |\n| 3 | 13    |\n+---+-------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The number or column expression to add."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "add",
        "callExpression": ".add()",
        "signature": "$df.col(<column_name>).add(val: NumericArg)",
        "signatureDetailed": "$df.col(<column_name>).add(val: number | bigint | IExpr | null)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 202,
        "lineEnd": 204,
        "typeTree": {
          "val": {
            "type": "NumericArg",
            "optional": false,
            "desc": "The number or column expression to add.",
            "resolvedType": "number | bigint | IExpr | null"
          }
        }
      },
      "alias": {
        "desc": "Renames the output expression column key.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").alias(\"renamed_a\"))\nshape: (3, 2)\n+---+-----------+\n| a | renamed_a |\n+---+-----------+\n| 1 | 1         |\n| 2 | 2         |\n| 3 | 3         |\n+---+-----------+"
        ],
        "params": [
          {
            "name": "name",
            "desc": "Name of the output column."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "alias",
        "callExpression": ".alias()",
        "signature": "$df.col(<column_name>).alias(name: string): this",
        "signatureDetailed": "$df.col(<column_name>).alias(name: string): this",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 223,
        "lineEnd": 227,
        "typeTree": {
          "name": {
            "type": "string",
            "optional": false,
            "desc": "Name of the output column."
          }
        }
      },
      "all": {
        "desc": "Aggregation: Returns true if all values in the group are truthy.",
        "examples": [
          ">>> const df = $df.data({ a: [true, true, false, false], b: [true, false, true, false] })\n>>> df\nshape: (4, 2)\n+-------+-------+\n| a     | b     |\n+-------+-------+\n| true  | true  |\n| true  | false |\n| false | true  |\n| false | false |\n+-------+-------+\n>>> df.select($df.col(\"a\").all().alias(\"all_true\"))\nshape: (1, 1)\n+----------+\n| all_true |\n+----------+\n| false    |\n+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "all",
        "callExpression": ".all()",
        "signature": "$df.col(<column_name>).all()",
        "signatureDetailed": "$df.col(<column_name>).all()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 242,
        "lineEnd": 244
      },
      "allNull": {
        "desc": "Aggregation: Checks if all values in the group are null.",
        "examples": [
          ">>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.select($df.col(\"a\").allNull().alias(\"all_null\"))\nshape: (1, 1)\n+----------+\n| all_null |\n+----------+\n| false    |\n+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "allNull",
        "callExpression": ".allNull()",
        "signature": "$df.col(<column_name>).allNull()",
        "signatureDetailed": "$df.col(<column_name>).allNull()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 259,
        "lineEnd": 261
      },
      "and": {
        "desc": "Performs an element-wise logical AND operation between the column and another operand using Kleene 3-valued logic (true, false, null).\n\nIn Kleene 3-valued logic: - `false` AND anything is `false`. - `true` AND `true` is `true`. - `true` AND `null` is `null` (unknown). - `null` AND `null` is `null` (unknown).",
        "examples": [
          ">>> const df = $df.data({ a: [true, true, false, false], b: [true, false, true, false] })\n>>> df\nshape: (4, 2)\n+-------+-------+\n| a     | b     |\n+-------+-------+\n| true  | true  |\n| true  | false |\n| false | true  |\n| false | false |\n+-------+-------+\n>>> df.withColumns($df.col(\"a\").and($df.col(\"b\")).alias(\"and_res\"))\nshape: (4, 3)\n+-------+-------+---------+\n| a     | b     | and_res |\n+-------+-------+---------+\n| true  | true  | true    |\n| true  | false | false   |\n| false | false | false   |\n| null  | true  | null    |\n+-------+-------+---------+"
        ],
        "params": [
          {
            "name": "other",
            "desc": "The boolean column expression or literal value to compare."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "and",
        "callExpression": ".and()",
        "signature": "$df.col(<column_name>).and(other: BooleanArg)",
        "signatureDetailed": "$df.col(<column_name>).and(other: boolean | boolean[] | IExpr | null | undefined)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 288,
        "lineEnd": 303,
        "typeTree": {
          "other": {
            "type": "BooleanArg",
            "optional": false,
            "desc": "The boolean column expression or literal value to compare.",
            "resolvedType": "boolean | boolean[] | IExpr | null | undefined"
          }
        }
      },
      "any": {
        "desc": "Aggregation: Checks if any value in the group is truthy.",
        "examples": [
          ">>> const df = $df.data({ a: [true, true, false, false], b: [true, false, true, false] })\n>>> df\nshape: (4, 2)\n+-------+-------+\n| a     | b     |\n+-------+-------+\n| true  | true  |\n| true  | false |\n| false | true  |\n| false | false |\n+-------+-------+\n>>> df.select($df.col(\"a\").any().alias(\"any_true\"))\nshape: (1, 1)\n+----------+\n| any_true |\n+----------+\n| true     |\n+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "any",
        "callExpression": ".any()",
        "signature": "$df.col(<column_name>).any()",
        "signatureDetailed": "$df.col(<column_name>).any()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 318,
        "lineEnd": 320
      },
      "anyNull": {
        "desc": "Aggregation: Checks if any value in the group is null.",
        "examples": [
          ">>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.select($df.col(\"a\").anyNull().alias(\"has_null\"))\nshape: (1, 1)\n+----------+\n| has_null |\n+----------+\n| true     |\n+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "anyNull",
        "callExpression": ".anyNull()",
        "signature": "$df.col(<column_name>).anyNull()",
        "signatureDetailed": "$df.col(<column_name>).anyNull()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 335,
        "lineEnd": 337
      },
      "arccos": {
        "desc": "Computes the mathematical arccosine (inverse cosine) of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").arccos().alias(\"arccos_a\"))\nshape: (3, 2)\n+---+----------+\n| a | arccos_a |\n+---+----------+\n| 1 | 0        |\n| 2 | null     |\n| 3 | null     |\n+---+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "arccos",
        "callExpression": ".arccos()",
        "signature": "$df.col(<column_name>).arccos()",
        "signatureDetailed": "$df.col(<column_name>).arccos()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 354,
        "lineEnd": 356
      },
      "arccosh": {
        "desc": "Computes the hyperbolic arccosine of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").arccosh().alias(\"arccosh_a\"))\nshape: (3, 2)\n+---+-----------+\n| a | arccosh_a |\n+---+-----------+\n| 1 | 0         |\n| 2 | 1.316958  |\n| 3 | 1.762747  |\n+---+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "arccosh",
        "callExpression": ".arccosh()",
        "signature": "$df.col(<column_name>).arccosh()",
        "signatureDetailed": "$df.col(<column_name>).arccosh()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 373,
        "lineEnd": 375
      },
      "arcsin": {
        "desc": "Computes the arcsine of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").arcsin().alias(\"arcsin_a\"))\nshape: (3, 2)\n+---+----------+\n| a | arcsin_a |\n+---+----------+\n| 1 | 1.570796 |\n| 2 | null     |\n| 3 | null     |\n+---+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "arcsin",
        "callExpression": ".arcsin()",
        "signature": "$df.col(<column_name>).arcsin()",
        "signatureDetailed": "$df.col(<column_name>).arcsin()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 392,
        "lineEnd": 394
      },
      "arcsinh": {
        "desc": "Computes the hyperbolic arcsine of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").arcsinh().alias(\"arcsinh_a\"))\nshape: (3, 2)\n+---+-----------+\n| a | arcsinh_a |\n+---+-----------+\n| 1 | 0.881374  |\n| 2 | 1.443635  |\n| 3 | 1.818446  |\n+---+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "arcsinh",
        "callExpression": ".arcsinh()",
        "signature": "$df.col(<column_name>).arcsinh()",
        "signatureDetailed": "$df.col(<column_name>).arcsinh()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 411,
        "lineEnd": 413
      },
      "arctan": {
        "desc": "Computes the arctangent of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").arctan().alias(\"arctan_a\"))\nshape: (3, 2)\n+---+----------+\n| a | arctan_a |\n+---+----------+\n| 1 | 0.785398 |\n| 2 | 1.107149 |\n| 3 | 1.249046 |\n+---+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "arctan",
        "callExpression": ".arctan()",
        "signature": "$df.col(<column_name>).arctan()",
        "signatureDetailed": "$df.col(<column_name>).arctan()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 430,
        "lineEnd": 432
      },
      "arctan2": {
        "desc": "Computes the quadrant-aware arctangent of two values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n| 3 | 30 |\n+---+----+\n>>> df.withColumns($df.col(\"a\").arctan2($df.col(\"b\")).alias(\"arctan2_a\"))\nshape: (3, 3)\n+---+----+-----------+\n| a | b  | arctan2_a |\n+---+----+-----------+\n| 1 | 10 | 0.099669  |\n| 2 | 20 | 0.099669  |\n| 3 | 30 | 0.099669  |\n+---+----+-----------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The x denominator number or column expression."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "arctan2",
        "callExpression": ".arctan2()",
        "signature": "$df.col(<column_name>).arctan2(val: NumericArg)",
        "signatureDetailed": "$df.col(<column_name>).arctan2(val: number | bigint | IExpr | null)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 450,
        "lineEnd": 452,
        "typeTree": {
          "val": {
            "type": "NumericArg",
            "optional": false,
            "desc": "The x denominator number or column expression.",
            "resolvedType": "number | bigint | IExpr | null"
          }
        }
      },
      "arctanh": {
        "desc": "Computes the hyperbolic arctangent of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").arctanh().alias(\"arctanh_a\"))\nshape: (3, 2)\n+---+-----------+\n| a | arctanh_a |\n+---+-----------+\n| 1 | null      |\n| 2 | null      |\n| 3 | null      |\n+---+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "arctanh",
        "callExpression": ".arctanh()",
        "signature": "$df.col(<column_name>).arctanh()",
        "signatureDetailed": "$df.col(<column_name>).arctanh()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 469,
        "lineEnd": 471
      },
      "argMax": {
        "desc": "Aggregation: Finds the index of the maximum value in the group.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.col(\"val\").argMax().alias(\"max_idx\"))\nshape: (1, 1)\n+---------+\n| max_idx |\n+---------+\n| 2       |\n+---------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "argMax",
        "callExpression": ".argMax()",
        "signature": "$df.col(<column_name>).argMax()",
        "signatureDetailed": "$df.col(<column_name>).argMax()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 486,
        "lineEnd": 488
      },
      "argMin": {
        "desc": "Aggregation: Finds the index of the minimum value in the group.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.col(\"val\").argMin().alias(\"min_idx\"))\nshape: (1, 1)\n+---------+\n| min_idx |\n+---------+\n| 0       |\n+---------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "argMin",
        "callExpression": ".argMin()",
        "signature": "$df.col(<column_name>).argMin()",
        "signatureDetailed": "$df.col(<column_name>).argMin()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 503,
        "lineEnd": 505
      },
      "avg": {
        "desc": "Aggregation: Computes the arithmetic mean of the group.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg($df.col(\"val\").avg().alias(\"mean\"))\nshape: (2, 2)\n+-------+------+\n| group | mean |\n+-------+------+\n| A     | 15   |\n| B     | 30   |\n+-------+------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "avg",
        "callExpression": ".avg()",
        "signature": "$df.col(<column_name>).avg()",
        "signatureDetailed": "$df.col(<column_name>).avg()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 521,
        "lineEnd": 523
      },
      "between": {
        "desc": "Checks if values fall inside lower and upper boundaries.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n| 3 | 30 |\n+---+----+\n>>> df.withColumns($df.col(\"a\").between(1, 2).alias(\"in_range\"))\nshape: (3, 3)\n+---+----+----------+\n| a | b  | in_range |\n+---+----+----------+\n| 1 | 10 | true     |\n| 2 | 20 | true     |\n| 3 | 30 | false    |\n+---+----+----------+"
        ],
        "params": [
          {
            "name": "lower",
            "desc": "The lower boundary value or expression."
          },
          {
            "name": "upper",
            "desc": "The upper boundary value or expression."
          },
          {
            "name": "[options]",
            "desc": "Boundary configuration options (see `BetweenOptions`)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "between",
        "callExpression": ".between()",
        "signature": "$df.col(<column_name>).between(\n  lower: ComparisonArg,\n  upper: ComparisonArg,\n  options: BetweenOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).between(\n  lower: ScalarArg | ArrayArg,\n  upper: ScalarArg | ArrayArg,\n  options: {\n    closed?: \"both\" | \"left\" | \"right\" | \"none\" = \"both\"\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 544,
        "lineEnd": 550,
        "typeTree": {
          "lower": {
            "type": "ComparisonArg",
            "optional": false,
            "desc": "The lower boundary value or expression.",
            "resolvedType": "ScalarArg | ArrayArg"
          },
          "upper": {
            "type": "ComparisonArg",
            "optional": false,
            "desc": "The upper boundary value or expression.",
            "resolvedType": "ScalarArg | ArrayArg"
          },
          "options": {
            "type": "BetweenOptions",
            "optional": true,
            "default": "{}",
            "desc": "Boundary configuration options (see `BetweenOptions`).",
            "properties": {
              "closed": {
                "type": "ClosedBoundary",
                "optional": true,
                "desc": "Controls boundary inclusivity: - `\"both\"`: `lower <= x <= upper` (default) - `\"left\"`: `lower <= x < upper` - `\"right\"`: `lower < x <= upper` - `\"none\"`: `lower < x < upper`",
                "default": "\"both\"",
                "resolvedType": "\"both\" | \"left\" | \"right\" | \"none\""
              }
            }
          }
        }
      },
      "bitwiseAnd": {
        "desc": "Aggregation: Computes bitwise AND across all elements in the group.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.col(\"a\").bitwiseAnd().alias(\"res\"))\nshape: (1, 1)\n+-----+\n| res |\n+-----+\n| 0   |\n+-----+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "bitwiseAnd",
        "callExpression": ".bitwiseAnd()",
        "signature": "$df.col(<column_name>).bitwiseAnd()",
        "signatureDetailed": "$df.col(<column_name>).bitwiseAnd()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 565,
        "lineEnd": 567
      },
      "bitwiseOr": {
        "desc": "Aggregation: Computes bitwise OR across all elements in the group.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.col(\"a\").bitwiseOr().alias(\"res\"))\nshape: (1, 1)\n+-----+\n| res |\n+-----+\n| 3   |\n+-----+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "bitwiseOr",
        "callExpression": ".bitwiseOr()",
        "signature": "$df.col(<column_name>).bitwiseOr()",
        "signatureDetailed": "$df.col(<column_name>).bitwiseOr()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 582,
        "lineEnd": 584
      },
      "bitwiseXor": {
        "desc": "Aggregation: Computes bitwise XOR across all elements in the group.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.col(\"a\").bitwiseXor().alias(\"res\"))\nshape: (1, 1)\n+-----+\n| res |\n+-----+\n| 0   |\n+-----+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "bitwiseXor",
        "callExpression": ".bitwiseXor()",
        "signature": "$df.col(<column_name>).bitwiseXor()",
        "signatureDetailed": "$df.col(<column_name>).bitwiseXor()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 599,
        "lineEnd": 601
      },
      "cast": {
        "desc": "Coerces the column data type to another type.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").cast($df.DataType.Float64).alias(\"float_a\"))\nshape: (3, 2)\n+---+---------+\n| a | float_a |\n+---+---------+\n| 1 | 1.0     |\n| 2 | 2.0     |\n| 3 | 3.0     |\n+---+---------+"
        ],
        "params": [
          {
            "name": "dataType",
            "desc": "Registered target data type (e.g. `$df.DataType.Int32`, `$df.DataType.String`)."
          },
          {
            "name": "[options]",
            "desc": "Type casting options (e.g. `{ strict: false }` to produce nulls instead of throwing on invalid values)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "cast",
        "callExpression": ".cast()",
        "signature": "$df.col(<column_name>).cast(\n  dataType: RegisteredDataType,\n  options: CastOptions = {}\n): this",
        "signatureDetailed": "$df.col(<column_name>).cast(\n  dataType: Int8Type | Int16Type | Int32Type | Int64Type | UInt8Type | UInt16Type | UInt32Type | UInt64Type | Float32Type | Float64Type | DecimalType | BooleanType | Utf8Type | BinaryType | NullType | ObjectType | DateType | DatetimeType | TimeType | DurationType | ArrayType<any> | StructType<any>,\n  options: {\n    strict?: boolean = true\n  } = {}\n): this",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 621,
        "lineEnd": 628,
        "typeTree": {
          "dataType": {
            "type": "RegisteredDataType",
            "optional": false,
            "desc": "Registered target data type (e.g. `$df.DataType.Int32`, `$df.DataType.String`).",
            "resolvedType": "Int8Type | Int16Type | Int32Type | Int64Type | UInt8Type | UInt16Type | UInt32Type | UInt64Type | Float32Type | Float64Type | DecimalType | BooleanType | Utf8Type | BinaryType | NullType | ObjectType | DateType | DatetimeType | TimeType | DurationType | ArrayType<any> | StructType<any>"
          },
          "options": {
            "type": "CastOptions",
            "optional": true,
            "default": "{}",
            "desc": "Type casting options (e.g. `{ strict: false }` to produce nulls instead of throwing on invalid values).",
            "properties": {
              "strict": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether cast errors should throw or produce `null` values.",
                "default": "true"
              }
            }
          }
        }
      },
      "cbrt": {
        "desc": "Computes the cube root of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").cbrt().alias(\"cbrt_a\"))\nshape: (3, 2)\n+---+----------+\n| a | cbrt_a   |\n+---+----------+\n| 1 | 1        |\n| 2 | 1.259921 |\n| 3 | 1.44225  |\n+---+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "cbrt",
        "callExpression": ".cbrt()",
        "signature": "$df.col(<column_name>).cbrt()",
        "signatureDetailed": "$df.col(<column_name>).cbrt()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 645,
        "lineEnd": 647
      },
      "ceil": {
        "desc": "Rounds column values up to the nearest integer.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").ceil().alias(\"ceil_a\"))\nshape: (3, 2)\n+---+--------+\n| a | ceil_a |\n+---+--------+\n| 1 | 1      |\n| 2 | 2      |\n| 3 | 3      |\n+---+--------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "ceil",
        "callExpression": ".ceil()",
        "signature": "$df.col(<column_name>).ceil()",
        "signatureDetailed": "$df.col(<column_name>).ceil()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 664,
        "lineEnd": 666
      },
      "clip": {
        "desc": "Clamps column values between lower and upper numeric thresholds.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").clip(2, 3).alias(\"clipped\"))\nshape: (3, 2)\n+---+---------+\n| a | clipped |\n+---+---------+\n| 1 | 2       |\n| 2 | 2       |\n| 3 | 3       |\n+---+---------+"
        ],
        "params": [
          {
            "name": "lower",
            "desc": "The lower threshold value (default: null)."
          },
          {
            "name": "upper",
            "desc": "The upper threshold value (default: null)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "clip",
        "callExpression": ".clip()",
        "signature": "$df.col(<column_name>).clip(\n  lower: number | null = null,\n  upper: number | null = null\n)",
        "signatureDetailed": "$df.col(<column_name>).clip(\n  lower: number | null = null,\n  upper: number | null = null\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 685,
        "lineEnd": 687,
        "typeTree": {
          "lower": {
            "type": "number | null",
            "optional": true,
            "default": "null",
            "desc": "The lower threshold value (default: null)."
          },
          "upper": {
            "type": "number | null",
            "optional": true,
            "default": "null",
            "desc": "The upper threshold value (default: null)."
          }
        }
      },
      "copysign": {
        "desc": "Returns absolute value of expr with the sign of other.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n| 3 | 30 |\n+---+----+\n>>> df.withColumns($df.col(\"a\").copysign($df.col(\"b\")).alias(\"signed\"))\nshape: (3, 3)\n+---+----+--------+\n| a | b  | signed |\n+---+----+--------+\n| 1 | 10 | 1      |\n| 2 | 20 | 2      |\n| 3 | 30 | 3      |\n+---+----+--------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The sign source value or column expression."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "copysign",
        "callExpression": ".copysign()",
        "signature": "$df.col(<column_name>).copysign(val: NumericArg)",
        "signatureDetailed": "$df.col(<column_name>).copysign(val: number | bigint | IExpr | null)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 705,
        "lineEnd": 707,
        "typeTree": {
          "val": {
            "type": "NumericArg",
            "optional": false,
            "desc": "The sign source value or column expression.",
            "resolvedType": "number | bigint | IExpr | null"
          }
        }
      },
      "corr": {
        "desc": "Aggregation: Computes the Pearson correlation coefficient between this column and another column expression or numeric array.\n\nComputes the sample Pearson product-moment correlation coefficient $r \\in [-1, 1]$ using a single-pass, numerically stable Welford algorithm. Pairs containing `null`, `undefined`, or `NaN` are automatically dropped (pairwise deletion). Returns `null` if fewer than 2 valid pairs exist or if either column has zero variance.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n| 3 | 30 |\n+---+----+\n>>> df.select($df.col(\"a\").corr($df.col(\"b\")).alias(\"correlation\"))\nshape: (1, 1)\n+-------------+\n| correlation |\n+-------------+\n| 1           |\n+-------------+"
        ],
        "params": [
          {
            "name": "other",
            "type": "NumericSeriesArg",
            "desc": "The target column expression, numeric literal, or numeric array to correlate with."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "corr",
        "callExpression": ".corr()",
        "signature": "$df.col(<column_name>).corr(other: NumericSeriesArg)",
        "signatureDetailed": "$df.col(<column_name>).corr(other: NumericArg | number[] | AnyTypedArray)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 728,
        "lineEnd": 730,
        "typeTree": {
          "other": {
            "type": "NumericSeriesArg",
            "optional": false,
            "desc": "The target column expression, numeric literal, or numeric array to correlate with.",
            "resolvedType": "NumericArg | number[] | AnyTypedArray"
          }
        }
      },
      "cos": {
        "desc": "Computes the cosine of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").cos().alias(\"cos_a\"))\nshape: (3, 2)\n+---+-----------+\n| a | cos_a     |\n+---+-----------+\n| 1 | 0.540302  |\n| 2 | -0.416147 |\n| 3 | -0.989992 |\n+---+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "cos",
        "callExpression": ".cos()",
        "signature": "$df.col(<column_name>).cos()",
        "signatureDetailed": "$df.col(<column_name>).cos()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 747,
        "lineEnd": 749
      },
      "cosh": {
        "desc": "Computes the hyperbolic cosine of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").cosh().alias(\"cosh_a\"))\nshape: (3, 2)\n+---+-----------+\n| a | cosh_a    |\n+---+-----------+\n| 1 | 1.543081  |\n| 2 | 3.762196  |\n| 3 | 10.067662 |\n+---+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "cosh",
        "callExpression": ".cosh()",
        "signature": "$df.col(<column_name>).cosh()",
        "signatureDetailed": "$df.col(<column_name>).cosh()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 766,
        "lineEnd": 768
      },
      "cot": {
        "desc": "Computes the cotangent of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").cot().alias(\"cot_a\"))\nshape: (3, 2)\n+---+-----------+\n| a | cot_a     |\n+---+-----------+\n| 1 | 0.642093  |\n| 2 | -0.457658 |\n| 3 | -7.015253 |\n+---+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "cot",
        "callExpression": ".cot()",
        "signature": "$df.col(<column_name>).cot()",
        "signatureDetailed": "$df.col(<column_name>).cot()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 785,
        "lineEnd": 792
      },
      "count": {
        "desc": "Aggregation: Returns the count of records inside the group or column.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg($df.col(\"val\").count().alias(\"cnt\"))\nshape: (2, 2)\n+-------+-----+\n| group | cnt |\n+-------+-----+\n| A     | 2   |\n| B     | 1   |\n+-------+-----+"
        ],
        "params": [
          {
            "name": "[options]",
            "type": "CountOptions",
            "default": "{}",
            "desc": "Configuration options for counting."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "count",
        "callExpression": ".count()",
        "signature": "$df.col(<column_name>).count(options: CountOptions = {})",
        "signatureDetailed": "$df.col(<column_name>).count(\n  options: {\n    includeNulls?: boolean = false\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 809,
        "lineEnd": 812,
        "typeTree": {
          "options": {
            "type": "CountOptions",
            "optional": true,
            "default": "{}",
            "desc": "Configuration options for counting.",
            "properties": {
              "includeNulls": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether to include `null`, `undefined`, or `NaN` values in the count. When `false`, counts only non-null, valid elements.",
                "default": "false"
              }
            }
          }
        }
      },
      "cov": {
        "desc": "Aggregation: Computes the sample covariance between this column and another column expression or numeric array.\n\nComputes sample covariance with $N - 1$ degrees of freedom using a single-pass, numerically stable Welford algorithm. Pairs containing `null`, `undefined`, or `NaN` are automatically dropped (pairwise deletion). Returns `null` if fewer than 2 valid pairs exist.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n| 3 | 30 |\n+---+----+\n>>> df.select($df.col(\"a\").cov($df.col(\"b\")).alias(\"covariance\"))\nshape: (1, 1)\n+------------+\n| covariance |\n+------------+\n| 10         |\n+------------+"
        ],
        "params": [
          {
            "name": "other",
            "type": "NumericSeriesArg",
            "desc": "The target column expression, numeric literal, or numeric array to compute covariance with."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "cov",
        "callExpression": ".cov()",
        "signature": "$df.col(<column_name>).cov(other: NumericSeriesArg)",
        "signatureDetailed": "$df.col(<column_name>).cov(other: NumericArg | number[] | AnyTypedArray)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 833,
        "lineEnd": 835,
        "typeTree": {
          "other": {
            "type": "NumericSeriesArg",
            "optional": false,
            "desc": "The target column expression, numeric literal, or numeric array to compute covariance with.",
            "resolvedType": "NumericArg | number[] | AnyTypedArray"
          }
        }
      },
      "cumCount": {
        "desc": "Window: Computes cumulative count.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").cumCount().alias(\"c_count\"))\nshape: (3, 2)\n+-----+---------+\n| val | c_count |\n+-----+---------+\n| 10  | 1       |\n| 20  | 2       |\n| 30  | 3       |\n+-----+---------+"
        ],
        "params": [
          {
            "name": "reverse",
            "desc": "Flag indicating whether to compute from reverse direction."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "cumCount",
        "callExpression": ".cumCount()",
        "signature": "$df.col(<column_name>).cumCount(reverse: boolean = false)",
        "signatureDetailed": "$df.col(<column_name>).cumCount(reverse: boolean = false)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 853,
        "lineEnd": 855,
        "typeTree": {
          "reverse": {
            "type": "boolean",
            "optional": true,
            "default": "false",
            "desc": "Flag indicating whether to compute from reverse direction."
          }
        }
      },
      "cumMax": {
        "desc": "Window: Computes cumulative maximum value.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").cumMax().alias(\"c_max\"))\nshape: (3, 2)\n+-----+-------+\n| val | c_max |\n+-----+-------+\n| 10  | 10    |\n| 20  | 20    |\n| 30  | 30    |\n+-----+-------+"
        ],
        "params": [
          {
            "name": "reverse",
            "desc": "Flag indicating whether to compute in reverse direction."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "cumMax",
        "callExpression": ".cumMax()",
        "signature": "$df.col(<column_name>).cumMax(reverse: boolean = false)",
        "signatureDetailed": "$df.col(<column_name>).cumMax(reverse: boolean = false)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 873,
        "lineEnd": 875,
        "typeTree": {
          "reverse": {
            "type": "boolean",
            "optional": true,
            "default": "false",
            "desc": "Flag indicating whether to compute in reverse direction."
          }
        }
      },
      "cumMin": {
        "desc": "Window: Computes cumulative minimum value.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").cumMin().alias(\"c_min\"))\nshape: (3, 2)\n+-----+-------+\n| val | c_min |\n+-----+-------+\n| 10  | 10    |\n| 20  | 10    |\n| 30  | 10    |\n+-----+-------+"
        ],
        "params": [
          {
            "name": "reverse",
            "desc": "Flag indicating whether to compute in reverse direction."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "cumMin",
        "callExpression": ".cumMin()",
        "signature": "$df.col(<column_name>).cumMin(reverse: boolean = false)",
        "signatureDetailed": "$df.col(<column_name>).cumMin(reverse: boolean = false)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 893,
        "lineEnd": 895,
        "typeTree": {
          "reverse": {
            "type": "boolean",
            "optional": true,
            "default": "false",
            "desc": "Flag indicating whether to compute in reverse direction."
          }
        }
      },
      "cumProd": {
        "desc": "Window: Computes cumulative product of values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").cumProd().alias(\"c_prod\"))\nshape: (4, 2)\n+---+--------+\n| a | c_prod |\n+---+--------+\n| 1 | 1      |\n| 2 | 2      |\n| 3 | 6      |\n| 4 | 24     |\n+---+--------+"
        ],
        "params": [
          {
            "name": "reverse",
            "desc": "Flag indicating whether to compute in reverse direction."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "cumProd",
        "callExpression": ".cumProd()",
        "signature": "$df.col(<column_name>).cumProd(reverse: boolean = false)",
        "signatureDetailed": "$df.col(<column_name>).cumProd(reverse: boolean = false)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 914,
        "lineEnd": 916,
        "typeTree": {
          "reverse": {
            "type": "boolean",
            "optional": true,
            "default": "false",
            "desc": "Flag indicating whether to compute in reverse direction."
          }
        }
      },
      "cumSum": {
        "desc": "Window: Computes cumulative sum of values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").cumSum().alias(\"c_sum\"))\nshape: (3, 2)\n+-----+-------+\n| val | c_sum |\n+-----+-------+\n| 10  | 10    |\n| 20  | 30    |\n| 30  | 60    |\n+-----+-------+"
        ],
        "params": [
          {
            "name": "reverse",
            "desc": "Flag indicating whether to compute in reverse direction."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "cumSum",
        "callExpression": ".cumSum()",
        "signature": "$df.col(<column_name>).cumSum(reverse: boolean = false)",
        "signatureDetailed": "$df.col(<column_name>).cumSum(reverse: boolean = false)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 934,
        "lineEnd": 936,
        "typeTree": {
          "reverse": {
            "type": "boolean",
            "optional": true,
            "default": "false",
            "desc": "Flag indicating whether to compute in reverse direction."
          }
        }
      },
      "degrees": {
        "desc": "Converts angles from radians to degrees.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").degrees().alias(\"deg\"))\nshape: (3, 2)\n+---+------------+\n| a | deg        |\n+---+------------+\n| 1 | 57.29578   |\n| 2 | 114.591559 |\n| 3 | 171.887339 |\n+---+------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "degrees",
        "callExpression": ".degrees()",
        "signature": "$df.col(<column_name>).degrees()",
        "signatureDetailed": "$df.col(<column_name>).degrees()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 953,
        "lineEnd": 955
      },
      "denseRank": {
        "desc": "Window: Computes dense rank (ranks without gaps) within group partition.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"score\").denseRank().alias(\"dr\"))\nshape: (2, 2)\n+-------+----+\n| score | dr |\n+-------+----+\n| 75    | 1  |\n| 95    | 2  |\n+-------+----+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "denseRank",
        "callExpression": ".denseRank()",
        "signature": "$df.col(<column_name>).denseRank()",
        "signatureDetailed": "$df.col(<column_name>).denseRank()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 971,
        "lineEnd": 973
      },
      "div": {
        "desc": "Divides column values by a scalar or another column expression.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").div(2).alias(\"div_a\"))\nshape: (3, 2)\n+---+-------+\n| a | div_a |\n+---+-------+\n| 1 | 0.5   |\n| 2 | 1     |\n| 3 | 1.5   |\n+---+-------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The denominator value or column expression."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "div",
        "callExpression": ".div()",
        "signature": "$df.col(<column_name>).div(val: NumericArg)",
        "signatureDetailed": "$df.col(<column_name>).div(val: number | bigint | IExpr | null)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 991,
        "lineEnd": 993,
        "typeTree": {
          "val": {
            "type": "NumericArg",
            "optional": false,
            "desc": "The denominator value or column expression.",
            "resolvedType": "number | bigint | IExpr | null"
          }
        }
      },
      "dot": {
        "desc": "Aggregation: Computes the dot product between this column and another column expression, numeric scalar, or array.\n\nComputes $\\mathbf{x} \\cdot \\mathbf{y} = \\sum_{i} x_i y_i$. Pairs containing `null`, `undefined`, or non-finite values (`NaN`, `Infinity`) are automatically dropped. Returns `null` if no valid pairs exist or if the DataFrame is empty.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n| 3 | 30 |\n+---+----+\n>>> df.select($df.col(\"a\").dot($df.col(\"b\")).alias(\"dot_product\"))\nshape: (1, 1)\n+-------------+\n| dot_product |\n+-------------+\n| 32          |\n+-------------+"
        ],
        "params": [
          {
            "name": "other",
            "type": "NumericSeriesArg",
            "desc": "The other column expression, numeric literal, or numeric array to compute the dot product with."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "dot",
        "callExpression": ".dot()",
        "signature": "$df.col(<column_name>).dot(other: NumericSeriesArg)",
        "signatureDetailed": "$df.col(<column_name>).dot(other: NumericArg | number[] | AnyTypedArray)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1013,
        "lineEnd": 1015,
        "typeTree": {
          "other": {
            "type": "NumericSeriesArg",
            "optional": false,
            "desc": "The other column expression, numeric literal, or numeric array to compute the dot product with.",
            "resolvedType": "NumericArg | number[] | AnyTypedArray"
          }
        }
      },
      "entropy": {
        "desc": "Aggregation: Computes the Shannon entropy of a column or group.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.col(\"a\").entropy().alias(\"h\"))\nshape: (1, 1)\n+----------+\n| h        |\n+----------+\n| 1.386294 |\n+----------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Entropy options ({ base?: number, normalize?: boolean }, default base=Math.E, normalize=true)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "entropy",
        "callExpression": ".entropy()",
        "signature": "$df.col(<column_name>).entropy(options: EntropyOptions = { base: Math.E, normalize: true })",
        "signatureDetailed": "$df.col(<column_name>).entropy(\n  options: {\n    base?: number = Math.E,\n    normalize?: boolean = true\n  } = { base: Math.E, normalize: true }\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1031,
        "lineEnd": 1033,
        "typeTree": {
          "options": {
            "type": "EntropyOptions",
            "optional": true,
            "default": "{ base: Math.E, normalize: true }",
            "desc": "Entropy options ({ base?: number, normalize?: boolean }, default base=Math.E, normalize=true).",
            "properties": {
              "base": {
                "type": "number",
                "optional": true,
                "desc": "Logarithm base used to compute entropy.",
                "default": "Math.E"
              },
              "normalize": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, normalizes categorical value frequencies; if `false`, treats numeric values directly as discrete probabilities.",
                "default": "true"
              }
            }
          }
        }
      },
      "eq": {
        "desc": "Boolean comparison: Returns true if column values match the specified value exactly under Kleene logic.\n\nEvaluates strict equality (`===`) between this column and `val`. Under standard three-valued (Kleene) logic, comparing any value to `null` or `undefined` yields `null` (unknown). In IEEE-754 arithmetic, `NaN === NaN` yields `false`.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").eq(2).alias(\"is_two\"))\nshape: (3, 2)\n+---+--------+\n| a | is_two |\n+---+--------+\n| 1 | false  |\n| 2 | true   |\n| 3 | false  |\n+---+--------+"
        ],
        "params": [
          {
            "name": "val",
            "type": "ComparisonArg",
            "desc": "The value, literal array, or column expression to compare against."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "eq",
        "callExpression": ".eq()",
        "signature": "$df.col(<column_name>).eq(val: ComparisonArg)",
        "signatureDetailed": "$df.col(<column_name>).eq(val: ScalarArg | ArrayArg)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1055,
        "lineEnd": 1057,
        "typeTree": {
          "val": {
            "type": "ComparisonArg",
            "optional": false,
            "desc": "The value, literal array, or column expression to compare against.",
            "resolvedType": "ScalarArg | ArrayArg"
          }
        }
      },
      "eqMissing": {
        "desc": "Equivalence comparison that treats null and missing values as equal to each other.\n\nReturns `true` if both values are identical, or if both values are nullish (`null` or `undefined`). Returns `false` if one value is nullish while the other is non-null. Non-null values follow standard equality.",
        "examples": [
          ">>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.withColumns($df.col(\"a\").eqMissing(null).alias(\"is_missing\"))\nshape: (3, 2)\n+------+------------+\n| a    | is_missing |\n+------+------------+\n| 1    | false      |\n| null | true       |\n| 3    | false      |\n+------+------------+"
        ],
        "params": [
          {
            "name": "val",
            "type": "ComparisonArg",
            "desc": "The value, literal array, or column expression to compare against."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "eqMissing",
        "callExpression": ".eqMissing()",
        "signature": "$df.col(<column_name>).eqMissing(val: ComparisonArg)",
        "signatureDetailed": "$df.col(<column_name>).eqMissing(val: ScalarArg | ArrayArg)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1079,
        "lineEnd": 1084,
        "typeTree": {
          "val": {
            "type": "ComparisonArg",
            "optional": false,
            "desc": "The value, literal array, or column expression to compare against.",
            "resolvedType": "ScalarArg | ArrayArg"
          }
        }
      },
      "ewmKurt": {
        "desc": "Window: Computes exponentially weighted moving kurtosis.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").ewmKurt({ alpha: 0.5 }).alias(\"ewm_kurt\"))\nshape: (3, 2)\n+---+----------+\n| a | ewm_kurt |\n+---+----------+\n| 1 | null     |\n| 2 | -1       |\n| 3 | 1.052409 |\n+---+----------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Configuration specifying decay rate (`alpha`, `span`, `com`, `halfLife`), `adjust`, `minSamples`, `ignoreNulls`, and optional `by`."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "ewmKurt",
        "callExpression": ".ewmKurt()",
        "signature": "$df.col(<column_name>).ewmKurt(options: EwmKurtOptions)",
        "signatureDetailed": "$df.col(<column_name>).ewmKurt(\n  options: {\n    adjust?: boolean = true,\n    alpha?: number,\n    bias?: boolean = false,\n    by?: string | IExpr,\n    com?: number,\n    fisher?: boolean = true,\n    halfLife?: number | string,\n    ignoreNulls?: boolean = false,\n    minSamples?: number = 1,\n    span?: number\n  }\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1102,
        "lineEnd": 1110,
        "typeTree": {
          "options": {
            "type": "EwmKurtOptions",
            "optional": false,
            "desc": "Configuration specifying decay rate (`alpha`, `span`, `com`, `halfLife`), `adjust`, `minSamples`, `ignoreNulls`, and optional `by`.",
            "properties": {
              "adjust": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, divides by the decaying adjustment factor in beginning periods to account for imbalance in relative weightings.",
                "default": "true"
              },
              "alpha": {
                "type": "number",
                "optional": true,
                "desc": "Smoothing factor `alpha` directly in `(0, 1]`. Mutually exclusive with `span`, `halfLife`, and `com`."
              },
              "bias": {
                "type": "boolean",
                "optional": true,
                "desc": "When `false`, applies sample bias correction; when `true`, computes population moments without bias correction.",
                "default": "false"
              },
              "by": {
                "type": "ColumnOrExprArg",
                "optional": true,
                "desc": "Optional timestamp/index column name or expression used to scale `halfLife` decay by elapsed time deltas.",
                "resolvedType": "string | IExpr"
              },
              "com": {
                "type": "number",
                "optional": true,
                "desc": "Decay in terms of center of mass (`alpha = 1 / (1 + com)`), where `com >= 0`."
              },
              "fisher": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true` (default), computes excess kurtosis (Fisher's definition, subtracting 3.0); when `false`, computes Pearson's kurtosis.",
                "default": "true"
              },
              "halfLife": {
                "type": "DurationValueArg",
                "optional": true,
                "desc": "Decay in terms of half-life (`alpha = 1 - exp(-ln(2) / halfLife)`), as a positive number or duration string.",
                "resolvedType": "number | string"
              },
              "ignoreNulls": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, ignores missing/null values when calculating weights; when `false`, weights decay across null positions.",
                "default": "false"
              },
              "minSamples": {
                "type": "number",
                "optional": true,
                "desc": "Minimum number of non-null observations in window required to produce a value (otherwise `null`).",
                "default": "1"
              },
              "span": {
                "type": "number",
                "optional": true,
                "desc": "Decay in terms of span (`alpha = 2 / (span + 1)`), where `span >= 1`."
              }
            }
          }
        }
      },
      "ewmMean": {
        "desc": "Window: Computes exponentially weighted moving average (mean).",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").ewmMean({ alpha: 0.5 }).alias(\"ewm_mean\"))\nshape: (3, 2)\n+---+----------+\n| a | ewm_mean |\n+---+----------+\n| 1 | 1        |\n| 2 | 1.666667 |\n| 3 | 2.428571 |\n+---+----------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Configuration specifying decay rate (`alpha`, `span`, `com`, `halfLife`), `adjust`, `minSamples`, `ignoreNulls`, and optional `by`."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "ewmMean",
        "callExpression": ".ewmMean()",
        "signature": "$df.col(<column_name>).ewmMean(options: EwmMeanOptions)",
        "signatureDetailed": "$df.col(<column_name>).ewmMean(\n  options: {\n    adjust?: boolean = true,\n    alpha?: number,\n    by?: string | IExpr,\n    com?: number,\n    halfLife?: number | string,\n    ignoreNulls?: boolean = false,\n    minSamples?: number = 1,\n    span?: number\n  }\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1128,
        "lineEnd": 1130,
        "typeTree": {
          "options": {
            "type": "EwmMeanOptions",
            "optional": false,
            "desc": "Configuration specifying decay rate (`alpha`, `span`, `com`, `halfLife`), `adjust`, `minSamples`, `ignoreNulls`, and optional `by`.",
            "properties": {
              "adjust": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, divides by the decaying adjustment factor in beginning periods to account for imbalance in relative weightings.",
                "default": "true"
              },
              "alpha": {
                "type": "number",
                "optional": true,
                "desc": "Smoothing factor `alpha` directly in `(0, 1]`. Mutually exclusive with `span`, `halfLife`, and `com`."
              },
              "by": {
                "type": "ColumnOrExprArg",
                "optional": true,
                "desc": "Optional timestamp/index column name or expression used to scale `halfLife` decay by elapsed time deltas.",
                "resolvedType": "string | IExpr"
              },
              "com": {
                "type": "number",
                "optional": true,
                "desc": "Decay in terms of center of mass (`alpha = 1 / (1 + com)`), where `com >= 0`."
              },
              "halfLife": {
                "type": "DurationValueArg",
                "optional": true,
                "desc": "Decay in terms of half-life (`alpha = 1 - exp(-ln(2) / halfLife)`), as a positive number or duration string.",
                "resolvedType": "number | string"
              },
              "ignoreNulls": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, ignores missing/null values when calculating weights; when `false`, weights decay across null positions.",
                "default": "false"
              },
              "minSamples": {
                "type": "number",
                "optional": true,
                "desc": "Minimum number of non-null observations in window required to produce a value (otherwise `null`).",
                "default": "1"
              },
              "span": {
                "type": "number",
                "optional": true,
                "desc": "Decay in terms of span (`alpha = 2 / (span + 1)`), where `span >= 1`."
              }
            }
          }
        }
      },
      "ewmSkew": {
        "desc": "Window: Computes exponentially weighted moving skewness.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").ewmSkew({ alpha: 0.5 }).alias(\"ewm_skew\"))\nshape: (3, 2)\n+---+-----------+\n| a | ewm_skew  |\n+---+-----------+\n| 1 | null      |\n| 2 | -0.816497 |\n| 3 | -1.125865 |\n+---+-----------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Configuration specifying decay rate (`alpha`, `span`, `com`, `halfLife`), `adjust`, `minSamples`, `ignoreNulls`, optional `bias`, and optional `by`."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "ewmSkew",
        "callExpression": ".ewmSkew()",
        "signature": "$df.col(<column_name>).ewmSkew(options: EwmSkewOptions)",
        "signatureDetailed": "$df.col(<column_name>).ewmSkew(\n  options: {\n    adjust?: boolean = true,\n    alpha?: number,\n    bias?: boolean = false,\n    by?: string | IExpr,\n    com?: number,\n    halfLife?: number | string,\n    ignoreNulls?: boolean = false,\n    minSamples?: number = 1,\n    span?: number\n  }\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1148,
        "lineEnd": 1156,
        "typeTree": {
          "options": {
            "type": "EwmSkewOptions",
            "optional": false,
            "desc": "Configuration specifying decay rate (`alpha`, `span`, `com`, `halfLife`), `adjust`, `minSamples`, `ignoreNulls`, optional `bias`, and optional `by`.",
            "properties": {
              "adjust": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, divides by the decaying adjustment factor in beginning periods to account for imbalance in relative weightings.",
                "default": "true"
              },
              "alpha": {
                "type": "number",
                "optional": true,
                "desc": "Smoothing factor `alpha` directly in `(0, 1]`. Mutually exclusive with `span`, `halfLife`, and `com`."
              },
              "bias": {
                "type": "boolean",
                "optional": true,
                "desc": "When `false`, applies sample bias correction; when `true`, computes population moments without bias correction.",
                "default": "false"
              },
              "by": {
                "type": "ColumnOrExprArg",
                "optional": true,
                "desc": "Optional timestamp/index column name or expression used to scale `halfLife` decay by elapsed time deltas.",
                "resolvedType": "string | IExpr"
              },
              "com": {
                "type": "number",
                "optional": true,
                "desc": "Decay in terms of center of mass (`alpha = 1 / (1 + com)`), where `com >= 0`."
              },
              "halfLife": {
                "type": "DurationValueArg",
                "optional": true,
                "desc": "Decay in terms of half-life (`alpha = 1 - exp(-ln(2) / halfLife)`), as a positive number or duration string.",
                "resolvedType": "number | string"
              },
              "ignoreNulls": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, ignores missing/null values when calculating weights; when `false`, weights decay across null positions.",
                "default": "false"
              },
              "minSamples": {
                "type": "number",
                "optional": true,
                "desc": "Minimum number of non-null observations in window required to produce a value (otherwise `null`).",
                "default": "1"
              },
              "span": {
                "type": "number",
                "optional": true,
                "desc": "Decay in terms of span (`alpha = 2 / (span + 1)`), where `span >= 1`."
              }
            }
          }
        }
      },
      "ewmStd": {
        "desc": "Window: Computes exponentially weighted moving standard deviation.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").ewmStd({ alpha: 0.5 }).alias(\"ewm_std\"))\nshape: (3, 2)\n+---+----------+\n| a | ewm_std  |\n+---+----------+\n| 1 | null     |\n| 2 | 0.471405 |\n| 3 | 0.728431 |\n+---+----------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Configuration specifying decay rate (`alpha`, `span`, `com`, `halfLife`), `adjust`, `minSamples`, `ignoreNulls`, and optional `by`."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "ewmStd",
        "callExpression": ".ewmStd()",
        "signature": "$df.col(<column_name>).ewmStd(options: EwmStdOptions)",
        "signatureDetailed": "$df.col(<column_name>).ewmStd(\n  options: {\n    adjust?: boolean = true,\n    alpha?: number,\n    by?: string | IExpr,\n    com?: number,\n    halfLife?: number | string,\n    ignoreNulls?: boolean = false,\n    minSamples?: number = 1,\n    span?: number\n  }\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1174,
        "lineEnd": 1176,
        "typeTree": {
          "options": {
            "type": "EwmStdOptions",
            "optional": false,
            "desc": "Configuration specifying decay rate (`alpha`, `span`, `com`, `halfLife`), `adjust`, `minSamples`, `ignoreNulls`, and optional `by`.",
            "properties": {
              "adjust": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, divides by the decaying adjustment factor in beginning periods to account for imbalance in relative weightings.",
                "default": "true"
              },
              "alpha": {
                "type": "number",
                "optional": true,
                "desc": "Smoothing factor `alpha` directly in `(0, 1]`. Mutually exclusive with `span`, `halfLife`, and `com`."
              },
              "by": {
                "type": "ColumnOrExprArg",
                "optional": true,
                "desc": "Optional timestamp/index column name or expression used to scale `halfLife` decay by elapsed time deltas.",
                "resolvedType": "string | IExpr"
              },
              "com": {
                "type": "number",
                "optional": true,
                "desc": "Decay in terms of center of mass (`alpha = 1 / (1 + com)`), where `com >= 0`."
              },
              "halfLife": {
                "type": "DurationValueArg",
                "optional": true,
                "desc": "Decay in terms of half-life (`alpha = 1 - exp(-ln(2) / halfLife)`), as a positive number or duration string.",
                "resolvedType": "number | string"
              },
              "ignoreNulls": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, ignores missing/null values when calculating weights; when `false`, weights decay across null positions.",
                "default": "false"
              },
              "minSamples": {
                "type": "number",
                "optional": true,
                "desc": "Minimum number of non-null observations in window required to produce a value (otherwise `null`).",
                "default": "1"
              },
              "span": {
                "type": "number",
                "optional": true,
                "desc": "Decay in terms of span (`alpha = 2 / (span + 1)`), where `span >= 1`."
              }
            }
          }
        }
      },
      "ewmSum": {
        "desc": "Window: Computes exponentially weighted moving sum.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").ewmSum({ alpha: 0.5 }).alias(\"ewm_sum\"))\nshape: (3, 2)\n+---+---------+\n| a | ewm_sum |\n+---+---------+\n| 1 | 1       |\n| 2 | 2.5     |\n| 3 | 4.25    |\n+---+---------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Configuration specifying decay rate (`alpha`, `span`, `com`, `halfLife`), `minSamples`, `ignoreNulls`, and optional `by`."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "ewmSum",
        "callExpression": ".ewmSum()",
        "signature": "$df.col(<column_name>).ewmSum(options: EwmSumOptions)",
        "signatureDetailed": "$df.col(<column_name>).ewmSum(\n  options: {\n    alpha?: number,\n    by?: string | IExpr,\n    com?: number,\n    halfLife?: number | string,\n    ignoreNulls?: boolean = false,\n    minSamples?: number = 1,\n    span?: number\n  }\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1194,
        "lineEnd": 1196,
        "typeTree": {
          "options": {
            "type": "EwmSumOptions",
            "optional": false,
            "desc": "Configuration specifying decay rate (`alpha`, `span`, `com`, `halfLife`), `minSamples`, `ignoreNulls`, and optional `by`.",
            "properties": {
              "alpha": {
                "type": "number",
                "optional": true,
                "desc": "Smoothing factor `alpha` directly in `(0, 1]`. Mutually exclusive with `span`, `halfLife`, and `com`."
              },
              "by": {
                "type": "ColumnOrExprArg",
                "optional": true,
                "desc": "Optional timestamp/index column name or expression used to scale `halfLife` decay by elapsed time deltas.",
                "resolvedType": "string | IExpr"
              },
              "com": {
                "type": "number",
                "optional": true,
                "desc": "Decay in terms of center of mass (`alpha = 1 / (1 + com)`), where `com >= 0`."
              },
              "halfLife": {
                "type": "DurationValueArg",
                "optional": true,
                "desc": "Decay in terms of half-life (`alpha = 1 - exp(-ln(2) / halfLife)`), as a positive number or duration string.",
                "resolvedType": "number | string"
              },
              "ignoreNulls": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, ignores missing/null values when calculating weights; when `false`, weights decay across null positions.",
                "default": "false"
              },
              "minSamples": {
                "type": "number",
                "optional": true,
                "desc": "Minimum number of non-null observations in window required to produce a value (otherwise `null`).",
                "default": "1"
              },
              "span": {
                "type": "number",
                "optional": true,
                "desc": "Decay in terms of span (`alpha = 2 / (span + 1)`), where `span >= 1`."
              }
            }
          }
        }
      },
      "ewmVar": {
        "desc": "Window: Computes exponentially weighted moving variance.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").ewmVar({ alpha: 0.5 }).alias(\"ewm_var\"))\nshape: (3, 2)\n+---+----------+\n| a | ewm_var  |\n+---+----------+\n| 1 | null     |\n| 2 | 0.222222 |\n| 3 | 0.530612 |\n+---+----------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Configuration specifying decay rate (`alpha`, `span`, `com`, `halfLife`), `adjust`, `minSamples`, `ignoreNulls`, and optional `by`."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "ewmVar",
        "callExpression": ".ewmVar()",
        "signature": "$df.col(<column_name>).ewmVar(options: EwmVarOptions)",
        "signatureDetailed": "$df.col(<column_name>).ewmVar(\n  options: {\n    adjust?: boolean = true,\n    alpha?: number,\n    by?: string | IExpr,\n    com?: number,\n    halfLife?: number | string,\n    ignoreNulls?: boolean = false,\n    minSamples?: number = 1,\n    span?: number\n  }\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1214,
        "lineEnd": 1216,
        "typeTree": {
          "options": {
            "type": "EwmVarOptions",
            "optional": false,
            "desc": "Configuration specifying decay rate (`alpha`, `span`, `com`, `halfLife`), `adjust`, `minSamples`, `ignoreNulls`, and optional `by`.",
            "properties": {
              "adjust": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, divides by the decaying adjustment factor in beginning periods to account for imbalance in relative weightings.",
                "default": "true"
              },
              "alpha": {
                "type": "number",
                "optional": true,
                "desc": "Smoothing factor `alpha` directly in `(0, 1]`. Mutually exclusive with `span`, `halfLife`, and `com`."
              },
              "by": {
                "type": "ColumnOrExprArg",
                "optional": true,
                "desc": "Optional timestamp/index column name or expression used to scale `halfLife` decay by elapsed time deltas.",
                "resolvedType": "string | IExpr"
              },
              "com": {
                "type": "number",
                "optional": true,
                "desc": "Decay in terms of center of mass (`alpha = 1 / (1 + com)`), where `com >= 0`."
              },
              "halfLife": {
                "type": "DurationValueArg",
                "optional": true,
                "desc": "Decay in terms of half-life (`alpha = 1 - exp(-ln(2) / halfLife)`), as a positive number or duration string.",
                "resolvedType": "number | string"
              },
              "ignoreNulls": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, ignores missing/null values when calculating weights; when `false`, weights decay across null positions.",
                "default": "false"
              },
              "minSamples": {
                "type": "number",
                "optional": true,
                "desc": "Minimum number of non-null observations in window required to produce a value (otherwise `null`).",
                "default": "1"
              },
              "span": {
                "type": "number",
                "optional": true,
                "desc": "Decay in terms of span (`alpha = 2 / (span + 1)`), where `span >= 1`."
              }
            }
          }
        }
      },
      "exp": {
        "desc": "Computes natural exponent (e^x) of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").exp().alias(\"exp_a\"))\nshape: (3, 2)\n+---+-----------+\n| a | exp_a     |\n+---+-----------+\n| 1 | 2.718282  |\n| 2 | 7.389056  |\n| 3 | 20.085537 |\n+---+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "exp",
        "callExpression": ".exp()",
        "signature": "$df.col(<column_name>).exp()",
        "signatureDetailed": "$df.col(<column_name>).exp()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1233,
        "lineEnd": 1235
      },
      "expm1": {
        "desc": "Computes e^x - 1 for each element in the column.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").expm1().alias(\"expm1_a\"))\nshape: (3, 2)\n+---+-----------+\n| a | expm1_a   |\n+---+-----------+\n| 1 | 1.718282  |\n| 2 | 6.389056  |\n| 3 | 19.085537 |\n+---+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "expm1",
        "callExpression": ".expm1()",
        "signature": "$df.col(<column_name>).expm1()",
        "signatureDetailed": "$df.col(<column_name>).expm1()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1252,
        "lineEnd": 1254
      },
      "fill": {
        "desc": "Replaces targeted values (\"null\", \"nan\", or \"all\") with a specified value or strategy.",
        "examples": [
          ">>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.withColumns($df.col(\"a\").fill(\"null\", { value: 0 }).alias(\"filled\"))\nshape: (3, 2)\n+------+--------+\n| a    | filled |\n+------+--------+\n| 1    | 1      |\n| null | 0      |\n| 3    | 3      |\n+------+--------+"
        ],
        "params": [
          {
            "name": "target",
            "type": "FillTarget",
            "desc": "The target value type to replace: \"null\", \"nan\", or \"all\"."
          },
          {
            "name": "[options]",
            "type": "FillOptions",
            "default": "{}",
            "desc": "Configuration options specifying replacement value, strategy, and optional limit."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "fill",
        "callExpression": ".fill()",
        "signature": "$df.col(<column_name>).fill(\n  target: FillTarget,\n  options: FillOptions = {}\n): this",
        "signatureDetailed": "$df.col(<column_name>).fill(\n  target: \"null\" | \"nan\" | \"all\" | ScalarArg,\n  options: {\n    limit?: number,\n    strategy?: \"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\",\n    value?: IExpr | ValidScalarTypes\n  } = {}\n): this",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1273,
        "lineEnd": 1341,
        "typeTree": {
          "target": {
            "type": "FillTarget",
            "optional": false,
            "desc": "The target value type to replace: \"null\", \"nan\", or \"all\".",
            "resolvedType": "\"null\" | \"nan\" | \"all\" | ScalarArg"
          },
          "options": {
            "type": "FillOptions",
            "optional": true,
            "default": "{}",
            "desc": "Configuration options specifying replacement value, strategy, and optional limit.",
            "properties": {
              "limit": {
                "type": "number",
                "optional": true,
                "desc": "Maximum number of consecutive target values to fill when using directional strategies (`\"forward\"`, `\"backward\"`)."
              },
              "strategy": {
                "type": "FillNullStrategy",
                "optional": true,
                "desc": "Filling strategy to calculate or propagate replacement values (`\"forward\"`, `\"backward\"`, `\"min\"`, `\"max\"`, `\"mean\"`, `\"zero\"`, `\"one\"`).",
                "resolvedType": "\"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\""
              },
              "value": {
                "type": "ScalarArg",
                "optional": true,
                "desc": "Replacement scalar value or column expression to substitute in place of target values.",
                "resolvedType": "IExpr | ValidScalarTypes"
              }
            }
          }
        }
      },
      "fillNan": {
        "desc": "Replaces NaN values with a specified value or strategy.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").fillNan({ value: 0 }).alias(\"clean\"))\nshape: (3, 2)\n+---+-------+\n| a | clean |\n+---+-------+\n| 1 | 1     |\n| 2 | 2     |\n| 3 | 3     |\n+---+-------+"
        ],
        "params": [
          {
            "name": "[options]",
            "type": "FillNullOptions",
            "default": "{}",
            "desc": "Configuration options specifying replacement value, strategy, and optional limit."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "fillNan",
        "callExpression": ".fillNan()",
        "signature": "$df.col(<column_name>).fillNan(options: FillNullOptions = {}): this",
        "signatureDetailed": "$df.col(<column_name>).fillNan(\n  options: {\n    limit?: number,\n    strategy?: \"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\",\n    value?: IExpr | ValidScalarTypes\n  } = {}\n): this",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1359,
        "lineEnd": 1361,
        "typeTree": {
          "options": {
            "type": "FillNullOptions",
            "optional": true,
            "default": "{}",
            "desc": "Configuration options specifying replacement value, strategy, and optional limit.",
            "properties": {
              "limit": {
                "type": "number",
                "optional": true,
                "desc": "Maximum number of consecutive target values to fill when using directional strategies (`\"forward\"`, `\"backward\"`)."
              },
              "strategy": {
                "type": "FillNullStrategy",
                "optional": true,
                "desc": "Filling strategy to calculate or propagate replacement values (`\"forward\"`, `\"backward\"`, `\"min\"`, `\"max\"`, `\"mean\"`, `\"zero\"`, `\"one\"`).",
                "resolvedType": "\"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\""
              },
              "value": {
                "type": "ScalarArg",
                "optional": true,
                "desc": "Replacement scalar value or column expression to substitute in place of target values.",
                "resolvedType": "IExpr | ValidScalarTypes"
              }
            }
          }
        }
      },
      "fillNull": {
        "desc": "Replaces null, undefined, or missing values with a specified value or strategy.",
        "examples": [
          ">>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.withColumns($df.col(\"a\").fillNull({ value: 0 }).alias(\"filled\"))\nshape: (3, 2)\n+------+--------+\n| a    | filled |\n+------+--------+\n| 1    | 1      |\n| null | 0      |\n| 3    | 3      |\n+------+--------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Configuration options including fill value, strategy (\"forward\", \"backward\", \"zero\", \"one\", \"mean\", \"min\", \"max\"), and optional limit."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "fillNull",
        "callExpression": ".fillNull()",
        "signature": "$df.col(<column_name>).fillNull(options: FillNullOptions = {}): this",
        "signatureDetailed": "$df.col(<column_name>).fillNull(\n  options: {\n    limit?: number,\n    strategy?: \"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\",\n    value?: IExpr | ValidScalarTypes\n  } = {}\n): this",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1379,
        "lineEnd": 1381,
        "typeTree": {
          "options": {
            "type": "FillNullOptions",
            "optional": true,
            "default": "{}",
            "desc": "Configuration options including fill value, strategy (\"forward\", \"backward\", \"zero\", \"one\", \"mean\", \"min\", \"max\"), and optional limit.",
            "properties": {
              "limit": {
                "type": "number",
                "optional": true,
                "desc": "Maximum number of consecutive target values to fill when using directional strategies (`\"forward\"`, `\"backward\"`)."
              },
              "strategy": {
                "type": "FillNullStrategy",
                "optional": true,
                "desc": "Filling strategy to calculate or propagate replacement values (`\"forward\"`, `\"backward\"`, `\"min\"`, `\"max\"`, `\"mean\"`, `\"zero\"`, `\"one\"`).",
                "resolvedType": "\"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\""
              },
              "value": {
                "type": "ScalarArg",
                "optional": true,
                "desc": "Replacement scalar value or column expression to substitute in place of target values.",
                "resolvedType": "IExpr | ValidScalarTypes"
              }
            }
          }
        }
      },
      "filter": {
        "desc": "Filters elements of the column expression where the predicate evaluates to truthy.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.col(\"a\").filter($df.col(\"a\").gt(1)).alias(\"filtered\"))\nshape: (2, 1)\n+----------+\n| filtered |\n+----------+\n| 2        |\n| 3        |\n+----------+"
        ],
        "params": [
          {
            "name": "predicate",
            "desc": "Boolean column expression used to filter values."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "filter",
        "callExpression": ".filter()",
        "signature": "$df.col(<column_name>).filter(predicate: IExpr): this",
        "signatureDetailed": "$df.col(<column_name>).filter(predicate: IExpr): this",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1398,
        "lineEnd": 1403,
        "typeTree": {
          "predicate": {
            "type": "IExpr",
            "optional": false,
            "desc": "Boolean column expression used to filter values."
          }
        }
      },
      "first": {
        "desc": "Aggregation: Finds the first value in the group.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg($df.col(\"val\").first().alias(\"first_val\"))\nshape: (2, 2)\n+-------+-----------+\n| group | first_val |\n+-------+-----------+\n| A     | 10        |\n| B     | 30        |\n+-------+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "first",
        "callExpression": ".first()",
        "signature": "$df.col(<column_name>).first()",
        "signatureDetailed": "$df.col(<column_name>).first()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1419,
        "lineEnd": 1421
      },
      "floor": {
        "desc": "Rounds column values down to the nearest integer.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").floor().alias(\"floor_a\"))\nshape: (3, 2)\n+---+---------+\n| a | floor_a |\n+---+---------+\n| 1 | 1       |\n| 2 | 2       |\n| 3 | 3       |\n+---+---------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "floor",
        "callExpression": ".floor()",
        "signature": "$df.col(<column_name>).floor()",
        "signatureDetailed": "$df.col(<column_name>).floor()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1438,
        "lineEnd": 1440
      },
      "floordiv": {
        "desc": "Performs integer division floor(x / y) on column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").floordiv(2).alias(\"fdiv\"))\nshape: (3, 2)\n+---+------+\n| a | fdiv |\n+---+------+\n| 1 | 0    |\n| 2 | 1    |\n| 3 | 1    |\n+---+------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The divisor value or column expression."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "floordiv",
        "callExpression": ".floordiv()",
        "signature": "$df.col(<column_name>).floordiv(val: NumericArg)",
        "signatureDetailed": "$df.col(<column_name>).floordiv(val: number | bigint | IExpr | null)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1458,
        "lineEnd": 1460,
        "typeTree": {
          "val": {
            "type": "NumericArg",
            "optional": false,
            "desc": "The divisor value or column expression.",
            "resolvedType": "number | bigint | IExpr | null"
          }
        }
      },
      "ge": {
        "desc": "Boolean comparison: Returns true if greater than or equal to argument.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").ge(2).alias(\"ge_two\"))\nshape: (3, 2)\n+---+--------+\n| a | ge_two |\n+---+--------+\n| 1 | false  |\n| 2 | true   |\n| 3 | true   |\n+---+--------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The value or column expression to compare against."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "ge",
        "callExpression": ".ge()",
        "signature": "$df.col(<column_name>).ge(val: ComparisonArg)",
        "signatureDetailed": "$df.col(<column_name>).ge(val: ScalarArg | ArrayArg)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1478,
        "lineEnd": 1480,
        "typeTree": {
          "val": {
            "type": "ComparisonArg",
            "optional": false,
            "desc": "The value or column expression to compare against.",
            "resolvedType": "ScalarArg | ArrayArg"
          }
        }
      },
      "gt": {
        "desc": "Boolean comparison: Returns true if column value is greater than argument.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").gt(2).alias(\"gt_two\"))\nshape: (3, 2)\n+---+--------+\n| a | gt_two |\n+---+--------+\n| 1 | false  |\n| 2 | false  |\n| 3 | true   |\n+---+--------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The value or column expression to compare against."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "gt",
        "callExpression": ".gt()",
        "signature": "$df.col(<column_name>).gt(val: ComparisonArg)",
        "signatureDetailed": "$df.col(<column_name>).gt(val: ScalarArg | ArrayArg)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1498,
        "lineEnd": 1500,
        "typeTree": {
          "val": {
            "type": "ComparisonArg",
            "optional": false,
            "desc": "The value or column expression to compare against.",
            "resolvedType": "ScalarArg | ArrayArg"
          }
        }
      },
      "hasNulls": {
        "desc": "Aggregation: Checks if any value in the group is null.",
        "examples": [
          ">>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.select($df.col(\"a\").hasNulls().alias(\"has_nulls\"))\nshape: (1, 1)\n+-----------+\n| has_nulls |\n+-----------+\n| true      |\n+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "hasNulls",
        "callExpression": ".hasNulls()",
        "signature": "$df.col(<column_name>).hasNulls()",
        "signatureDetailed": "$df.col(<column_name>).hasNulls()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1515,
        "lineEnd": 1517
      },
      "hypot": {
        "desc": "Computes the hypotenuse sqrt(x^2 + y^2) of two values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n| 3 | 30 |\n+---+----+\n>>> df.withColumns($df.col(\"a\").hypot($df.col(\"b\")).alias(\"hypot_a\"))\nshape: (3, 3)\n+---+----+-----------+\n| a | b  | hypot_a   |\n+---+----+-----------+\n| 1 | 10 | 10.049876 |\n| 2 | 20 | 20.099751 |\n| 3 | 30 | 30.149627 |\n+---+----+-----------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The other numeric value or column expression."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "hypot",
        "callExpression": ".hypot()",
        "signature": "$df.col(<column_name>).hypot(val: NumericArg)",
        "signatureDetailed": "$df.col(<column_name>).hypot(val: number | bigint | IExpr | null)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1535,
        "lineEnd": 1537,
        "typeTree": {
          "val": {
            "type": "NumericArg",
            "optional": false,
            "desc": "The other numeric value or column expression.",
            "resolvedType": "number | bigint | IExpr | null"
          }
        }
      },
      "implode": {
        "desc": "Aggregation: Combines all values in the group into a single array/list cell.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg($df.col(\"val\").implode().alias(\"list_val\"))\nshape: (2, 2)\n+-------+----------+\n| group | list_val |\n+-------+----------+\n| A     | [10, 20] |\n| B     | [30]     |\n+-------+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "implode",
        "callExpression": ".implode()",
        "signature": "$df.col(<column_name>).implode()",
        "signatureDetailed": "$df.col(<column_name>).implode()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1553,
        "lineEnd": 1555
      },
      "isClose": {
        "desc": "Determines if floating-point values are approximately equal within tolerances.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").isClose(1.0).alias(\"close\"))\nshape: (3, 2)\n+---+-------+\n| a | close |\n+---+-------+\n| 1 | true  |\n| 2 | false |\n| 3 | false |\n+---+-------+"
        ],
        "params": [
          {
            "name": "other",
            "desc": "The value or expression to compare against."
          },
          {
            "name": "options",
            "desc": "Tolerance values absolute (absTol) and relative (relTol), and NaN options."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "isClose",
        "callExpression": ".isClose()",
        "signature": "$df.col(<column_name>).isClose(\n  other: any,\n  {\n    absTol = 1e-8,\n    relTol = 1e-8,\n    nansEqual = false\n  }: IsCloseOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).isClose(\n  other: any,\n  options: {\n    absTol?: number = 1e-8,\n    nansEqual?: boolean = false,\n    relTol?: number = 1e-8\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1574,
        "lineEnd": 1591,
        "typeTree": {
          "other": {
            "type": "any",
            "optional": false,
            "desc": "The value or expression to compare against."
          },
          "options": {
            "type": "IsCloseOptions",
            "optional": true,
            "default": "{}",
            "desc": "Tolerance values absolute (absTol) and relative (relTol), and NaN options.",
            "properties": {
              "absTol": {
                "type": "number",
                "optional": true,
                "desc": "Non-negative absolute tolerance threshold.",
                "default": "1e-8"
              },
              "nansEqual": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, two `NaN` values are treated as close (`true`).",
                "default": "false"
              },
              "relTol": {
                "type": "number",
                "optional": true,
                "desc": "Non-negative relative tolerance threshold scaled by operand magnitude.",
                "default": "1e-8"
              }
            }
          }
        }
      },
      "isDuplicated": {
        "desc": "Checks if values occur more than once in the column.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").isDuplicated().alias(\"dup\"))\nshape: (3, 2)\n+---+-------+\n| a | dup   |\n+---+-------+\n| 1 | false |\n| 2 | false |\n| 3 | false |\n+---+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "isDuplicated",
        "callExpression": ".isDuplicated()",
        "signature": "$df.col(<column_name>).isDuplicated()",
        "signatureDetailed": "$df.col(<column_name>).isDuplicated()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1608,
        "lineEnd": 1618
      },
      "isFinite": {
        "desc": "Checks if values are finite numbers (not NaN or Infinity).",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").isFinite().alias(\"finite\"))\nshape: (3, 2)\n+---+--------+\n| a | finite |\n+---+--------+\n| 1 | true   |\n| 2 | true   |\n| 3 | true   |\n+---+--------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "isFinite",
        "callExpression": ".isFinite()",
        "signature": "$df.col(<column_name>).isFinite()",
        "signatureDetailed": "$df.col(<column_name>).isFinite()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1636,
        "lineEnd": 1638
      },
      "isIn": {
        "desc": "Checks if column values are members of a specified array or list.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").isIn([\"apple\", \"banana\"]).alias(\"in_list\"))\nshape: (3, 2)\n+----------+---------+\n| s        | in_list |\n+----------+---------+\n| \"apple\"  | true    |\n| \"banana\" | true    |\n| \"cherry\" | false   |\n+----------+---------+"
        ],
        "params": [
          {
            "name": "values",
            "desc": "An array of candidate values or a single value to match against."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "isIn",
        "callExpression": ".isIn()",
        "signature": "$df.col(<column_name>).isIn(values: ComparisonArg)",
        "signatureDetailed": "$df.col(<column_name>).isIn(values: ScalarArg | ArrayArg)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1656,
        "lineEnd": 1658,
        "typeTree": {
          "values": {
            "type": "ComparisonArg",
            "optional": false,
            "desc": "An array of candidate values or a single value to match against.",
            "resolvedType": "ScalarArg | ArrayArg"
          }
        }
      },
      "isInfinite": {
        "desc": "Checks if values are positive or negative Infinity.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").isInfinite().alias(\"inf\"))\nshape: (3, 2)\n+---+-------+\n| a | inf   |\n+---+-------+\n| 1 | false |\n| 2 | false |\n| 3 | false |\n+---+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "isInfinite",
        "callExpression": ".isInfinite()",
        "signature": "$df.col(<column_name>).isInfinite()",
        "signatureDetailed": "$df.col(<column_name>).isInfinite()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1675,
        "lineEnd": 1677
      },
      "isNan": {
        "desc": "Checks if values are NaN.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").isNan().alias(\"nan\"))\nshape: (3, 2)\n+---+-------+\n| a | nan   |\n+---+-------+\n| 1 | false |\n| 2 | false |\n| 3 | false |\n+---+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "isNan",
        "callExpression": ".isNan()",
        "signature": "$df.col(<column_name>).isNan()",
        "signatureDetailed": "$df.col(<column_name>).isNan()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1694,
        "lineEnd": 1696
      },
      "isNDistinct": {
        "desc": "Checks if column values match the N-th distinct value by positive or negative index position.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n| 3 | 30 |\n+---+----+\n>>> df.withColumns($df.col(\"a\").isNDistinct(0).alias(\"is_first\"))\nshape: (3, 3)\n+---+----+----------+\n| a | b  | is_first |\n+---+----+----------+\n| 1 | 10 | true     |\n| 2 | 20 | false    |\n| 3 | 30 | false    |\n+---+----+----------+"
        ],
        "params": [
          {
            "name": "index",
            "desc": "The 0-based or negative index position into the ordered distinct values (e.g. 0 for first distinct, -1 for last distinct)."
          },
          {
            "name": "nullOnOob",
            "desc": "If true, returns null if index is out of bounds (default: true)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "isNDistinct",
        "callExpression": ".isNDistinct()",
        "signature": "$df.col(<column_name>).isNDistinct(\n  index: number,\n  options: IsNDistinctOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).isNDistinct(\n  index: number,\n  options: {\n    nullOnOob?: boolean = true\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1715,
        "lineEnd": 1722,
        "typeTree": {
          "index": {
            "type": "number",
            "optional": false,
            "desc": "The 0-based or negative index position into the ordered distinct values (e.g. 0 for first distinct, -1 for last distinct)."
          },
          "options": {
            "type": "IsNDistinctOptions",
            "optional": true,
            "default": "{}",
            "desc": "If true, returns null if index is out of bounds (default: true).",
            "properties": {
              "nullOnOob": {
                "type": "boolean",
                "optional": true,
                "desc": "If true (default), returns null when index is out of bounds. If false, throws an error if index is out of bounds.",
                "default": "true"
              }
            }
          }
        }
      },
      "isNotNan": {
        "desc": "Checks if values are not NaN.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").isNotNan().alias(\"not_nan\"))\nshape: (3, 2)\n+---+---------+\n| a | not_nan |\n+---+---------+\n| 1 | true    |\n| 2 | true    |\n| 3 | true    |\n+---+---------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "isNotNan",
        "callExpression": ".isNotNan()",
        "signature": "$df.col(<column_name>).isNotNan()",
        "signatureDetailed": "$df.col(<column_name>).isNotNan()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1739,
        "lineEnd": 1741
      },
      "isNotNull": {
        "desc": "Checks if column values are non-null and valid (not null, undefined, or missing).",
        "examples": [
          ">>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.withColumns($df.col(\"a\").isNotNull().alias(\"valid\"))\nshape: (3, 2)\n+------+-------+\n| a    | valid |\n+------+-------+\n| 1    | true  |\n| null | false |\n| 3    | true  |\n+------+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "isNotNull",
        "callExpression": ".isNotNull()",
        "signature": "$df.col(<column_name>).isNotNull()",
        "signatureDetailed": "$df.col(<column_name>).isNotNull()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1758,
        "lineEnd": 1760
      },
      "isNull": {
        "desc": "Checks if column values are null, undefined, or missing.",
        "examples": [
          ">>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.withColumns($df.col(\"a\").isNull().alias(\"missing\"))\nshape: (3, 2)\n+------+---------+\n| a    | missing |\n+------+---------+\n| 1    | false   |\n| null | true    |\n| 3    | false   |\n+------+---------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "isNull",
        "callExpression": ".isNull()",
        "signature": "$df.col(<column_name>).isNull()",
        "signatureDetailed": "$df.col(<column_name>).isNull()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1777,
        "lineEnd": 1779
      },
      "isUnique": {
        "desc": "Checks if values occur exactly once in the column.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").isUnique().alias(\"uniq\"))\nshape: (3, 2)\n+---+------+\n| a | uniq |\n+---+------+\n| 1 | true |\n| 2 | true |\n| 3 | true |\n+---+------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "isUnique",
        "callExpression": ".isUnique()",
        "signature": "$df.col(<column_name>).isUnique()",
        "signatureDetailed": "$df.col(<column_name>).isUnique()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1796,
        "lineEnd": 1798
      },
      "kurtosis": {
        "desc": "Aggregation: Computes the kurtosis (peakedness/tailedness) of a numeric column.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.col(\"a\").kurtosis().alias(\"kurt\"))\nshape: (1, 1)\n+-------+\n| kurt  |\n+-------+\n| -1.36 |\n+-------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Kurtosis calculation options ({ fisher?: boolean, bias?: boolean }, default fisher=true, bias=true)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "kurtosis",
        "callExpression": ".kurtosis()",
        "signature": "$df.col(<column_name>).kurtosis(options: KurtosisOptions = {})",
        "signatureDetailed": "$df.col(<column_name>).kurtosis(\n  options: {\n    bias?: boolean = true,\n    fisher?: boolean = true\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1814,
        "lineEnd": 1816,
        "typeTree": {
          "options": {
            "type": "KurtosisOptions",
            "optional": true,
            "default": "{}",
            "desc": "Kurtosis calculation options ({ fisher?: boolean, bias?: boolean }, default fisher=true, bias=true).",
            "properties": {
              "bias": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, computes biased population kurtosis; if `false`, applies sample bias correction.",
                "default": "true"
              },
              "fisher": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, computes Fisher's excess kurtosis (subtracts 3 so a normal distribution equals 0); if `false`, computes Pearson's kurtosis.",
                "default": "true"
              }
            }
          }
        }
      },
      "lag": {
        "desc": "Window: Shifts values down by offset, filling missing slots with default value.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").lag(1, { fillValue: 0 }).alias(\"prev\"))\nshape: (3, 2)\n+-----+------+\n| val | prev |\n+-----+------+\n| 10  | 0    |\n| 20  | 10   |\n| 30  | 20   |\n+-----+------+"
        ],
        "params": [
          {
            "name": "offset",
            "desc": "Number of rows to shift down (default 1)."
          },
          {
            "name": "options",
            "desc": "Shift options configuring fallback fillValue (default null)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "lag",
        "callExpression": ".lag()",
        "signature": "$df.col(<column_name>).lag(\n  offset: number = 1,\n  options: ShiftOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).lag(\n  offset: number = 1,\n  options: {\n    fillValue?: any = null\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1835,
        "lineEnd": 1846,
        "typeTree": {
          "offset": {
            "type": "number",
            "optional": true,
            "default": "1",
            "desc": "Number of rows to shift down (default 1)."
          },
          "options": {
            "type": "ShiftOptions",
            "optional": true,
            "default": "{}",
            "desc": "Shift options configuring fallback fillValue (default null).",
            "properties": {
              "fillValue": {
                "type": "any",
                "optional": true,
                "desc": "Fallback fill value for empty slots introduced by shift/lag/lead.",
                "default": "null"
              }
            }
          }
        }
      },
      "last": {
        "desc": "Aggregation: Finds the last value in the group.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg($df.col(\"val\").last().alias(\"last_val\"))\nshape: (2, 2)\n+-------+----------+\n| group | last_val |\n+-------+----------+\n| A     | 20       |\n| B     | 30       |\n+-------+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "last",
        "callExpression": ".last()",
        "signature": "$df.col(<column_name>).last()",
        "signatureDetailed": "$df.col(<column_name>).last()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1862,
        "lineEnd": 1864
      },
      "le": {
        "desc": "Boolean comparison: Returns true if less than or equal to argument.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").le(2).alias(\"le_two\"))\nshape: (3, 2)\n+---+--------+\n| a | le_two |\n+---+--------+\n| 1 | true   |\n| 2 | true   |\n| 3 | false  |\n+---+--------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The value or column expression to compare against."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "le",
        "callExpression": ".le()",
        "signature": "$df.col(<column_name>).le(val: ComparisonArg)",
        "signatureDetailed": "$df.col(<column_name>).le(val: ScalarArg | ArrayArg)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1882,
        "lineEnd": 1884,
        "typeTree": {
          "val": {
            "type": "ComparisonArg",
            "optional": false,
            "desc": "The value or column expression to compare against.",
            "resolvedType": "ScalarArg | ArrayArg"
          }
        }
      },
      "lead": {
        "desc": "Window: Shifts values up by offset, filling missing slots with default value.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").lead(1, { fillValue: 0 }).alias(\"next\"))\nshape: (3, 2)\n+-----+------+\n| val | next |\n+-----+------+\n| 10  | 20   |\n| 20  | 30   |\n| 30  | 0    |\n+-----+------+"
        ],
        "params": [
          {
            "name": "offset",
            "desc": "Number of rows to shift up (default 1)."
          },
          {
            "name": "options",
            "desc": "Shift options configuring fallback fillValue (default null)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "lead",
        "callExpression": ".lead()",
        "signature": "$df.col(<column_name>).lead(\n  offset: number = 1,\n  options: ShiftOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).lead(\n  offset: number = 1,\n  options: {\n    fillValue?: any = null\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1903,
        "lineEnd": 1905,
        "typeTree": {
          "offset": {
            "type": "number",
            "optional": true,
            "default": "1",
            "desc": "Number of rows to shift up (default 1)."
          },
          "options": {
            "type": "ShiftOptions",
            "optional": true,
            "default": "{}",
            "desc": "Shift options configuring fallback fillValue (default null).",
            "properties": {
              "fillValue": {
                "type": "any",
                "optional": true,
                "desc": "Fallback fill value for empty slots introduced by shift/lag/lead.",
                "default": "null"
              }
            }
          }
        }
      },
      "log": {
        "desc": "Computes the logarithm of positive values with a specified base.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").log(10).alias(\"log_a\"))\nshape: (3, 2)\n+---+----------+\n| a | log_a    |\n+---+----------+\n| 1 | 0        |\n| 2 | 0.30103  |\n| 3 | 0.477121 |\n+---+----------+"
        ],
        "params": [
          {
            "name": "base",
            "desc": "The base of the logarithm (default: Math.E)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "log",
        "callExpression": ".log()",
        "signature": "$df.col(<column_name>).log(base: number = Math.E)",
        "signatureDetailed": "$df.col(<column_name>).log(base: number = Math.E)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1923,
        "lineEnd": 1925,
        "typeTree": {
          "base": {
            "type": "number",
            "optional": true,
            "default": "Math.E",
            "desc": "The base of the logarithm (default: Math.E)."
          }
        }
      },
      "log1p": {
        "desc": "Computes natural logarithm of 1 + x.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").log1p().alias(\"log1p_a\"))\nshape: (3, 2)\n+---+----------+\n| a | log1p_a  |\n+---+----------+\n| 1 | 0.693147 |\n| 2 | 1.098612 |\n| 3 | 1.386294 |\n+---+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "log1p",
        "callExpression": ".log1p()",
        "signature": "$df.col(<column_name>).log1p()",
        "signatureDetailed": "$df.col(<column_name>).log1p()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1942,
        "lineEnd": 1944
      },
      "lt": {
        "desc": "Boolean comparison: Returns true if less than argument.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").lt(2).alias(\"lt_two\"))\nshape: (3, 2)\n+---+--------+\n| a | lt_two |\n+---+--------+\n| 1 | true   |\n| 2 | false  |\n| 3 | false  |\n+---+--------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The value or column expression to compare against."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "lt",
        "callExpression": ".lt()",
        "signature": "$df.col(<column_name>).lt(val: ComparisonArg)",
        "signatureDetailed": "$df.col(<column_name>).lt(val: ScalarArg | ArrayArg)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1962,
        "lineEnd": 1964,
        "typeTree": {
          "val": {
            "type": "ComparisonArg",
            "optional": false,
            "desc": "The value or column expression to compare against.",
            "resolvedType": "ScalarArg | ArrayArg"
          }
        }
      },
      "max": {
        "desc": "Aggregation: Finds the maximum value in the group.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg($df.col(\"val\").max().alias(\"max_val\"))\nshape: (2, 2)\n+-------+---------+\n| group | max_val |\n+-------+---------+\n| A     | 20      |\n| B     | 30      |\n+-------+---------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "max",
        "callExpression": ".max()",
        "signature": "$df.col(<column_name>).max()",
        "signatureDetailed": "$df.col(<column_name>).max()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1980,
        "lineEnd": 1982
      },
      "maxBy": {
        "desc": "Aggregation: Finds the value in this column corresponding to the maximum value in the `by` expression.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.select($df.col(\"group\").maxBy($df.col(\"val\")).alias(\"top_group\"))\nshape: (1, 1)\n+-----------+\n| top_group |\n+-----------+\n| B         |\n+-----------+"
        ],
        "params": [
          {
            "name": "by",
            "desc": "Column or expression to order by."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "maxBy",
        "callExpression": ".maxBy()",
        "signature": "$df.col(<column_name>).maxBy(by: ComparisonArg)",
        "signatureDetailed": "$df.col(<column_name>).maxBy(by: ScalarArg | ArrayArg)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 1998,
        "lineEnd": 2000,
        "typeTree": {
          "by": {
            "type": "ComparisonArg",
            "optional": false,
            "desc": "Column or expression to order by.",
            "resolvedType": "ScalarArg | ArrayArg"
          }
        }
      },
      "mean": {
        "desc": "Aggregation: Computes the arithmetic mean of elements in the group.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg($df.col(\"val\").mean().alias(\"mean_val\"))\nshape: (2, 2)\n+-------+----------+\n| group | mean_val |\n+-------+----------+\n| A     | 15       |\n| B     | 30       |\n+-------+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "mean",
        "callExpression": ".mean()",
        "signature": "$df.col(<column_name>).mean()",
        "signatureDetailed": "$df.col(<column_name>).mean()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2016,
        "lineEnd": 2018
      },
      "median": {
        "desc": "Aggregation: Computes the 50th percentile median.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg($df.col(\"val\").median().alias(\"med\"))\nshape: (2, 2)\n+-------+-----+\n| group | med |\n+-------+-----+\n| A     | 15  |\n| B     | 30  |\n+-------+-----+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "median",
        "callExpression": ".median()",
        "signature": "$df.col(<column_name>).median()",
        "signatureDetailed": "$df.col(<column_name>).median()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2034,
        "lineEnd": 2036
      },
      "min": {
        "desc": "Aggregation: Finds the minimum value in the group.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg($df.col(\"val\").min().alias(\"min_val\"))\nshape: (2, 2)\n+-------+---------+\n| group | min_val |\n+-------+---------+\n| A     | 10      |\n| B     | 30      |\n+-------+---------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "min",
        "callExpression": ".min()",
        "signature": "$df.col(<column_name>).min()",
        "signatureDetailed": "$df.col(<column_name>).min()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2052,
        "lineEnd": 2054
      },
      "minBy": {
        "desc": "Aggregation: Finds the value in this column corresponding to the minimum value in the `by` expression.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.select($df.col(\"group\").minBy($df.col(\"val\")).alias(\"lowest_group\"))\nshape: (1, 1)\n+--------------+\n| lowest_group |\n+--------------+\n| A            |\n+--------------+"
        ],
        "params": [
          {
            "name": "by",
            "desc": "Column or expression to order by."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "minBy",
        "callExpression": ".minBy()",
        "signature": "$df.col(<column_name>).minBy(by: ComparisonArg)",
        "signatureDetailed": "$df.col(<column_name>).minBy(by: ScalarArg | ArrayArg)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2070,
        "lineEnd": 2072,
        "typeTree": {
          "by": {
            "type": "ComparisonArg",
            "optional": false,
            "desc": "Column or expression to order by.",
            "resolvedType": "ScalarArg | ArrayArg"
          }
        }
      },
      "mod": {
        "desc": "Computes modulo remainder (x % y) of column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").mod(2).alias(\"mod_a\"))\nshape: (3, 2)\n+---+-------+\n| a | mod_a |\n+---+-------+\n| 1 | 1     |\n| 2 | 0     |\n| 3 | 1     |\n+---+-------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The divisor value or column expression."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "mod",
        "callExpression": ".mod()",
        "signature": "$df.col(<column_name>).mod(val: NumericArg)",
        "signatureDetailed": "$df.col(<column_name>).mod(val: number | bigint | IExpr | null)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2090,
        "lineEnd": 2092,
        "typeTree": {
          "val": {
            "type": "NumericArg",
            "optional": false,
            "desc": "The divisor value or column expression.",
            "resolvedType": "number | bigint | IExpr | null"
          }
        }
      },
      "mode": {
        "desc": "Aggregation: Finds the statistical mode (most frequent value).",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.select($df.col(\"group\").mode().alias(\"mode_group\"))\nshape: (1, 1)\n+------------+\n| mode_group |\n+------------+\n| [\"A\"]      |\n+------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "mode",
        "callExpression": ".mode()",
        "signature": "$df.col(<column_name>).mode()",
        "signatureDetailed": "$df.col(<column_name>).mode()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2107,
        "lineEnd": 2109
      },
      "mul": {
        "desc": "Multiplies column values by a scalar or another column expression.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").mul(5).alias(\"multiplied\"))\nshape: (3, 2)\n+---+------------+\n| a | multiplied |\n+---+------------+\n| 1 | 5          |\n| 2 | 10         |\n| 3 | 15         |\n+---+------------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The multiplier value or column expression."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "mul",
        "callExpression": ".mul()",
        "signature": "$df.col(<column_name>).mul(val: NumericArg)",
        "signatureDetailed": "$df.col(<column_name>).mul(val: number | bigint | IExpr | null)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2127,
        "lineEnd": 2129,
        "typeTree": {
          "val": {
            "type": "NumericArg",
            "optional": false,
            "desc": "The multiplier value or column expression.",
            "resolvedType": "number | bigint | IExpr | null"
          }
        }
      },
      "nanMax": {
        "desc": "Aggregation: Finds the maximum value in the group, taking NaN values into account (NaN propagates).",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.col(\"val\").nanMax().alias(\"nan_max_val\"))\nshape: (1, 1)\n+-------------+\n| nan_max_val |\n+-------------+\n| 30          |\n+-------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "nanMax",
        "callExpression": ".nanMax()",
        "signature": "$df.col(<column_name>).nanMax()",
        "signatureDetailed": "$df.col(<column_name>).nanMax()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2144,
        "lineEnd": 2146
      },
      "nanMin": {
        "desc": "Aggregation: Finds the minimum value in the group, taking NaN values into account (NaN propagates).",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.col(\"val\").nanMin().alias(\"nan_min_val\"))\nshape: (1, 1)\n+-------------+\n| nan_min_val |\n+-------------+\n| 10          |\n+-------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "nanMin",
        "callExpression": ".nanMin()",
        "signature": "$df.col(<column_name>).nanMin()",
        "signatureDetailed": "$df.col(<column_name>).nanMin()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2161,
        "lineEnd": 2163
      },
      "ne": {
        "desc": "Boolean comparison: Returns true if values do not match.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").ne(2).alias(\"not_two\"))\nshape: (3, 2)\n+---+---------+\n| a | not_two |\n+---+---------+\n| 1 | true    |\n| 2 | false   |\n| 3 | true    |\n+---+---------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The value or column expression to compare against."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "ne",
        "callExpression": ".ne()",
        "signature": "$df.col(<column_name>).ne(val: ComparisonArg)",
        "signatureDetailed": "$df.col(<column_name>).ne(val: ScalarArg | ArrayArg)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2181,
        "lineEnd": 2183,
        "typeTree": {
          "val": {
            "type": "ComparisonArg",
            "optional": false,
            "desc": "The value or column expression to compare against.",
            "resolvedType": "ScalarArg | ArrayArg"
          }
        }
      },
      "negate": {
        "desc": "Negates column values (-x).",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").negate().alias(\"negated\"))\nshape: (3, 2)\n+---+---------+\n| a | negated |\n+---+---------+\n| 1 | -1      |\n| 2 | -2      |\n| 3 | -3      |\n+---+---------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "negate",
        "callExpression": ".negate()",
        "signature": "$df.col(<column_name>).negate()",
        "signatureDetailed": "$df.col(<column_name>).negate()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2200,
        "lineEnd": 2202
      },
      "neMissing": {
        "desc": "Difference check that treats null values as equal to each other.",
        "examples": [
          ">>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.withColumns($df.col(\"a\").neMissing(null).alias(\"not_missing\"))\nshape: (3, 2)\n+------+-------------+\n| a    | not_missing |\n+------+-------------+\n| 1    | true        |\n| null | false       |\n| 3    | true        |\n+------+-------------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The value or column expression to compare against."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "neMissing",
        "callExpression": ".neMissing()",
        "signature": "$df.col(<column_name>).neMissing(val: ComparisonArg)",
        "signatureDetailed": "$df.col(<column_name>).neMissing(val: ScalarArg | ArrayArg)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2220,
        "lineEnd": 2222,
        "typeTree": {
          "val": {
            "type": "ComparisonArg",
            "optional": false,
            "desc": "The value or column expression to compare against.",
            "resolvedType": "ScalarArg | ArrayArg"
          }
        }
      },
      "not": {
        "desc": "Logical negation.",
        "examples": [
          ">>> const df = $df.data({ a: [true, true, false, false], b: [true, false, true, false] })\n>>> df\nshape: (4, 2)\n+-------+-------+\n| a     | b     |\n+-------+-------+\n| true  | true  |\n| true  | false |\n| false | true  |\n| false | false |\n+-------+-------+\n>>> df.withColumns($df.col(\"a\").not().alias(\"not_a\"))\nshape: (4, 3)\n+-------+-------+-------+\n| a     | b     | not_a |\n+-------+-------+-------+\n| true  | true  | false |\n| true  | false | false |\n| false | false | true  |\n| null  | true  | null  |\n+-------+-------+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "not",
        "callExpression": ".not()",
        "signature": "$df.col(<column_name>).not()",
        "signatureDetailed": "$df.col(<column_name>).not()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2240,
        "lineEnd": 2242
      },
      "notIn": {
        "desc": "Checks if values are not elements of a specific array or set list.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").notIn([\"apple\", \"banana\"]).alias(\"not_in\"))\nshape: (3, 2)\n+----------+--------+\n| s        | not_in |\n+----------+--------+\n| \"apple\"  | false  |\n| \"banana\" | false  |\n| \"cherry\" | true   |\n+----------+--------+"
        ],
        "params": [
          {
            "name": "values",
            "desc": "An array of candidate values or a single value to match against."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "notIn",
        "callExpression": ".notIn()",
        "signature": "$df.col(<column_name>).notIn(values: ComparisonArg)",
        "signatureDetailed": "$df.col(<column_name>).notIn(values: ScalarArg | ArrayArg)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2260,
        "lineEnd": 2262,
        "typeTree": {
          "values": {
            "type": "ComparisonArg",
            "optional": false,
            "desc": "An array of candidate values or a single value to match against.",
            "resolvedType": "ScalarArg | ArrayArg"
          }
        }
      },
      "nullCount": {
        "desc": "Aggregation: Counts the number of null or missing records.",
        "examples": [
          ">>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.select($df.col(\"a\").nullCount().alias(\"nulls\"))\nshape: (1, 1)\n+-------+\n| nulls |\n+-------+\n| 1     |\n+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "nullCount",
        "callExpression": ".nullCount()",
        "signature": "$df.col(<column_name>).nullCount()",
        "signatureDetailed": "$df.col(<column_name>).nullCount()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2277,
        "lineEnd": 2279
      },
      "nUnique": {
        "desc": "Aggregation: Computes number of unique elements.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.select($df.col(\"group\").nUnique().alias(\"unique_cnt\"))\nshape: (1, 1)\n+------------+\n| unique_cnt |\n+------------+\n| 2          |\n+------------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Uniqueness options."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "nUnique",
        "callExpression": ".nUnique()",
        "signature": "$df.col(<column_name>).nUnique(options: UniqueArrayStatsOptions = {})",
        "signatureDetailed": "$df.col(<column_name>).nUnique(\n  options: {\n    keySelector?: (val: any) => any,\n    strict?: boolean = false\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2295,
        "lineEnd": 2297,
        "typeTree": {
          "options": {
            "type": "UniqueArrayStatsOptions",
            "optional": true,
            "default": "{}",
            "desc": "Uniqueness options.",
            "properties": {
              "keySelector": {
                "type": "(val: any) => any",
                "optional": true,
                "desc": "Custom function to extract a unique comparison key from each element."
              },
              "strict": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, uses canonical serialization to group nested structures (Arrays, Sets, Maps, Dates) by value instead of reference.",
                "default": "false"
              }
            }
          }
        }
      },
      "or": {
        "desc": "Logical OR check supporting Kleene logic.",
        "examples": [
          ">>> const df = $df.data({ a: [true, true, false, false], b: [true, false, true, false] })\n>>> df\nshape: (4, 2)\n+-------+-------+\n| a     | b     |\n+-------+-------+\n| true  | true  |\n| true  | false |\n| false | true  |\n| false | false |\n+-------+-------+\n>>> df.withColumns($df.col(\"a\").or($df.col(\"b\")).alias(\"or_res\"))\nshape: (4, 3)\n+-------+-------+--------+\n| a     | b     | or_res |\n+-------+-------+--------+\n| true  | true  | true   |\n| true  | false | true   |\n| false | false | false  |\n| null  | true  | true   |\n+-------+-------+--------+"
        ],
        "params": [
          {
            "name": "other",
            "desc": "The other boolean column expression or literal value to compare."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "or",
        "callExpression": ".or()",
        "signature": "$df.col(<column_name>).or(other: BooleanArg)",
        "signatureDetailed": "$df.col(<column_name>).or(other: boolean | boolean[] | IExpr | null | undefined)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2316,
        "lineEnd": 2331,
        "typeTree": {
          "other": {
            "type": "BooleanArg",
            "optional": false,
            "desc": "The other boolean column expression or literal value to compare.",
            "resolvedType": "boolean | boolean[] | IExpr | null | undefined"
          }
        }
      },
      "over": {
        "desc": "Executes a window aggregation partitioned by column keys.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.withColumns($df.col(\"val\").sum().over(\"group\").alias(\"cat_sum\"))\nshape: (3, 3)\n+-------+-----+---------+\n| group | val | cat_sum |\n+-------+-----+---------+\n| A     | 10  | 30      |\n| A     | 20  | 30      |\n| B     | 30  | 30      |\n+-------+-----+---------+"
        ],
        "params": [
          {
            "name": "columns",
            "desc": "Column expression or array of columns to partition by."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "over",
        "callExpression": ".over()",
        "signature": "$df.col(<column_name>).over(columns: string | IExpr | (string | IExpr)[])",
        "signatureDetailed": "$df.col(<column_name>).over(columns: string | IExpr | (string | IExpr)[])",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2349,
        "lineEnd": 2354,
        "typeTree": {
          "columns": {
            "type": "string | IExpr | (string | IExpr)[]",
            "optional": false,
            "desc": "Column expression or array of columns to partition by."
          }
        }
      },
      "pow": {
        "desc": "Raises column values to the specified power.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").pow(2).alias(\"pow_a\"))\nshape: (3, 2)\n+---+-------+\n| a | pow_a |\n+---+-------+\n| 1 | 1     |\n| 2 | 4     |\n| 3 | 9     |\n+---+-------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The exponent power value or column expression."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "pow",
        "callExpression": ".pow()",
        "signature": "$df.col(<column_name>).pow(val: NumericArg)",
        "signatureDetailed": "$df.col(<column_name>).pow(val: number | bigint | IExpr | null)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2372,
        "lineEnd": 2374,
        "typeTree": {
          "val": {
            "type": "NumericArg",
            "optional": false,
            "desc": "The exponent power value or column expression.",
            "resolvedType": "number | bigint | IExpr | null"
          }
        }
      },
      "product": {
        "desc": "Aggregation: Computes the product of all elements in the group.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg($df.col(\"val\").product().alias(\"p\"))\nshape: (2, 2)\n+-------+-----+\n| group | p   |\n+-------+-----+\n| A     | 200 |\n| B     | 30  |\n+-------+-----+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "product",
        "callExpression": ".product()",
        "signature": "$df.col(<column_name>).product()",
        "signatureDetailed": "$df.col(<column_name>).product()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2390,
        "lineEnd": 2392
      },
      "quantile": {
        "desc": "Aggregation: Computes the specific quantile values (0.0 to 1.0).",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.col(\"a\").quantile(0.75).alias(\"q75\"))\nshape: (1, 1)\n+------+\n| q75  |\n+------+\n| 3.25 |\n+------+"
        ],
        "params": [
          {
            "name": "q",
            "desc": "The quantile parameter value between 0.0 and 1.0."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "quantile",
        "callExpression": ".quantile()",
        "signature": "$df.col(<column_name>).quantile(q: number)",
        "signatureDetailed": "$df.col(<column_name>).quantile(q: number)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2408,
        "lineEnd": 2411,
        "typeTree": {
          "q": {
            "type": "number",
            "optional": false,
            "desc": "The quantile parameter value between 0.0 and 1.0."
          }
        }
      },
      "radians": {
        "desc": "Converts angles from degrees to radians.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").radians().alias(\"rad\"))\nshape: (3, 2)\n+---+----------+\n| a | rad      |\n+---+----------+\n| 1 | 0.017453 |\n| 2 | 0.034907 |\n| 3 | 0.05236  |\n+---+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "radians",
        "callExpression": ".radians()",
        "signature": "$df.col(<column_name>).radians()",
        "signatureDetailed": "$df.col(<column_name>).radians()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2428,
        "lineEnd": 2430
      },
      "rand": {
        "desc": "Fills sequence with pseudo-random generated floats or integers.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").rand(42, { min: 1, max: 10, integer: true }).alias(\"random\"))\nshape: (3, 2)\n+---+--------+\n| a | random |\n+---+--------+\n| 1 | 7      |\n| 2 | 8      |\n| 3 | 6      |\n+---+--------+"
        ],
        "params": [
          {
            "name": "seed",
            "desc": "Optional seed to initialize the pseudo-random generator."
          },
          {
            "name": "options",
            "desc": "Config options including min, max, and integer flag."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "rand",
        "callExpression": ".rand()",
        "signature": "$df.col(<column_name>).rand(\n  seed?: number,\n  {\n    min = 0,\n    max = 1,\n    integer = false\n  }: RandomOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).rand(\n  seed?: number,\n  options: {\n    integer?: boolean = false,\n    max?: number = 1,\n    min?: number = 0\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2449,
        "lineEnd": 2462,
        "typeTree": {
          "seed": {
            "type": "number",
            "optional": true,
            "desc": "Optional seed to initialize the pseudo-random generator."
          },
          "options": {
            "type": "RandomOptions",
            "optional": true,
            "default": "{}",
            "desc": "Config options including min, max, and integer flag.",
            "properties": {
              "integer": {
                "type": "boolean",
                "optional": true,
                "desc": "When `true`, generates random integers in `[min, max]`. When `false`, generates floating-point numbers in `[min, max)`.",
                "default": "false"
              },
              "max": {
                "type": "number",
                "optional": true,
                "desc": "Maximum bound (exclusive for floats, inclusive for integers) for generated random values.",
                "default": "1"
              },
              "min": {
                "type": "number",
                "optional": true,
                "desc": "Minimum bound (inclusive) for generated random values.",
                "default": "0"
              }
            }
          }
        }
      },
      "rank": {
        "desc": "Window: Computes rank within group partition.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"score\").rank().alias(\"rank\"))\nshape: (2, 2)\n+-------+------+\n| score | rank |\n+-------+------+\n| 75    | 1    |\n| 95    | 2    |\n+-------+------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "rank",
        "callExpression": ".rank()",
        "signature": "$df.col(<column_name>).rank(options: RankOptions = {})",
        "signatureDetailed": "$df.col(<column_name>).rank(\n  options: {\n    dense?: boolean = false\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2478,
        "lineEnd": 2480,
        "typeTree": {
          "options": {
            "type": "RankOptions",
            "optional": true,
            "default": "{}",
            "desc": "Configuration options for window rank calculation (`$df.col().rank()`).",
            "properties": {
              "dense": {
                "type": "boolean",
                "optional": true,
                "desc": "When true, ranks are consecutive integers without gaps between tied values (1, 2, 2, 3). When false (default), ranks have gaps for tied values (1, 2, 2, 4).",
                "default": "false"
              }
            }
          }
        }
      },
      "reverse": {
        "desc": "Reverses the order of values in the column.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").reverse().alias(\"reversed\"))\nshape: (3, 2)\n+---+----------+\n| a | reversed |\n+---+----------+\n| 1 | 3        |\n| 2 | 2        |\n| 3 | 1        |\n+---+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "reverse",
        "callExpression": ".reverse()",
        "signature": "$df.col(<column_name>).reverse(): this",
        "signatureDetailed": "$df.col(<column_name>).reverse(): this",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2497,
        "lineEnd": 2499
      },
      "rolling": {
        "desc": "Window: Computes a rolling window reduction using a ColumnExpression or a custom callback function.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").rolling(2, $df.col(\"val\").sum()).alias(\"r_sum\"))\nshape: (3, 2)\n+-----+-------+\n| val | r_sum |\n+-----+-------+\n| 10  | 10    |\n| 20  | 30    |\n| 30  | 50    |\n+-----+-------+"
        ],
        "params": [
          {
            "name": "optionsOrWindowSize",
            "desc": "Window row count or RollingOptions configuration."
          },
          {
            "name": "exprOrFn",
            "desc": "ColumnExpression to evaluate over each window slice, or a custom reducer function."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "rolling",
        "callExpression": ".rolling()",
        "signature": "$df.col(<column_name>).rolling(\n  optionsOrWindowSize: number | RollingOptions,\n  exprOrFn: IExpr | ((vals: any[]) => any)\n)",
        "signatureDetailed": "$df.col(<column_name>).rolling(\n  optionsOrWindowSize: {\n    windowSize: number\n  },\n  exprOrFn: IExpr | ((vals: any[]) => any)\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2518,
        "lineEnd": 2539,
        "typeTree": {
          "optionsOrWindowSize": {
            "type": "number | RollingOptions",
            "optional": false,
            "desc": "Window row count or RollingOptions configuration.",
            "properties": {
              "windowSize": {
                "type": "number",
                "optional": false,
                "desc": "Number of consecutive elements in the moving window."
              }
            }
          },
          "exprOrFn": {
            "type": "IExpr | ((vals: any[]) => any)",
            "optional": false,
            "desc": "ColumnExpression to evaluate over each window slice, or a custom reducer function."
          }
        }
      },
      "rollingMax": {
        "desc": "Window: Computes rolling window maximum value.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").rollingMax(2).alias(\"r_max\"))\nshape: (3, 2)\n+-----+-------+\n| val | r_max |\n+-----+-------+\n| 10  | 10    |\n| 20  | 20    |\n| 30  | 30    |\n+-----+-------+"
        ],
        "params": [
          {
            "name": "windowSize",
            "desc": "Size of rolling window."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "rollingMax",
        "callExpression": ".rollingMax()",
        "signature": "$df.col(<column_name>).rollingMax(windowSize: number)",
        "signatureDetailed": "$df.col(<column_name>).rollingMax(windowSize: number)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2557,
        "lineEnd": 2559,
        "typeTree": {
          "windowSize": {
            "type": "number",
            "optional": false,
            "desc": "Size of rolling window."
          }
        }
      },
      "rollingMean": {
        "desc": "Window: Computes rolling window mean average.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").rollingMean(2).alias(\"r_mean\"))\nshape: (3, 2)\n+-----+--------+\n| val | r_mean |\n+-----+--------+\n| 10  | 10     |\n| 20  | 15     |\n| 30  | 25     |\n+-----+--------+"
        ],
        "params": [
          {
            "name": "windowSize",
            "desc": "Size of rolling window."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "rollingMean",
        "callExpression": ".rollingMean()",
        "signature": "$df.col(<column_name>).rollingMean(windowSize: number)",
        "signatureDetailed": "$df.col(<column_name>).rollingMean(windowSize: number)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2577,
        "lineEnd": 2579,
        "typeTree": {
          "windowSize": {
            "type": "number",
            "optional": false,
            "desc": "Size of rolling window."
          }
        }
      },
      "rollingMedian": {
        "desc": "Window: Computes rolling window median value.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").rollingMedian(2).alias(\"r_med\"))\nshape: (3, 2)\n+-----+-------+\n| val | r_med |\n+-----+-------+\n| 10  | 10    |\n| 20  | 15    |\n| 30  | 25    |\n+-----+-------+"
        ],
        "params": [
          {
            "name": "windowSize",
            "desc": "Size of rolling window."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "rollingMedian",
        "callExpression": ".rollingMedian()",
        "signature": "$df.col(<column_name>).rollingMedian(windowSize: number)",
        "signatureDetailed": "$df.col(<column_name>).rollingMedian(windowSize: number)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2597,
        "lineEnd": 2599,
        "typeTree": {
          "windowSize": {
            "type": "number",
            "optional": false,
            "desc": "Size of rolling window."
          }
        }
      },
      "rollingMin": {
        "desc": "Window: Computes rolling window minimum value.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").rollingMin(2).alias(\"r_min\"))\nshape: (3, 2)\n+-----+-------+\n| val | r_min |\n+-----+-------+\n| 10  | 10    |\n| 20  | 10    |\n| 30  | 20    |\n+-----+-------+"
        ],
        "params": [
          {
            "name": "windowSize",
            "desc": "Size of rolling window."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "rollingMin",
        "callExpression": ".rollingMin()",
        "signature": "$df.col(<column_name>).rollingMin(windowSize: number)",
        "signatureDetailed": "$df.col(<column_name>).rollingMin(windowSize: number)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2617,
        "lineEnd": 2619,
        "typeTree": {
          "windowSize": {
            "type": "number",
            "optional": false,
            "desc": "Size of rolling window."
          }
        }
      },
      "rollingQuantile": {
        "desc": "Window: Computes rolling window quantile value.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").rollingQuantile(0.5, 2).alias(\"r_quant\"))\nshape: (3, 2)\n+-----+---------+\n| val | r_quant |\n+-----+---------+\n| 10  | 10      |\n| 20  | 15      |\n| 30  | 25      |\n+-----+---------+"
        ],
        "params": [
          {
            "name": "quantile",
            "desc": "Quantile boundary between 0.0 and 1.0."
          },
          {
            "name": "windowSize",
            "desc": "Size of rolling window."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "rollingQuantile",
        "callExpression": ".rollingQuantile()",
        "signature": "$df.col(<column_name>).rollingQuantile(\n  quantile: number,\n  windowSize: number\n)",
        "signatureDetailed": "$df.col(<column_name>).rollingQuantile(\n  quantile: number,\n  windowSize: number\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2638,
        "lineEnd": 2640,
        "typeTree": {
          "quantile": {
            "type": "number",
            "optional": false,
            "desc": "Quantile boundary between 0.0 and 1.0."
          },
          "windowSize": {
            "type": "number",
            "optional": false,
            "desc": "Size of rolling window."
          }
        }
      },
      "rollingRank": {
        "desc": "Window: Computes rolling window rank.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").rollingRank(2).alias(\"r_rank\"))\nshape: (3, 2)\n+-----+--------+\n| val | r_rank |\n+-----+--------+\n| 10  | 1      |\n| 20  | 2      |\n| 30  | 2      |\n+-----+--------+"
        ],
        "params": [
          {
            "name": "windowSize",
            "desc": "Size of rolling window."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "rollingRank",
        "callExpression": ".rollingRank()",
        "signature": "$df.col(<column_name>).rollingRank(windowSize: number)",
        "signatureDetailed": "$df.col(<column_name>).rollingRank(windowSize: number)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2658,
        "lineEnd": 2662,
        "typeTree": {
          "windowSize": {
            "type": "number",
            "optional": false,
            "desc": "Size of rolling window."
          }
        }
      },
      "rollingStd": {
        "desc": "Window: Computes rolling window standard deviation.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").rollingStd(2).alias(\"r_std\"))\nshape: (3, 2)\n+-----+--------+\n| val | r_std  |\n+-----+--------+\n| 10  | 0      |\n| 20  | 7.071  |\n| 30  | 7.071  |\n+-----+--------+"
        ],
        "params": [
          {
            "name": "windowSize",
            "desc": "Size of rolling window."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "rollingStd",
        "callExpression": ".rollingStd()",
        "signature": "$df.col(<column_name>).rollingStd(windowSize: number)",
        "signatureDetailed": "$df.col(<column_name>).rollingStd(windowSize: number)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2680,
        "lineEnd": 2682,
        "typeTree": {
          "windowSize": {
            "type": "number",
            "optional": false,
            "desc": "Size of rolling window."
          }
        }
      },
      "rollingSum": {
        "desc": "Window: Computes rolling window sum.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"val\").rollingSum(2).alias(\"r_sum\"))\nshape: (3, 2)\n+-----+-------+\n| val | r_sum |\n+-----+-------+\n| 10  | 10    |\n| 20  | 30    |\n| 30  | 50    |\n+-----+-------+"
        ],
        "params": [
          {
            "name": "windowSize",
            "desc": "Size of rolling window."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "rollingSum",
        "callExpression": ".rollingSum()",
        "signature": "$df.col(<column_name>).rollingSum(windowSize: number)",
        "signatureDetailed": "$df.col(<column_name>).rollingSum(windowSize: number)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2700,
        "lineEnd": 2702,
        "typeTree": {
          "windowSize": {
            "type": "number",
            "optional": false,
            "desc": "Size of rolling window."
          }
        }
      },
      "round": {
        "desc": "Rounds values to a specific scale of decimal digits.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").round(1).alias(\"rounded\"))\nshape: (3, 2)\n+---+---------+\n| a | rounded |\n+---+---------+\n| 1 | 1       |\n| 2 | 2       |\n| 3 | 3       |\n+---+---------+"
        ],
        "params": [
          {
            "name": "decimals",
            "desc": "Number of decimal places to round to (default: 0)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "round",
        "callExpression": ".round()",
        "signature": "$df.col(<column_name>).round(decimals: number = 0)",
        "signatureDetailed": "$df.col(<column_name>).round(decimals: number = 0)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2720,
        "lineEnd": 2722,
        "typeTree": {
          "decimals": {
            "type": "number",
            "optional": true,
            "default": "0",
            "desc": "Number of decimal places to round to (default: 0)."
          }
        }
      },
      "roundSigFigs": {
        "desc": "Rounds values to a specific number of significant figures.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").roundSigFigs(2).alias(\"sig_figs\"))\nshape: (3, 2)\n+---+----------+\n| a | sig_figs |\n+---+----------+\n| 1 | 1        |\n| 2 | 2        |\n| 3 | 3        |\n+---+----------+"
        ],
        "params": [
          {
            "name": "sigFigs",
            "desc": "Number of significant figures."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "roundSigFigs",
        "callExpression": ".roundSigFigs()",
        "signature": "$df.col(<column_name>).roundSigFigs(sigFigs: number)",
        "signatureDetailed": "$df.col(<column_name>).roundSigFigs(sigFigs: number)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2740,
        "lineEnd": 2742,
        "typeTree": {
          "sigFigs": {
            "type": "number",
            "optional": false,
            "desc": "Number of significant figures."
          }
        }
      },
      "rowNumber": {
        "desc": "Window: Computes 1-indexed row number count within group partitions.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.withColumns($df.col(\"val\").rowNumber().over(\"group\").alias(\"rn\"))\nshape: (3, 3)\n+-------+-----+----+\n| group | val | rn |\n+-------+-----+----+\n| A     | 10  | 1  |\n| A     | 20  | 2  |\n| B     | 30  | 1  |\n+-------+-----+----+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "rowNumber",
        "callExpression": ".rowNumber()",
        "signature": "$df.col(<column_name>).rowNumber()",
        "signatureDetailed": "$df.col(<column_name>).rowNumber()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2759,
        "lineEnd": 2763
      },
      "shift": {
        "desc": "Shifts values by the given number of rows, filling newly introduced slots with null. Positive offsets shift values down (lag); negative offsets shift values up (lead).\n\nSupports windowing and partition grouping via `.over(...)`.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").shift(1).alias(\"shifted\"))\nshape: (3, 2)\n+---+---------+\n| a | shifted |\n+---+---------+\n| 1 | null    |\n| 2 | 1       |\n| 3 | 2       |\n+---+---------+"
        ],
        "params": [
          {
            "name": "n",
            "desc": "Number of rows to shift (positive for down, negative for up). Default 1."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "shift",
        "callExpression": ".shift()",
        "signature": "$df.col(<column_name>).shift(\n  n: number = 1,\n  options: ShiftOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).shift(\n  n: number = 1,\n  options: {\n    fillValue?: any = null\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2785,
        "lineEnd": 2787,
        "typeTree": {
          "n": {
            "type": "number",
            "optional": true,
            "default": "1",
            "desc": "Number of rows to shift (positive for down, negative for up). Default 1."
          },
          "options": {
            "type": "ShiftOptions",
            "optional": true,
            "default": "{}",
            "desc": "Configuration options for shifting column or array elements (`shift`, `lag`, `lead`).",
            "properties": {
              "fillValue": {
                "type": "any",
                "optional": true,
                "desc": "Fallback fill value for empty slots introduced by shift/lag/lead.",
                "default": "null"
              }
            }
          }
        }
      },
      "sign": {
        "desc": "Returns sign indicator of column values (-1, 0, or 1).",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").sign().alias(\"sign_a\"))\nshape: (3, 2)\n+---+--------+\n| a | sign_a |\n+---+--------+\n| 1 | 1      |\n| 2 | 1      |\n| 3 | 1      |\n+---+--------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "sign",
        "callExpression": ".sign()",
        "signature": "$df.col(<column_name>).sign()",
        "signatureDetailed": "$df.col(<column_name>).sign()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2804,
        "lineEnd": 2806
      },
      "sin": {
        "desc": "Computes the sine of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").sin().alias(\"sin_a\"))\nshape: (3, 2)\n+---+----------+\n| a | sin_a    |\n+---+----------+\n| 1 | 0.841471 |\n| 2 | 0.909297 |\n| 3 | 0.14112  |\n+---+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "sin",
        "callExpression": ".sin()",
        "signature": "$df.col(<column_name>).sin()",
        "signatureDetailed": "$df.col(<column_name>).sin()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2823,
        "lineEnd": 2825
      },
      "sinh": {
        "desc": "Computes the hyperbolic sine of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").sinh().alias(\"sinh_a\"))\nshape: (3, 2)\n+---+-----------+\n| a | sinh_a    |\n+---+-----------+\n| 1 | 1.175201  |\n| 2 | 3.62686   |\n| 3 | 10.017875 |\n+---+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "sinh",
        "callExpression": ".sinh()",
        "signature": "$df.col(<column_name>).sinh()",
        "signatureDetailed": "$df.col(<column_name>).sinh()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2842,
        "lineEnd": 2844
      },
      "skew": {
        "desc": "Aggregation: Computes the sample skewness as the Fisher-Pearson coefficient of skewness.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.col(\"a\").skew().alias(\"skewness\"))\nshape: (1, 1)\n+----------+\n| skewness |\n+----------+\n| 0        |\n+----------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Skew calculation options ({ bias?: boolean }, default bias=true)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "skew",
        "callExpression": ".skew()",
        "signature": "$df.col(<column_name>).skew(options: SkewOptions = {})",
        "signatureDetailed": "$df.col(<column_name>).skew(\n  options: {\n    bias?: boolean = true\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2860,
        "lineEnd": 2862,
        "typeTree": {
          "options": {
            "type": "SkewOptions",
            "optional": true,
            "default": "{}",
            "desc": "Skew calculation options ({ bias?: boolean }, default bias=true).",
            "properties": {
              "bias": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, computes biased population skewness; if `false`, applies the Fisher-Pearson sample bias correction.",
                "default": "true"
              }
            }
          }
        }
      },
      "spearmanCorr": {
        "desc": "Aggregation: Computes the Spearman rank correlation coefficient.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n| 3 | 30 |\n+---+----+\n>>> df.select($df.col(\"a\").spearmanCorr($df.col(\"b\")).alias(\"spearman\"))\nshape: (1, 1)\n+----------+\n| spearman |\n+----------+\n| 1        |\n+----------+"
        ],
        "params": [
          {
            "name": "other",
            "desc": "The other column expression to correlate with."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "spearmanCorr",
        "callExpression": ".spearmanCorr()",
        "signature": "$df.col(<column_name>).spearmanCorr(other: NumericSeriesArg)",
        "signatureDetailed": "$df.col(<column_name>).spearmanCorr(other: NumericArg | number[] | AnyTypedArray)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2878,
        "lineEnd": 2880,
        "typeTree": {
          "other": {
            "type": "NumericSeriesArg",
            "optional": false,
            "desc": "The other column expression to correlate with.",
            "resolvedType": "NumericArg | number[] | AnyTypedArray"
          }
        }
      },
      "sqrt": {
        "desc": "Computes the square root of non-negative column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").sqrt().alias(\"sqrt_a\"))\nshape: (3, 2)\n+---+----------+\n| a | sqrt_a   |\n+---+----------+\n| 1 | 1        |\n| 2 | 1.414214 |\n| 3 | 1.732051 |\n+---+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "sqrt",
        "callExpression": ".sqrt()",
        "signature": "$df.col(<column_name>).sqrt()",
        "signatureDetailed": "$df.col(<column_name>).sqrt()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2897,
        "lineEnd": 2899
      },
      "std": {
        "desc": "Aggregation: Computes sample standard deviation.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.col(\"val\").std().alias(\"std_dev\"))\nshape: (1, 1)\n+---------+\n| std_dev |\n+---------+\n| 10      |\n+---------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "std",
        "callExpression": ".std()",
        "signature": "$df.col(<column_name>).std()",
        "signatureDetailed": "$df.col(<column_name>).std()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2914,
        "lineEnd": 2916
      },
      "sub": {
        "desc": "Subtracts a scalar or another column expression.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").sub(5).alias(\"sub_a\"))\nshape: (3, 2)\n+---+-------+\n| a | sub_a |\n+---+-------+\n| 1 | -4    |\n| 2 | -3    |\n| 3 | -2    |\n+---+-------+"
        ],
        "params": [
          {
            "name": "val",
            "desc": "The value or column expression to subtract."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "sub",
        "callExpression": ".sub()",
        "signature": "$df.col(<column_name>).sub(val: NumericArg)",
        "signatureDetailed": "$df.col(<column_name>).sub(val: number | bigint | IExpr | null)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2934,
        "lineEnd": 2936,
        "typeTree": {
          "val": {
            "type": "NumericArg",
            "optional": false,
            "desc": "The value or column expression to subtract.",
            "resolvedType": "number | bigint | IExpr | null"
          }
        }
      },
      "sum": {
        "desc": "Aggregation: Computes the sum of elements in the group.",
        "examples": [
          ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg($df.col(\"val\").sum().alias(\"total\"))\nshape: (2, 2)\n+-------+-------+\n| group | total |\n+-------+-------+\n| A     | 30    |\n| B     | 30    |\n+-------+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "sum",
        "callExpression": ".sum()",
        "signature": "$df.col(<column_name>).sum()",
        "signatureDetailed": "$df.col(<column_name>).sum()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2952,
        "lineEnd": 2954
      },
      "tan": {
        "desc": "Computes the tangent of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").tan().alias(\"tan_a\"))\nshape: (3, 2)\n+---+-----------+\n| a | tan_a     |\n+---+-----------+\n| 1 | 1.557408  |\n| 2 | -2.18504  |\n| 3 | -0.142547 |\n+---+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "tan",
        "callExpression": ".tan()",
        "signature": "$df.col(<column_name>).tan()",
        "signatureDetailed": "$df.col(<column_name>).tan()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2971,
        "lineEnd": 2973
      },
      "tanh": {
        "desc": "Computes the hyperbolic tangent of the column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").tanh().alias(\"tanh_a\"))\nshape: (3, 2)\n+---+----------+\n| a | tanh_a   |\n+---+----------+\n| 1 | 0.761594 |\n| 2 | 0.964028 |\n| 3 | 0.995055 |\n+---+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "tanh",
        "callExpression": ".tanh()",
        "signature": "$df.col(<column_name>).tanh()",
        "signatureDetailed": "$df.col(<column_name>).tanh()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 2990,
        "lineEnd": 2992
      },
      "trunc": {
        "desc": "Truncates fractional digits of column values.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.withColumns($df.col(\"a\").trunc().alias(\"trunc_a\"))\nshape: (3, 2)\n+---+---------+\n| a | trunc_a |\n+---+---------+\n| 1 | 1       |\n| 2 | 2       |\n| 3 | 3       |\n+---+---------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "trunc",
        "callExpression": ".trunc()",
        "signature": "$df.col(<column_name>).trunc()",
        "signatureDetailed": "$df.col(<column_name>).trunc()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 3009,
        "lineEnd": 3011
      },
      "variance": {
        "desc": "Aggregation: Computes sample variance.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.col(\"val\").variance().alias(\"v\"))\nshape: (1, 1)\n+-----+\n| v   |\n+-----+\n| 100 |\n+-----+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "variance",
        "callExpression": ".variance()",
        "signature": "$df.col(<column_name>).variance()",
        "signatureDetailed": "$df.col(<column_name>).variance()",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 3026,
        "lineEnd": 3028
      },
      "wAvg": {
        "desc": "Aggregation: Computes weighted average.",
        "examples": [
          ">>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n| 3 | 30 |\n+---+----+\n>>> df.select($df.col(\"a\").wAvg($df.col(\"b\")).alias(\"w_mean\"))\nshape: (1, 1)\n+----------+\n| w_mean   |\n+----------+\n| 2.333333 |\n+----------+"
        ],
        "params": [
          {
            "name": "weights",
            "desc": "The weight values or column expression."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "wAvg",
        "callExpression": ".wAvg()",
        "signature": "$df.col(<column_name>).wAvg(weights: NumericSeriesArg)",
        "signatureDetailed": "$df.col(<column_name>).wAvg(weights: NumericArg | number[] | AnyTypedArray)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 3044,
        "lineEnd": 3046,
        "typeTree": {
          "weights": {
            "type": "NumericSeriesArg",
            "optional": false,
            "desc": "The weight values or column expression.",
            "resolvedType": "NumericArg | number[] | AnyTypedArray"
          }
        }
      },
      "xor": {
        "desc": "Logical XOR check.",
        "examples": [
          ">>> const df = $df.data({ a: [true, true, false, false], b: [true, false, true, false] })\n>>> df\nshape: (4, 2)\n+-------+-------+\n| a     | b     |\n+-------+-------+\n| true  | true  |\n| true  | false |\n| false | true  |\n| false | false |\n+-------+-------+\n>>> df.withColumns($df.col(\"a\").xor($df.col(\"b\")).alias(\"xor_res\"))\nshape: (4, 3)\n+-------+-------+---------+\n| a     | b     | xor_res |\n+-------+-------+---------+\n| true  | true  | false   |\n| true  | false | true    |\n| false | true  | true    |\n| false | false | false   |\n+-------+-------+---------+"
        ],
        "params": [
          {
            "name": "other",
            "desc": "The other boolean column expression or literal value to compare."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "category": "ColumnExpression",
        "propertyAccess": "xor",
        "callExpression": ".xor()",
        "signature": "$df.col(<column_name>).xor(other: BooleanArg)",
        "signatureDetailed": "$df.col(<column_name>).xor(other: boolean | boolean[] | IExpr | null | undefined)",
        "filePath": "columnExpressions/mixins/standardExpr.ts",
        "lineStart": 3065,
        "lineEnd": 3067,
        "typeTree": {
          "other": {
            "type": "BooleanArg",
            "optional": false,
            "desc": "The other boolean column expression or literal value to compare.",
            "resolvedType": "boolean | boolean[] | IExpr | null | undefined"
          }
        }
      }
    },
    "stringExpr": {
      "concat": {
        "desc": "Concatenates string elements with another string value or expression.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.concat(\"!\").alias(\"exclaimed\"))\nshape: (3, 2)\n+----------+-----------+\n| s        | exclaimed |\n+----------+-----------+\n| \"apple\"  | apple!    |\n| \"banana\" | banana!   |\n| \"cherry\" | cherry!   |\n+----------+-----------+"
        ],
        "params": [
          {
            "name": "other",
            "desc": "The string value or column expression to concatenate."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "concat",
        "callExpression": ".str.concat()",
        "signature": "$df.col(<column_name>).str.concat(other: StringArg)",
        "signatureDetailed": "$df.col(<column_name>).str.concat(other: string | IExpr)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 94,
        "lineEnd": 96,
        "typeTree": {
          "other": {
            "type": "StringArg",
            "optional": false,
            "desc": "The string value or column expression to concatenate.",
            "resolvedType": "string | IExpr"
          }
        }
      },
      "contains": {
        "desc": "Checks if a string contains the search substring pattern (supports Regex).",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"email\").str.contains(\"@example.com\").alias(\"is_example\"))\nshape: (2, 2)\n+------------------+------------+\n| email            | is_example |\n+------------------+------------+\n| user@example.com | true       |\n| admin@test.org   | false      |\n+------------------+------------+"
        ],
        "params": [
          {
            "name": "pattern",
            "desc": "The search substring or regular expression pattern."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "contains",
        "callExpression": ".str.contains()",
        "signature": "$df.col(<column_name>).str.contains(pattern: RegexPatternArg)",
        "signatureDetailed": "$df.col(<column_name>).str.contains(pattern: string | RegExp)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 113,
        "lineEnd": 115,
        "typeTree": {
          "pattern": {
            "type": "RegexPatternArg",
            "optional": false,
            "desc": "The search substring or regular expression pattern.",
            "resolvedType": "string | RegExp"
          }
        }
      },
      "containsAny": {
        "desc": "Checks if a string contains any of the search patterns.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"email\").str.containsAny([\"@example.com\", \"@test.org\"]).alias(\"is_target\"))\nshape: (2, 2)\n+------------------+-----------+\n| email            | is_target |\n+------------------+-----------+\n| user@example.com | true      |\n| admin@test.org   | true      |\n+------------------+-----------+"
        ],
        "params": [
          {
            "name": "patterns",
            "desc": "Array of substring or regular expression search patterns."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "containsAny",
        "callExpression": ".str.containsAny()",
        "signature": "$df.col(<column_name>).str.containsAny(patterns: RegexPatternSeriesArg)",
        "signatureDetailed": "$df.col(<column_name>).str.containsAny(patterns: (string | RegExp)[])",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 132,
        "lineEnd": 139,
        "typeTree": {
          "patterns": {
            "type": "RegexPatternSeriesArg",
            "optional": false,
            "desc": "Array of substring or regular expression search patterns.",
            "resolvedType": "(string | RegExp)[]"
          }
        }
      },
      "countMatches": {
        "desc": "Counts occurrences of a substring or regular expression match in each string element.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.countMatches(\"a\").alias(\"a_count\"))\nshape: (3, 2)\n+----------+---------+\n| s        | a_count |\n+----------+---------+\n| \"apple\"  | 1       |\n| \"banana\" | 3       |\n| \"cherry\" | 0       |\n+----------+---------+"
        ],
        "params": [
          {
            "name": "pattern",
            "desc": "Search substring or regular expression."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "countMatches",
        "callExpression": ".str.countMatches()",
        "signature": "$df.col(<column_name>).str.countMatches(\n  pattern: RegexPatternArg,\n  options: CountMatchesOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).str.countMatches(\n  pattern: string | RegExp,\n  options: {\n    literal?: boolean = false\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 157,
        "lineEnd": 168,
        "typeTree": {
          "pattern": {
            "type": "RegexPatternArg",
            "optional": false,
            "desc": "Search substring or regular expression.",
            "resolvedType": "string | RegExp"
          },
          "options": {
            "type": "CountMatchesOptions",
            "optional": true,
            "default": "{}",
            "desc": "Configuration options for counting matching pattern occurrences in a string.",
            "properties": {
              "literal": {
                "type": "boolean",
                "optional": true,
                "desc": "If true, treats the pattern as a literal string rather than a regular expression.",
                "default": "false"
              }
            }
          }
        }
      },
      "decode": {
        "desc": "Decodes hex or base64 encoded string column values into string.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.encode({ encoding: \"hex\" }).str.decode({ encoding: \"hex\" }).alias(\"decoded\"))\nshape: (3, 2)\n+----------+---------+\n| s        | decoded |\n+----------+---------+\n| \"apple\"  | apple   |\n| \"banana\" | banana  |\n| \"cherry\" | cherry  |\n+----------+---------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Object containing encoding (\"hex\" | \"base64\") and optional strict flag"
          }
        ],
        "returns": "ColumnExpression",
        "notes": [
          "[Runtime Fallback]: Automatically leverages native `Uint8Array.fromBase64` / `Uint8Array.fromHex` when available in the runtime, with seamless automatic fallback to standard decoding across older environments."
        ],
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "decode",
        "callExpression": ".str.decode()",
        "signature": "$df.col(<column_name>).str.decode(options: StringDecodeOptions)",
        "signatureDetailed": "$df.col(<column_name>).str.decode(\n  options: {\n    encoding: \"hex\" | \"base64\",\n    strict?: boolean = true\n  }\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 188,
        "lineEnd": 190,
        "typeTree": {
          "options": {
            "type": "StringDecodeOptions",
            "optional": false,
            "desc": "Object containing encoding (\"hex\" | \"base64\") and optional strict flag",
            "properties": {
              "encoding": {
                "type": "StringEncoding",
                "optional": false,
                "desc": "Target string encoding format (`\"hex\"` or `\"base64\"`).",
                "resolvedType": "\"hex\" | \"base64\""
              },
              "strict": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether invalid encoded sequences should throw an error (`true`) or return `null` (`false`).",
                "default": "true"
              }
            }
          }
        }
      },
      "decodeUriComponent": {
        "desc": "Decodes Uniform Resource Identifier (URI) components.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.encodeUriComponent().str.decodeUriComponent().alias(\"decoded\"))\nshape: (2, 2)\n+-------------+-------------+\n| s           | decoded     |\n+-------------+-------------+\n| \"  hello  \" | \"  hello  \" |\n| \"  world  \" | \"  world  \" |\n+-------------+-------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "decodeUriComponent",
        "callExpression": ".str.decodeUriComponent()",
        "signature": "$df.col(<column_name>).str.decodeUriComponent()",
        "signatureDetailed": "$df.col(<column_name>).str.decodeUriComponent()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 206,
        "lineEnd": 210
      },
      "encode": {
        "desc": "Encodes string column values into hex or base64.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.encode({ encoding: \"hex\" }).alias(\"encoded\"))\nshape: (3, 2)\n+----------+----------------+\n| s        | encoded        |\n+----------+----------------+\n| \"apple\"  | 6170706c65     |\n| \"banana\" | 62616e616e61   |\n| \"cherry\" | 636865727279   |\n+----------+----------------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Object containing encoding (\"hex\" | \"base64\")"
          }
        ],
        "returns": "ColumnExpression",
        "notes": [
          "[Runtime Fallback]: Automatically leverages native `Uint8Array.prototype.toBase64` / `Uint8Array.prototype.toHex` when available, with automatic fallback across standard environments."
        ],
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "encode",
        "callExpression": ".str.encode()",
        "signature": "$df.col(<column_name>).str.encode(options: StringEncodeOptions)",
        "signatureDetailed": "$df.col(<column_name>).str.encode(\n  options: {\n    encoding: \"hex\" | \"base64\"\n  }\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 230,
        "lineEnd": 232,
        "typeTree": {
          "options": {
            "type": "StringEncodeOptions",
            "optional": false,
            "desc": "Object containing encoding (\"hex\" | \"base64\")",
            "properties": {
              "encoding": {
                "type": "StringEncoding",
                "optional": false,
                "desc": "Target string encoding format (`\"hex\"` or `\"base64\"`).",
                "resolvedType": "\"hex\" | \"base64\""
              }
            }
          }
        }
      },
      "encodeUriComponent": {
        "desc": "Encodes Uniform Resource Identifier (URI) components.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.encodeUriComponent().alias(\"encoded\"))\nshape: (2, 2)\n+-------------+-------------------+\n| s           | encoded           |\n+-------------+-------------------+\n| \"  hello  \" | \"%20%20hello%20%20\" |\n| \"  world  \" | \"%20%20world%20%20\" |\n+-------------+-------------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "encodeUriComponent",
        "callExpression": ".str.encodeUriComponent()",
        "signature": "$df.col(<column_name>).str.encodeUriComponent()",
        "signatureDetailed": "$df.col(<column_name>).str.encodeUriComponent()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 248,
        "lineEnd": 252
      },
      "endsWith": {
        "desc": "Checks if string ends with a suffix.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"email\").str.endsWith(\".org\").alias(\"is_org\"))\nshape: (2, 2)\n+------------------+--------+\n| email            | is_org |\n+------------------+--------+\n| user@example.com | false  |\n| admin@test.org   | true   |\n+------------------+--------+"
        ],
        "params": [
          {
            "name": "suffix",
            "desc": "The suffix substring."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "endsWith",
        "callExpression": ".str.endsWith()",
        "signature": "$df.col(<column_name>).str.endsWith(suffix: string)",
        "signatureDetailed": "$df.col(<column_name>).str.endsWith(suffix: string)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 269,
        "lineEnd": 271,
        "typeTree": {
          "suffix": {
            "type": "string",
            "optional": false,
            "desc": "The suffix substring."
          }
        }
      },
      "escapeRegex": {
        "desc": "Escapes special regular expression characters in string elements.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.escapeRegex().alias(\"escaped\"))\nshape: (3, 2)\n+----------+---------+\n| s        | escaped |\n+----------+---------+\n| \"apple\"  | apple   |\n| \"banana\" | banana  |\n| \"cherry\" | cherry  |\n+----------+---------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "escapeRegex",
        "callExpression": ".str.escapeRegex()",
        "signature": "$df.col(<column_name>).str.escapeRegex(options: EscapeRegexOptions = {})",
        "signatureDetailed": "$df.col(<column_name>).str.escapeRegex(\n  options: {\n    mode?: \"tc39\" | \"nonAlphanumericAscii\" = \"tc39\"\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 288,
        "lineEnd": 290,
        "typeTree": {
          "options": {
            "type": "EscapeRegexOptions",
            "optional": true,
            "default": "{}",
            "desc": "Configuration options for `escapeRegExp()` and `str.escapeRegex()`.",
            "properties": {
              "mode": {
                "type": "EscapeRegexMode",
                "optional": true,
                "desc": "Escaping mode: `\"tc39\"` (ECMAScript `RegExp.escape` specification) or `\"nonAlphanumericAscii\"` (escapes all `[^A-Za-z0-9]`).",
                "default": "\"tc39\"",
                "resolvedType": "\"tc39\" | \"nonAlphanumericAscii\""
              }
            }
          }
        }
      },
      "explode": {
        "desc": "Splits strings into lists of single characters.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.explode().alias(\"chars\"))\nshape: (3, 2)\n+----------+-------------------------------------+\n| s        | chars                               |\n+----------+-------------------------------------+\n| \"apple\"  | [\"a\", \"p\", \"p\", \"l\", \"e\"]           |\n| \"banana\" | [\"b\", \"a\", \"n\", \"a\", \"n\", \"a\"]     |\n| \"cherry\" | [\"c\", \"h\", \"e\", \"r\", \"r\", \"y\"]     |\n+----------+-------------------------------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "explode",
        "callExpression": ".str.explode()",
        "signature": "$df.col(<column_name>).str.explode()",
        "signatureDetailed": "$df.col(<column_name>).str.explode()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 307,
        "lineEnd": 309
      },
      "extract": {
        "desc": "Extracts a captured group from the first regex match.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"email\").str.extract(/@(\\w+)/).alias(\"domain\"))\nshape: (2, 2)\n+------------------+---------+\n| email            | domain  |\n+------------------+---------+\n| user@example.com | example |\n| admin@test.org   | test    |\n+------------------+---------+"
        ],
        "params": [
          {
            "name": "pattern",
            "desc": "The regex pattern containing capture groups."
          },
          {
            "name": "options",
            "desc": "Options object. Use `groupIndex` to select the group (default 1)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "extract",
        "callExpression": ".str.extract()",
        "signature": "$df.col(<column_name>).str.extract(\n  pattern: RegexPatternArg,\n  options?: ExtractRegexEngineOptions\n)",
        "signatureDetailed": "$df.col(<column_name>).str.extract(\n  pattern: string | RegExp,\n  options?: {\n    asciiCaseInsensitive?: boolean = false,\n    global?: boolean = false,\n    groupIndex?: number | string = 1\n  }\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 327,
        "lineEnd": 329,
        "typeTree": {
          "pattern": {
            "type": "RegexPatternArg",
            "optional": false,
            "desc": "The regex pattern containing capture groups.",
            "resolvedType": "string | RegExp"
          },
          "options": {
            "type": "ExtractRegexEngineOptions",
            "optional": true,
            "desc": "Options object. Use `groupIndex` to select the group (default 1).",
            "properties": {
              "asciiCaseInsensitive": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether matching should be case-insensitive for ASCII characters.",
                "default": "false"
              },
              "global": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether to return all matches (global flag).",
                "default": "false"
              },
              "groupIndex": {
                "type": "ColumnIndexOrNameArg",
                "optional": true,
                "desc": "0-based index or name of the capture group to extract.",
                "default": "1",
                "resolvedType": "number | string"
              }
            }
          }
        }
      },
      "extractAll": {
        "desc": "Extracts all occurrences matching a regular expression pattern.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.extractAll(/[aeiou]/).alias(\"vowels\"))\nshape: (3, 2)\n+----------+-----------------+\n| s        | vowels          |\n+----------+-----------------+\n| \"apple\"  | [\"a\", \"e\"]      |\n| \"banana\" | [\"a\", \"a\", \"a\"] |\n| \"cherry\" | [\"e\"]           |\n+----------+-----------------+"
        ],
        "params": [
          {
            "name": "pattern",
            "desc": "Search pattern (string or RegExp)."
          },
          {
            "name": "options",
            "desc": "Options object. Use `groupIndex` to select the group (default 0)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "extractAll",
        "callExpression": ".str.extractAll()",
        "signature": "$df.col(<column_name>).str.extractAll(\n  pattern: RegexPatternArg,\n  options?: ExtractRegexEngineOptions\n)",
        "signatureDetailed": "$df.col(<column_name>).str.extractAll(\n  pattern: string | RegExp,\n  options?: {\n    asciiCaseInsensitive?: boolean = false,\n    global?: boolean = false,\n    groupIndex?: number | string = 1\n  }\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 348,
        "lineEnd": 350,
        "typeTree": {
          "pattern": {
            "type": "RegexPatternArg",
            "optional": false,
            "desc": "Search pattern (string or RegExp).",
            "resolvedType": "string | RegExp"
          },
          "options": {
            "type": "ExtractRegexEngineOptions",
            "optional": true,
            "desc": "Options object. Use `groupIndex` to select the group (default 0).",
            "properties": {
              "asciiCaseInsensitive": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether matching should be case-insensitive for ASCII characters.",
                "default": "false"
              },
              "global": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether to return all matches (global flag).",
                "default": "false"
              },
              "groupIndex": {
                "type": "ColumnIndexOrNameArg",
                "optional": true,
                "desc": "0-based index or name of the capture group to extract.",
                "default": "1",
                "resolvedType": "number | string"
              }
            }
          }
        }
      },
      "extractGroups": {
        "desc": "Extracts all captured groups from the first regex match into a structured object (struct).",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"email\").str.extractGroups(/(?<user>\\w+)@(?<domain>\\w+)/).alias(\"parsed\"))\nshape: (2, 2)\n+------------------+------------------------------------+\n| email            | parsed                             |\n+------------------+------------------------------------+\n| user@example.com | { user: \"user\", domain: \"example\" }|\n| admin@test.org   | { user: \"admin\", domain: \"test\" }  |\n+------------------+------------------------------------+"
        ],
        "params": [
          {
            "name": "pattern",
            "desc": "Search pattern containing capture groups."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "extractGroups",
        "callExpression": ".str.extractGroups()",
        "signature": "$df.col(<column_name>).str.extractGroups(\n  pattern: RegexPatternArg,\n  options: ExtractRegexEngineOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).str.extractGroups(\n  pattern: string | RegExp,\n  options: {\n    asciiCaseInsensitive?: boolean = false,\n    global?: boolean = false,\n    groupIndex?: number | string = 1\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 367,
        "lineEnd": 369,
        "typeTree": {
          "pattern": {
            "type": "RegexPatternArg",
            "optional": false,
            "desc": "Search pattern containing capture groups.",
            "resolvedType": "string | RegExp"
          },
          "options": {
            "type": "ExtractRegexEngineOptions",
            "optional": true,
            "default": "{}",
            "desc": "Configuration options for regex extraction (`str.extract`, `str.extractAll`, `extractRegexEngine`).",
            "properties": {
              "asciiCaseInsensitive": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether matching should be case-insensitive for ASCII characters.",
                "default": "false"
              },
              "global": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether to return all matches (global flag).",
                "default": "false"
              },
              "groupIndex": {
                "type": "ColumnIndexOrNameArg",
                "optional": true,
                "desc": "0-based index or name of the capture group to extract.",
                "default": "1",
                "resolvedType": "number | string"
              }
            }
          }
        }
      },
      "extractMany": {
        "desc": "Extracts the first regex match for each pattern in a list of patterns.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.extractMany([/app/, /ban/, /che/]).alias(\"extracted\"))\nshape: (3, 2)\n+----------+-------------+\n| s        | extracted   |\n+----------+-------------+\n| \"apple\"  | [\"app\"]     |\n| \"banana\" | [\"ban\"]     |\n| \"cherry\" | [\"che\"]     |\n+----------+-------------+"
        ],
        "params": [
          {
            "name": "patterns",
            "desc": "Array of regular expression patterns or strings."
          },
          {
            "name": "options",
            "desc": "Named options object ({ asciiCaseInsensitive, overlapping })."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "extractMany",
        "callExpression": ".str.extractMany()",
        "signature": "$df.col(<column_name>).str.extractMany(\n  patterns: RegexPatternSeriesArg,\n  options: ExtractManyOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).str.extractMany(\n  patterns: (string | RegExp)[],\n  options: {\n    asciiCaseInsensitive?: boolean = false,\n    global?: boolean = false,\n    groupIndex?: number | string = 0,\n    leftmost?: boolean = false,\n    overlapping?: boolean = false\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 388,
        "lineEnd": 390,
        "typeTree": {
          "patterns": {
            "type": "RegexPatternSeriesArg",
            "optional": false,
            "desc": "Array of regular expression patterns or strings.",
            "resolvedType": "(string | RegExp)[]"
          },
          "options": {
            "type": "ExtractManyOptions",
            "optional": true,
            "default": "{}",
            "desc": "Named options object ({ asciiCaseInsensitive, overlapping }).",
            "properties": {
              "asciiCaseInsensitive": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether matching should be case-insensitive for ASCII characters.",
                "default": "false"
              },
              "global": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether to return all matches (global flag).",
                "default": "false"
              },
              "groupIndex": {
                "type": "ColumnIndexOrNameArg",
                "optional": true,
                "desc": "0-based index or name of the capture group to extract.",
                "default": "0",
                "resolvedType": "number | string"
              },
              "leftmost": {
                "type": "boolean",
                "optional": true,
                "desc": "Guarantees that the leftmost match is selected when multiple patterns match. Cannot be combined with `overlapping: true`.",
                "default": "false"
              },
              "overlapping": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether overlapping matches across patterns are allowed.",
                "default": "false"
              }
            }
          }
        }
      },
      "find": {
        "desc": "Return the byte offset of the first substring matching a pattern. Returns null if pattern is not found.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.find(\"a\").alias(\"pos\"))\nshape: (3, 2)\n+----------+------+\n| s        | pos  |\n+----------+------+\n| \"apple\"  | 0    |\n| \"banana\" | 1    |\n| \"cherry\" | null |\n+----------+------+"
        ],
        "params": [
          {
            "name": "value",
            "desc": "Search string or regular expression."
          },
          {
            "name": "options",
            "desc": "Configuration options ({ literal, asciiCaseInsensitive })."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "find",
        "callExpression": ".str.find()",
        "signature": "$df.col(<column_name>).str.find(\n  value: RegexPatternArg,\n  options: FindOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).str.find(\n  value: string | RegExp,\n  options: {\n    asciiCaseInsensitive?: boolean = false,\n    global?: boolean = false,\n    groupIndex?: number | string = 0,\n    literal?: boolean = false,\n    mode?: \"tc39\" | \"nonAlphanumericAscii\" = \"tc39\"\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 410,
        "lineEnd": 412,
        "typeTree": {
          "value": {
            "type": "RegexPatternArg",
            "optional": false,
            "desc": "Search string or regular expression.",
            "resolvedType": "string | RegExp"
          },
          "options": {
            "type": "FindOptions",
            "optional": true,
            "default": "{}",
            "desc": "Configuration options ({ literal, asciiCaseInsensitive }).",
            "properties": {
              "asciiCaseInsensitive": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether matching should be case-insensitive for ASCII characters.",
                "default": "false"
              },
              "global": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether to return all matches (global flag).",
                "default": "false"
              },
              "groupIndex": {
                "type": "ColumnIndexOrNameArg",
                "optional": true,
                "desc": "0-based index or name of the capture group to locate.",
                "default": "0",
                "resolvedType": "number | string"
              },
              "literal": {
                "type": "boolean",
                "optional": true,
                "desc": "Treat pattern as a literal substring instead of a regular expression.",
                "default": "false"
              },
              "mode": {
                "type": "EscapeRegexMode",
                "optional": true,
                "desc": "Escaping mode when `literal` is `true`.",
                "default": "\"tc39\"",
                "resolvedType": "\"tc39\" | \"nonAlphanumericAscii\""
              }
            }
          }
        }
      },
      "findMany": {
        "desc": "Return the starting byte offset of each match for multiple patterns.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.findMany([\"a\", \"e\"]).alias(\"positions\"))\nshape: (3, 2)\n+----------+-----------+\n| s        | positions |\n+----------+-----------+\n| \"apple\"  | [0, 4]    |\n| \"banana\" | [1]       |\n| \"cherry\" | [2]       |\n+----------+-----------+"
        ],
        "params": [
          {
            "name": "patterns",
            "desc": "Array of regular expressions or literal search strings."
          },
          {
            "name": "options",
            "desc": "Configuration options ({ literal, asciiCaseInsensitive, overlapping, leftmost })."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "findMany",
        "callExpression": ".str.findMany()",
        "signature": "$df.col(<column_name>).str.findMany(\n  patterns: RegexPatternSeriesArg,\n  options: FindManyOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).str.findMany(\n  patterns: (string | RegExp)[],\n  options: {\n    asciiCaseInsensitive?: boolean = false,\n    global?: boolean = false,\n    groupIndex?: number | string = 0,\n    leftmost?: boolean = false,\n    literal?: boolean = false,\n    mode?: \"tc39\" | \"nonAlphanumericAscii\" = \"tc39\",\n    overlapping?: boolean = false\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 431,
        "lineEnd": 433,
        "typeTree": {
          "patterns": {
            "type": "RegexPatternSeriesArg",
            "optional": false,
            "desc": "Array of regular expressions or literal search strings.",
            "resolvedType": "(string | RegExp)[]"
          },
          "options": {
            "type": "FindManyOptions",
            "optional": true,
            "default": "{}",
            "desc": "Configuration options ({ literal, asciiCaseInsensitive, overlapping, leftmost }).",
            "properties": {
              "asciiCaseInsensitive": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether matching should be case-insensitive for ASCII characters.",
                "default": "false"
              },
              "global": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether to return all matches (global flag).",
                "default": "false"
              },
              "groupIndex": {
                "type": "ColumnIndexOrNameArg",
                "optional": true,
                "desc": "0-based index or name of the capture group to locate.",
                "default": "0",
                "resolvedType": "number | string"
              },
              "leftmost": {
                "type": "boolean",
                "optional": true,
                "desc": "Guarantees that the leftmost match is selected when multiple patterns match.",
                "default": "false"
              },
              "literal": {
                "type": "boolean",
                "optional": true,
                "desc": "Treat patterns as literal substrings instead of regular expressions.",
                "default": "false"
              },
              "mode": {
                "type": "EscapeRegexMode",
                "optional": true,
                "desc": "Escaping mode when `literal` is `true`.",
                "default": "\"tc39\"",
                "resolvedType": "\"tc39\" | \"nonAlphanumericAscii\""
              },
              "overlapping": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether overlapping matches across patterns are allowed.",
                "default": "false"
              }
            }
          }
        }
      },
      "head": {
        "desc": "Extracts the first n characters of each string element.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.head(3).alias(\"prefix\"))\nshape: (3, 2)\n+----------+--------+\n| s        | prefix |\n+----------+--------+\n| \"apple\"  | app    |\n| \"banana\" | ban    |\n| \"cherry\" | che    |\n+----------+--------+"
        ],
        "params": [
          {
            "name": "n",
            "desc": "Number of characters to extract from the start of the string (default 1)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "head",
        "callExpression": ".str.head()",
        "signature": "$df.col(<column_name>).str.head(n: number = 1)",
        "signatureDetailed": "$df.col(<column_name>).str.head(n: number = 1)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 451,
        "lineEnd": 453,
        "typeTree": {
          "n": {
            "type": "number",
            "optional": true,
            "default": "1",
            "desc": "Number of characters to extract from the start of the string (default 1)."
          }
        }
      },
      "join": {
        "desc": "Joins a list of string elements into a single string using a delimiter. Accepts `JoinArrayOptions` (`{ ignoreNulls, nullValue, prefix, suffix, limit, truncationMarker, valueFormatter }`).",
        "examples": [
          ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.withColumns($df.col(\"a\").str.join(\"-\").alias(\"joined\"))\nshape: (2, 2)\n+------------+--------+\n| a          | joined |\n+------------+--------+\n| [\"a\", \"b\"] | a-b    |\n| [\"c\"]      | c      |\n+------------+--------+"
        ],
        "params": [
          {
            "name": "delimiter",
            "desc": "The string delimiter to join elements with."
          },
          {
            "name": "options",
            "desc": "Formatting configuration options (`JoinArrayOptions`)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "join",
        "callExpression": ".str.join()",
        "signature": "$df.col(<column_name>).str.join(\n  delimiter: string = \"\",\n  options: JoinArrayOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).str.join(\n  delimiter: string = \"\",\n  options: {\n    ignoreNulls?: boolean = false,\n    limit?: number,\n    nullValue?: string = \"\",\n    prefix?: string = \"\",\n    suffix?: string = \"\",\n    truncationMarker?: string = \"...\",\n    valueFormatter?: (val: any, index: number) => string\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 472,
        "lineEnd": 476,
        "typeTree": {
          "delimiter": {
            "type": "string",
            "optional": true,
            "default": "\"\"",
            "desc": "The string delimiter to join elements with."
          },
          "options": {
            "type": "JoinArrayOptions",
            "optional": true,
            "default": "{}",
            "desc": "Formatting configuration options (`JoinArrayOptions`).",
            "properties": {
              "ignoreNulls": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, `null` and `undefined` elements are skipped during joining.",
                "default": "false"
              },
              "limit": {
                "type": "number",
                "optional": true,
                "desc": "Maximum number of array elements to join before truncating with `truncationMarker`."
              },
              "nullValue": {
                "type": "string",
                "optional": true,
                "desc": "Custom string representation for `null` and `undefined` elements when `ignoreNulls` is `false`.",
                "default": "\"\""
              },
              "prefix": {
                "type": "string",
                "optional": true,
                "desc": "Prefix string prepended to the joined result.",
                "default": "\"\""
              },
              "suffix": {
                "type": "string",
                "optional": true,
                "desc": "Suffix string appended to the joined result.",
                "default": "\"\""
              },
              "truncationMarker": {
                "type": "string",
                "optional": true,
                "desc": "Placeholder string appended when `limit` truncation occurs.",
                "default": "\"...\""
              },
              "valueFormatter": {
                "type": "(val: any, index: number) => string",
                "optional": true,
                "desc": "Callback function used to format each non-null element to a string."
              }
            }
          }
        }
      },
      "jsonDecode": {
        "desc": "Decodes JSON string elements into parsed objects or arrays. Reuses safeJsonParse utility.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.trim().str.jsonDecode().alias(\"parsed\"))\nshape: (2, 2)\n+-------------+---------+\n| s           | parsed  |\n+-------------+---------+\n| \"  hello  \" | \"hello\" |\n| \"  world  \" | \"world\" |\n+-------------+---------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Configuration options for parsing (`SafeJsonParseOptions`)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "jsonDecode",
        "callExpression": ".str.jsonDecode()",
        "signature": "$df.col(<column_name>).str.jsonDecode(options: SafeJsonParseOptions = {})",
        "signatureDetailed": "$df.col(<column_name>).str.jsonDecode(\n  options: {\n    allowPrimitives?: boolean = false,\n    fallback?: unknown,\n    format?: \"json\" | \"ndjson\" = \"json\",\n    guard?: ((value: unknown) => value is unknown) | ((value: unknown) => boolean),\n    ndjson?: {\n      maxLines?: number,\n      skipInvalidLines?: boolean = false,\n      skipLines?: number = 0\n    },\n    onError?: (err: unknown) => void,\n    reviver?: Parameters<typeof JSON.parse>[1],\n    trimBeforeParse?: boolean = false\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 494,
        "lineEnd": 496,
        "typeTree": {
          "options": {
            "type": "SafeJsonParseOptions",
            "optional": true,
            "default": "{}",
            "desc": "Configuration options for parsing (`SafeJsonParseOptions`).",
            "properties": {
              "allowPrimitives": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether to allow JSON primitive roots (numbers, booleans, strings, `null`) instead of requiring objects or arrays.",
                "default": "false"
              },
              "fallback": {
                "type": "unknown",
                "optional": true,
                "desc": "Fallback value returned when parsing or guard validation fails."
              },
              "format": {
                "type": "JSONFormat",
                "optional": true,
                "desc": "Format of the JSON content: `\"json\"` (standard JSON) or `\"ndjson\"` (Newline Delimited JSON).",
                "default": "\"json\"",
                "resolvedType": "\"json\" | \"ndjson\""
              },
              "guard": {
                "type": "((value: unknown) => value is unknown) | ((value: unknown) => boolean)",
                "optional": true,
                "desc": "Guard predicate to validate the parsed value. If it returns `false`, `onError` is called and `fallback` is returned."
              },
              "ndjson": {
                "type": "NDJSONParseOptions",
                "optional": true,
                "desc": "Options specific to NDJSON parsing when `format` is `\"ndjson\"`.",
                "properties": {
                  "maxLines": {
                    "type": "number",
                    "optional": true,
                    "desc": "Maximum number of non-empty lines to validate or parse."
                  },
                  "skipInvalidLines": {
                    "type": "boolean",
                    "optional": true,
                    "desc": "Skip malformed or invalid lines instead of failing the entire parse.",
                    "default": "false"
                  },
                  "skipLines": {
                    "type": "number",
                    "optional": true,
                    "desc": "Number of non-empty lines to skip at the beginning of the content.",
                    "default": "0"
                  }
                }
              },
              "onError": {
                "type": "(err: unknown) => void",
                "optional": true,
                "desc": "Callback invoked when parsing fails or the `guard` check returns `false`."
              },
              "reviver": {
                "type": "Parameters<typeof JSON.parse>[1]",
                "optional": true,
                "desc": "Reviver function passed to `JSON.parse` for custom value transformation."
              },
              "trimBeforeParse": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether to trim leading and trailing whitespace before validating/parsing.",
                "default": "false"
              }
            }
          }
        }
      },
      "jsonPathMatch": {
        "desc": "Extracts fields or array elements from JSON strings using JSONPath syntax.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.trim().str.jsonPathMatch(\"$\").alias(\"val\"))\nshape: (2, 2)\n+-------------+---------+\n| s           | val     |\n+-------------+---------+\n| \"  hello  \" | \"hello\" |\n| \"  world  \" | \"world\" |\n+-------------+---------+"
        ],
        "params": [
          {
            "name": "jsonPath",
            "desc": "The JSONPath expression (e.g. `\"$.store.book[0].title\"` or `\"$.a.b\"`)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "jsonPathMatch",
        "callExpression": ".str.jsonPathMatch()",
        "signature": "$df.col(<column_name>).str.jsonPathMatch(jsonPath: string)",
        "signatureDetailed": "$df.col(<column_name>).str.jsonPathMatch(jsonPath: string)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 513,
        "lineEnd": 515,
        "typeTree": {
          "jsonPath": {
            "type": "string",
            "optional": false,
            "desc": "The JSONPath expression (e.g. `\"$.store.book[0].title\"` or `\"$.a.b\"`)."
          }
        }
      },
      "len": {
        "desc": "Returns string length in UTF-16 code units. Alias for lenChars.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.len().alias(\"length\"))\nshape: (3, 2)\n+----------+--------+\n| s        | length |\n+----------+--------+\n| \"apple\"  | 5      |\n| \"banana\" | 6      |\n| \"cherry\" | 6      |\n+----------+--------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "len",
        "callExpression": ".str.len()",
        "signature": "$df.col(<column_name>).str.len()",
        "signatureDetailed": "$df.col(<column_name>).str.len()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 532,
        "lineEnd": 534
      },
      "lenBytes": {
        "desc": "Returns string length in UTF-8 encoded bytes.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.lenBytes().alias(\"bytes\"))\nshape: (3, 2)\n+----------+-------+\n| s        | bytes |\n+----------+-------+\n| \"apple\"  | 5     |\n| \"banana\" | 6     |\n| \"cherry\" | 6     |\n+----------+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "lenBytes",
        "callExpression": ".str.lenBytes()",
        "signature": "$df.col(<column_name>).str.lenBytes()",
        "signatureDetailed": "$df.col(<column_name>).str.lenBytes()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 551,
        "lineEnd": 553
      },
      "lenChars": {
        "desc": "Returns string length in character count.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.lenChars().alias(\"length\"))\nshape: (3, 2)\n+----------+--------+\n| s        | length |\n+----------+--------+\n| \"apple\"  | 5      |\n| \"banana\" | 6      |\n| \"cherry\" | 6      |\n+----------+--------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "lenChars",
        "callExpression": ".str.lenChars()",
        "signature": "$df.col(<column_name>).str.lenChars()",
        "signatureDetailed": "$df.col(<column_name>).str.lenChars()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 570,
        "lineEnd": 572
      },
      "lower": {
        "desc": "Converts strings to lowercase.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.lower().alias(\"lowered\"))\nshape: (3, 2)\n+-------------+-----------+\n| s           | lowered   |\n+-------------+-----------+\n| \"HELLO\"     | hello     |\n| \"World\"     | world     |\n| \"df-script\" | df-script |\n+-------------+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "lower",
        "callExpression": ".str.lower()",
        "signature": "$df.col(<column_name>).str.lower()",
        "signatureDetailed": "$df.col(<column_name>).str.lower()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 589,
        "lineEnd": 591
      },
      "lpad": {
        "desc": "Pads start of strings to specified width.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.lpad(8, \"_\").alias(\"padded\"))\nshape: (3, 2)\n+----------+----------+\n| s        | padded   |\n+----------+----------+\n| \"apple\"  | ___apple |\n| \"banana\" | __banana |\n| \"cherry\" | __cherry |\n+----------+----------+"
        ],
        "params": [
          {
            "name": "width",
            "desc": "Minimum resulting string length."
          },
          {
            "name": "fill",
            "desc": "Character sequence used for padding."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "lpad",
        "callExpression": ".str.lpad()",
        "signature": "$df.col(<column_name>).str.lpad(\n  width: number,\n  fill: string = \" \"\n)",
        "signatureDetailed": "$df.col(<column_name>).str.lpad(\n  width: number,\n  fill: string = \" \"\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 610,
        "lineEnd": 612,
        "typeTree": {
          "width": {
            "type": "number",
            "optional": false,
            "desc": "Minimum resulting string length."
          },
          "fill": {
            "type": "string",
            "optional": true,
            "default": "\" \"",
            "desc": "Character sequence used for padding."
          }
        }
      },
      "normalize": {
        "desc": "Normalizes Unicode strings using standard normalization forms (NFC, NFD, NFKC, NFKD).",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.normalize(\"NFC\").alias(\"normalized\"))\nshape: (3, 2)\n+-------------+------------+\n| s           | normalized |\n+-------------+------------+\n| \"HELLO\"     | HELLO      |\n| \"World\"     | World      |\n| \"df-script\" | df-script  |\n+-------------+------------+"
        ],
        "params": [
          {
            "name": "form",
            "desc": "The Unicode normalization form to apply (\"NFC\", \"NFD\", \"NFKC\", or \"NFKD\"). Default is \"NFC\"."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "normalize",
        "callExpression": ".str.normalize()",
        "signature": "$df.col(<column_name>).str.normalize(form: UnicodeNormalizeForm = \"NFC\")",
        "signatureDetailed": "$df.col(<column_name>).str.normalize(form: \"NFC\" | \"NFD\" | \"NFKC\" | \"NFKD\" = \"NFC\")",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 631,
        "lineEnd": 633,
        "typeTree": {
          "form": {
            "type": "UnicodeNormalizeForm",
            "optional": true,
            "default": "\"NFC\"",
            "desc": "The Unicode normalization form to apply (\"NFC\", \"NFD\", \"NFKC\", or \"NFKD\"). Default is \"NFC\".",
            "resolvedType": "\"NFC\" | \"NFD\" | \"NFKC\" | \"NFKD\""
          }
        }
      },
      "padEnd": {
        "desc": "Pads end of strings to specified width. Alias for rpad.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.padEnd(8, \"_\").alias(\"padded\"))\nshape: (3, 2)\n+----------+----------+\n| s        | padded   |\n+----------+----------+\n| \"apple\"  | apple___ |\n| \"banana\" | banana__ |\n| \"cherry\" | cherry__ |\n+----------+----------+"
        ],
        "params": [
          {
            "name": "width",
            "desc": "Target string length."
          },
          {
            "name": "fill",
            "desc": "Character sequence used for padding."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "padEnd",
        "callExpression": ".str.padEnd()",
        "signature": "$df.col(<column_name>).str.padEnd(\n  width: number,\n  fill: string = \" \"\n)",
        "signatureDetailed": "$df.col(<column_name>).str.padEnd(\n  width: number,\n  fill: string = \" \"\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 652,
        "lineEnd": 654,
        "typeTree": {
          "width": {
            "type": "number",
            "optional": false,
            "desc": "Target string length."
          },
          "fill": {
            "type": "string",
            "optional": true,
            "default": "\" \"",
            "desc": "Character sequence used for padding."
          }
        }
      },
      "padStart": {
        "desc": "Pads start of strings to specified width. Alias for lpad.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.padStart(8, \"_\").alias(\"padded\"))\nshape: (3, 2)\n+----------+----------+\n| s        | padded   |\n+----------+----------+\n| \"apple\"  | ___apple |\n| \"banana\" | __banana |\n| \"cherry\" | __cherry |\n+----------+----------+"
        ],
        "params": [
          {
            "name": "width",
            "desc": "Target string length."
          },
          {
            "name": "fill",
            "desc": "Character sequence used for padding."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "padStart",
        "callExpression": ".str.padStart()",
        "signature": "$df.col(<column_name>).str.padStart(\n  width: number,\n  fill: string = \" \"\n)",
        "signatureDetailed": "$df.col(<column_name>).str.padStart(\n  width: number,\n  fill: string = \" \"\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 673,
        "lineEnd": 675,
        "typeTree": {
          "width": {
            "type": "number",
            "optional": false,
            "desc": "Target string length."
          },
          "fill": {
            "type": "string",
            "optional": true,
            "default": "\" \"",
            "desc": "Character sequence used for padding."
          }
        }
      },
      "replace": {
        "desc": "Replaces the first occurrence matching a string pattern.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"email\").str.replace(\"example\", \"test\").alias(\"updated\"))\nshape: (2, 2)\n+------------------+---------------+\n| email            | updated       |\n+------------------+---------------+\n| user@example.com | user@test.com |\n| admin@test.org   | admin@test.org|\n+------------------+---------------+"
        ],
        "params": [
          {
            "name": "pattern",
            "desc": "The search pattern string or regular expression."
          },
          {
            "name": "replacement",
            "desc": "The string value or match replacement function."
          },
          {
            "name": "options",
            "desc": "Optional replace options (literal, asciiCaseInsensitive, n)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "replace",
        "callExpression": ".str.replace()",
        "signature": "$df.col(<column_name>).str.replace(\n  pattern: RegexPatternArg,\n  replacement: StringReplacementArg,\n  options?: ReplaceOptions\n)",
        "signatureDetailed": "$df.col(<column_name>).str.replace(\n  pattern: string | RegExp,\n  replacement: string | StringReplacerFn,\n  options?: {\n    asciiCaseInsensitive?: boolean = false,\n    global?: boolean = false,\n    literal?: boolean = false,\n    mode?: \"tc39\" | \"nonAlphanumericAscii\" = \"tc39\",\n    n?: number = 1\n  }\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 694,
        "lineEnd": 700,
        "typeTree": {
          "pattern": {
            "type": "RegexPatternArg",
            "optional": false,
            "desc": "The search pattern string or regular expression.",
            "resolvedType": "string | RegExp"
          },
          "replacement": {
            "type": "StringReplacementArg",
            "optional": false,
            "desc": "The string value or match replacement function.",
            "resolvedType": "string | StringReplacerFn"
          },
          "options": {
            "type": "ReplaceOptions",
            "optional": true,
            "desc": "Optional replace options (literal, asciiCaseInsensitive, n).",
            "properties": {
              "asciiCaseInsensitive": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether matching should be case-insensitive for ASCII characters.",
                "default": "false"
              },
              "global": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether to replace all matches globally.",
                "default": "false"
              },
              "literal": {
                "type": "boolean",
                "optional": true,
                "desc": "Treat pattern as a literal substring instead of a regular expression.",
                "default": "false"
              },
              "mode": {
                "type": "EscapeRegexMode",
                "optional": true,
                "desc": "Escaping mode when `literal` is `true`.",
                "default": "\"tc39\"",
                "resolvedType": "\"tc39\" | \"nonAlphanumericAscii\""
              },
              "n": {
                "type": "number",
                "optional": true,
                "desc": "Maximum number of occurrences to replace (`-1` or `Infinity` replaces all).",
                "default": "1"
              }
            }
          }
        }
      },
      "replaceAll": {
        "desc": "Replaces all occurrences matching a string pattern or global regular expression.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.replaceAll(\"a\", \"@\").alias(\"replaced\"))\nshape: (3, 2)\n+----------+----------+\n| s        | replaced |\n+----------+----------+\n| \"apple\"  | @pple    |\n| \"banana\" | b@n@n@   |\n| \"cherry\" | cherry   |\n+----------+----------+"
        ],
        "params": [
          {
            "name": "pattern",
            "desc": "The search pattern string or regular expression."
          },
          {
            "name": "replacement",
            "desc": "The replacement value."
          },
          {
            "name": "options",
            "desc": "Optional replace options (literal, asciiCaseInsensitive)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "replaceAll",
        "callExpression": ".str.replaceAll()",
        "signature": "$df.col(<column_name>).str.replaceAll(\n  pattern: RegexPatternArg,\n  replacement: StringReplacementArg,\n  options: ReplaceAllOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).str.replaceAll(\n  pattern: string | RegExp,\n  replacement: string | StringReplacerFn,\n  options: {\n    asciiCaseInsensitive?: boolean = false,\n    global?: boolean = false,\n    literal?: boolean = false,\n    mode?: \"tc39\" | \"nonAlphanumericAscii\" = \"tc39\"\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 720,
        "lineEnd": 726,
        "typeTree": {
          "pattern": {
            "type": "RegexPatternArg",
            "optional": false,
            "desc": "The search pattern string or regular expression.",
            "resolvedType": "string | RegExp"
          },
          "replacement": {
            "type": "StringReplacementArg",
            "optional": false,
            "desc": "The replacement value.",
            "resolvedType": "string | StringReplacerFn"
          },
          "options": {
            "type": "ReplaceAllOptions",
            "optional": true,
            "default": "{}",
            "desc": "Optional replace options (literal, asciiCaseInsensitive).",
            "properties": {
              "asciiCaseInsensitive": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether matching should be case-insensitive for ASCII characters.",
                "default": "false"
              },
              "global": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether to replace all matches globally.",
                "default": "false"
              },
              "literal": {
                "type": "boolean",
                "optional": true,
                "desc": "Treat pattern as a literal substring instead of a regular expression.",
                "default": "false"
              },
              "mode": {
                "type": "EscapeRegexMode",
                "optional": true,
                "desc": "Escaping mode when `literal` is `true`.",
                "default": "\"tc39\"",
                "resolvedType": "\"tc39\" | \"nonAlphanumericAscii\""
              }
            }
          }
        }
      },
      "replaceMany": {
        "desc": "Replaces multiple string patterns simultaneously or sequentially with their respective replacements. Matches Polars `.str.replaceMany()` behavior, accepting pattern/replacement arrays or a pattern-to-replacement map dictionary.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.replaceMany([\"apple\", \"banana\"], [\"1\", \"2\"]).alias(\"res\"))\nshape: (3, 2)\n+----------+--------+\n| s        | res    |\n+----------+--------+\n| \"apple\"  | 1      |\n| \"banana\" | 2      |\n| \"cherry\" | cherry |\n+----------+--------+"
        ],
        "params": [
          {
            "name": "patterns",
            "desc": "Array of patterns or an object mapping target patterns to replacements."
          },
          {
            "name": "replacements",
            "desc": "Array of replacement strings/callbacks (when patterns is an array)."
          },
          {
            "name": "options",
            "desc": "Configuration options ({ literal, asciiCaseInsensitive, mode })."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "replaceMany",
        "callExpression": ".str.replaceMany()",
        "signature": "$df.col(<column_name>).str.replaceMany(\n  patterns: RegexPatternSeriesArg | Record<string, string>,\n  replacements?: StringReplacementSeriesArg,\n  options?: ReplaceManyOptions\n)",
        "signatureDetailed": "$df.col(<column_name>).str.replaceMany(\n  patterns: RegexPatternSeriesArg | Record<string, string>,\n  replacements?: (string | StringReplacerFn)[],\n  options?: {\n    asciiCaseInsensitive?: boolean = false,\n    global?: boolean = false,\n    groupIndex?: number | string = 0,\n    leftmost?: boolean = false,\n    literal?: boolean = false,\n    mode?: \"tc39\" | \"nonAlphanumericAscii\" = \"tc39\",\n    overlapping?: boolean = false\n  }\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 747,
        "lineEnd": 753,
        "typeTree": {
          "patterns": {
            "type": "RegexPatternSeriesArg | Record<string, string>",
            "optional": false,
            "desc": "Array of patterns or an object mapping target patterns to replacements."
          },
          "replacements": {
            "type": "StringReplacementSeriesArg",
            "optional": true,
            "desc": "Array of replacement strings/callbacks (when patterns is an array).",
            "resolvedType": "(string | StringReplacerFn)[]"
          },
          "options": {
            "type": "ReplaceManyOptions",
            "optional": true,
            "desc": "Configuration options ({ literal, asciiCaseInsensitive, mode }).",
            "properties": {
              "asciiCaseInsensitive": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether matching should be case-insensitive for ASCII characters.",
                "default": "false"
              },
              "global": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether to replace all matches globally.",
                "default": "false"
              },
              "groupIndex": {
                "type": "ColumnIndexOrNameArg",
                "optional": true,
                "desc": "0-based index or name of the capture group to replace.",
                "default": "0",
                "resolvedType": "number | string"
              },
              "leftmost": {
                "type": "boolean",
                "optional": true,
                "desc": "Guarantees that the leftmost match is selected when multiple patterns match.",
                "default": "false"
              },
              "literal": {
                "type": "boolean",
                "optional": true,
                "desc": "Treat patterns as literal substrings instead of regular expressions.",
                "default": "false"
              },
              "mode": {
                "type": "EscapeRegexMode",
                "optional": true,
                "desc": "Escaping mode when `literal` is `true`.",
                "default": "\"tc39\"",
                "resolvedType": "\"tc39\" | \"nonAlphanumericAscii\""
              },
              "overlapping": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether overlapping matches across patterns are allowed.",
                "default": "false"
              }
            }
          }
        }
      },
      "reverse": {
        "desc": "Reverses characters in each string element.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.reverse().alias(\"rev\"))\nshape: (3, 2)\n+----------+--------+\n| s        | rev    |\n+----------+--------+\n| \"apple\"  | elppa  |\n| \"banana\" | ananab |\n| \"cherry\" | yrrehc |\n+----------+--------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "reverse",
        "callExpression": ".str.reverse()",
        "signature": "$df.col(<column_name>).str.reverse()",
        "signatureDetailed": "$df.col(<column_name>).str.reverse()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 770,
        "lineEnd": 772
      },
      "rpad": {
        "desc": "Pads end of strings to specified width.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.rpad(8, \"_\").alias(\"padded\"))\nshape: (3, 2)\n+----------+----------+\n| s        | padded   |\n+----------+----------+\n| \"apple\"  | apple___ |\n| \"banana\" | banana__ |\n| \"cherry\" | cherry__ |\n+----------+----------+"
        ],
        "params": [
          {
            "name": "width",
            "desc": "Minimum resulting string length."
          },
          {
            "name": "fill",
            "desc": "Character sequence used for padding."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "rpad",
        "callExpression": ".str.rpad()",
        "signature": "$df.col(<column_name>).str.rpad(\n  width: number,\n  fill: string = \" \"\n)",
        "signatureDetailed": "$df.col(<column_name>).str.rpad(\n  width: number,\n  fill: string = \" \"\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 791,
        "lineEnd": 793,
        "typeTree": {
          "width": {
            "type": "number",
            "optional": false,
            "desc": "Minimum resulting string length."
          },
          "fill": {
            "type": "string",
            "optional": true,
            "default": "\" \"",
            "desc": "Character sequence used for padding."
          }
        }
      },
      "slice": {
        "desc": "Extracts a substring slice using start offset and length.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.slice(0, 3).alias(\"sub\"))\nshape: (3, 2)\n+----------+-----+\n| s        | sub |\n+----------+-----+\n| \"apple\"  | app |\n| \"banana\" | ban |\n| \"cherry\" | che |\n+----------+-----+"
        ],
        "params": [
          {
            "name": "offset",
            "desc": "Starting position index."
          },
          {
            "name": "length",
            "desc": "Number of characters to include."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "slice",
        "callExpression": ".str.slice()",
        "signature": "$df.col(<column_name>).str.slice(\n  offset: number,\n  length?: number\n)",
        "signatureDetailed": "$df.col(<column_name>).str.slice(\n  offset: number,\n  length?: number\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 812,
        "lineEnd": 818,
        "typeTree": {
          "offset": {
            "type": "number",
            "optional": false,
            "desc": "Starting position index."
          },
          "length": {
            "type": "number",
            "optional": true,
            "desc": "Number of characters to include."
          }
        }
      },
      "split": {
        "desc": "Splits strings into lists by delimiter with optional limit and exact padding.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"email\").str.split(\"@\").alias(\"parts\"))\nshape: (2, 2)\n+------------------+------------------------+\n| email            | parts                  |\n+------------------+------------------------+\n| user@example.com | [\"user\", \"example.com\"]|\n| admin@test.org   | [\"admin\", \"test.org\"]  |\n+------------------+------------------------+"
        ],
        "params": [
          {
            "name": "delimiter",
            "desc": "Substring delimiter."
          },
          {
            "name": "options",
            "desc": "Options for controlling limit and exact padding."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "split",
        "callExpression": ".str.split()",
        "signature": "$df.col(<column_name>).str.split(\n  delimiter: string,\n  options?: SplitOptions\n)",
        "signatureDetailed": "$df.col(<column_name>).str.split(\n  delimiter: string,\n  options?: {\n    asciiCaseInsensitive?: boolean = false,\n    exact?: boolean = false,\n    global?: boolean = false,\n    inclusive?: boolean = false,\n    limit?: number,\n    literal?: boolean = true,\n    mode?: \"tc39\" | \"nonAlphanumericAscii\" = \"tc39\",\n    strict?: boolean = false\n  }\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 836,
        "lineEnd": 838,
        "typeTree": {
          "delimiter": {
            "type": "string",
            "optional": false,
            "desc": "Substring delimiter."
          },
          "options": {
            "type": "SplitOptions",
            "optional": true,
            "desc": "Options for controlling limit and exact padding.",
            "properties": {
              "asciiCaseInsensitive": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether matching should be case-insensitive for ASCII characters.",
                "default": "false"
              },
              "exact": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, pads missing splits with `null` to guarantee `limit + 1` elements.",
                "default": "false"
              },
              "global": {
                "type": "boolean",
                "optional": true,
                "desc": "Whether to match globally.",
                "default": "false"
              },
              "inclusive": {
                "type": "boolean",
                "optional": true,
                "desc": "Include matched delimiter substrings in the split output array.",
                "default": "false"
              },
              "limit": {
                "type": "number",
                "optional": true,
                "desc": "Maximum number of splits to perform."
              },
              "literal": {
                "type": "boolean",
                "optional": true,
                "desc": "Treat delimiter as a literal substring (`true`) or regular expression (`false`).",
                "default": "true"
              },
              "mode": {
                "type": "EscapeRegexMode",
                "optional": true,
                "desc": "Escaping mode when `literal` is `true`.",
                "default": "\"tc39\"",
                "resolvedType": "\"tc39\" | \"nonAlphanumericAscii\""
              },
              "strict": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, throws an `InvalidArgumentError` when the split yields fewer than `limit + 1` elements.",
                "default": "false"
              }
            }
          }
        }
      },
      "startsWith": {
        "desc": "Checks if string starts with a prefix.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.startsWith(\"a\").alias(\"starts_a\"))\nshape: (3, 2)\n+----------+----------+\n| s        | starts_a |\n+----------+----------+\n| \"apple\"  | true     |\n| \"banana\" | false    |\n| \"cherry\" | false    |\n+----------+----------+"
        ],
        "params": [
          {
            "name": "prefix",
            "desc": "The prefix substring."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "startsWith",
        "callExpression": ".str.startsWith()",
        "signature": "$df.col(<column_name>).str.startsWith(prefix: string)",
        "signatureDetailed": "$df.col(<column_name>).str.startsWith(prefix: string)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 856,
        "lineEnd": 858,
        "typeTree": {
          "prefix": {
            "type": "string",
            "optional": false,
            "desc": "The prefix substring."
          }
        }
      },
      "stripChars": {
        "desc": "Strips matching characters from start and end of string.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.stripChars().alias(\"stripped\"))\nshape: (2, 2)\n+-------------+----------+\n| s           | stripped |\n+-------------+----------+\n| \"  hello  \" | hello    |\n| \"  world  \" | world    |\n+-------------+----------+"
        ],
        "params": [
          {
            "name": "characters",
            "desc": "Characters or regex pattern to strip."
          },
          {
            "name": "options",
            "desc": "Configuration options for strip operation."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "stripChars",
        "callExpression": ".str.stripChars()",
        "signature": "$df.col(<column_name>).str.stripChars(\n  characters?: RegexPatternArg,\n  options?: StripCharsOptions\n)",
        "signatureDetailed": "$df.col(<column_name>).str.stripChars(\n  characters?: string | RegExp,\n  options?: {\n    maxMatchesEnd?: number | null,\n    maxMatchesStart?: number | null,\n    maxScanEnd?: number | null,\n    maxScanStart?: number | null,\n    mode?: \"both\" | \"start\" | \"end\" = \"both\",\n    returnStringOnNull?: boolean = false,\n    stringOptions?: {\n      caseInsensitive?: boolean = false,\n      literal?: boolean = false\n    },\n    trimFirst?: boolean = false\n  }\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 876,
        "lineEnd": 878,
        "typeTree": {
          "characters": {
            "type": "RegexPatternArg",
            "optional": true,
            "desc": "Characters or regex pattern to strip.",
            "resolvedType": "string | RegExp"
          },
          "options": {
            "type": "StripCharsOptions",
            "optional": true,
            "desc": "Configuration options for strip operation.",
            "properties": {
              "maxMatchesEnd": {
                "type": "number | null",
                "optional": true,
                "desc": "Maximum number of non-contiguous matching blocks allowed to be stripped from the end (`-1` or `null` strips all)."
              },
              "maxMatchesStart": {
                "type": "number | null",
                "optional": true,
                "desc": "Maximum number of non-contiguous matching blocks allowed to be stripped from the start (`-1` or `null` strips all)."
              },
              "maxScanEnd": {
                "type": "number | null",
                "optional": true,
                "desc": "Maximum number of non-matching characters allowed to be skipped from the end before a match block is found (`-1` or `null` scans full length)."
              },
              "maxScanStart": {
                "type": "number | null",
                "optional": true,
                "desc": "Maximum number of non-matching characters allowed to be skipped from the start before a match block is found (`-1` or `null` scans full length)."
              },
              "mode": {
                "type": "StripMode",
                "optional": true,
                "desc": "Boundary strip mode: `\"both\"`, `\"start\"`, or `\"end\"`.",
                "default": "\"both\"",
                "resolvedType": "\"both\" | \"start\" | \"end\""
              },
              "returnStringOnNull": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, returns `\"\"` instead of `null` when the stripped result is empty or input is `null`.",
                "default": "false"
              },
              "stringOptions": {
                "type": "object",
                "optional": true,
                "desc": "Options that apply only when `characters` is a string (and not a `RegExp`).",
                "properties": {
                  "caseInsensitive": {
                    "type": "boolean",
                    "optional": true,
                    "desc": "* If `true`, performs case-insensitive character and substring matching. * @default false",
                    "default": "false"
                  },
                  "literal": {
                    "type": "boolean",
                    "optional": true,
                    "desc": "* If `true`, treats `characters` as a literal substring rather than a set of characters. * @default false",
                    "default": "false"
                  }
                }
              },
              "trimFirst": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, trims standard whitespace first before performing character stripping.",
                "default": "false"
              }
            }
          }
        }
      },
      "stripCharsEnd": {
        "desc": "Strips matching characters from end of string.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.stripCharsEnd().alias(\"stripped\"))\nshape: (2, 2)\n+-------------+----------+\n| s           | stripped |\n+-------------+----------+\n| \"  hello  \" | \"  hello\" |\n| \"  world  \" | \"  world\" |\n+-------------+----------+"
        ],
        "params": [
          {
            "name": "characters",
            "desc": "Characters or regex pattern to strip."
          },
          {
            "name": "options",
            "desc": "Configuration options."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "stripCharsEnd",
        "callExpression": ".str.stripCharsEnd()",
        "signature": "$df.col(<column_name>).str.stripCharsEnd(\n  characters?: RegexPatternArg,\n  options?: StripCharsOptions\n)",
        "signatureDetailed": "$df.col(<column_name>).str.stripCharsEnd(\n  characters?: string | RegExp,\n  options?: {\n    maxMatchesEnd?: number | null,\n    maxMatchesStart?: number | null,\n    maxScanEnd?: number | null,\n    maxScanStart?: number | null,\n    mode?: \"both\" | \"start\" | \"end\" = \"both\",\n    returnStringOnNull?: boolean = false,\n    stringOptions?: {\n      caseInsensitive?: boolean = false,\n      literal?: boolean = false\n    },\n    trimFirst?: boolean = false\n  }\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 896,
        "lineEnd": 898,
        "typeTree": {
          "characters": {
            "type": "RegexPatternArg",
            "optional": true,
            "desc": "Characters or regex pattern to strip.",
            "resolvedType": "string | RegExp"
          },
          "options": {
            "type": "StripCharsOptions",
            "optional": true,
            "desc": "Configuration options.",
            "properties": {
              "maxMatchesEnd": {
                "type": "number | null",
                "optional": true,
                "desc": "Maximum number of non-contiguous matching blocks allowed to be stripped from the end (`-1` or `null` strips all)."
              },
              "maxMatchesStart": {
                "type": "number | null",
                "optional": true,
                "desc": "Maximum number of non-contiguous matching blocks allowed to be stripped from the start (`-1` or `null` strips all)."
              },
              "maxScanEnd": {
                "type": "number | null",
                "optional": true,
                "desc": "Maximum number of non-matching characters allowed to be skipped from the end before a match block is found (`-1` or `null` scans full length)."
              },
              "maxScanStart": {
                "type": "number | null",
                "optional": true,
                "desc": "Maximum number of non-matching characters allowed to be skipped from the start before a match block is found (`-1` or `null` scans full length)."
              },
              "mode": {
                "type": "StripMode",
                "optional": true,
                "desc": "Boundary strip mode: `\"both\"`, `\"start\"`, or `\"end\"`.",
                "default": "\"both\"",
                "resolvedType": "\"both\" | \"start\" | \"end\""
              },
              "returnStringOnNull": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, returns `\"\"` instead of `null` when the stripped result is empty or input is `null`.",
                "default": "false"
              },
              "stringOptions": {
                "type": "object",
                "optional": true,
                "desc": "Options that apply only when `characters` is a string (and not a `RegExp`).",
                "properties": {
                  "caseInsensitive": {
                    "type": "boolean",
                    "optional": true,
                    "desc": "* If `true`, performs case-insensitive character and substring matching. * @default false",
                    "default": "false"
                  },
                  "literal": {
                    "type": "boolean",
                    "optional": true,
                    "desc": "* If `true`, treats `characters` as a literal substring rather than a set of characters. * @default false",
                    "default": "false"
                  }
                }
              },
              "trimFirst": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, trims standard whitespace first before performing character stripping.",
                "default": "false"
              }
            }
          }
        }
      },
      "stripCharsStart": {
        "desc": "Strips matching characters from start of string.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.stripCharsStart().alias(\"stripped\"))\nshape: (2, 2)\n+-------------+----------+\n| s           | stripped |\n+-------------+----------+\n| \"  hello  \" | \"hello  \" |\n| \"  world  \" | \"world  \" |\n+-------------+----------+"
        ],
        "params": [
          {
            "name": "characters",
            "desc": "Characters or regex pattern to strip."
          },
          {
            "name": "options",
            "desc": "Configuration options."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "stripCharsStart",
        "callExpression": ".str.stripCharsStart()",
        "signature": "$df.col(<column_name>).str.stripCharsStart(\n  characters?: RegexPatternArg,\n  options?: StripCharsOptions\n)",
        "signatureDetailed": "$df.col(<column_name>).str.stripCharsStart(\n  characters?: string | RegExp,\n  options?: {\n    maxMatchesEnd?: number | null,\n    maxMatchesStart?: number | null,\n    maxScanEnd?: number | null,\n    maxScanStart?: number | null,\n    mode?: \"both\" | \"start\" | \"end\" = \"both\",\n    returnStringOnNull?: boolean = false,\n    stringOptions?: {\n      caseInsensitive?: boolean = false,\n      literal?: boolean = false\n    },\n    trimFirst?: boolean = false\n  }\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 916,
        "lineEnd": 918,
        "typeTree": {
          "characters": {
            "type": "RegexPatternArg",
            "optional": true,
            "desc": "Characters or regex pattern to strip.",
            "resolvedType": "string | RegExp"
          },
          "options": {
            "type": "StripCharsOptions",
            "optional": true,
            "desc": "Configuration options.",
            "properties": {
              "maxMatchesEnd": {
                "type": "number | null",
                "optional": true,
                "desc": "Maximum number of non-contiguous matching blocks allowed to be stripped from the end (`-1` or `null` strips all)."
              },
              "maxMatchesStart": {
                "type": "number | null",
                "optional": true,
                "desc": "Maximum number of non-contiguous matching blocks allowed to be stripped from the start (`-1` or `null` strips all)."
              },
              "maxScanEnd": {
                "type": "number | null",
                "optional": true,
                "desc": "Maximum number of non-matching characters allowed to be skipped from the end before a match block is found (`-1` or `null` scans full length)."
              },
              "maxScanStart": {
                "type": "number | null",
                "optional": true,
                "desc": "Maximum number of non-matching characters allowed to be skipped from the start before a match block is found (`-1` or `null` scans full length)."
              },
              "mode": {
                "type": "StripMode",
                "optional": true,
                "desc": "Boundary strip mode: `\"both\"`, `\"start\"`, or `\"end\"`.",
                "default": "\"both\"",
                "resolvedType": "\"both\" | \"start\" | \"end\""
              },
              "returnStringOnNull": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, returns `\"\"` instead of `null` when the stripped result is empty or input is `null`.",
                "default": "false"
              },
              "stringOptions": {
                "type": "object",
                "optional": true,
                "desc": "Options that apply only when `characters` is a string (and not a `RegExp`).",
                "properties": {
                  "caseInsensitive": {
                    "type": "boolean",
                    "optional": true,
                    "desc": "* If `true`, performs case-insensitive character and substring matching. * @default false",
                    "default": "false"
                  },
                  "literal": {
                    "type": "boolean",
                    "optional": true,
                    "desc": "* If `true`, treats `characters` as a literal substring rather than a set of characters. * @default false",
                    "default": "false"
                  }
                }
              },
              "trimFirst": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, trims standard whitespace first before performing character stripping.",
                "default": "false"
              }
            }
          }
        }
      },
      "stripPrefix": {
        "desc": "Strips matching prefix substring from start of string.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.stripPrefix(\"df-\").alias(\"stripped\"))\nshape: (3, 2)\n+-------------+----------+\n| s           | stripped |\n+-------------+----------+\n| \"HELLO\"     | HELLO    |\n| \"World\"     | World    |\n| \"df-script\" | script   |\n+-------------+----------+"
        ],
        "params": [
          {
            "name": "prefix",
            "desc": "Prefix substring to remove."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "stripPrefix",
        "callExpression": ".str.stripPrefix()",
        "signature": "$df.col(<column_name>).str.stripPrefix(prefix: string)",
        "signatureDetailed": "$df.col(<column_name>).str.stripPrefix(prefix: string)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 936,
        "lineEnd": 946,
        "typeTree": {
          "prefix": {
            "type": "string",
            "optional": false,
            "desc": "Prefix substring to remove."
          }
        }
      },
      "stripSuffix": {
        "desc": "Strips matching suffix substring from end of string.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"email\").str.stripSuffix(\".com\").alias(\"stripped\"))\nshape: (2, 2)\n+------------------+----------------+\n| email            | stripped       |\n+------------------+----------------+\n| user@example.com | user@example   |\n| admin@test.org   | admin@test.org |\n+------------------+----------------+"
        ],
        "params": [
          {
            "name": "suffix",
            "desc": "Suffix substring to remove."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "stripSuffix",
        "callExpression": ".str.stripSuffix()",
        "signature": "$df.col(<column_name>).str.stripSuffix(suffix: string)",
        "signatureDetailed": "$df.col(<column_name>).str.stripSuffix(suffix: string)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 963,
        "lineEnd": 973,
        "typeTree": {
          "suffix": {
            "type": "string",
            "optional": false,
            "desc": "Suffix substring to remove."
          }
        }
      },
      "strptime": {
        "desc": "Parses date/time string into Datetime.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").str.strptime({ format: \"%Y-%m-%d\" }).alias(\"parsed\"))\nshape: (1, 2)\n+------------+--------------------------+\n| d          | parsed                   |\n+------------+--------------------------+\n| 2026-05-20 | 2026-05-20T00:00:00.000Z |\n+------------+--------------------------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Parsing configuration options."
          }
        ],
        "returns": "ColumnExpression",
        "notes": [
          "[Timezone Compatibility]: Direct string parsing with timezone offsets relies on native `Intl.DateTimeFormat` and `Date.UTC`. Unrecognized timezone identifiers safely default to `\"UTC\"`."
        ],
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "strptime",
        "callExpression": ".str.strptime()",
        "signature": "$df.col(<column_name>).str.strptime(options: StrptimeOptions)",
        "signatureDetailed": "$df.col(<column_name>).str.strptime(\n  options: {\n    defaultTimeZone?: string = \"UTC\",\n    format: string,\n    strict?: boolean = true\n  }\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 991,
        "lineEnd": 993,
        "typeTree": {
          "options": {
            "type": "StrptimeOptions",
            "optional": false,
            "desc": "Parsing configuration options.",
            "properties": {
              "defaultTimeZone": {
                "type": "string",
                "optional": true,
                "desc": "Default IANA timezone or UTC offset applied when the parsed string has no `%z`/`%Z` directive.",
                "default": "\"UTC\""
              },
              "format": {
                "type": "string",
                "optional": false,
                "desc": "Format string containing `%` date/time directives (e.g. `\"%Y-%m-%d %H:%M:%S\"`)."
              },
              "strict": {
                "type": "boolean",
                "optional": true,
                "desc": "If `true`, throws an error when a string fails to match `format`; if `false`, returns `null`.",
                "default": "true"
              }
            }
          }
        }
      },
      "tail": {
        "desc": "Extracts the last n characters of each string element.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.tail(3).alias(\"suffix\"))\nshape: (3, 2)\n+----------+--------+\n| s        | suffix |\n+----------+--------+\n| \"apple\"  | ple    |\n| \"banana\" | ana    |\n| \"cherry\" | rry    |\n+----------+--------+"
        ],
        "params": [
          {
            "name": "n",
            "desc": "Number of characters to extract from the end of the string (default 1)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "tail",
        "callExpression": ".str.tail()",
        "signature": "$df.col(<column_name>).str.tail(n: number = 1)",
        "signatureDetailed": "$df.col(<column_name>).str.tail(n: number = 1)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1011,
        "lineEnd": 1013,
        "typeTree": {
          "n": {
            "type": "number",
            "optional": true,
            "default": "1",
            "desc": "Number of characters to extract from the end of the string (default 1)."
          }
        }
      },
      "toCamelCase": {
        "desc": "Converts string casing to camelCase.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.toCamelCase().alias(\"camel\"))\nshape: (3, 2)\n+-------------+-----------+\n| s           | camel     |\n+-------------+-----------+\n| \"HELLO\"     | hello     |\n| \"World\"     | world     |\n| \"df-script\" | dfScript  |\n+-------------+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "toCamelCase",
        "callExpression": ".str.toCamelCase()",
        "signature": "$df.col(<column_name>).str.toCamelCase()",
        "signatureDetailed": "$df.col(<column_name>).str.toCamelCase()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1030,
        "lineEnd": 1032
      },
      "toDate": {
        "desc": "Parses string into Date object.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").str.toDate().alias(\"date\"))\nshape: (1, 2)\n+------------+--------------------------+\n| d          | date                     |\n+------------+--------------------------+\n| 2026-05-20 | 2026-05-20T00:00:00.000Z |\n+------------+--------------------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "toDate",
        "callExpression": ".str.toDate()",
        "signature": "$df.col(<column_name>).str.toDate()",
        "signatureDetailed": "$df.col(<column_name>).str.toDate()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1047,
        "lineEnd": 1049
      },
      "toDatetime": {
        "desc": "Parses string into Datetime value.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").str.toDatetime().alias(\"dt\"))\nshape: (1, 2)\n+------------+--------------------------+\n| d          | dt                       |\n+------------+--------------------------+\n| 2026-05-20 | 2026-05-20T00:00:00.000Z |\n+------------+--------------------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "toDatetime",
        "callExpression": ".str.toDatetime()",
        "signature": "$df.col(<column_name>).str.toDatetime()",
        "signatureDetailed": "$df.col(<column_name>).str.toDatetime()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1064,
        "lineEnd": 1066
      },
      "toDecimal": {
        "desc": "Converts string into numeric decimal representation.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.len().str.toDecimal().alias(\"num\"))\nshape: (3, 2)\n+----------+-----+\n| s        | num |\n+----------+-----+\n| \"apple\"  | 5   |\n| \"banana\" | 6   |\n| \"cherry\" | 6   |\n+----------+-----+"
        ],
        "params": [
          {
            "name": "precision",
            "desc": "Optional precision limit."
          },
          {
            "name": "scale",
            "desc": "Optional scale limit."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "toDecimal",
        "callExpression": ".str.toDecimal()",
        "signature": "$df.col(<column_name>).str.toDecimal(\n  precision?: number,\n  scale?: number\n)",
        "signatureDetailed": "$df.col(<column_name>).str.toDecimal(\n  precision?: number,\n  scale?: number\n)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1085,
        "lineEnd": 1087,
        "typeTree": {
          "precision": {
            "type": "number",
            "optional": true,
            "desc": "Optional precision limit."
          },
          "scale": {
            "type": "number",
            "optional": true,
            "desc": "Optional scale limit."
          }
        }
      },
      "toInteger": {
        "desc": "Parses string into integer number.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.len().str.toInteger().alias(\"num\"))\nshape: (3, 2)\n+----------+-----+\n| s        | num |\n+----------+-----+\n| \"apple\"  | 5   |\n| \"banana\" | 6   |\n| \"cherry\" | 6   |\n+----------+-----+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "toInteger",
        "callExpression": ".str.toInteger()",
        "signature": "$df.col(<column_name>).str.toInteger()",
        "signatureDetailed": "$df.col(<column_name>).str.toInteger()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1104,
        "lineEnd": 1106
      },
      "toKebabCase": {
        "desc": "Converts string casing to kebab-case.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.toKebabCase().alias(\"kebab\"))\nshape: (3, 2)\n+-------------+-----------+\n| s           | kebab     |\n+-------------+-----------+\n| \"HELLO\"     | hello     |\n| \"World\"     | world     |\n| \"df-script\" | df-script |\n+-------------+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "toKebabCase",
        "callExpression": ".str.toKebabCase()",
        "signature": "$df.col(<column_name>).str.toKebabCase()",
        "signatureDetailed": "$df.col(<column_name>).str.toKebabCase()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1123,
        "lineEnd": 1125
      },
      "toLowerCase": {
        "desc": "Converts all string elements in the column to lowercase.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.toLowerCase().alias(\"lower_name\"))\nshape: (3, 2)\n+-------------+------------+\n| s           | lower_name |\n+-------------+------------+\n| \"HELLO\"     | hello      |\n| \"World\"     | world      |\n| \"df-script\" | df-script  |\n+-------------+------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "toLowerCase",
        "callExpression": ".str.toLowerCase()",
        "signature": "$df.col(<column_name>).str.toLowerCase()",
        "signatureDetailed": "$df.col(<column_name>).str.toLowerCase()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1142,
        "lineEnd": 1144
      },
      "toPascalCase": {
        "desc": "Converts string casing to PascalCase.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.toPascalCase().alias(\"pascal\"))\nshape: (3, 2)\n+-------------+-----------+\n| s           | pascal    |\n+-------------+-----------+\n| \"HELLO\"     | Hello     |\n| \"World\"     | World     |\n| \"df-script\" | DfScript  |\n+-------------+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "toPascalCase",
        "callExpression": ".str.toPascalCase()",
        "signature": "$df.col(<column_name>).str.toPascalCase()",
        "signatureDetailed": "$df.col(<column_name>).str.toPascalCase()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1161,
        "lineEnd": 1163
      },
      "toSnakeCase": {
        "desc": "Converts string casing to snake_case.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.toSnakeCase().alias(\"snake\"))\nshape: (3, 2)\n+-------------+-----------+\n| s           | snake     |\n+-------------+-----------+\n| \"HELLO\"     | hello     |\n| \"World\"     | world     |\n| \"df-script\" | df_script |\n+-------------+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "toSnakeCase",
        "callExpression": ".str.toSnakeCase()",
        "signature": "$df.col(<column_name>).str.toSnakeCase()",
        "signatureDetailed": "$df.col(<column_name>).str.toSnakeCase()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1180,
        "lineEnd": 1182
      },
      "toTime": {
        "desc": "Parses string into time component representation.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.toTime().alias(\"time\"))\nshape: (3, 2)\n+----------+------+\n| s        | time |\n+----------+------+\n| \"apple\"  | null |\n| \"banana\" | null |\n| \"cherry\" | null |\n+----------+------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "toTime",
        "callExpression": ".str.toTime()",
        "signature": "$df.col(<column_name>).str.toTime()",
        "signatureDetailed": "$df.col(<column_name>).str.toTime()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1199,
        "lineEnd": 1201
      },
      "toTitleCase": {
        "desc": "Converts string casing to Title Case.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.toTitleCase().alias(\"title\"))\nshape: (3, 2)\n+-------------+-----------+\n| s           | title     |\n+-------------+-----------+\n| \"HELLO\"     | Hello     |\n| \"World\"     | World     |\n| \"df-script\" | Df Script |\n+-------------+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "toTitleCase",
        "callExpression": ".str.toTitleCase()",
        "signature": "$df.col(<column_name>).str.toTitleCase()",
        "signatureDetailed": "$df.col(<column_name>).str.toTitleCase()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1218,
        "lineEnd": 1220
      },
      "toUpperCase": {
        "desc": "Converts all string elements in the column to uppercase.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.toUpperCase().alias(\"upper\"))\nshape: (3, 2)\n+-------------+-----------+\n| s           | upper     |\n+-------------+-----------+\n| \"HELLO\"     | HELLO     |\n| \"World\"     | WORLD     |\n| \"df-script\" | DF-SCRIPT |\n+-------------+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "toUpperCase",
        "callExpression": ".str.toUpperCase()",
        "signature": "$df.col(<column_name>).str.toUpperCase()",
        "signatureDetailed": "$df.col(<column_name>).str.toUpperCase()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1237,
        "lineEnd": 1239
      },
      "trim": {
        "desc": "Trims leading and trailing whitespace characters from each string element.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.trim().alias(\"clean\"))\nshape: (2, 2)\n+-------------+-------+\n| s           | clean |\n+-------------+-------+\n| \"  hello  \" | hello |\n| \"  world  \" | world |\n+-------------+-------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "trim",
        "callExpression": ".str.trim()",
        "signature": "$df.col(<column_name>).str.trim()",
        "signatureDetailed": "$df.col(<column_name>).str.trim()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1255,
        "lineEnd": 1257
      },
      "trimEnd": {
        "desc": "Trims trailing whitespace characters from each string element.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.trimEnd().alias(\"clean\"))\nshape: (2, 2)\n+-------------+----------+\n| s           | clean    |\n+-------------+----------+\n| \"  hello  \" | \"  hello\" |\n| \"  world  \" | \"  world\" |\n+-------------+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "trimEnd",
        "callExpression": ".str.trimEnd()",
        "signature": "$df.col(<column_name>).str.trimEnd()",
        "signatureDetailed": "$df.col(<column_name>).str.trimEnd()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1273,
        "lineEnd": 1275
      },
      "trimStart": {
        "desc": "Trims leading whitespace characters from each string element.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.trimStart().alias(\"clean\"))\nshape: (2, 2)\n+-------------+----------+\n| s           | clean    |\n+-------------+----------+\n| \"  hello  \" | \"hello  \"|\n| \"  world  \" | \"world  \"|\n+-------------+----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "trimStart",
        "callExpression": ".str.trimStart()",
        "signature": "$df.col(<column_name>).str.trimStart()",
        "signatureDetailed": "$df.col(<column_name>).str.trimStart()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1291,
        "lineEnd": 1293
      },
      "upper": {
        "desc": "Converts string to uppercase.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.upper().alias(\"upper\"))\nshape: (3, 2)\n+-------------+-----------+\n| s           | upper     |\n+-------------+-----------+\n| \"HELLO\"     | HELLO     |\n| \"World\"     | WORLD     |\n| \"df-script\" | DF-SCRIPT |\n+-------------+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "upper",
        "callExpression": ".str.upper()",
        "signature": "$df.col(<column_name>).str.upper()",
        "signatureDetailed": "$df.col(<column_name>).str.upper()",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1310,
        "lineEnd": 1312
      },
      "zfill": {
        "desc": "Pads start of string with zeros to target width.",
        "examples": [
          ">>> const df = $df.data({ s: [\"apple\", \"banana\", \"cherry\"] })\n>>> df\nshape: (3, 1)\n+----------+\n| s        |\n+----------+\n| \"apple\"  |\n| \"banana\" |\n| \"cherry\" |\n+----------+\n>>> df.withColumns($df.col(\"s\").str.zfill(8).alias(\"padded\"))\nshape: (3, 2)\n+----------+----------+\n| s        | padded   |\n+----------+----------+\n| \"apple\"  | 000apple |\n| \"banana\" | 00banana |\n| \"cherry\" | 00cherry |\n+----------+----------+"
        ],
        "params": [
          {
            "name": "width",
            "desc": "Minimum resulting string width."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "str",
        "category": "ColumnExpression",
        "propertyAccess": "zfill",
        "callExpression": ".str.zfill()",
        "signature": "$df.col(<column_name>).str.zfill(width: number)",
        "signatureDetailed": "$df.col(<column_name>).str.zfill(width: number)",
        "filePath": "columnExpressions/mixins/stringExpr.ts",
        "lineStart": 1330,
        "lineEnd": 1332,
        "typeTree": {
          "width": {
            "type": "number",
            "optional": false,
            "desc": "Minimum resulting string width."
          }
        }
      }
    },
    "structExpr": {
      "field": {
        "desc": "Extracts a sub-field property value from nested objects/struct columns.",
        "examples": [
          ">>> const df = $df.data({ user: [{ name: \"Alice\", age: 30 }] })\n>>> df\nshape: (1, 1)\n+--------------------------------+\n| user                           |\n+--------------------------------+\n| { name: \"Alice\", age: 30 }     |\n+--------------------------------+\n>>> df.withColumns($df.col(\"user\").struct.field(\"name\").alias(\"user_name\"))\nshape: (1, 2)\n+---------------------------+-----------+\n| user                      | user_name |\n+---------------------------+-----------+\n| { name: \"Alice\", id: 1 }  | Alice     |\n+---------------------------+-----------+"
        ],
        "params": [
          {
            "name": "name",
            "desc": "Name of the field key to extract."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "struct",
        "category": "ColumnExpression",
        "propertyAccess": "field",
        "callExpression": ".struct.field()",
        "signature": "$df.col(<column_name>).struct.field(name: string)",
        "signatureDetailed": "$df.col(<column_name>).struct.field(name: string)",
        "filePath": "columnExpressions/mixins/structExpr.ts",
        "lineStart": 35,
        "lineEnd": 40,
        "typeTree": {
          "name": {
            "type": "string",
            "optional": false,
            "desc": "Name of the field key to extract."
          }
        }
      },
      "renameFields": {
        "desc": "Renames existing field keys inside structured object columns.",
        "examples": [
          ">>> const df = $df.data({ user: [{ name: \"Alice\", age: 30 }] })\n>>> df\nshape: (1, 1)\n+--------------------------------+\n| user                           |\n+--------------------------------+\n| { name: \"Alice\", age: 30 }     |\n+--------------------------------+\n>>> df.withColumns($df.col(\"user\").struct.renameFields({ name: \"first_name\" }).alias(\"user_renamed\"))\nshape: (1, 2)\n+---------------------------+--------------------------------+\n| user                      | user_renamed                   |\n+---------------------------+--------------------------------+\n| { name: \"Alice\", id: 1 }  | { id: 1, first_name: \"Alice\" } |\n+---------------------------+--------------------------------+"
        ],
        "params": [
          {
            "name": "mapping",
            "desc": "Key-value map of current field names to new field names."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "struct",
        "category": "ColumnExpression",
        "propertyAccess": "renameFields",
        "callExpression": ".struct.renameFields()",
        "signature": "$df.col(<column_name>).struct.renameFields(mapping: RenameMappingArg)",
        "signatureDetailed": "$df.col(<column_name>).struct.renameFields(mapping: RenameMappingArg)",
        "filePath": "columnExpressions/mixins/structExpr.ts",
        "lineStart": 56,
        "lineEnd": 69,
        "typeTree": {
          "mapping": {
            "type": "RenameMappingArg",
            "optional": false,
            "desc": "Key-value map of current field names to new field names."
          }
        }
      },
      "withFields": {
        "desc": "Inserts or updates fields inside structured object columns.",
        "examples": [
          ">>> const df = $df.data({ user: [{ name: \"Alice\", age: 30 }] })\n>>> df\nshape: (1, 1)\n+--------------------------------+\n| user                           |\n+--------------------------------+\n| { name: \"Alice\", age: 30 }     |\n+--------------------------------+\n>>> df.withColumns($df.col(\"user\").struct.withFields({ is_active: $df.lit(true) }).alias(\"updated_user\"))\nshape: (1, 2)\n+------------------------------+-------------------------------------------+\n| user                         | updated_user                              |\n+------------------------------+-------------------------------------------+\n| { name: \"Alice\", age: 30 }   | { name: \"Alice\", age: 30, is_active: true }|\n+------------------------------+-------------------------------------------+"
        ],
        "params": [
          {
            "name": "fields",
            "desc": "Expressions or field map defining new or updated fields."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "struct",
        "category": "ColumnExpression",
        "propertyAccess": "withFields",
        "callExpression": ".struct.withFields()",
        "signature": "$df.col(<column_name>).struct.withFields(fields: StructFieldsArg)",
        "signatureDetailed": "$df.col(<column_name>).struct.withFields(fields: IntoExprSeriesArg | ExprDict)",
        "filePath": "columnExpressions/mixins/structExpr.ts",
        "lineStart": 86,
        "lineEnd": 131,
        "typeTree": {
          "fields": {
            "type": "StructFieldsArg",
            "optional": false,
            "desc": "Expressions or field map defining new or updated fields.",
            "resolvedType": "IntoExprSeriesArg | ExprDict"
          }
        }
      },
      "unnest": {
        "desc": "Expands nested struct attributes into distinct columns in the DataFrame schema.",
        "examples": [
          ">>> const df = $df.data({ user: [{ name: \"Alice\", age: 30 }] })\n>>> df\nshape: (1, 1)\n+--------------------------------+\n| user                           |\n+--------------------------------+\n| { name: \"Alice\", age: 30 }     |\n+--------------------------------+\n>>> df.select($df.col(\"user\").struct.unnest())\nshape: (1, 2)\n+-------+-----+\n| name  | age |\n+-------+-----+\n| Alice | 30  |\n+-------+-----+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "struct",
        "category": "ColumnExpression",
        "propertyAccess": "unnest",
        "callExpression": ".struct.unnest()",
        "signature": "$df.col(<column_name>).struct.unnest()",
        "signatureDetailed": "$df.col(<column_name>).struct.unnest()",
        "filePath": "columnExpressions/mixins/structExpr.ts",
        "lineStart": 146,
        "lineEnd": 151
      }
    },
    "temporalExpr": {
      "castTimeUnit": {
        "desc": "Casts the schema time unit of a Datetime column (`\"ms\"`, `\"us\"`, `\"ns\"`). This is a metadata-only operation — underlying millisecond Date timestamps are preserved.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"ts\").dt.castTimeUnit(\"us\").alias(\"ts_us\"))\nshape: (1, 2)\n+--------------------------+--------------------------+\n| ts                       | ts_us                    |\n+--------------------------+--------------------------+\n| 2026-05-20T10:00:00.123Z | 2026-05-20T10:00:00.123Z |\n+--------------------------+--------------------------+"
        ],
        "params": [
          {
            "name": "unit",
            "desc": "Target time unit: `\"ms\"` (milliseconds), `\"us\"` (microseconds), or `\"ns\"` (nanoseconds)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "castTimeUnit",
        "callExpression": ".dt.castTimeUnit()",
        "signature": "$df.col(<column_name>).dt.castTimeUnit(unit: DatetimeTimeUnit)",
        "signatureDetailed": "$df.col(<column_name>).dt.castTimeUnit(unit: \"ms\" | \"us\" | \"ns\")",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 69,
        "lineEnd": 71,
        "typeTree": {
          "unit": {
            "type": "DatetimeTimeUnit",
            "optional": false,
            "desc": "Target time unit: `\"ms\"` (milliseconds), `\"us\"` (microseconds), or `\"ns\"` (nanoseconds).",
            "resolvedType": "\"ms\" | \"us\" | \"ns\""
          }
        }
      },
      "century": {
        "desc": "Extracts the 1-indexed century component (e.g. 21 for 2026) from a Datetime column.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.century().alias(\"century\"))\nshape: (1, 2)\n+------------+---------+\n| d          | century |\n+------------+---------+\n| 2026-05-20 | 21      |\n+------------+---------+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "century",
        "callExpression": ".dt.century()",
        "signature": "$df.col(<column_name>).dt.century(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.century(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 87,
        "lineEnd": 89,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        }
      },
      "convertTimeZone": {
        "desc": "Converts a Datetime column to a different IANA timezone. Preserves the exact UTC epoch instant while changing the timezone label, affecting how local wall-clock component extractors (`hour()`, `day()`, etc.) and `strftime` interpret values. Requires the column to already be timezone-aware; use `replace({ timeZone })` to assign a timezone to a naive column first.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"ts\").dt.replace({ timeZone: \"UTC\" }).dt.convertTimeZone(\"America/New_York\").alias(\"ts_ny\"))\nshape: (1, 2)\n+--------------------------+-------------------------------+\n| ts                       | ts_ny                         |\n+--------------------------+-------------------------------+\n| 2026-05-20T10:00:00.123Z | 2026-05-20 06:00:00.123 EDT   |\n+--------------------------+-------------------------------+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Target IANA timezone identifier (e.g. `\"UTC\"`, `\"America/New_York\"`, `\"Europe/London\"`)."
          }
        ],
        "returns": "ColumnExpression",
        "notes": [
          "[Timezone Compatibility]: Converting across named timezones relies on native `Intl.DateTimeFormat` IANA database resolution. Unrecognized timezones safely fallback to `\"UTC\"`."
        ],
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "convertTimeZone",
        "callExpression": ".dt.convertTimeZone()",
        "signature": "$df.col(<column_name>).dt.convertTimeZone(timeZone: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.convertTimeZone(timeZone: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 111,
        "lineEnd": 120,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": false,
            "desc": "Target IANA timezone identifier (e.g. `\"UTC\"`, `\"America/New_York\"`, `\"Europe/London\"`)."
          }
        }
      },
      "date": {
        "desc": "Extracts the Date object component from a Datetime column, truncating time to 00:00:00.000 UTC.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"ts\").dt.date().alias(\"date_only\"))\nshape: (1, 2)\n+--------------------------+--------------------------+\n| ts                       | date_only                |\n+--------------------------+--------------------------+\n| 2026-05-20T10:00:00.123Z | 2026-05-20T00:00:00.000Z |\n+--------------------------+--------------------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "date",
        "callExpression": ".dt.date()",
        "signature": "$df.col(<column_name>).dt.date()",
        "signatureDetailed": "$df.col(<column_name>).dt.date()",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 135,
        "lineEnd": 137
      },
      "day": {
        "desc": "Extracts the calendar day component (1-31) from a Datetime column.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.day().alias(\"day\"))\nshape: (1, 2)\n+------------+-----+\n| d          | day |\n+------------+-----+\n| 2026-05-20 | 20  |\n+------------+-----+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "day",
        "callExpression": ".dt.day()",
        "signature": "$df.col(<column_name>).dt.day(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.day(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 153,
        "lineEnd": 155,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        }
      },
      "daysInMonth": {
        "desc": "Extracts the total number of days in the month (28-31) for each Datetime value.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.daysInMonth().alias(\"dim\"))\nshape: (1, 2)\n+------------+-----+\n| d          | dim |\n+------------+-----+\n| 2026-05-20 | 31  |\n+------------+-----+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "daysInMonth",
        "callExpression": ".dt.daysInMonth()",
        "signature": "$df.col(<column_name>).dt.daysInMonth(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.daysInMonth(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 171,
        "lineEnd": 173,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        }
      },
      "epoch": {
        "desc": "Returns the epoch duration timestamp offset in the specified time resolution unit.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.epoch(\"s\").alias(\"epoch_s\"))\nshape: (1, 2)\n+------------+------------+\n| d          | epoch_s    |\n+------------+------------+\n| 2026-05-20 | 1779235200 |\n+------------+------------+"
        ],
        "params": [
          {
            "name": "unit",
            "desc": "Time resolution unit (`\"ms\"`, `\"us\"`, `\"ns\"`, `\"s\"`). Defaults to `\"ms\"`."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "epoch",
        "callExpression": ".dt.epoch()",
        "signature": "$df.col(<column_name>).dt.epoch(unit: TimeUnit = \"ms\")",
        "signatureDetailed": "$df.col(<column_name>).dt.epoch(unit: \"s\" | \"ms\" | \"us\" | \"ns\" = \"ms\")",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 189,
        "lineEnd": 191,
        "typeTree": {
          "unit": {
            "type": "TimeUnit",
            "optional": true,
            "default": "\"ms\"",
            "desc": "Time resolution unit (`\"ms\"`, `\"us\"`, `\"ns\"`, `\"s\"`). Defaults to `\"ms\"`.",
            "resolvedType": "\"s\" | \"ms\" | \"us\" | \"ns\""
          }
        }
      },
      "hour": {
        "desc": "Extracts the local hour component (0-23) from a Datetime column.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"ts\").dt.hour().alias(\"hr\"))\nshape: (1, 2)\n+--------------------------+----+\n| ts                       | hr |\n+--------------------------+----+\n| 2026-05-20T10:00:00.123Z | 10 |\n+--------------------------+----+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "hour",
        "callExpression": ".dt.hour()",
        "signature": "$df.col(<column_name>).dt.hour(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.hour(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 207,
        "lineEnd": 209,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        }
      },
      "isBusinessDay": {
        "desc": "Evaluates whether each Datetime value falls on a business day. Supports custom weekend day definitions and holiday arrays or timestamp sets.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.isBusinessDay().alias(\"is_bday\"))\nshape: (1, 2)\n+------------+---------+\n| d          | is_bday |\n+------------+---------+\n| 2026-05-20 | true    |\n+------------+---------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Business day rules and custom holiday configuration options."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "isBusinessDay",
        "callExpression": ".dt.isBusinessDay()",
        "signature": "$df.col(<column_name>).dt.isBusinessDay(options: IsBusinessDayOptions = {})",
        "signatureDetailed": "$df.col(<column_name>).dt.isBusinessDay(\n  options: {\n    excludeWeekdays?: number[] = [6, 7],\n    holidays?: (Date | string | number)[] | Set<number>\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 226,
        "lineEnd": 228,
        "typeTree": {
          "options": {
            "type": "IsBusinessDayOptions",
            "optional": true,
            "default": "{}",
            "desc": "Business day rules and custom holiday configuration options.",
            "properties": {
              "excludeWeekdays": {
                "type": "number[]",
                "optional": true,
                "desc": "ISO weekday numbers (`1 = Monday` ... `7 = Sunday`) considered non-business weekend days.",
                "default": "[6, 7]"
              },
              "holidays": {
                "type": "(Date | string | number)[] | Set<number>",
                "optional": true,
                "desc": "List or set of holiday dates (`Date`, ISO date string, or UTC timestamp) to exclude as business days."
              }
            }
          }
        }
      },
      "isLeapYear": {
        "desc": "Checks if the calendar year of a Datetime value is a leap year (366 days).",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.isLeapYear().alias(\"leap\"))\nshape: (1, 2)\n+------------+-------+\n| d          | leap  |\n+------------+-------+\n| 2026-05-20 | false |\n+------------+-------+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "isLeapYear",
        "callExpression": ".dt.isLeapYear()",
        "signature": "$df.col(<column_name>).dt.isLeapYear(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.isLeapYear(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 244,
        "lineEnd": 247,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        }
      },
      "isoYear": {
        "desc": "Extracts the ISO 8601 week-numbering year from a Datetime column.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.isoYear().alias(\"iso_yr\"))\nshape: (1, 2)\n+------------+--------+\n| d          | iso_yr |\n+------------+--------+\n| 2026-05-20 | 2026   |\n+------------+--------+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "isoYear",
        "callExpression": ".dt.isoYear()",
        "signature": "$df.col(<column_name>).dt.isoYear(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.isoYear(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 264,
        "lineEnd": 266,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        }
      },
      "microsecond": {
        "desc": "Extracts the microsecond component (0-999,000) scaled from Datetime millisecond precision.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"ts\").dt.microsecond().alias(\"us\"))\nshape: (1, 2)\n+--------------------------+--------+\n| ts                       | us     |\n+--------------------------+--------+\n| 2026-05-20T10:00:00.123Z | 123000 |\n+--------------------------+--------+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "microsecond",
        "callExpression": ".dt.microsecond()",
        "signature": "$df.col(<column_name>).dt.microsecond(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.microsecond(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 282,
        "lineEnd": 284,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        }
      },
      "millennium": {
        "desc": "Extracts the 1-indexed millennium component index (e.g. 3 for the year 2026) from a Datetime column.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.millennium().alias(\"mil\"))\nshape: (1, 2)\n+------------+-----+\n| d          | mil |\n+------------+-----+\n| 2026-05-20 | 3   |\n+------------+-----+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "millennium",
        "callExpression": ".dt.millennium()",
        "signature": "$df.col(<column_name>).dt.millennium(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.millennium(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 300,
        "lineEnd": 302,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        }
      },
      "millisecond": {
        "desc": "Extracts the millisecond component (0-999) from a Datetime column.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"ts\").dt.millisecond().alias(\"ms\"))\nshape: (1, 2)\n+--------------------------+-----+\n| ts                       | ms  |\n+--------------------------+-----+\n| 2026-05-20T10:00:00.123Z | 123 |\n+--------------------------+-----+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "millisecond",
        "callExpression": ".dt.millisecond()",
        "signature": "$df.col(<column_name>).dt.millisecond(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.millisecond(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 318,
        "lineEnd": 320,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        }
      },
      "minute": {
        "desc": "Extracts the minute component (0-59) from a Datetime column.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"ts\").dt.minute().alias(\"min\"))\nshape: (1, 2)\n+--------------------------+-----+\n| ts                       | min |\n+--------------------------+-----+\n| 2026-05-20T10:00:00.123Z | 0   |\n+--------------------------+-----+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "minute",
        "callExpression": ".dt.minute()",
        "signature": "$df.col(<column_name>).dt.minute(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.minute(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 336,
        "lineEnd": 338,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        }
      },
      "month": {
        "desc": "Extracts the calendar month component (1-12) from a Datetime column.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.month().alias(\"m\"))\nshape: (1, 2)\n+------------+---+\n| d          | m |\n+------------+---+\n| 2026-05-20 | 5 |\n+------------+---+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "month",
        "callExpression": ".dt.month()",
        "signature": "$df.col(<column_name>).dt.month(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.month(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 354,
        "lineEnd": 356,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        }
      },
      "monthEnd": {
        "desc": "Returns a Datetime column shifted to the last calendar day of the month at 00:00:00.000 UTC.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.monthEnd().alias(\"m_end\"))\nshape: (1, 2)\n+------------+--------------------------+\n| d          | m_end                    |\n+------------+--------------------------+\n| 2026-05-20 | 2026-05-31T00:00:00.000Z |\n+------------+--------------------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "monthEnd",
        "callExpression": ".dt.monthEnd()",
        "signature": "$df.col(<column_name>).dt.monthEnd()",
        "signatureDetailed": "$df.col(<column_name>).dt.monthEnd()",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 371,
        "lineEnd": 373
      },
      "monthStart": {
        "desc": "Returns a Datetime column shifted to the first calendar day of the month at 00:00:00.000 UTC.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.monthStart().alias(\"m_start\"))\nshape: (1, 2)\n+------------+--------------------------+\n| d          | m_start                  |\n+------------+--------------------------+\n| 2026-05-20 | 2026-05-01T00:00:00.000Z |\n+------------+--------------------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "monthStart",
        "callExpression": ".dt.monthStart()",
        "signature": "$df.col(<column_name>).dt.monthStart()",
        "signatureDetailed": "$df.col(<column_name>).dt.monthStart()",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 388,
        "lineEnd": 390
      },
      "nanosecond": {
        "desc": "Extracts the nanosecond component (0-999,000,000) scaled from Datetime millisecond precision.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"ts\").dt.nanosecond().alias(\"ns\"))\nshape: (1, 2)\n+--------------------------+-----------+\n| ts                       | ns        |\n+--------------------------+-----------+\n| 2026-05-20T10:00:00.123Z | 123000000 |\n+--------------------------+-----------+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "nanosecond",
        "callExpression": ".dt.nanosecond()",
        "signature": "$df.col(<column_name>).dt.nanosecond(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.nanosecond(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 406,
        "lineEnd": 408,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        }
      },
      "offsetDay": {
        "desc": "Offsets a Datetime column by N calendar days (numeric constant, column reference, or expression). Reuses $df.duration({ days: n }) and expression addition math under the hood.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.offsetDay(5).alias(\"later\"))\nshape: (1, 2)\n+------------+--------------------------+\n| d          | later                    |\n+------------+--------------------------+\n| 2026-05-20 | 2026-05-25T00:00:00.000Z |\n+------------+--------------------------+"
        ],
        "params": [
          {
            "name": "n",
            "desc": "Number of calendar days to offset (positive or negative)."
          },
          {
            "name": "options",
            "desc": "Day offset configuration options."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "offsetDay",
        "callExpression": ".dt.offsetDay()",
        "signature": "$df.col(<column_name>).dt.offsetDay(\n  n: NumericArg,\n  options: DayOffsetOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).dt.offsetDay(\n  n: number | bigint | IExpr | null,\n  options: {\n    excludeWeekdays?: number[] = [6, 7],\n    holidays?: (Date | string | number)[] | Set<number>,\n    roll?: \"raise\" | \"forward\" | \"backward\" = \"raise\"\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 426,
        "lineEnd": 433,
        "typeTree": {
          "n": {
            "type": "NumericArg",
            "optional": false,
            "desc": "Number of calendar days to offset (positive or negative).",
            "resolvedType": "number | bigint | IExpr | null"
          },
          "options": {
            "type": "DayOffsetOptions",
            "optional": true,
            "default": "{}",
            "desc": "Day offset configuration options.",
            "properties": {
              "excludeWeekdays": {
                "type": "number[]",
                "optional": true,
                "desc": "ISO weekday numbers (`1 = Monday` ... `7 = Sunday`) considered non-business weekend days.",
                "default": "[6, 7]"
              },
              "holidays": {
                "type": "(Date | string | number)[] | Set<number>",
                "optional": true,
                "desc": "List or set of holiday dates (`Date`, ISO date string, or UTC timestamp) to exclude as business days."
              },
              "roll": {
                "type": "BusinessDayRollType",
                "optional": true,
                "desc": "How to handle a starting date that falls on a non-business day: `\"raise\"`, `\"forward\"`, or `\"backward\"`.",
                "default": "\"raise\"",
                "resolvedType": "\"raise\" | \"forward\" | \"backward\""
              }
            }
          }
        }
      },
      "ordinalDay": {
        "desc": "Extracts the day of the year (1-366) from a Datetime column.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.ordinalDay().alias(\"doy\"))\nshape: (1, 2)\n+------------+-----+\n| d          | doy |\n+------------+-----+\n| 2026-05-20 | 140 |\n+------------+-----+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "ordinalDay",
        "callExpression": ".dt.ordinalDay()",
        "signature": "$df.col(<column_name>).dt.ordinalDay(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.ordinalDay(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 449,
        "lineEnd": 451,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        }
      },
      "quarter": {
        "desc": "Extracts the calendar quarter of the year (1-4) from a Datetime column.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.quarter().alias(\"qtr\"))\nshape: (1, 2)\n+------------+-----+\n| d          | qtr |\n+------------+-----+\n| 2026-05-20 | 2   |\n+------------+-----+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "quarter",
        "callExpression": ".dt.quarter()",
        "signature": "$df.col(<column_name>).dt.quarter(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.quarter(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 467,
        "lineEnd": 469,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to UTC."
          }
        }
      },
      "replace": {
        "desc": "Replaces specific date and time components (`year`, `month`, `day`, `hour`, `minute`, `second`, `ms`, `timeZone`) of a Datetime column. Unspecified components are preserved from the original value. When `timeZone` is provided in options, components are interpreted in that timezone. Note: `month` is 1-indexed (1 = January, 12 = December); `day` is 1-indexed (1-31).",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"ts\").dt.replace({ year: 2030, month: 1, day: 1 }).alias(\"replaced\"))\nshape: (1, 2)\n+--------------------------+--------------------------+\n| ts                       | replaced                 |\n+--------------------------+--------------------------+\n| 2026-05-20T10:00:00.123Z | 2030-01-01T10:00:00.123Z |\n+--------------------------+--------------------------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Object specifying which components to replace."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "replace",
        "callExpression": ".dt.replace()",
        "signature": "$df.col(<column_name>).dt.replace(options: ReplaceDateOptions)",
        "signatureDetailed": "$df.col(<column_name>).dt.replace(\n  options: {\n    day?: number,\n    hour?: number,\n    minute?: number,\n    month?: number,\n    ms?: number,\n    second?: number,\n    timeZone?: string | null,\n    year?: number\n  }\n)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 488,
        "lineEnd": 490,
        "typeTree": {
          "options": {
            "type": "ReplaceDateOptions",
            "optional": false,
            "desc": "Object specifying which components to replace.",
            "properties": {
              "day": {
                "type": "number",
                "optional": true,
                "desc": "Replacement 1-indexed day of the month (1 to 31)."
              },
              "hour": {
                "type": "number",
                "optional": true,
                "desc": "Replacement 0-indexed hour of day (0 to 23)."
              },
              "minute": {
                "type": "number",
                "optional": true,
                "desc": "Replacement 0-indexed minute of hour (0 to 59)."
              },
              "month": {
                "type": "number",
                "optional": true,
                "desc": "Replacement 1-indexed calendar month (1 to 12)."
              },
              "ms": {
                "type": "number",
                "optional": true,
                "desc": "Replacement 0-indexed millisecond (0 to 999)."
              },
              "second": {
                "type": "number",
                "optional": true,
                "desc": "Replacement 0-indexed second of minute (0 to 59)."
              },
              "timeZone": {
                "type": "string | null",
                "optional": true,
                "desc": "Target timezone identifier used to interpret and re-project the replaced components."
              },
              "year": {
                "type": "number",
                "optional": true,
                "desc": "Replacement calendar year."
              }
            }
          }
        }
      },
      "second": {
        "desc": "Extracts the second component (0-59) from a Datetime column.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"ts\").dt.second().alias(\"sec\"))\nshape: (1, 2)\n+--------------------------+-----+\n| ts                       | sec |\n+--------------------------+-----+\n| 2026-05-20T10:00:00.123Z | 0   |\n+--------------------------+-----+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "second",
        "callExpression": ".dt.second()",
        "signature": "$df.col(<column_name>).dt.second()",
        "signatureDetailed": "$df.col(<column_name>).dt.second()",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 505,
        "lineEnd": 507
      },
      "strftime": {
        "desc": "Formats Datetime values into custom formatted strings using strftime directive pattern tokens. Automatically applies the column's assigned timezone unless explicitly overridden in options.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.strftime(\"%Y/%m/%d\").alias(\"formatted\"))\nshape: (1, 2)\n+------------+------------+\n| d          | formatted  |\n+------------+------------+\n| 2026-05-20 | 2026/05/20 |\n+------------+------------+"
        ],
        "params": [
          {
            "name": "options",
            "desc": "Formatting pattern string (e.g. `\"%Y-%m-%d %H:%M:%S\"`) or configuration object."
          }
        ],
        "returns": "ColumnExpression",
        "notes": [
          "[Timezone Compatibility]: Timezone-aware formatting relies on native `Intl.DateTimeFormat` timezone resolution. If an invalid or unsupported IANA timezone is provided, formatting safely defaults to `\"UTC\"`."
        ],
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "strftime",
        "callExpression": ".dt.strftime()",
        "signature": "$df.col(<column_name>).dt.strftime(options: StrftimeOptions)",
        "signatureDetailed": "$df.col(<column_name>).dt.strftime(\n  options: {\n    format: string,\n    locale?: string = \"en-US\",\n    timeZone?: string = \"UTC\"\n  }\n)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 526,
        "lineEnd": 532,
        "typeTree": {
          "options": {
            "type": "StrftimeOptions",
            "optional": false,
            "desc": "Formatting pattern string (e.g. `\"%Y-%m-%d %H:%M:%S\"`) or configuration object.",
            "properties": {
              "format": {
                "type": "string",
                "optional": false,
                "desc": "Format string containing `%` date/time directives (e.g. `\"%Y-%m-%d\"`)."
              },
              "locale": {
                "type": "string",
                "optional": true,
                "desc": "BCP 47 locale tag used for localized month and weekday names.",
                "default": "\"en-US\""
              },
              "timeZone": {
                "type": "string",
                "optional": true,
                "desc": "Target IANA timezone identifier used when formatting date/time parts.",
                "default": "\"UTC\""
              }
            }
          }
        }
      },
      "time": {
        "desc": "Extracts the time component formatted string (`\"HH:MM:SS.mmm\"`) from a Datetime column.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"ts\").dt.time().alias(\"time\"))\nshape: (1, 2)\n+--------------------------+--------------+\n| ts                       | time         |\n+--------------------------+--------------+\n| 2026-05-20T10:00:00.123Z | 10:00:00.123 |\n+--------------------------+--------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "time",
        "callExpression": ".dt.time()",
        "signature": "$df.col(<column_name>).dt.time()",
        "signatureDetailed": "$df.col(<column_name>).dt.time()",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 547,
        "lineEnd": 549
      },
      "timestamp": {
        "desc": "Returns numeric timestamp relative to Epoch. Alias for epoch.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.timestamp(\"s\").alias(\"ts\"))\nshape: (1, 2)\n+------------+------------+\n| d          | ts         |\n+------------+------------+\n| 2026-05-20 | 1779235200 |\n+------------+------------+"
        ],
        "params": [
          {
            "name": "unit",
            "desc": "Time unit resolution."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "timestamp",
        "callExpression": ".dt.timestamp()",
        "signature": "$df.col(<column_name>).dt.timestamp(unit: TimeUnit = \"ms\")",
        "signatureDetailed": "$df.col(<column_name>).dt.timestamp(unit: \"s\" | \"ms\" | \"us\" | \"ns\" = \"ms\")",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 565,
        "lineEnd": 567,
        "typeTree": {
          "unit": {
            "type": "TimeUnit",
            "optional": true,
            "default": "\"ms\"",
            "desc": "Time unit resolution.",
            "resolvedType": "\"s\" | \"ms\" | \"us\" | \"ns\""
          }
        }
      },
      "totalDays": {
        "desc": "Converts a Duration value (in milliseconds) to total days count.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.duration({ days: $df.col(\"add\") }).dt.totalDays().alias(\"days\"))\nshape: (2, 3)\n+------------+-----+------+\n| dt         | add | days |\n+------------+-----+------+\n| 2026-01-01 | 1   | 1    |\n| 2026-01-01 | 2   | 2    |\n+------------+-----+------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "totalDays",
        "callExpression": ".dt.totalDays()",
        "signature": "$df.col(<column_name>).dt.totalDays()",
        "signatureDetailed": "$df.col(<column_name>).dt.totalDays()",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 584,
        "lineEnd": 586
      },
      "totalHours": {
        "desc": "Converts a Duration value (in milliseconds) to total hours count.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.duration({ days: $df.col(\"add\") }).dt.totalHours().alias(\"hrs\"))\nshape: (2, 3)\n+------------+-----+-----+\n| dt         | add | hrs |\n+------------+-----+-----+\n| 2026-01-01 | 1   | 24  |\n| 2026-01-01 | 2   | 48  |\n+------------+-----+-----+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "totalHours",
        "callExpression": ".dt.totalHours()",
        "signature": "$df.col(<column_name>).dt.totalHours()",
        "signatureDetailed": "$df.col(<column_name>).dt.totalHours()",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 602,
        "lineEnd": 604
      },
      "totalMicroseconds": {
        "desc": "Converts Duration to microsecond count.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.duration({ days: $df.col(\"add\") }).dt.totalMicroseconds().alias(\"us\"))\nshape: (2, 3)\n+------------+-----+--------------+\n| dt         | add | us           |\n+------------+-----+--------------+\n| 2026-01-01 | 1   | 86400000000  |\n| 2026-01-01 | 2   | 172800000000 |\n+------------+-----+--------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "totalMicroseconds",
        "callExpression": ".dt.totalMicroseconds()",
        "signature": "$df.col(<column_name>).dt.totalMicroseconds()",
        "signatureDetailed": "$df.col(<column_name>).dt.totalMicroseconds()",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 620,
        "lineEnd": 622
      },
      "totalMilliseconds": {
        "desc": "Converts Duration to millisecond count.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.duration({ days: $df.col(\"add\") }).dt.totalMilliseconds().alias(\"ms\"))\nshape: (2, 3)\n+------------+-----+-----------+\n| dt         | add | ms        |\n+------------+-----+-----------+\n| 2026-01-01 | 1   | 86400000  |\n| 2026-01-01 | 2   | 172800000 |\n+------------+-----+-----------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "totalMilliseconds",
        "callExpression": ".dt.totalMilliseconds()",
        "signature": "$df.col(<column_name>).dt.totalMilliseconds()",
        "signatureDetailed": "$df.col(<column_name>).dt.totalMilliseconds()",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 638,
        "lineEnd": 640
      },
      "totalMinutes": {
        "desc": "Converts Duration to floating point minutes.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.duration({ days: $df.col(\"add\") }).dt.totalMinutes().alias(\"mins\"))\nshape: (2, 3)\n+------------+-----+------+\n| dt         | add | mins |\n+------------+-----+------+\n| 2026-01-01 | 1   | 1440 |\n| 2026-01-01 | 2   | 2880 |\n+------------+-----+------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "totalMinutes",
        "callExpression": ".dt.totalMinutes()",
        "signature": "$df.col(<column_name>).dt.totalMinutes()",
        "signatureDetailed": "$df.col(<column_name>).dt.totalMinutes()",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 656,
        "lineEnd": 658
      },
      "totalNanoseconds": {
        "desc": "Converts Duration to nanosecond count.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.duration({ days: $df.col(\"add\") }).dt.totalNanoseconds().alias(\"ns\"))\nshape: (2, 3)\n+------------+-----+-----------------+\n| dt         | add | ns              |\n+------------+-----+-----------------+\n| 2026-01-01 | 1   | 86400000000000  |\n| 2026-01-01 | 2   | 172800000000000 |\n+------------+-----+-----------------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "totalNanoseconds",
        "callExpression": ".dt.totalNanoseconds()",
        "signature": "$df.col(<column_name>).dt.totalNanoseconds()",
        "signatureDetailed": "$df.col(<column_name>).dt.totalNanoseconds()",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 674,
        "lineEnd": 676
      },
      "totalSeconds": {
        "desc": "Converts Duration to floating point seconds.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.duration({ days: $df.col(\"add\") }).dt.totalSeconds().alias(\"secs\"))\nshape: (2, 3)\n+------------+-----+--------+\n| dt         | add | secs   |\n+------------+-----+--------+\n| 2026-01-01 | 1   | 86400  |\n| 2026-01-01 | 2   | 172800 |\n+------------+-----+--------+"
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "totalSeconds",
        "callExpression": ".dt.totalSeconds()",
        "signature": "$df.col(<column_name>).dt.totalSeconds()",
        "signatureDetailed": "$df.col(<column_name>).dt.totalSeconds()",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 692,
        "lineEnd": 694
      },
      "utcOffset": {
        "desc": "Returns the UTC offset of a timezone for a given Datetime value. Supports returning the total offset, the standard (base) offset, or just the daylight saving time component, in multiple output formats.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.utcOffset(\"UTC\").alias(\"offset\"))\nshape: (1, 2)\n+------------+--------+\n| d          | offset |\n+------------+--------+\n| 2026-05-20 | 0      |\n+------------+--------+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the system local timezone."
          },
          {
            "name": "options",
            "desc": "Output configuration: `type` selects which offset component to return (`\"total\"` | `\"standardTime\"` | `\"daylightSavingTime\"`), and `format` controls the output unit (`\"milliseconds\"` | `\"minutes\"` | `\"hours\"` | `\"iso\"` | `\"basic\"`)."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "utcOffset",
        "callExpression": ".dt.utcOffset()",
        "signature": "$df.col(<column_name>).dt.utcOffset(\n  timeZone?: string,\n  options: UtcOffsetOptions = {}\n)",
        "signatureDetailed": "$df.col(<column_name>).dt.utcOffset(\n  timeZone?: string,\n  options: {\n    format?: \"milliseconds\" | \"minutes\" | \"hours\" | \"iso\" | \"basic\" = \"milliseconds\",\n    type?: \"base\" | \"total\" | \"daylightSavingTime\" = \"total\"\n  } = {}\n)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 715,
        "lineEnd": 717,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the system local timezone."
          },
          "options": {
            "type": "UtcOffsetOptions",
            "optional": true,
            "default": "{}",
            "desc": "Output configuration: `type` selects which offset component to return (`\"total\"` | `\"standardTime\"` | `\"daylightSavingTime\"`), and `format` controls the output unit (`\"milliseconds\"` | `\"minutes\"` | `\"hours\"` | `\"iso\"` | `\"basic\"`).",
            "properties": {
              "format": {
                "type": "UtcOffsetFormat",
                "optional": true,
                "desc": "Output format: `\"milliseconds\"`, `\"minutes\"`, `\"hours\"`, `\"iso\"` (`\"+HH:MM\"`), or `\"basic\"` (`\"+HHMM\"`).",
                "default": "\"milliseconds\"",
                "resolvedType": "\"milliseconds\" | \"minutes\" | \"hours\" | \"iso\" | \"basic\""
              },
              "type": {
                "type": "UtcOffsetType",
                "optional": true,
                "desc": "Which offset component to compute: `\"base\"` (standard offset), `\"total\"` (wall-clock offset), or `\"daylightSavingTime\"` (DST delta).",
                "default": "\"total\"",
                "resolvedType": "\"base\" | \"total\" | \"daylightSavingTime\""
              }
            }
          }
        }
      },
      "week": {
        "desc": "Extracts the ISO 8601 week number (1-53) from a Datetime column.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.week().alias(\"week\"))\nshape: (1, 2)\n+------------+------+\n| d          | week |\n+------------+------+\n| 2026-05-20 | 21   |\n+------------+------+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "week",
        "callExpression": ".dt.week()",
        "signature": "$df.col(<column_name>).dt.week(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.week(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 733,
        "lineEnd": 735,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to the column timezone or UTC."
          }
        }
      },
      "weekday": {
        "desc": "Extracts weekday component (1=Monday, 7=Sunday).",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.weekday().alias(\"wd\"))\nshape: (1, 2)\n+------------+----+\n| d          | wd |\n+------------+----+\n| 2026-05-20 | 3  |\n+------------+----+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "weekday",
        "callExpression": ".dt.weekday()",
        "signature": "$df.col(<column_name>).dt.weekday(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.weekday(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 751,
        "lineEnd": 753,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to UTC."
          }
        }
      },
      "year": {
        "desc": "Extracts the year component from a Datetime column.",
        "examples": [
          ">>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.withColumns($df.col(\"d\").dt.year().alias(\"yr\"))\nshape: (1, 2)\n+------------+------+\n| d          | yr   |\n+------------+------+\n| 2026-05-20 | 2026 |\n+------------+------+"
        ],
        "params": [
          {
            "name": "timeZone",
            "desc": "Optional IANA timezone identifier. Defaults to UTC."
          }
        ],
        "returns": "ColumnExpression",
        "namespace": "$df.col",
        "accessor": "dt",
        "category": "ColumnExpression",
        "propertyAccess": "year",
        "callExpression": ".dt.year()",
        "signature": "$df.col(<column_name>).dt.year(timeZone?: string)",
        "signatureDetailed": "$df.col(<column_name>).dt.year(timeZone?: string)",
        "filePath": "columnExpressions/mixins/temporalExpr.ts",
        "lineStart": 769,
        "lineEnd": 771,
        "typeTree": {
          "timeZone": {
            "type": "string",
            "optional": true,
            "desc": "Optional IANA timezone identifier. Defaults to UTC."
          }
        }
      }
    }
  },
  "dataframe": {
    "cast": {
      "desc": "Casts columns in the DataFrame to the specified data type(s).",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.cast($df.Float64)\n>>> df.cast({ a: $df.Float64, b: $df.Utf8 })\n>>> df.cast({ num_str: $df.Int64 }, { strict: false })"
      ],
      "params": [
        {
          "name": "dtypes",
          "type": "CastTargetArg",
          "desc": "Target data type for all columns, or mapping of column names to target data types."
        },
        {
          "name": "[options]",
          "type": "CastOptions",
          "desc": "Casting options (e.g. strict)."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "cast",
      "callExpression": ".cast()",
      "signature": "df.cast(\n  dtypes: CastTargetArg,\n  options: CastOptions = {}\n): DataFrame<any>",
      "signatureDetailed": "df.cast(\n  dtypes: RegisteredDataType | DataFrameSchema,\n  options: {\n    strict?: boolean = true\n  } = {}\n): DataFrame<any>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 181,
      "lineEnd": 202,
      "typeTree": {
        "dtypes": {
          "type": "CastTargetArg",
          "optional": false,
          "desc": "Target data type for all columns, or mapping of column names to target data types.",
          "resolvedType": "RegisteredDataType | DataFrameSchema"
        },
        "options": {
          "type": "CastOptions",
          "optional": true,
          "default": "{}",
          "desc": "Casting options (e.g. strict).",
          "properties": {
            "strict": {
              "type": "boolean",
              "optional": true,
              "desc": "Whether cast errors should throw or produce `null` values.",
              "default": "true"
            }
          }
        }
      }
    },
    "clone": {
      "desc": "Creates a deep copy of the current DataFrame instance, duplicating all underlying column data arrays and schema metadata. Modifying columns or values in the cloned DataFrame will not mutate the original.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+"
      ],
      "returns": "DataFrame<T>",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "clone",
      "callExpression": ".clone()",
      "signature": "df.clone(): DataFrame<T>",
      "signatureDetailed": "df.clone(): DataFrame<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 220,
      "lineEnd": 222
    },
    "columns": {
      "desc": "Gets array of column names in the DataFrame.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.columns\n[\"a\", \"b\"]"
      ],
      "returns": "Array of column name strings.",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "columns",
      "callExpression": ".columns",
      "signature": "df.columns: string[]",
      "signatureDetailed": "df.columns: string[]",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 232,
      "lineEnd": 234
    },
    "concat": {
      "desc": "Concatenates items vertically, horizontally, or diagonally.",
      "examples": [
        "// 1. Vertical Concatenation (default):\n>>> const df1 = $df.data({ a: [1, 2] })\n>>> const df2 = $df.data({ b: [10, 20] })\n>>> df1\nshape: (2, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n+---+\n>>> df2\nshape: (2, 1)\n+----+\n| b  |\n+----+\n| 10 |\n| 20 |\n+----+\n>>> df1.concat(df2, { how: \"vertical\" })\nshape: (4, 1)\n+------+\n| a    |\n+------+\n| 1    |\n| 2    |\n| null |\n| null |\n+------+",
        "// 2. Horizontal Concatenation:\n>>> const df1 = $df.data({ a: [1, 2] })\n>>> const df2 = $df.data({ b: [10, 20] })\n>>> df1\nshape: (2, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n+---+\n>>> df2\nshape: (2, 1)\n+----+\n| b  |\n+----+\n| 10 |\n| 20 |\n+----+\n>>> df1.concat(df2, { how: \"horizontal\" })\nshape: (2, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n+---+----+",
        "// 3. Diagonal Concatenation (mismatched columns):\n>>> const df1 = $df.data({ a: [1, 2] })\n>>> const df2 = $df.data({ b: [10, 20] })\n>>> df1\nshape: (2, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n+---+\n>>> df2\nshape: (2, 1)\n+----+\n| b  |\n+----+\n| 10 |\n| 20 |\n+----+\n>>> df1.concat(df2, { how: \"diagonal\" })\nshape: (4, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| 2    | null |\n| null | 10   |\n| null | 20   |\n+------+------+"
      ],
      "params": [
        {
          "name": "items",
          "type": "ConcatItemsArg",
          "desc": "Single DataFrame or array of DataFrames/rows to concatenate."
        },
        {
          "name": "[options]",
          "type": "ConcatOptions",
          "desc": "Configuration options for concatenation layout and strictness."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "concat",
      "callExpression": ".concat()",
      "signature": "df.concat<U extends RowRecord = any>(\n  items: ConcatItemsArg,\n  options: ConcatOptions = {}\n): DataFrame<U>",
      "signatureDetailed": "df.concat<U extends RowRecord = any>(\n  items: ConcatItem | ConcatItem[],\n  options: {\n    horizontal?: {\n      strict?: boolean = true\n    },\n    how?: \"vertical\" | \"horizontal\" | \"diagonal\" = \"vertical\"\n  } = {}\n): DataFrame<U>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 283,
      "lineEnd": 291,
      "typeTree": {
        "items": {
          "type": "ConcatItemsArg",
          "optional": false,
          "desc": "Single DataFrame or array of DataFrames/rows to concatenate.",
          "resolvedType": "ConcatItem | ConcatItem[]"
        },
        "options": {
          "type": "ConcatOptions",
          "optional": true,
          "default": "{}",
          "desc": "Configuration options for concatenation layout and strictness.",
          "properties": {
            "horizontal": {
              "type": "HorizontalConcatOptions",
              "optional": true,
              "desc": "Configuration options specific to horizontal concatenation.",
              "properties": {
                "strict": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "When `true`, throws an error if row counts mismatch in horizontal concatenation. Set `false` to pad shorter DataFrames with `null`.",
                  "default": "true"
                }
              }
            },
            "how": {
              "type": "ConcatHow",
              "optional": true,
              "desc": "Layout strategy: `\"vertical\"` (appends rows top-to-bottom), `\"horizontal\"` (joins unique columns side-by-side), or `\"diagonal\"` (concatenates mismatched columns with null padding).",
              "default": "\"vertical\"",
              "resolvedType": "\"vertical\" | \"horizontal\" | \"diagonal\""
            }
          }
        }
      }
    },
    "drop": {
      "desc": "Drops specified columns from the DataFrame.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.drop(\"b\")\nshape: (2, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n+---+"
      ],
      "params": [
        {
          "name": "args",
          "type": "ColumnKeyArg<K>[]",
          "desc": "Column names or arrays of column names to remove."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "drop",
      "callExpression": ".drop()",
      "signature": "df.drop<K extends keyof T>(...args: ColumnKeyArg<K>[]): DataFrame<Omit<T, K>>",
      "signatureDetailed": "df.drop<K extends keyof T>(...args: (K | K[])[]): DataFrame<Omit<T, K>>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 308,
      "lineEnd": 310,
      "typeTree": {
        "args": {
          "type": "ColumnKeyArg<K>[]",
          "optional": false,
          "variadic": true,
          "desc": "Column names or arrays of column names to remove.",
          "resolvedType": "(K | K[])[]"
        }
      }
    },
    "dropNulls": {
      "desc": "Drops rows with null or undefined values.",
      "examples": [
        ">>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.dropNulls()\nshape: (2, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 3 |\n+---+"
      ],
      "params": [
        {
          "name": "[subset]",
          "type": "ColumnKeyArg<string>",
          "desc": "Column name or array of column names to check for nulls."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "dropNulls",
      "callExpression": ".dropNulls()",
      "signature": "df.dropNulls(subset?: ColumnKeyArg<string>): DataFrame<T>",
      "signatureDetailed": "df.dropNulls(subset?: string | string[]): DataFrame<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 327,
      "lineEnd": 329,
      "typeTree": {
        "subset": {
          "type": "ColumnKeyArg<string>",
          "optional": true,
          "desc": "Column name or array of column names to check for nulls.",
          "resolvedType": "string | string[]"
        }
      }
    },
    "dtypes": {
      "desc": "Gets array of registered column DataTypes matching current schema order.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.dtypes\n[Float64, Utf8]"
      ],
      "returns": "Array of RegisteredDataType definitions.",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "dtypes",
      "callExpression": ".dtypes",
      "signature": "df.dtypes: RegisteredDataType[]",
      "signatureDetailed": "df.dtypes: RegisteredDataType[]",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 339,
      "lineEnd": 347
    },
    "equals": {
      "desc": "Compares this DataFrame with another for equality. Checks shape, column names, column order, schemas, and row values.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.equals(df2)\ntrue"
      ],
      "params": [
        {
          "name": "other",
          "type": "DataFrame",
          "desc": "The other DataFrame to compare with."
        },
        {
          "name": "[options]",
          "type": "EqualsOptions",
          "desc": "Comparison configuration options."
        }
      ],
      "returns": "boolean",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "equals",
      "callExpression": ".equals()",
      "signature": "df.equals<U extends RowRecord = any>(\n  other: DataFrame<U>,\n  {\n    nullsEqual = true\n  }: EqualsOptions = {}\n): boolean",
      "signatureDetailed": "df.equals<U extends RowRecord = any>(\n  other: DataFrame<U>,\n  options: {\n    nullsEqual?: boolean = true\n  } = {}\n): boolean",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 361,
      "lineEnd": 403,
      "typeTree": {
        "other": {
          "type": "DataFrame<U>",
          "optional": false,
          "desc": "The other DataFrame to compare with."
        },
        "options": {
          "type": "EqualsOptions",
          "optional": true,
          "default": "{}",
          "desc": "Comparison configuration options.",
          "properties": {
            "nullsEqual": {
              "type": "boolean",
              "optional": true,
              "desc": "Whether nulls and NaNs compare as equal.",
              "default": "true"
            }
          }
        }
      }
    },
    "explode": {
      "desc": "Explodes an array column into multiple rows, replicating non-target row attributes.",
      "examples": [
        ">>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.explode(\"values\")\nshape: (2, 2)\n+-------+--------+\n| group | values |\n+-------+--------+\n| A     | 1      |\n| A     | 2      |\n+-------+--------+"
      ],
      "params": [
        {
          "name": "columns",
          "type": "IntoExprArg",
          "desc": "Target column expression or array column name to explode."
        },
        {
          "name": "[options]",
          "type": "ExplodeOptions",
          "desc": "Configuration options for empty array and null handling."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "explode",
      "callExpression": ".explode()",
      "signature": "df.explode(\n  columns: IntoExprArg,\n  options?: ExplodeOptions\n): DataFrame<any>",
      "signatureDetailed": "df.explode(\n  columns: IntoExpr | IntoExpr[],\n  options?: {\n    emptyAsNull?: boolean = true,\n    keepNulls?: boolean = true\n  }\n): DataFrame<any>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 421,
      "lineEnd": 440,
      "typeTree": {
        "columns": {
          "type": "IntoExprArg",
          "optional": false,
          "desc": "Target column expression or array column name to explode.",
          "resolvedType": "IntoExpr | IntoExpr[]"
        },
        "options": {
          "type": "ExplodeOptions",
          "optional": true,
          "desc": "Configuration options for empty array and null handling.",
          "properties": {
            "emptyAsNull": {
              "type": "boolean",
              "optional": true,
              "desc": "When `true`, converts empty arrays to `null` rows.",
              "default": "true"
            },
            "keepNulls": {
              "type": "boolean",
              "optional": true,
              "desc": "When `true`, retains `null` array values during explosion.",
              "default": "true"
            }
          }
        }
      }
    },
    "fill": {
      "desc": "Fills targeted values (\"null\", \"nan\", or \"all\") across columns using scalar values or statistical strategies.",
      "examples": [
        ">>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.fill(\"null\", { value: 0 })\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 0 |\n| 3 |\n+---+"
      ],
      "params": [
        {
          "name": "target",
          "type": "FillTarget",
          "desc": "Target type (\"null\", \"nan\", \"all\")."
        },
        {
          "name": "[options]",
          "type": "FillOptions",
          "default": "{}",
          "desc": "Configuration options specifying replacement value, strategy, and optional limit."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "fill",
      "callExpression": ".fill()",
      "signature": "df.fill(\n  target: FillTarget,\n  options: FillOptions = {}\n): DataFrame<T>",
      "signatureDetailed": "df.fill(\n  target: \"null\" | \"nan\" | \"all\" | ScalarArg,\n  options: {\n    limit?: number,\n    strategy?: \"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\",\n    value?: IExpr | ValidScalarTypes\n  } = {}\n): DataFrame<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 459,
      "lineEnd": 465,
      "typeTree": {
        "target": {
          "type": "FillTarget",
          "optional": false,
          "desc": "Target type (\"null\", \"nan\", \"all\").",
          "resolvedType": "\"null\" | \"nan\" | \"all\" | ScalarArg"
        },
        "options": {
          "type": "FillOptions",
          "optional": true,
          "default": "{}",
          "desc": "Configuration options specifying replacement value, strategy, and optional limit.",
          "properties": {
            "limit": {
              "type": "number",
              "optional": true,
              "desc": "Maximum number of consecutive target values to fill when using directional strategies (`\"forward\"`, `\"backward\"`)."
            },
            "strategy": {
              "type": "FillNullStrategy",
              "optional": true,
              "desc": "Filling strategy to calculate or propagate replacement values (`\"forward\"`, `\"backward\"`, `\"min\"`, `\"max\"`, `\"mean\"`, `\"zero\"`, `\"one\"`).",
              "resolvedType": "\"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\""
            },
            "value": {
              "type": "ScalarArg",
              "optional": true,
              "desc": "Replacement scalar value or column expression to substitute in place of target values.",
              "resolvedType": "IExpr | ValidScalarTypes"
            }
          }
        }
      }
    },
    "fillNan": {
      "desc": "Fills NaN values across numeric columns using scalar values or statistical strategies.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.fillNan({ value: 0 })\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+"
      ],
      "params": [
        {
          "name": "[options]",
          "type": "FillNullOptions",
          "default": "{}",
          "desc": "Configuration options specifying replacement value, strategy, and optional limit."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "fillNan",
      "callExpression": ".fillNan()",
      "signature": "df.fillNan(options: FillNullOptions = {}): DataFrame<T>",
      "signatureDetailed": "df.fillNan(\n  options: {\n    limit?: number,\n    strategy?: \"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\",\n    value?: IExpr | ValidScalarTypes\n  } = {}\n): DataFrame<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 483,
      "lineEnd": 486,
      "typeTree": {
        "options": {
          "type": "FillNullOptions",
          "optional": true,
          "default": "{}",
          "desc": "Configuration options specifying replacement value, strategy, and optional limit.",
          "properties": {
            "limit": {
              "type": "number",
              "optional": true,
              "desc": "Maximum number of consecutive target values to fill when using directional strategies (`\"forward\"`, `\"backward\"`)."
            },
            "strategy": {
              "type": "FillNullStrategy",
              "optional": true,
              "desc": "Filling strategy to calculate or propagate replacement values (`\"forward\"`, `\"backward\"`, `\"min\"`, `\"max\"`, `\"mean\"`, `\"zero\"`, `\"one\"`).",
              "resolvedType": "\"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\""
            },
            "value": {
              "type": "ScalarArg",
              "optional": true,
              "desc": "Replacement scalar value or column expression to substitute in place of target values.",
              "resolvedType": "IExpr | ValidScalarTypes"
            }
          }
        }
      }
    },
    "fillNull": {
      "desc": "Fills null values across columns using scalar values or statistical strategies.",
      "examples": [
        ">>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.fillNull({ value: 0 })\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 0 |\n| 3 |\n+---+"
      ],
      "params": [
        {
          "name": "[options]",
          "type": "FillNullOptions",
          "desc": "Configuration options for null replacement."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "fillNull",
      "callExpression": ".fillNull()",
      "signature": "df.fillNull(options: FillNullOptions = {}): DataFrame<T>",
      "signatureDetailed": "df.fillNull(\n  options: {\n    limit?: number,\n    strategy?: \"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\",\n    value?: IExpr | ValidScalarTypes\n  } = {}\n): DataFrame<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 504,
      "lineEnd": 507,
      "typeTree": {
        "options": {
          "type": "FillNullOptions",
          "optional": true,
          "default": "{}",
          "desc": "Configuration options for null replacement.",
          "properties": {
            "limit": {
              "type": "number",
              "optional": true,
              "desc": "Maximum number of consecutive target values to fill when using directional strategies (`\"forward\"`, `\"backward\"`)."
            },
            "strategy": {
              "type": "FillNullStrategy",
              "optional": true,
              "desc": "Filling strategy to calculate or propagate replacement values (`\"forward\"`, `\"backward\"`, `\"min\"`, `\"max\"`, `\"mean\"`, `\"zero\"`, `\"one\"`).",
              "resolvedType": "\"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\""
            },
            "value": {
              "type": "ScalarArg",
              "optional": true,
              "desc": "Replacement scalar value or column expression to substitute in place of target values.",
              "resolvedType": "IExpr | ValidScalarTypes"
            }
          }
        }
      }
    },
    "filter": {
      "desc": "Filters rows matching boolean column expressions or predicate callbacks.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n| 3 | 30 |\n+---+----+\n>>> df.filter($df.col(\"a\").gt(1))\nshape: (2, 1)\n+---+\n| a |\n+---+\n| 2 |\n| 3 |\n+---+"
      ],
      "params": [
        {
          "name": "exprs",
          "type": "FilterPredicateArg<T>[]",
          "desc": "Expressions or predicate functions evaluated per row."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "filter",
      "callExpression": ".filter()",
      "signature": "df.filter(...exprs: FilterPredicateArg<T>[]): DataFrame<T>",
      "signatureDetailed": "df.filter(...exprs: (IExpr | (row: T) => any | FilterPredicate<T>[])[]): DataFrame<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 524,
      "lineEnd": 596,
      "typeTree": {
        "exprs": {
          "type": "FilterPredicateArg<T>[]",
          "optional": false,
          "variadic": true,
          "desc": "Expressions or predicate functions evaluated per row.",
          "resolvedType": "(IExpr | (row: T) => any | FilterPredicate<T>[])[]"
        }
      }
    },
    "groupBy": {
      "desc": "Groups rows by key columns to prepare for aggregations.",
      "examples": [
        "// 1. Group by single column with single aggregation:\n>>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg($df.col(\"val\").sum().alias(\"sum\"))\nshape: (2, 2)\n+-------+-----+\n| group | sum |\n+-------+-----+\n| A     | 30  |\n| B     | 30  |\n+-------+-----+",
        "// 2. Group by with multiple parallel aggregations:\n>>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg(\n...   $df.col(\"val\").mean().alias(\"avg\"),\n...   $df.col(\"val\").sum().alias(\"total\")\n... )\nshape: (2, 3)\n+-------+-----+-------+\n| group | avg | total |\n+-------+-----+-------+\n| A     | 15  | 30    |\n| B     | 30  | 30    |\n+-------+-----+-------+"
      ],
      "params": [
        {
          "name": "keys",
          "type": "ColumnKeyArg<K>",
          "desc": "Column name or array of key column names."
        }
      ],
      "returns": "GroupedData",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "groupBy",
      "callExpression": ".groupBy()",
      "signature": "df.groupBy<K extends keyof T>(keys: ColumnKeyArg<K>): GroupedData<T, K>",
      "signatureDetailed": "df.groupBy<K extends keyof T>(keys: K | K[]): GroupedData<T, K>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 629,
      "lineEnd": 639,
      "typeTree": {
        "keys": {
          "type": "ColumnKeyArg<K>",
          "optional": false,
          "desc": "Column name or array of key column names.",
          "resolvedType": "K | K[]"
        }
      }
    },
    "groupByDynamic": {
      "desc": "Groups dynamically based on a time or integer index column over sliding / stepping windows.",
      "examples": [
        ">>> const df = $df.data([\n...   { time: new Date(\"2024-01-01T00:00:00Z\"), val: 10 },\n...   { time: new Date(\"2024-01-01T12:00:00Z\"), val: 20 },\n...   { time: new Date(\"2024-01-02T00:00:00Z\"), val: 30 }\n... ])\n>>> df\nshape: (3, 2)\n+--------------------------+-----+\n| time                     | val |\n+--------------------------+-----+\n| 2024-01-01T00:00:00.000Z | 10  |\n| 2024-01-01T12:00:00.000Z | 20  |\n| 2024-01-02T00:00:00.000Z | 30  |\n+--------------------------+-----+\n>>> df.groupByDynamic(\"time\", { every: \"1d\", period: \"1d\" }).agg($df.col(\"val\").sum().alias(\"daily_sum\"))\nshape: (2, 2)\n+--------------------------+-----------+\n| time                     | daily_sum |\n+--------------------------+-----------+\n| 2024-01-01T00:00:00.000Z | 30        |\n| 2024-01-02T00:00:00.000Z | 30        |\n+--------------------------+-----------+"
      ],
      "params": [
        {
          "name": "indexColumn",
          "desc": "The time/integer column or column expression to group on."
        },
        {
          "name": "options",
          "desc": "Dynamic grouping configuration options (`every`, `period`, `offset`, `truncate`, `includeBoundaries`, `closed`, `label`, `by`, `startBy`, `checkSorted`)."
        }
      ],
      "returns": "GroupedData",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "groupByDynamic",
      "callExpression": ".groupByDynamic()",
      "signature": "df.groupByDynamic<K extends keyof T & string>(\n  indexColumn: DynamicIndexColumnArg<K>,\n  options: GroupByDynamicOptions<T>\n): GroupedData<T, K>",
      "signatureDetailed": "df.groupByDynamic<K extends keyof T & string>(\n  indexColumn: K | IntoExpr,\n  options: {\n    by?: keyof any | keyof any[],\n    checkSorted?: boolean = true,\n    closed?: \"both\" | \"left\" | \"right\" | \"none\" = \"left\",\n    every: number | string,\n    groupBy?: keyof any | keyof any[],\n    includeBoundaries?: boolean = false,\n    label?: \"left\" | \"right\" | \"datapoint\" = \"left\",\n    offset?: number | string = 0,\n    period?: number | string = `every` if omitted,\n    startBy?: \"window\" | \"datapoint\" | \"monday\" | \"tuesday\" | \"wednesday\" | \"thursday\" | \"friday\" | \"saturday\" | \"sunday\" = \"window\",\n    truncate?: boolean = true\n  }\n): GroupedData<T, K>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 658,
      "lineEnd": 855,
      "typeTree": {
        "indexColumn": {
          "type": "DynamicIndexColumnArg<K>",
          "optional": false,
          "desc": "The time/integer column or column expression to group on.",
          "resolvedType": "K | IntoExpr"
        },
        "options": {
          "type": "GroupByDynamicOptions<T>",
          "optional": false,
          "desc": "Dynamic grouping configuration options (`every`, `period`, `offset`, `truncate`, `includeBoundaries`, `closed`, `label`, `by`, `startBy`, `checkSorted`).",
          "properties": {
            "by": {
              "type": "ColumnKeyArg<keyof any>",
              "optional": true,
              "desc": "Additional columns to partition / group by before dynamic windowing.",
              "resolvedType": "keyof any | keyof any[]"
            },
            "checkSorted": {
              "type": "boolean",
              "optional": true,
              "desc": "Verify whether index column is sorted in ascending order.",
              "default": "true"
            },
            "closed": {
              "type": "ClosedBoundary",
              "optional": true,
              "desc": "Which boundary of the window interval is closed (`\"left\"`, `\"right\"`, `\"both\"`, `\"none\"`).",
              "default": "\"left\"",
              "resolvedType": "\"both\" | \"left\" | \"right\" | \"none\""
            },
            "every": {
              "type": "DurationValueArg",
              "optional": false,
              "desc": "Time interval window step period (e.g. `\"1d\"`, `\"1h\"`, `1000`).",
              "resolvedType": "number | string"
            },
            "groupBy": {
              "type": "ColumnKeyArg<keyof any>",
              "optional": true,
              "desc": "Polars alias for `by`.",
              "resolvedType": "keyof any | keyof any[]"
            },
            "includeBoundaries": {
              "type": "boolean",
              "optional": true,
              "desc": "Include the lower and upper window boundaries (`_lower_boundary`, `_upper_boundary`).",
              "default": "false"
            },
            "label": {
              "type": "DynamicLabel",
              "optional": true,
              "desc": "Which window boundary to use as the timestamp label (`\"left\"`, `\"right\"`, `\"datapoint\"`).",
              "default": "\"left\"",
              "resolvedType": "\"left\" | \"right\" | \"datapoint\""
            },
            "offset": {
              "type": "DurationValueArg",
              "optional": true,
              "desc": "Offset window start by a duration.",
              "default": "0",
              "resolvedType": "number | string"
            },
            "period": {
              "type": "DurationValueArg",
              "optional": true,
              "desc": "Time period duration window width. Defaults to `every` if omitted.",
              "default": "`every` if omitted",
              "resolvedType": "number | string"
            },
            "startBy": {
              "type": "DynamicStartBy",
              "optional": true,
              "desc": "Strategy to determine window start (`\"window\"`, `\"datapoint\"`, or day of week).",
              "default": "\"window\"",
              "resolvedType": "\"window\" | \"datapoint\" | \"monday\" | \"tuesday\" | \"wednesday\" | \"thursday\" | \"friday\" | \"saturday\" | \"sunday\""
            },
            "truncate": {
              "type": "boolean",
              "optional": true,
              "desc": "Truncate the index column values to the window start.",
              "default": "true"
            }
          }
        }
      }
    },
    "head": {
      "desc": "Returns the first N rows as a new DataFrame.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.head(2)\nshape: (2, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n+---+"
      ],
      "params": [
        {
          "name": "n",
          "desc": "Number of leading rows to slice (default 10)."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "head",
      "callExpression": ".head()",
      "signature": "df.head(n: number = 10): DataFrame<T>",
      "signatureDetailed": "df.head(n: number = 10): DataFrame<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 873,
      "lineEnd": 875,
      "typeTree": {
        "n": {
          "type": "number",
          "optional": true,
          "default": "10",
          "desc": "Number of leading rows to slice (default 10)."
        }
      }
    },
    "height": {
      "desc": "Gets height (total row count) of the DataFrame.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.height\n3"
      ],
      "returns": "Number of rows.",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "height",
      "callExpression": ".height",
      "signature": "df.height: number",
      "signatureDetailed": "df.height: number",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 885,
      "lineEnd": 887
    },
    "insertColumn": {
      "desc": "Inserts a new column at a specific ordinal index position.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.insertColumn(1, \"c\", [10, 20])\nshape: (2, 3)\n+---+----+---+\n| a | c  | b |\n+---+----+---+\n| 1 | 10 | x |\n| 2 | 20 | y |\n+---+----+---+"
      ],
      "params": [
        {
          "name": "index",
          "type": "number",
          "desc": "Target column index position."
        },
        {
          "name": "name",
          "type": "string",
          "desc": "Name of the inserted column."
        },
        {
          "name": "expr",
          "type": "InsertColumnArg",
          "desc": "Value expression, column definition, or raw column values array."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "insertColumn",
      "callExpression": ".insertColumn()",
      "signature": "df.insertColumn(\n  index: number,\n  name: string,\n  expr: InsertColumnArg\n): DataFrame<any>",
      "signatureDetailed": "df.insertColumn(\n  index: number,\n  name: string,\n  expr: IntoExpr | ArrayLike<any>\n): DataFrame<any>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 906,
      "lineEnd": 927,
      "typeTree": {
        "index": {
          "type": "number",
          "optional": false,
          "desc": "Target column index position."
        },
        "name": {
          "type": "string",
          "optional": false,
          "desc": "Name of the inserted column."
        },
        "expr": {
          "type": "InsertColumnArg",
          "optional": false,
          "desc": "Value expression, column definition, or raw column values array.",
          "resolvedType": "IntoExpr | ArrayLike<any>"
        }
      }
    },
    "item": {
      "desc": "Retrieves a single scalar cell value by row and column position or name.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.item(0, \"val\")\n42"
      ],
      "params": [
        {
          "name": "[row]",
          "type": "number",
          "desc": "Row index position."
        },
        {
          "name": "[column]",
          "type": "ColumnIndexOrNameArg",
          "desc": "Column index or column name string."
        }
      ],
      "returns": "any",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "item",
      "callExpression": ".item()",
      "signature": "df.item(\n  row?: number,\n  column?: ColumnIndexOrNameArg\n): any",
      "signatureDetailed": "df.item(\n  row?: number,\n  column?: number | string\n): any",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 941,
      "lineEnd": 970,
      "typeTree": {
        "row": {
          "type": "number",
          "optional": true,
          "desc": "Row index position."
        },
        "column": {
          "type": "ColumnIndexOrNameArg",
          "optional": true,
          "desc": "Column index or column name string.",
          "resolvedType": "number | string"
        }
      }
    },
    "iterColumns": {
      "desc": "Yields a generator iterating over raw column arrays.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+"
      ],
      "returns": "Generator of ColumnData arrays.",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "iterColumns",
      "callExpression": ".iterColumns()",
      "signature": "df.iterColumns(): Generator<ColumnData>",
      "signatureDetailed": "df.iterColumns(): Generator<ColumnData>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 980,
      "lineEnd": 984
    },
    "iterRows": {
      "desc": "Yields a generator iterating over rows as tuples or named objects.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+"
      ],
      "params": [
        {
          "name": "[config]",
          "desc": "Iteration format configuration."
        }
      ],
      "returns": "Generator of rows.",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "iterRows",
      "callExpression": ".iterRows()",
      "signature": "df.iterRows(\n  {\n    named = false\n  }: IterRowsOptions = {}\n): Generator<IterRowResult<T>>",
      "signatureDetailed": "df.iterRows(\n  config: {\n    named?: boolean = false\n  } = {}\n): Generator<IterRowResult<T>>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 995,
      "lineEnd": 1017,
      "typeTree": {
        "config": {
          "type": "IterRowsOptions",
          "optional": true,
          "default": "{}",
          "desc": "Iteration format configuration.",
          "properties": {
            "named": {
              "type": "boolean",
              "optional": true,
              "desc": "When `true`, yields row objects with column keys (`{ col: val }`). When `false` (default), yields positional arrays (`[val1, val2]`).",
              "default": "false"
            }
          }
        }
      }
    },
    "join": {
      "desc": "Joins two DataFrames on key columns using a specified join strategy.",
      "examples": [
        "// 1. Inner join on matching key column:\n>>> const df1 = $df.data({ id: [1, 2], val: [\"a\", \"b\"] })\n>>> const df2 = $df.data({ id: [1, 2], num: [100, 200] })\n>>> df1\nshape: (2, 2)\n+----+-----+\n| id | val |\n+----+-----+\n| 1  | a   |\n| 2  | b   |\n+----+-----+\n>>> df2\nshape: (2, 2)\n+----+-----+\n| id | num |\n+----+-----+\n| 1  | 100 |\n| 2  | 200 |\n+----+-----+\n>>> df1.join(df2, { on: \"id\" })\nshape: (2, 3)\n+----+-----+-----+\n| id | val | num |\n+----+-----+-----+\n| 1  | a   | 100 |\n| 2  | b   | 200 |\n+----+-----+-----+",
        "// 2. Outer join on matching key column:\n>>> const df1 = $df.data({ id: [1, 2], val: [\"a\", \"b\"] })\n>>> const df2 = $df.data({ id: [1, 2], num: [100, 200] })\n>>> df1\nshape: (2, 2)\n+----+-----+\n| id | val |\n+----+-----+\n| 1  | a   |\n| 2  | b   |\n+----+-----+\n>>> df2\nshape: (2, 2)\n+----+-----+\n| id | num |\n+----+-----+\n| 1  | 100 |\n| 2  | 200 |\n+----+-----+\n>>> df1.join(df2, { on: \"id\", how: \"outer\" })\nshape: (2, 3)\n+----+-----+-----+\n| id | val | num |\n+----+-----+-----+\n| 1  | a   | 100 |\n| 2  | b   | 200 |\n+----+-----+-----+"
      ],
      "params": [
        {
          "name": "other",
          "type": "DataFrame",
          "desc": "Right DataFrame to join with."
        },
        {
          "name": "[options]",
          "type": "JoinOptions",
          "default": "{}",
          "desc": "Join configuration object."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "join",
      "callExpression": ".join()",
      "signature": "df.join<U extends RowRecord = any, R extends RowRecord = any>(\n  other: DataFrame<U>,\n  options: JoinOptions<T, U> = {}\n): DataFrame<R>",
      "signatureDetailed": "df.join<U extends RowRecord = any, R extends RowRecord = any>(\n  other: DataFrame<U>,\n  options: {\n    coalesce?: boolean = true,\n    how?: \"inner\" | \"outer\" | \"left\" | \"right\" | \"semi\" | \"anti\" | \"cross\" = \"inner\",\n    joinNulls?: boolean = false,\n    leftOn?: keyof any | keyof any[],\n    maintainOrder?: JoinMaintainOrder | boolean = \"none\",\n    on?: keyof any & keyof any | (keyof any & keyof any)[],\n    rightOn?: keyof any | keyof any[],\n    suffixes?: [string, string] = [\"\", \"_right\"]\n  } = {}\n): DataFrame<R>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1048,
      "lineEnd": 1143,
      "typeTree": {
        "other": {
          "type": "DataFrame<U>",
          "optional": false,
          "desc": "Right DataFrame to join with."
        },
        "options": {
          "type": "JoinOptions<T, U>",
          "optional": true,
          "default": "{}",
          "desc": "Join configuration object.",
          "properties": {
            "coalesce": {
              "type": "boolean",
              "optional": true,
              "desc": "Coalescing behavior for join key columns. If `true`, coalesces join key values into left key columns and drops right key columns.",
              "default": "true"
            },
            "how": {
              "type": "JoinType",
              "optional": true,
              "desc": "Join strategy (`\"inner\"`, `\"left\"`, `\"right\"`, `\"outer\"`, `\"semi\"`, `\"anti\"`, or `\"cross\"`).",
              "default": "\"inner\"",
              "resolvedType": "\"inner\" | \"outer\" | \"left\" | \"right\" | \"semi\" | \"anti\" | \"cross\""
            },
            "joinNulls": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, null key values are treated as equal and match each other across DataFrames.",
              "default": "false"
            },
            "leftOn": {
              "type": "ColumnKeyArg<keyof any>",
              "optional": true,
              "desc": "Join key column(s) in the left DataFrame when key names differ.",
              "resolvedType": "keyof any | keyof any[]"
            },
            "maintainOrder": {
              "type": "JoinMaintainOrder | boolean",
              "optional": true,
              "desc": "Row order preservation strategy (`\"none\"`, `\"left\"`, `\"right\"`, `\"left_right\"`, `\"right_left\"`, or boolean).",
              "default": "\"none\""
            },
            "on": {
              "type": "ColumnKeyArg<keyof any & keyof any>",
              "optional": true,
              "desc": "Join key column name or array of key column names that exist in both DataFrames.",
              "resolvedType": "keyof any & keyof any | (keyof any & keyof any)[]"
            },
            "rightOn": {
              "type": "ColumnKeyArg<keyof any>",
              "optional": true,
              "desc": "Join key column(s) in the right DataFrame when key names differ.",
              "resolvedType": "keyof any | keyof any[]"
            },
            "suffixes": {
              "type": "JoinSuffixes",
              "optional": true,
              "desc": "Suffix tuple `[leftSuffix, rightSuffix]` appended to overlapping non-key column names. Ignored for `\"semi\"` and `\"anti\"` joins.",
              "default": "[\"\", \"_right\"]",
              "resolvedType": "[string, string]"
            }
          }
        }
      }
    },
    "joinAsof": {
      "desc": "Performs an asof (as-of) join for inexact matching on ordered numeric or temporal key columns.\n\nSimilar to a left join, but instead of exact key equality, matches the nearest key row from the right DataFrame according to the selected `strategy` (\"backward\", \"forward\", or \"nearest\") and optional `tolerance`. Both DataFrames must be sorted in ascending order on their respective `on` / `leftOn` / `rightOn` join keys.",
      "examples": [
        ">>> const trades = $df.data([\n...   { time: 1000, ticker: \"AAPL\", price: 150.0 },\n...   { time: 1005, ticker: \"AAPL\", price: 150.5 },\n...   { time: 1015, ticker: \"AAPL\", price: 151.0 }\n... ])\n>>> const quotes = $df.data([\n...   { time: 998, ticker: \"AAPL\", bid: 149.9 },\n...   { time: 1004, ticker: \"AAPL\", bid: 150.4 },\n...   { time: 1010, ticker: \"AAPL\", bid: 150.8 }\n... ])\n>>> trades\nshape: (3, 3)\n+------+--------+-------+\n| time | ticker | price |\n+------+--------+-------+\n| 1000 | AAPL   | 150.0 |\n| 1005 | AAPL   | 150.5 |\n| 1015 | AAPL   | 151.0 |\n+------+--------+-------+\n>>> quotes\nshape: (3, 3)\n+------+--------+-------+\n| time | ticker | bid   |\n+------+--------+-------+\n| 998  | AAPL   | 149.9 |\n| 1004 | AAPL   | 150.4 |\n| 1010 | AAPL   | 150.8 |\n+------+--------+-------+\n>>> trades.joinAsof(quotes, { on: \"time\", by: \"ticker\" })\nshape: (3, 4)\n+------+--------+-------+-------+\n| time | ticker | price | bid   |\n+------+--------+-------+-------+\n| 1000 | AAPL   | 150.0 | 149.9 |\n| 1005 | AAPL   | 150.5 | 150.4 |\n| 1015 | AAPL   | 151.0 | 150.8 |\n+------+--------+-------+-------+"
      ],
      "params": [
        {
          "name": "other",
          "type": "DataFrame",
          "desc": "The right DataFrame to join with."
        },
        {
          "name": "options",
          "type": "JoinAsofOptions",
          "desc": "Asof join configuration options."
        }
      ],
      "returns": "A new DataFrame containing the joined results.",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "joinAsof",
      "callExpression": ".joinAsof()",
      "signature": "df.joinAsof<U extends RowRecord = any, R extends RowRecord = any>(\n  other: DataFrame<U>,\n  options: JoinAsofOptions<T, U>\n): DataFrame<R>",
      "signatureDetailed": "df.joinAsof<U extends RowRecord = any, R extends RowRecord = any>(\n  other: DataFrame<U>,\n  options: {\n    allowExactMatches?: boolean = true,\n    by?: keyof any & keyof any | (keyof any & keyof any)[],\n    checkSorted?: boolean = true,\n    coalesce?: boolean = true,\n    leftBy?: keyof any | keyof any[],\n    leftOn?: (keyof any),\n    on?: (keyof any & keyof any),\n    rightBy?: keyof any | keyof any[],\n    rightOn?: (keyof any),\n    strategy?: \"backward\" | \"forward\" | \"nearest\" = \"backward\",\n    suffixes?: [string, string] = [\"\", \"_right\"],\n    tolerance?: number | string\n  }\n): DataFrame<R>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1167,
      "lineEnd": 1246,
      "typeTree": {
        "other": {
          "type": "DataFrame<U>",
          "optional": false,
          "desc": "The right DataFrame to join with."
        },
        "options": {
          "type": "JoinAsofOptions<T, U>",
          "optional": false,
          "desc": "Asof join configuration options.",
          "properties": {
            "allowExactMatches": {
              "type": "boolean",
              "optional": true,
              "desc": "Whether exact key matches are permitted.",
              "default": "true"
            },
            "by": {
              "type": "ColumnKeyArg<keyof any & keyof any>",
              "optional": true,
              "desc": "Optional exact-match group column(s) present in both DataFrames.",
              "resolvedType": "keyof any & keyof any | (keyof any & keyof any)[]"
            },
            "checkSorted": {
              "type": "boolean",
              "optional": true,
              "desc": "Whether to verify that join keys are sorted ascending prior to matching.",
              "default": "true"
            },
            "coalesce": {
              "type": "boolean",
              "optional": true,
              "desc": "Coalescing behavior for join key columns.",
              "default": "true"
            },
            "leftBy": {
              "type": "ColumnKeyArg<keyof any>",
              "optional": true,
              "desc": "Group column(s) for exact key matching in left DataFrame.",
              "resolvedType": "keyof any | keyof any[]"
            },
            "leftOn": {
              "type": "(keyof any)",
              "optional": true,
              "desc": "Left DataFrame join key column name."
            },
            "on": {
              "type": "(keyof any & keyof any)",
              "optional": true,
              "desc": "Column name to join on (must exist in both DataFrames and be sorted ascending)."
            },
            "rightBy": {
              "type": "ColumnKeyArg<keyof any>",
              "optional": true,
              "desc": "Group column(s) for exact key matching in right DataFrame.",
              "resolvedType": "keyof any | keyof any[]"
            },
            "rightOn": {
              "type": "(keyof any)",
              "optional": true,
              "desc": "Right DataFrame join key column name."
            },
            "strategy": {
              "type": "JoinAsofStrategy",
              "optional": true,
              "desc": "Match search strategy (`\"backward\"`, `\"forward\"`, or `\"nearest\"`).",
              "default": "\"backward\"",
              "resolvedType": "\"backward\" | \"forward\" | \"nearest\""
            },
            "suffixes": {
              "type": "JoinSuffixes",
              "optional": true,
              "desc": "Column name suffixes `[leftSuffix, rightSuffix]` to resolve name collisions.",
              "default": "[\"\", \"_right\"]",
              "resolvedType": "[string, string]"
            },
            "tolerance": {
              "type": "DurationValueArg",
              "optional": true,
              "desc": "Maximum allowed distance between left key and right key.",
              "resolvedType": "number | string"
            }
          }
        }
      }
    },
    "joinWhere": {
      "desc": "Joins two DataFrames based on arbitrary expression predicates (non-equi joins).\n\nEvaluates one or more boolean expressions across combined rows from both DataFrames. When column names collide between the two DataFrames, columns are suffixed according to `options.suffixes` (default `[\"\", \"_right\"]`).",
      "examples": [
        ">>> const east = $df.data([\n...   { id: 100, dur: 120, rev: 12, cores: 2 },\n...   { id: 101, dur: 140, rev: 14, cores: 8 },\n...   { id: 102, dur: 160, rev: 16, cores: 4 }\n... ])\n>>> const west = $df.data([\n...   { t_id: 404, time: 90, cost: 9, cores: 4 },\n...   { t_id: 498, time: 130, cost: 13, cores: 2 },\n...   { t_id: 676, time: 150, cost: 15, cores: 1 },\n...   { t_id: 742, time: 170, cost: 16, cores: 4 }\n... ])\n>>> east\nshape: (3, 4)\n+-----+-----+-----+-------+\n| id  | dur | rev | cores |\n+-----+-----+-----+-------+\n| 100 | 120 | 12  | 2     |\n| 101 | 140 | 14  | 8     |\n| 102 | 160 | 16  | 4     |\n+-----+-----+-----+-------+\n>>> west\nshape: (4, 4)\n+------+------+------+-------+\n| t_id | time | cost | cores |\n+------+------+------+-------+\n| 404  | 90   | 9    | 4     |\n| 498  | 130  | 13   | 2     |\n| 676  | 150  | 15   | 1     |\n| 742  | 170  | 16   | 4     |\n+------+------+------+-------+"
      ],
      "params": [
        {
          "name": "other",
          "type": "DataFrame",
          "desc": "The right DataFrame to join with."
        },
        {
          "name": "args",
          "type": "...JoinWhereArg",
          "desc": "Predicate expression(s), arrays of expressions, and an optional configuration options object (`{ how, suffixes }`)."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "joinWhere",
      "callExpression": ".joinWhere()",
      "signature": "df.joinWhere<U extends RowRecord = any, R extends RowRecord = any>(\n  other: DataFrame<U>,\n  ...args: JoinWhereArg[]\n): DataFrame<R>",
      "signatureDetailed": "df.joinWhere<U extends RowRecord = any, R extends RowRecord = any>(\n  other: DataFrame<U>,\n  ...args: {\n    how?: \"inner\" | \"left\" | \"right\" = \"inner\",\n    suffixes?: [string, string] = [\"\", \"_right\"]\n  }\n): DataFrame<R>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1277,
      "lineEnd": 1330,
      "typeTree": {
        "other": {
          "type": "DataFrame<U>",
          "optional": false,
          "desc": "The right DataFrame to join with."
        },
        "args": {
          "type": "JoinWhereArg[]",
          "optional": false,
          "variadic": true,
          "desc": "Predicate expression(s), arrays of expressions, and an optional configuration options object (`{ how, suffixes }`).",
          "resolvedType": "(IntoExprArg | JoinWhereOptions)[]",
          "properties": {
            "how": {
              "type": "JoinWhereStrategy",
              "optional": true,
              "desc": "Join strategy: `\"inner\"`, `\"left\"`, or `\"right\"`.",
              "default": "\"inner\"",
              "resolvedType": "\"inner\" | \"left\" | \"right\""
            },
            "suffixes": {
              "type": "JoinSuffixes",
              "optional": true,
              "desc": "Column name suffixes `[leftSuffix, rightSuffix]` to resolve duplicate column names.",
              "default": "[\"\", \"_right\"]",
              "resolvedType": "[string, string]"
            }
          }
        }
      }
    },
    "limit": {
      "desc": "Limits the output to N rows starting from offset.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.limit(2, { offset: 1 })\nshape: (2, 1)\n+----+\n| a  |\n+----+\n| 20 |\n| 30 |\n+----+"
      ],
      "params": [
        {
          "name": "n",
          "type": "number",
          "desc": "Maximum number of rows to take."
        },
        {
          "name": "[options]",
          "type": "LimitOptions",
          "desc": "Offset and slice direction options."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "limit",
      "callExpression": ".limit()",
      "signature": "df.limit(\n  n: number,\n  {\n    offset = 0,\n    from = \"start\"\n  }: LimitOptions = {}\n): DataFrame<T>",
      "signatureDetailed": "df.limit(\n  n: number,\n  options: {\n    from?: \"start\" | \"end\" = \"start\",\n    offset?: number = 0\n  } = {}\n): DataFrame<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1348,
      "lineEnd": 1372,
      "typeTree": {
        "n": {
          "type": "number",
          "optional": false,
          "desc": "Maximum number of rows to take."
        },
        "options": {
          "type": "LimitOptions",
          "optional": true,
          "default": "{}",
          "desc": "Offset and slice direction options.",
          "properties": {
            "from": {
              "type": "LimitPosition",
              "optional": true,
              "desc": "Slice direction starting point (`\"start\"` or `\"end\"`).",
              "default": "\"start\"",
              "resolvedType": "\"start\" | \"end\""
            },
            "offset": {
              "type": "number",
              "optional": true,
              "desc": "Number of rows to skip before taking `n` rows.",
              "default": "0"
            }
          }
        }
      }
    },
    "partitionBy": {
      "desc": "Splits a DataFrame into sub-DataFrames partitioned by column names or expressions (reusing `.over()` partition semantics).",
      "examples": [
        ""
      ],
      "params": [
        {
          "name": "by",
          "type": "ColumnKeyArg<K>",
          "desc": "Key column(s) or column expressions to partition by."
        },
        {
          "name": "[options]",
          "type": "PartitionByOptions",
          "default": "{}",
          "desc": "Partition configuration options."
        }
      ],
      "returns": "PartitionByResult<T>",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "partitionBy",
      "callExpression": ".partitionBy()",
      "signature": "df.partitionBy<K extends PartitionByKey<T>>(\n  by: ColumnKeyArg<K>,\n  options: PartitionByOptions = {}\n): PartitionByResult<T>",
      "signatureDetailed": "df.partitionBy<K extends PartitionByKey<T>>(\n  by: K | K[],\n  options: {\n    asDict?: boolean = false,\n    maintainOrder?: boolean = true\n  } = {}\n): PartitionByResult<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1384,
      "lineEnd": 1401,
      "typeTree": {
        "by": {
          "type": "ColumnKeyArg<K>",
          "optional": false,
          "desc": "Key column(s) or column expressions to partition by.",
          "resolvedType": "K | K[]"
        },
        "options": {
          "type": "PartitionByOptions",
          "optional": true,
          "default": "{}",
          "desc": "Partition configuration options.",
          "properties": {
            "asDict": {
              "type": "boolean",
              "optional": true,
              "desc": "If true, returns a Record/dictionary mapping each partition key string to its DataFrame. If false (default), returns an array of DataFrames.",
              "default": "false"
            },
            "maintainOrder": {
              "type": "boolean",
              "optional": true,
              "desc": "If true (default), maintain original encounter order of partitions.",
              "default": "true"
            }
          }
        }
      }
    },
    "pivot": {
      "desc": "Pivots columns from long format to a wide datagrid structure.",
      "examples": [
        ">>> const df = $df.data({ year: [2020, 2020, 2021, 2021], month: [\"Jan\", \"Feb\", \"Jan\", \"Feb\"], revenue: [100, 150, 120, 180] })\n>>> df\nshape: (4, 3)\n+------+-------+---------+\n| year | month | revenue |\n+------+-------+---------+\n| 2020 | Jan   | 100     |\n| 2020 | Feb   | 150     |\n| 2021 | Jan   | 120     |\n| 2021 | Feb   | 180     |\n+------+-------+---------+\n>>> df.pivot({ index: \"year\", columns: \"month\", values: \"revenue\" })\nshape: (2, 3)\n+------+-----+-----+\n| year | Jan | Feb |\n+------+-----+-----+\n| 2020 | 100 | 150 |\n| 2021 | 120 | 180 |\n+------+-----+-----+"
      ],
      "params": [
        {
          "name": "config",
          "desc": "Pivot table configuration options."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "pivot",
      "callExpression": ".pivot()",
      "signature": "df.pivot<U extends RowRecord = any>(config: PivotOptions<T>): DataFrame<U>",
      "signatureDetailed": "df.pivot<U extends RowRecord = any>(\n  config: {\n    agg?: (values: any[]) => any | string,\n    columns: keyof T,\n    index: keyof T | keyof T[],\n    values: keyof T\n  }\n): DataFrame<U>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1418,
      "lineEnd": 1472,
      "typeTree": {
        "config": {
          "type": "PivotOptions<T>",
          "optional": false,
          "desc": "Pivot table configuration options.",
          "properties": {
            "agg": {
              "type": "AggFn<any> | string",
              "optional": true,
              "desc": "Aggregation function to apply when multiple values exist for a cell.",
              "resolvedType": "(values: any[]) => any | string"
            },
            "columns": {
              "type": "keyof T",
              "optional": false,
              "desc": "Column whose distinct values become new wide column headers."
            },
            "index": {
              "type": "ColumnKeyArg<keyof T>",
              "optional": false,
              "desc": "Key column(s) to use as new DataFrame rows.",
              "resolvedType": "keyof T | keyof T[]"
            },
            "values": {
              "type": "keyof T",
              "optional": false,
              "desc": "Column whose cell values populate the pivoted grid cells."
            }
          }
        }
      }
    },
    "rename": {
      "desc": "Renames columns based on a key-value mapping dictionary.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.rename({ a: \"id\", b: \"label\" })\nshape: (2, 2)\n+----+-------+\n| id | label |\n+----+-------+\n| 1  | x     |\n| 2  | y     |\n+----+-------+"
      ],
      "params": [
        {
          "name": "[mapping]",
          "type": "RenameMappingArg<T>",
          "desc": "Dictionary mapping old column names to new names."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "rename",
      "callExpression": ".rename()",
      "signature": "df.rename(mapping: RenameMappingArg<T> = {}): DataFrame<any>",
      "signatureDetailed": "df.rename(mapping: RenameMappingArg<T> = {}): DataFrame<any>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1489,
      "lineEnd": 1501,
      "typeTree": {
        "mapping": {
          "type": "RenameMappingArg<T>",
          "optional": true,
          "default": "{}",
          "desc": "Dictionary mapping old column names to new names."
        }
      }
    },
    "reverse": {
      "desc": "Reverses the row ordering of the DataFrame.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.reverse()\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 2 | y |\n| 1 | x |\n+---+---+"
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "reverse",
      "callExpression": ".reverse()",
      "signature": "df.reverse(): DataFrame<T>",
      "signatureDetailed": "df.reverse(): DataFrame<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1517,
      "lineEnd": 1519
    },
    "schema": {
      "desc": "Gets current DataFrameSchema dictionary mapping column names to DataType.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.schema\n{ a: Float64, b: Utf8 }"
      ],
      "returns": "DataFrameSchema mapping.",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "schema",
      "callExpression": ".schema",
      "signature": "df.schema: DataFrameSchema",
      "signatureDetailed": "df.schema: DataFrameSchema",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1529,
      "lineEnd": 1531
    },
    "select": {
      "desc": "Selects specific columns or evaluates column expressions.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.select(\"a\", $df.col(\"b\").add(100).alias(\"b_plus\"))\nshape: (2, 2)\n+---+--------+\n| a | b_plus |\n+---+--------+\n| 1 | 110    |\n| 2 | 120    |\n+---+--------+"
      ],
      "params": [
        {
          "name": "args",
          "type": "SelectArg[]",
          "desc": "Column names, column expressions, or object maps to evaluate."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "select",
      "callExpression": ".select()",
      "signature": "df.select<U extends RowRecord = any>(...args: SelectArg[]): DataFrame<U>",
      "signatureDetailed": "df.select<U extends RowRecord = any>(...args: (SelectItem | SelectItem[])[]): DataFrame<U>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1548,
      "lineEnd": 1645,
      "typeTree": {
        "args": {
          "type": "SelectArg[]",
          "optional": false,
          "variadic": true,
          "desc": "Column names, column expressions, or object maps to evaluate.",
          "resolvedType": "(SelectItem | SelectItem[])[]"
        }
      }
    },
    "shape": {
      "desc": "Gets DataFrame dimensions as [height, width] tuple.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.shape\n[2, 2]"
      ],
      "returns": "Tuple [height, width].",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "shape",
      "callExpression": ".shape",
      "signature": "df.shape: DataFrameShape",
      "signatureDetailed": "df.shape: DataFrameShape",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1655,
      "lineEnd": 1657
    },
    "slice": {
      "desc": "Slices a subset range of rows between start and end index.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.slice(1, 3)\nshape: (2, 1)\n+----+\n| a  |\n+----+\n| 20 |\n| 30 |\n+----+"
      ],
      "params": [
        {
          "name": "start",
          "type": "number",
          "desc": "Starting row index."
        },
        {
          "name": "[end]",
          "type": "number",
          "desc": "Optional ending row index (exclusive)."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "slice",
      "callExpression": ".slice()",
      "signature": "df.slice(\n  start: number,\n  end?: number\n): DataFrame<T>",
      "signatureDetailed": "df.slice(\n  start: number,\n  end?: number\n): DataFrame<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1675,
      "lineEnd": 1684,
      "typeTree": {
        "start": {
          "type": "number",
          "optional": false,
          "desc": "Starting row index."
        },
        "end": {
          "type": "number",
          "optional": true,
          "desc": "Optional ending row index (exclusive)."
        }
      }
    },
    "sort": {
      "desc": "Sorts DataFrame rows by one or more column expressions or custom sorters.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n| 3 | 30 |\n+---+----+\n>>> df.sort({ by: \"a\", descending: true })\nshape: (3, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 3 | 30 |\n| 2 | 20 |\n| 1 | 10 |\n+---+----+"
      ],
      "params": [
        {
          "name": "[config]",
          "type": "SortOptions<T>",
          "desc": "Sort configuration options."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "sort",
      "callExpression": ".sort()",
      "signature": "df.sort(config?: SortOptions<T>): DataFrame<T>",
      "signatureDetailed": "df.sort(\n  config?: {\n    by: keyof any | keyof any[] | IExpr | IExpr[],\n    customComp?: ((a: any, b: any) => number) | Partial<Record<keyof any, (a: any, b: any) => number>> | null,\n    descending?: boolean | boolean[] = false,\n    nullsLast?: boolean = true\n  }\n): DataFrame<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1702,
      "lineEnd": 1737,
      "typeTree": {
        "config": {
          "type": "SortOptions<T>",
          "optional": true,
          "desc": "Sort configuration options.",
          "properties": {
            "by": {
              "type": "ColumnKeyArg<keyof any> | ColumnKeyArg<IExpr>",
              "optional": false,
              "desc": "Column name(s) or expression(s) to sort by.",
              "resolvedType": "keyof any | keyof any[] | IExpr | IExpr[]"
            },
            "customComp": {
              "type": "((a: any, b: any) => number) | Partial<Record<keyof any, (a: any, b: any) => number>> | null",
              "optional": true,
              "desc": "Optional comparator function or dictionary mapping column names to custom comparator functions."
            },
            "descending": {
              "type": "ColumnKeyArg<boolean>",
              "optional": true,
              "desc": "Sort order boolean or array of booleans per key.",
              "default": "false",
              "resolvedType": "boolean | boolean[]"
            },
            "nullsLast": {
              "type": "boolean",
              "optional": true,
              "desc": "When `true`, places nulls at the end of sorted output.",
              "default": "true"
            }
          }
        }
      }
    },
    "tail": {
      "desc": "Returns the last N rows as a new DataFrame.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.tail(2)\nshape: (2, 1)\n+---+\n| a |\n+---+\n| 3 |\n| 4 |\n+---+"
      ],
      "params": [
        {
          "name": "n",
          "desc": "Number of trailing rows to take (default 10)."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "tail",
      "callExpression": ".tail()",
      "signature": "df.tail(n: number = 10): DataFrame<T>",
      "signatureDetailed": "df.tail(n: number = 10): DataFrame<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1754,
      "lineEnd": 1756,
      "typeTree": {
        "n": {
          "type": "number",
          "optional": true,
          "default": "10",
          "desc": "Number of trailing rows to take (default 10)."
        }
      }
    },
    "toArray": {
      "desc": "Evaluates a column expression or retrieves column values as a raw JavaScript array.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.toArray(\"a\")\n[10, 20]"
      ],
      "params": [
        {
          "name": "nameOrExpr",
          "type": "ColumnOrExprArg<K>",
          "desc": "Target column name or column expression."
        }
      ],
      "returns": "any[]",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "toArray",
      "callExpression": ".toArray()",
      "signature": "df.toArray<K extends keyof T>(nameOrExpr: ColumnOrExprArg<K>): any[]",
      "signatureDetailed": "df.toArray<K extends keyof T>(nameOrExpr: K | IExpr): any[]",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1767,
      "lineEnd": 1769,
      "typeTree": {
        "nameOrExpr": {
          "type": "ColumnOrExprArg<K>",
          "optional": false,
          "desc": "Target column name or column expression.",
          "resolvedType": "K | IExpr"
        }
      }
    },
    "toDict": {
      "desc": "Converts columns into a JavaScript dictionary mapping column keys to raw arrays.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.toDict()\n{ a: Float64Array([1, 2]), b: [\"x\", \"y\"] }"
      ],
      "returns": "Column dictionary map.",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "toDict",
      "callExpression": ".toDict()",
      "signature": "df.toDict(): DataFrameColumns<T>",
      "signatureDetailed": "df.toDict(): DataFrameColumns<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1779,
      "lineEnd": 1781
    },
    "toDicts": {
      "desc": "Converts rows into an array of JavaScript objects.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.toDicts()\n[{ a: 1, b: \"x\" }]"
      ],
      "returns": "Array of row record objects.",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "toDicts",
      "callExpression": ".toDicts()",
      "signature": "df.toDicts(): T[]",
      "signatureDetailed": "df.toDicts(): T[]",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1791,
      "lineEnd": 1793
    },
    "transpose": {
      "desc": "Transposes rows into columns and columns into rows.",
      "examples": [
        ">>> const df = $df.data({ year: [2020, 2020, 2021, 2021], month: [\"Jan\", \"Feb\", \"Jan\", \"Feb\"], revenue: [100, 150, 120, 180] })\n>>> df\nshape: (4, 3)\n+------+-------+---------+\n| year | month | revenue |\n+------+-------+---------+\n| 2020 | Jan   | 100     |\n| 2020 | Feb   | 150     |\n| 2021 | Jan   | 120     |\n| 2021 | Feb   | 180     |\n+------+-------+---------+\n>>> df.transpose({ includeHeader: true, headerName: \"metric\" })\nshape: (2, 3)\n+--------+----------+----------+\n| metric | column_0 | column_1 |\n+--------+----------+----------+\n| q1     | 100      | 500      |\n| q2     | 120      | 600      |\n+--------+----------+----------+"
      ],
      "params": [
        {
          "name": "[options]",
          "type": "TransposeOptions",
          "desc": "Transpose layout options."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "transpose",
      "callExpression": ".transpose()",
      "signature": "df.transpose(\n  {\n    includeHeader = false,\n    headerName = \"column\",\n    columnNames\n  }: TransposeOptions = {}\n): DataFrame<any>",
      "signatureDetailed": "df.transpose(\n  options: {\n    columnNames?: string | Iterable<string>,\n    headerName?: string = \"column\",\n    includeHeader?: boolean = false\n  } = {}\n): DataFrame<any>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1810,
      "lineEnd": 1866,
      "typeTree": {
        "options": {
          "type": "TransposeOptions",
          "optional": true,
          "default": "{}",
          "desc": "Transpose layout options.",
          "properties": {
            "columnNames": {
              "type": "TransposeColumnNamesArg",
              "optional": true,
              "desc": "Column name or iterable of strings to use as transposed column headers.",
              "resolvedType": "string | Iterable<string>"
            },
            "headerName": {
              "type": "string",
              "optional": true,
              "desc": "Name of the header column when `includeHeader` is `true`.",
              "default": "\"column\""
            },
            "includeHeader": {
              "type": "boolean",
              "optional": true,
              "desc": "When `true`, includes original column names as a new header column.",
              "default": "false"
            }
          }
        }
      }
    },
    "unique": {
      "desc": "Filters distinct unique rows matching target key columns.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.unique()\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+"
      ],
      "params": [
        {
          "name": "[columns]",
          "type": "ColumnKeyArg<K>",
          "desc": "Target column or array of column names to evaluate uniqueness."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "unique",
      "callExpression": ".unique()",
      "signature": "df.unique<K extends keyof T>(columns?: ColumnKeyArg<K>): DataFrame<T>",
      "signatureDetailed": "df.unique<K extends keyof T>(columns?: K | K[]): DataFrame<T>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1883,
      "lineEnd": 1886,
      "typeTree": {
        "columns": {
          "type": "ColumnKeyArg<K>",
          "optional": true,
          "desc": "Target column or array of column names to evaluate uniqueness.",
          "resolvedType": "K | K[]"
        }
      }
    },
    "unpivot": {
      "desc": "Unpivots a wide DataFrame into a long format structure.",
      "examples": [
        ">>> const df = $df.data({ year: [2020, 2020, 2021, 2021], month: [\"Jan\", \"Feb\", \"Jan\", \"Feb\"], revenue: [100, 150, 120, 180] })\n>>> df\nshape: (4, 3)\n+------+-------+---------+\n| year | month | revenue |\n+------+-------+---------+\n| 2020 | Jan   | 100     |\n| 2020 | Feb   | 150     |\n| 2021 | Jan   | 120     |\n| 2021 | Feb   | 180     |\n+------+-------+---------+\n>>> df.unpivot({ idVars: \"metric\", valueVars: [\"q1\", \"q2\"], varName: \"quarter\", valueName: \"val\" })\nshape: (4, 3)\n+--------+---------+-----+\n| metric | quarter | val |\n+--------+---------+-----+\n| sales  | q1      | 100 |\n| sales  | q2      | 120 |\n| clicks | q1      | 500 |\n| clicks | q2      | 600 |\n+--------+---------+-----+"
      ],
      "params": [
        {
          "name": "config",
          "type": "UnpivotOptions<T>",
          "desc": "Unpivot configuration options."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "unpivot",
      "callExpression": ".unpivot()",
      "signature": "df.unpivot<U extends RowRecord = any>(config: UnpivotOptions<T>): DataFrame<U>",
      "signatureDetailed": "df.unpivot<U extends RowRecord = any>(\n  config: {\n    idVars: keyof T | keyof T[],\n    valueName?: string = \"value\",\n    valueVars: keyof T | keyof T[],\n    varName?: string = \"variable\"\n  }\n): DataFrame<U>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1905,
      "lineEnd": 1952,
      "typeTree": {
        "config": {
          "type": "UnpivotOptions<T>",
          "optional": false,
          "desc": "Unpivot configuration options.",
          "properties": {
            "idVars": {
              "type": "ColumnKeyArg<keyof T>",
              "optional": false,
              "desc": "Key column(s) to retain as identifier variables.",
              "resolvedType": "keyof T | keyof T[]"
            },
            "valueName": {
              "type": "string",
              "optional": true,
              "desc": "Name for the new value column holding cell values.",
              "default": "\"value\""
            },
            "valueVars": {
              "type": "ColumnKeyArg<keyof T>",
              "optional": false,
              "desc": "Column(s) to unpivot into variable-value pairs.",
              "resolvedType": "keyof T | keyof T[]"
            },
            "varName": {
              "type": "string",
              "optional": true,
              "desc": "Name for the new variable column holding old column headers.",
              "default": "\"variable\""
            }
          }
        }
      }
    },
    "unstack": {
      "desc": "Unstacks selected columns into multiple wide columns of size `step`. Reshapes data from long to wide format without aggregation.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.unstack(\"a\", { step: 2, how: \"horizontal\" })\nshape: (2, 2)\n+-----+------+\n| a_0 | a_1  |\n+-----+------+\n| 1   | 2    |\n| 3   | null |\n+-----+------+"
      ],
      "params": [
        {
          "name": "columns",
          "desc": "Column name(s) or selector(s) to unstack."
        },
        {
          "name": "options",
          "desc": "Unstack configuration options (`step`, `how`, `fillValues`)."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "unstack",
      "callExpression": ".unstack()",
      "signature": "df.unstack(\n  columns: IntoExprArg,\n  options: UnstackOptions\n): DataFrame<any>",
      "signatureDetailed": "df.unstack(\n  columns: IntoExpr | IntoExpr[],\n  options: {\n    fillValues?: any = null,\n    how?: \"vertical\" | \"horizontal\" = \"vertical\",\n    step: number\n  }\n): DataFrame<any>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 1972,
      "lineEnd": 2028,
      "typeTree": {
        "columns": {
          "type": "IntoExprArg",
          "optional": false,
          "desc": "Column name(s) or selector(s) to unstack.",
          "resolvedType": "IntoExpr | IntoExpr[]"
        },
        "options": {
          "type": "UnstackOptions",
          "optional": false,
          "desc": "Unstack configuration options (`step`, `how`, `fillValues`).",
          "properties": {
            "fillValues": {
              "type": "any",
              "optional": true,
              "desc": "Value to fill in empty cells when length is not evenly divisible by step.",
              "default": "null"
            },
            "how": {
              "type": "UnstackDirection",
              "optional": true,
              "desc": "Reshaping direction: - \"vertical\" (default): fills down the new columns first before moving to the next column. - \"horizontal\": fills across row-by-row before moving to the next row.",
              "default": "\"vertical\"",
              "resolvedType": "\"vertical\" | \"horizontal\""
            },
            "step": {
              "type": "number",
              "optional": false,
              "desc": "Number of columns to reshape each input column into."
            }
          }
        }
      }
    },
    "width": {
      "desc": "Gets width (total column count) of the DataFrame.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.width\n2"
      ],
      "returns": "Number of columns.",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "width",
      "callExpression": ".width",
      "signature": "df.width: number",
      "signatureDetailed": "df.width: number",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 2038,
      "lineEnd": 2040
    },
    "withColumns": {
      "desc": "Adds new columns or updates existing ones using column expressions.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.withColumns($df.col(\"a\").mul(10).alias(\"a_x10\"))\nshape: (2, 3)\n+---+---+-------+\n| a | b | a_x10 |\n+---+---+-------+\n| 1 | x | 10    |\n| 2 | y | 20    |\n+---+---+-------+"
      ],
      "params": [
        {
          "name": "args",
          "type": "SelectArg[]",
          "desc": "Expressions or field objects defining column calculations."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "withColumns",
      "callExpression": ".withColumns()",
      "signature": "df.withColumns(...args: SelectArg[]): DataFrame<any>",
      "signatureDetailed": "df.withColumns(...args: (SelectItem | SelectItem[])[]): DataFrame<any>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 2057,
      "lineEnd": 2088,
      "typeTree": {
        "args": {
          "type": "SelectArg[]",
          "optional": false,
          "variadic": true,
          "desc": "Expressions or field objects defining column calculations.",
          "resolvedType": "(SelectItem | SelectItem[])[]"
        }
      }
    },
    "withRowIndex": {
      "desc": "Appends an incremental index column.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.withRowIndex(\"idx\")\nshape: (2, 3)\n+-----+---+---+\n| idx | a | b |\n+-----+---+---+\n| 0   | 1 | x |\n| 1   | 2 | y |\n+-----+---+---+"
      ],
      "params": [
        {
          "name": "[name]",
          "type": "string",
          "desc": "Name of index column (default \"index\")."
        },
        {
          "name": "[offset]",
          "type": "number",
          "desc": "Starting numeric index offset (default 0)."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "withRowIndex",
      "callExpression": ".withRowIndex()",
      "signature": "df.withRowIndex(\n  name: string = \"index\",\n  offset: number = 0\n): DataFrame<any>",
      "signatureDetailed": "df.withRowIndex(\n  name: string = \"index\",\n  offset: number = 0\n): DataFrame<any>",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 2106,
      "lineEnd": 2116,
      "typeTree": {
        "name": {
          "type": "string",
          "optional": true,
          "default": "\"index\"",
          "desc": "Name of index column (default \"index\")."
        },
        "offset": {
          "type": "number",
          "optional": true,
          "default": "0",
          "desc": "Starting numeric index offset (default 0)."
        }
      }
    },
    "writeCsv": {
      "desc": "Writes DataFrame to CSV format string or file/stream target.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.writeCsv()\n\"a,b\\n1,x\""
      ],
      "params": [
        {
          "name": "[file]",
          "type": "WriteFileTargetArg",
          "desc": "Target file path or writable stream target (optional)."
        },
        {
          "name": "[options]",
          "type": "WriteCSVOptions",
          "desc": "CSV formatting options."
        }
      ],
      "returns": "string",
      "notes": [
        "[Environment]: When `file` is provided as a string file path, execution requires a Node.js-compatible environment with `fs` access. In browser environments, omit `file` to receive a string or supply a custom writable stream object."
      ],
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "writeCsv",
      "callExpression": ".writeCsv()",
      "signature": "df.writeCsv(\n  file?: WriteFileTargetArg,\n  options: WriteCSVOptions = {}\n): string",
      "signatureDetailed": "df.writeCsv(\n  file?: {\n    write: (str: string) => void\n  },\n  options: {\n    dateFormat?: string,\n    datetimeFormat?: string,\n    includeBom?: boolean = false,\n    includeHeader?: boolean = true,\n    lineTerminator?: string = \"\\n\",\n    nullValue?: string = \"\",\n    numericFormatOptions?: {\n      accountingNegatives?: boolean = false,\n      fallback?: string = \"NaN\",\n      formatNonFinite?: boolean = false,\n      locale?: string = \"en-US\"\n    },\n    quoteChar?: string = '\"',\n    quoteStyle?: \"necessary\" | \"always\" | \"never\" | \"non_numeric\" = \"necessary\",\n    replacerOptions?: {\n      bigintStrategy?: \"string\" | \"number\" = \"string\",\n      formatDate?: (v: Date) => string,\n      handleCircular?: boolean = false,\n      onBigInt?: (v: bigint) => any,\n      onCircular?: (this: any, k: string, v: any) => any,\n      onCustom?: (this: any, k: string, v: any) => any,\n      onDate?: (v: Date) => any,\n      onError?: (v: Error) => any,\n      onMap?: (v: Map<any, any>) => any,\n      onRegExp?: (v: RegExp) => any,\n      onSet?: (v: Set<any>) => any,\n      onTypedArray?: (v: any) => any,\n      onURLSearchParams?: (v: URLSearchParams) => any,\n      replacer?: ((this: any, k: string, v: any) => any) | (string | number)[] | null,\n      voidBigIntReplacement?: boolean = false,\n      voidDateReplacement?: boolean = false,\n      voidMapReplacement?: boolean = false,\n      voidRegExpReplacement?: boolean = false,\n      voidSetReplacement?: boolean = false,\n      voidTypedArrayReplacement?: boolean = false\n    },\n    separator?: string = \",\",\n    timeFormat?: string\n  } = {}\n): string",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 2130,
      "lineEnd": 2165,
      "typeTree": {
        "file": {
          "type": "WriteFileTargetArg",
          "optional": true,
          "desc": "Target file path or writable stream target (optional).",
          "resolvedType": "string | WritableStreamTarget",
          "properties": {
            "write": {
              "type": "(str: string) => void",
              "optional": false,
              "desc": "Writes a serialized string chunk to the underlying stream target."
            }
          }
        },
        "options": {
          "type": "WriteCSVOptions",
          "optional": true,
          "default": "{}",
          "desc": "CSV formatting options.",
          "properties": {
            "dateFormat": {
              "type": "string",
              "optional": true,
              "desc": "Custom `strftime` format string for `Date` values (e.g. `\"%Y-%m-%d\"`)."
            },
            "datetimeFormat": {
              "type": "string",
              "optional": true,
              "desc": "Custom `strftime` format string for `Datetime` values (e.g. `\"%Y-%m-%d %H:%M:%S\"`)."
            },
            "includeBom": {
              "type": "boolean",
              "optional": true,
              "desc": "Whether to include a UTF-8 Byte Order Mark (BOM) at the start of the output.",
              "default": "false"
            },
            "includeHeader": {
              "type": "boolean",
              "optional": true,
              "desc": "Whether to write the header row.",
              "default": "true"
            },
            "lineTerminator": {
              "type": "string",
              "optional": true,
              "desc": "String used to terminate each row.",
              "default": "\"\\n\""
            },
            "nullValue": {
              "type": "string",
              "optional": true,
              "desc": "String representation to use for `null` or missing values.",
              "default": "\"\""
            },
            "numericFormatOptions": {
              "type": "NumericFormatOptions",
              "optional": true,
              "desc": "Options for numeric formatting (floats, ints, bigints).",
              "properties": {
                "accountingNegatives": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, formats negative numbers in accounting parentheses (e.g. `(1.23)`).",
                  "default": "false"
                },
                "fallback": {
                  "type": "string",
                  "optional": true,
                  "desc": "Fallback string returned when the value cannot be parsed into a formattable number.",
                  "default": "\"NaN\""
                },
                "formatNonFinite": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, returns `fallback` for `Infinity` and `-Infinity` values.",
                  "default": "false"
                },
                "locale": {
                  "type": "string",
                  "optional": true,
                  "desc": "BCP 47 language tag (e.g. `\"en-US\"`, `\"de-DE\"`).",
                  "default": "\"en-US\""
                }
              }
            },
            "quoteChar": {
              "type": "string",
              "optional": true,
              "desc": "Single-character quote symbol used for quoting fields.",
              "default": "'\"'"
            },
            "quoteStyle": {
              "type": "\"necessary\" | \"always\" | \"never\" | \"non_numeric\"",
              "optional": true,
              "desc": "Quoting strategy for CSV fields: `\"necessary\"`, `\"always\"`, `\"never\"`, or `\"non_numeric\"`.",
              "default": "\"necessary\""
            },
            "replacerOptions": {
              "type": "SafeJsonReplacerOptions",
              "optional": true,
              "desc": "Options for the safe JSON replacer used when formatting objects and arrays.",
              "properties": {
                "bigintStrategy": {
                  "type": "\"string\" | \"number\"",
                  "optional": true,
                  "desc": "Strategy for serializing `BigInt` values: `\"string\"` or `\"number\"`.",
                  "default": "\"string\""
                },
                "formatDate": {
                  "type": "(v: Date) => string",
                  "optional": true,
                  "desc": "Custom formatter function for `Date` objects (ignored if `onDate` is specified)."
                },
                "handleCircular": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, replaces circular references instead of throwing.",
                  "default": "false"
                },
                "onBigInt": {
                  "type": "(v: bigint) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `BigInt` values."
                },
                "onCircular": {
                  "type": "(this: any, k: string, v: any) => any",
                  "optional": true,
                  "desc": "Custom callback invoked when a circular reference is encountered."
                },
                "onCustom": {
                  "type": "(this: any, k: string, v: any) => any",
                  "optional": true,
                  "desc": "Catch-all serialization override for custom types, executed after native type checks."
                },
                "onDate": {
                  "type": "(v: Date) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `Date` objects (takes precedence over `formatDate`)."
                },
                "onError": {
                  "type": "(v: Error) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `Error` objects."
                },
                "onMap": {
                  "type": "(v: Map<any, any>) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `Map` objects."
                },
                "onRegExp": {
                  "type": "(v: RegExp) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `RegExp` objects."
                },
                "onSet": {
                  "type": "(v: Set<any>) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `Set` objects."
                },
                "onTypedArray": {
                  "type": "(v: any) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `TypedArray` values."
                },
                "onURLSearchParams": {
                  "type": "(v: URLSearchParams) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `URLSearchParams` objects."
                },
                "replacer": {
                  "type": "((this: any, k: string, v: any) => any) | (string | number)[] | null",
                  "optional": true,
                  "desc": "Custom `JSON.stringify` replacer function or property whitelist array applied first."
                },
                "voidBigIntReplacement": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, disables default safe serialization for `BigInt` values.",
                  "default": "false"
                },
                "voidDateReplacement": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, disables default safe serialization for `Date` objects.",
                  "default": "false"
                },
                "voidMapReplacement": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, disables default safe serialization for `Map` objects.",
                  "default": "false"
                },
                "voidRegExpReplacement": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, disables default safe serialization for `RegExp` objects.",
                  "default": "false"
                },
                "voidSetReplacement": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, disables default safe serialization for `Set` objects.",
                  "default": "false"
                },
                "voidTypedArrayReplacement": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, disables default safe serialization for `TypedArray` values.",
                  "default": "false"
                }
              }
            },
            "separator": {
              "type": "string",
              "optional": true,
              "desc": "Single-character delimiter that separates fields.",
              "default": "\",\""
            },
            "timeFormat": {
              "type": "string",
              "optional": true,
              "desc": "Custom `strftime` format string for `Time` values (e.g. `\"%H:%M:%S\"`)."
            }
          }
        }
      }
    },
    "writeJson": {
      "desc": "Writes DataFrame rows to JSON format string or file/stream target.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.writeJson()\n'[{\"a\":1,\"b\":\"x\"}]'"
      ],
      "params": [
        {
          "name": "[file]",
          "type": "WriteFileTargetArg",
          "desc": "Target file path or writable stream target (optional)."
        },
        {
          "name": "[options]",
          "type": "WriteJSONOptions",
          "desc": "JSON formatting and replacer options."
        }
      ],
      "returns": "string",
      "notes": [
        "[Environment]: When `file` is provided as a string file path, execution requires a Node.js-compatible environment with `fs` access. In browser environments, omit `file` to receive a string or supply a custom writable stream object."
      ],
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "writeJson",
      "callExpression": ".writeJson()",
      "signature": "df.writeJson(\n  file?: WriteFileTargetArg,\n  {\n    format = \"json\",\n    replacerOptions\n  }: WriteJSONOptions = {}\n): string",
      "signatureDetailed": "df.writeJson(\n  file?: {\n    write: (str: string) => void\n  },\n  options: {\n    format?: \"json\" | \"ndjson\" = \"json\",\n    replacerOptions?: {\n      bigintStrategy?: \"string\" | \"number\" = \"string\",\n      formatDate?: (v: Date) => string,\n      handleCircular?: boolean = false,\n      onBigInt?: (v: bigint) => any,\n      onCircular?: (this: any, k: string, v: any) => any,\n      onCustom?: (this: any, k: string, v: any) => any,\n      onDate?: (v: Date) => any,\n      onError?: (v: Error) => any,\n      onMap?: (v: Map<any, any>) => any,\n      onRegExp?: (v: RegExp) => any,\n      onSet?: (v: Set<any>) => any,\n      onTypedArray?: (v: any) => any,\n      onURLSearchParams?: (v: URLSearchParams) => any,\n      replacer?: ((this: any, k: string, v: any) => any) | (string | number)[] | null,\n      voidBigIntReplacement?: boolean = false,\n      voidDateReplacement?: boolean = false,\n      voidMapReplacement?: boolean = false,\n      voidRegExpReplacement?: boolean = false,\n      voidSetReplacement?: boolean = false,\n      voidTypedArrayReplacement?: boolean = false\n    }\n  } = {}\n): string",
      "filePath": "dataframe/dataframe.ts",
      "lineStart": 2179,
      "lineEnd": 2206,
      "typeTree": {
        "file": {
          "type": "WriteFileTargetArg",
          "optional": true,
          "desc": "Target file path or writable stream target (optional).",
          "resolvedType": "string | WritableStreamTarget",
          "properties": {
            "write": {
              "type": "(str: string) => void",
              "optional": false,
              "desc": "Writes a serialized string chunk to the underlying stream target."
            }
          }
        },
        "options": {
          "type": "WriteJSONOptions",
          "optional": true,
          "default": "{}",
          "desc": "JSON formatting and replacer options.",
          "properties": {
            "format": {
              "type": "JSONFormat",
              "optional": true,
              "desc": "The format of the JSON output (`\"json\"` or `\"ndjson\"`).",
              "default": "\"json\"",
              "resolvedType": "\"json\" | \"ndjson\""
            },
            "replacerOptions": {
              "type": "SafeJsonReplacerOptions",
              "optional": true,
              "desc": "Options for the safe JSON replacer.",
              "properties": {
                "bigintStrategy": {
                  "type": "\"string\" | \"number\"",
                  "optional": true,
                  "desc": "Strategy for serializing `BigInt` values: `\"string\"` or `\"number\"`.",
                  "default": "\"string\""
                },
                "formatDate": {
                  "type": "(v: Date) => string",
                  "optional": true,
                  "desc": "Custom formatter function for `Date` objects (ignored if `onDate` is specified)."
                },
                "handleCircular": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, replaces circular references instead of throwing.",
                  "default": "false"
                },
                "onBigInt": {
                  "type": "(v: bigint) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `BigInt` values."
                },
                "onCircular": {
                  "type": "(this: any, k: string, v: any) => any",
                  "optional": true,
                  "desc": "Custom callback invoked when a circular reference is encountered."
                },
                "onCustom": {
                  "type": "(this: any, k: string, v: any) => any",
                  "optional": true,
                  "desc": "Catch-all serialization override for custom types, executed after native type checks."
                },
                "onDate": {
                  "type": "(v: Date) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `Date` objects (takes precedence over `formatDate`)."
                },
                "onError": {
                  "type": "(v: Error) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `Error` objects."
                },
                "onMap": {
                  "type": "(v: Map<any, any>) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `Map` objects."
                },
                "onRegExp": {
                  "type": "(v: RegExp) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `RegExp` objects."
                },
                "onSet": {
                  "type": "(v: Set<any>) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `Set` objects."
                },
                "onTypedArray": {
                  "type": "(v: any) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `TypedArray` values."
                },
                "onURLSearchParams": {
                  "type": "(v: URLSearchParams) => any",
                  "optional": true,
                  "desc": "Custom serialization override for `URLSearchParams` objects."
                },
                "replacer": {
                  "type": "((this: any, k: string, v: any) => any) | (string | number)[] | null",
                  "optional": true,
                  "desc": "Custom `JSON.stringify` replacer function or property whitelist array applied first."
                },
                "voidBigIntReplacement": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, disables default safe serialization for `BigInt` values.",
                  "default": "false"
                },
                "voidDateReplacement": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, disables default safe serialization for `Date` objects.",
                  "default": "false"
                },
                "voidMapReplacement": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, disables default safe serialization for `Map` objects.",
                  "default": "false"
                },
                "voidRegExpReplacement": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, disables default safe serialization for `RegExp` objects.",
                  "default": "false"
                },
                "voidSetReplacement": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, disables default safe serialization for `Set` objects.",
                  "default": "false"
                },
                "voidTypedArrayReplacement": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "If `true`, disables default safe serialization for `TypedArray` values.",
                  "default": "false"
                }
              }
            }
          }
        }
      }
    },
    "agg": {
      "desc": "Aggregates grouped partitions using aggregation column expressions.",
      "examples": [
        ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg($df.col(\"val\").sum().alias(\"sum_val\"))\nshape: (2, 2)\n+-------+---------+\n| group | sum_val |\n+-------+---------+\n| A     | 30      |\n| B     | 30      |\n+-------+---------+"
      ],
      "params": [
        {
          "name": "exprs",
          "desc": "One or more aggregation column expressions."
        }
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "agg",
      "callExpression": ".agg()",
      "signature": "df.groupBy(...).agg<U extends RowRecord = any>(...exprs: SelectArg[]): DataFrame<U>",
      "signatureDetailed": "df.groupBy(...exprs: (SelectItem | SelectItem[])[]).agg<U extends RowRecord = any>(...exprs: SelectArg[]): DataFrame<U>",
      "filePath": "dataframe/grouped.ts",
      "lineStart": 87,
      "lineEnd": 124,
      "typeTree": {
        "exprs": {
          "type": "SelectArg[]",
          "optional": false,
          "variadic": true,
          "desc": "One or more aggregation column expressions.",
          "resolvedType": "(SelectItem | SelectItem[])[]"
        }
      }
    },
    "toDataframe": {
      "desc": "Converts group keys back into a single distinct DataFrame without aggregations.",
      "examples": [
        ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").toDataframe()\nshape: (2, 1)\n+-------+\n| group |\n+-------+\n| A     |\n| B     |\n+-------+"
      ],
      "returns": "DataFrame",
      "namespace": "df",
      "category": "DataFrame",
      "propertyAccess": "toDataframe",
      "callExpression": ".toDataframe()",
      "signature": "df.groupBy(...).toDataframe<U extends RowRecord = any>(): DataFrame<U>",
      "signatureDetailed": "df.groupBy(...).toDataframe<U extends RowRecord = any>(): DataFrame<U>",
      "filePath": "dataframe/grouped.ts",
      "lineStart": 140,
      "lineEnd": 143
    }
  },
  "datatypes": {},
  "exceptions": {
    "DFScriptError": {
      "desc": "Base exception class for all df-script errors.",
      "params": [
        {
          "name": "message",
          "type": "string",
          "desc": "The error message."
        }
      ],
      "namespace": "Exception",
      "category": "Exception",
      "propertyAccess": "DFScriptError",
      "callExpression": "DFScriptError",
      "signature": "new DFScriptError(message: string)",
      "signatureDetailed": "new DFScriptError(message: string)",
      "filePath": "exceptions/exceptions.ts",
      "lineStart": 12,
      "lineEnd": 20
    },
    "DataFrameError": {
      "desc": "General error thrown during DataFrame instantiation or execution.",
      "params": [
        {
          "name": "message",
          "type": "string",
          "desc": "The error message."
        }
      ],
      "namespace": "Exception",
      "category": "Exception",
      "propertyAccess": "DataFrameError",
      "callExpression": "DataFrameError",
      "signature": "new DataFrameError(message: string)",
      "signatureDetailed": "new DataFrameError(message: string)",
      "filePath": "exceptions/exceptions.ts",
      "lineStart": 27,
      "lineEnd": 32
    },
    "ColumnNotFoundError": {
      "desc": "Error thrown when a specified column name does not exist in the DataFrame schema.",
      "params": [
        {
          "name": "columnName",
          "type": "string",
          "desc": "The name of the missing column."
        },
        {
          "name": "[message]",
          "type": "string",
          "desc": "Optional custom error message override."
        }
      ],
      "namespace": "Exception",
      "category": "Exception",
      "propertyAccess": "ColumnNotFoundError",
      "callExpression": "ColumnNotFoundError",
      "signature": "new ColumnNotFoundError(\n  columnName: string,\n  message?: string\n)",
      "signatureDetailed": "new ColumnNotFoundError(\n  columnName: string,\n  message?: string\n)",
      "filePath": "exceptions/exceptions.ts",
      "lineStart": 41,
      "lineEnd": 46
    },
    "SchemaError": {
      "desc": "Error thrown when schema definitions, coercions, or data types are invalid.",
      "params": [
        {
          "name": "message",
          "type": "string",
          "desc": "The error message."
        }
      ],
      "namespace": "Exception",
      "category": "Exception",
      "propertyAccess": "SchemaError",
      "callExpression": "SchemaError",
      "signature": "new SchemaError(message: string)",
      "signatureDetailed": "new SchemaError(message: string)",
      "filePath": "exceptions/exceptions.ts",
      "lineStart": 53,
      "lineEnd": 58
    },
    "ComputeError": {
      "desc": "Error thrown during expression evaluation or element-wise calculations.",
      "params": [
        {
          "name": "message",
          "type": "string",
          "desc": "The error message."
        }
      ],
      "namespace": "Exception",
      "category": "Exception",
      "propertyAccess": "ComputeError",
      "callExpression": "ComputeError",
      "signature": "new ComputeError(message: string)",
      "signatureDetailed": "new ComputeError(message: string)",
      "filePath": "exceptions/exceptions.ts",
      "lineStart": 65,
      "lineEnd": 70
    },
    "ShapeError": {
      "desc": "Error thrown when shape dimensions or column heights mismatch.",
      "params": [
        {
          "name": "message",
          "type": "string",
          "desc": "The error message."
        }
      ],
      "namespace": "Exception",
      "category": "Exception",
      "propertyAccess": "ShapeError",
      "callExpression": "ShapeError",
      "signature": "new ShapeError(message: string)",
      "signatureDetailed": "new ShapeError(message: string)",
      "filePath": "exceptions/exceptions.ts",
      "lineStart": 77,
      "lineEnd": 82
    },
    "InvalidArgumentError": {
      "desc": "Error thrown when a parameter or argument provided to a function is invalid.",
      "params": [
        {
          "name": "message",
          "type": "string",
          "desc": "The error message."
        }
      ],
      "namespace": "Exception",
      "category": "Exception",
      "propertyAccess": "InvalidArgumentError",
      "callExpression": "InvalidArgumentError",
      "signature": "new InvalidArgumentError(message: string)",
      "signatureDetailed": "new InvalidArgumentError(message: string)",
      "filePath": "exceptions/exceptions.ts",
      "lineStart": 89,
      "lineEnd": 94
    },
    "IOStreamError": {
      "desc": "Error thrown during file I/O or streaming operations.",
      "params": [
        {
          "name": "message",
          "type": "string",
          "desc": "The error message."
        }
      ],
      "namespace": "Exception",
      "category": "Exception",
      "propertyAccess": "IOStreamError",
      "callExpression": "IOStreamError",
      "signature": "new IOStreamError(message: string)",
      "signatureDetailed": "new IOStreamError(message: string)",
      "filePath": "exceptions/exceptions.ts",
      "lineStart": 101,
      "lineEnd": 106
    }
  },
  "functions": {
    "all": {
      "desc": "Creates an expression targeting all columns in the DataFrame.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.select($df.all())\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+"
      ],
      "returns": "ColumnExpr<any>",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "all",
      "callExpression": "all()",
      "signature": "$df.all(): ColumnExpr<any>",
      "signatureDetailed": "$df.all(): ColumnExpr<any>",
      "filePath": "functions/all.ts",
      "lineStart": 22,
      "lineEnd": 24
    },
    "coalesce": {
      "desc": "Returns the first non-null value among the specified expressions.",
      "examples": [
        "// 1. Coalesce across multiple columns to pick the first non-null:\n>>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.select($df.coalesce($df.col(\"a\"), $df.col(\"b\")).alias(\"ab\"))\nshape: (3, 1)\n+----+\n| ab |\n+----+\n| 1  |\n| 2  |\n| 3  |\n+----+",
        "// 2. Coalesce column with a fallback literal value:\n>>> const df = $df.data({ a: [1, null, 3], b: [null, 2, null] })\n>>> df\nshape: (3, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| null | 2    |\n| 3    | null |\n+------+------+\n>>> df.select($df.coalesce($df.col(\"a\"), $df.lit(0)).alias(\"a0\"))\nshape: (3, 1)\n+----+\n| a0 |\n+----+\n| 1  |\n| 0  |\n| 3  |\n+----+"
      ],
      "params": [
        {
          "name": "exprs",
          "type": "...CoalesceArg",
          "desc": "The list of expressions or columns to coalesce."
        }
      ],
      "returns": "ColumnExpr<any>",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "coalesce",
      "callExpression": "coalesce()",
      "signature": "$df.coalesce(...exprs: CoalesceArg[]): ColumnExpr<any>",
      "signatureDetailed": "$df.coalesce(...exprs: (ScalarArg | ScalarArg[])[]): ColumnExpr<any>",
      "filePath": "functions/coalesce.ts",
      "lineStart": 41,
      "lineEnd": 70,
      "typeTree": {
        "exprs": {
          "type": "CoalesceArg[]",
          "optional": false,
          "variadic": true,
          "desc": "The list of expressions or columns to coalesce.",
          "resolvedType": "(ScalarArg | ScalarArg[])[]"
        }
      }
    },
    "col": {
      "desc": "Creates a column expression referencing one or more columns by name, regular expression, or data type.",
      "examples": [
        "// 1. Select single column by name:\n>>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.select($df.col(\"a\"))\nshape: (2, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n+---+",
        "// 2. Select multiple columns via array:\n>>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.select($df.col([\"a\", \"b\"]))\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+",
        "// 3. Select columns matching a RegExp pattern:\n>>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.select($df.col(/^b$/))\nshape: (2, 1)\n+---+\n| b |\n+---+\n| x |\n| y |\n+---+"
      ],
      "params": [
        {
          "name": "name",
          "type": "ColumnSelector<T>",
          "desc": "Column name, array of names, RegExp pattern, or DataType selector."
        }
      ],
      "returns": "ColumnExpr<T>",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "col",
      "callExpression": "col()",
      "signature": "$df.col<T = any>(name: ColumnSelector<T>): ColumnExpr<T>",
      "signatureDetailed": "$df.col<T = any>(name: keyof T | RegexPatternArg | (keyof T | RegexPatternArg)[] | DataType | Function | (DataType | Function)[]): ColumnExpr<T>",
      "filePath": "functions/col.ts",
      "lineStart": 49,
      "lineEnd": 51,
      "typeTree": {
        "name": {
          "type": "ColumnSelector<T>",
          "optional": false,
          "desc": "Column name, array of names, RegExp pattern, or DataType selector.",
          "resolvedType": "keyof T | RegexPatternArg | (keyof T | RegexPatternArg)[] | DataType | Function | (DataType | Function)[]"
        }
      }
    },
    "concat": {
      "desc": "Concatenates items vertically, horizontally, or diagonally.",
      "examples": [
        "// 1. Vertical Concatenation (default):\n>>> const df1 = $df.data({ a: [1, 2] })\n>>> const df2 = $df.data({ b: [10, 20] })\n>>> df1\nshape: (2, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n+---+\n>>> df2\nshape: (2, 1)\n+----+\n| b  |\n+----+\n| 10 |\n| 20 |\n+----+\n>>> $df.concat([df1, df2], { how: \"vertical\" })\nshape: (4, 1)\n+------+\n| a    |\n+------+\n| 1    |\n| 2    |\n| null |\n| null |\n+------+",
        "// 2. Horizontal Concatenation:\n>>> const df1 = $df.data({ a: [1, 2] })\n>>> const df2 = $df.data({ b: [10, 20] })\n>>> df1\nshape: (2, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n+---+\n>>> df2\nshape: (2, 1)\n+----+\n| b  |\n+----+\n| 10 |\n| 20 |\n+----+\n>>> $df.concat([df1, df2], { how: \"horizontal\" })\nshape: (2, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n+---+----+",
        "// 3. Diagonal Concatenation (mismatched columns):\n>>> const df1 = $df.data({ a: [1, 2] })\n>>> const df2 = $df.data({ b: [10, 20] })\n>>> df1\nshape: (2, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n+---+\n>>> df2\nshape: (2, 1)\n+----+\n| b  |\n+----+\n| 10 |\n| 20 |\n+----+\n>>> $df.concat([df1, df2], { how: \"diagonal\" })\nshape: (4, 2)\n+------+------+\n| a    | b    |\n+------+------+\n| 1    | null |\n| 2    | null |\n| null | 10   |\n| null | 20   |\n+------+------+"
      ],
      "params": [
        {
          "name": "rawItems",
          "desc": "Single DataFrame or array of DataFrames/rows to concatenate."
        },
        {
          "name": "[options]",
          "desc": "Configuration options for concatenation layout and strictness."
        }
      ],
      "returns": "DataFrame",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "concat",
      "callExpression": "concat()",
      "signature": "$df.concat<U extends RowRecord = any>(\n  rawItems: ConcatItemsArg,\n  {\n    how = 'vertical',\n    horizontal\n  }: ConcatOptions = {}\n): DataFrame<U>",
      "signatureDetailed": "$df.concat<U extends RowRecord = any>(\n  rawItems: ConcatItem | ConcatItem[],\n  options: {\n    horizontal?: {\n      strict?: boolean = true\n    },\n    how?: \"vertical\" | \"horizontal\" | \"diagonal\" = \"vertical\"\n  } = {}\n): DataFrame<U>",
      "filePath": "functions/concat.ts",
      "lineStart": 140,
      "lineEnd": 265,
      "typeTree": {
        "rawItems": {
          "type": "ConcatItemsArg",
          "optional": false,
          "desc": "Single DataFrame or array of DataFrames/rows to concatenate.",
          "resolvedType": "ConcatItem | ConcatItem[]"
        },
        "options": {
          "type": "ConcatOptions",
          "optional": true,
          "default": "{}",
          "desc": "Configuration options for concatenation layout and strictness.",
          "properties": {
            "horizontal": {
              "type": "HorizontalConcatOptions",
              "optional": true,
              "desc": "Configuration options specific to horizontal concatenation.",
              "properties": {
                "strict": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "When `true`, throws an error if row counts mismatch in horizontal concatenation. Set `false` to pad shorter DataFrames with `null`.",
                  "default": "true"
                }
              }
            },
            "how": {
              "type": "ConcatHow",
              "optional": true,
              "desc": "Layout strategy: `\"vertical\"` (appends rows top-to-bottom), `\"horizontal\"` (joins unique columns side-by-side), or `\"diagonal\"` (concatenates mismatched columns with null padding).",
              "default": "\"vertical\"",
              "resolvedType": "\"vertical\" | \"horizontal\" | \"diagonal\""
            }
          }
        }
      }
    },
    "data": {
      "desc": "Constructs a new DataFrame from an array of row records or a column dictionary.",
      "examples": [
        "// 1. Construct DataFrame from a column dictionary:\n>>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+",
        "// 2. Construct DataFrame from an array of row objects:\n>>> const df = $df.data([\n...   { a: 1, b: \"x\" },\n...   { a: 2, b: \"y\" }\n... ])\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+"
      ],
      "params": [
        {
          "name": "data",
          "type": "DataFrameDataArg<T>",
          "desc": "Array of row objects or column data dictionary."
        },
        {
          "name": "[schema]",
          "type": "DataFrameSchema",
          "desc": "Optional explicit column schema mapping."
        }
      ],
      "returns": "DataFrame<T>",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "data",
      "callExpression": "data()",
      "signature": "$df.data<T extends RowRecord = any>(\n  data: DataFrameDataArg<T>,\n  schema?: DataFrameSchema\n): DataFrame<T>",
      "signatureDetailed": "$df.data<T extends RowRecord = any>(\n  data: T[] | ColumnDict,\n  schema?: Record<string, RegisteredDataType>\n): DataFrame<T>",
      "filePath": "functions/data.ts",
      "lineStart": 41,
      "lineEnd": 46,
      "typeTree": {
        "data": {
          "type": "DataFrameDataArg<T>",
          "optional": false,
          "desc": "Array of row objects or column data dictionary.",
          "resolvedType": "T[] | ColumnDict"
        },
        "schema": {
          "type": "DataFrameSchema",
          "optional": true,
          "desc": "Optional explicit column schema mapping.",
          "resolvedType": "Record<string, RegisteredDataType>"
        }
      }
    },
    "duration": {
      "desc": "Constructs a Duration expression column from numeric values, string intervals, column references, or expressions.",
      "examples": [
        "// 1. Construct from a duration component options object:\n>>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.select($df.col(\"date\").cast($df.Datetime).add($df.duration({ days: 1 })).alias(\"plus_1_day\"))\nshape: (1, 1)\n+--------------------------+\n| plus_1_day               |\n+--------------------------+\n| 2026-05-21T10:00:00.123Z |\n+--------------------------+",
        "// 2. Construct from a duration string shorthand:\n>>> const df = $df.data({ date: [\"2026-05-20T10:00:00.123Z\"] })\n>>> df\nshape: (1, 1)\n+--------------------------+\n| date                     |\n+--------------------------+\n| 2026-05-20T10:00:00.123Z |\n+--------------------------+\n>>> df.select($df.col(\"date\").cast($df.Datetime).add($df.duration(\"12h\")).alias(\"plus_12h\"))\nshape: (1, 1)\n+--------------------------+\n| plus_12h                 |\n+--------------------------+\n| 2026-05-20T22:00:00.123Z |\n+--------------------------+"
      ],
      "params": [
        {
          "name": "[options]",
          "type": "DurationArg",
          "desc": "Duration component options or string interval (e.g. \"1d 12h\")."
        }
      ],
      "returns": "ColumnExpr<any>",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "duration",
      "callExpression": "duration()",
      "signature": "$df.duration(options: DurationArg = {}): ColumnExpr<any>",
      "signatureDetailed": "$df.duration(\n  options: {\n    days?: IntoExpr | number,\n    hours?: IntoExpr | number,\n    microseconds?: IntoExpr | number,\n    milliseconds?: IntoExpr | number,\n    minutes?: IntoExpr | number,\n    nanoseconds?: IntoExpr | number,\n    seconds?: IntoExpr | number,\n    weeks?: IntoExpr | number\n  } = {}\n): ColumnExpr<any>",
      "filePath": "functions/duration.ts",
      "lineStart": 40,
      "lineEnd": 82,
      "typeTree": {
        "options": {
          "type": "DurationArg",
          "optional": true,
          "default": "{}",
          "desc": "Duration component options or string interval (e.g. \"1d 12h\").",
          "resolvedType": "DurationOptions | string",
          "properties": {
            "days": {
              "type": "DurationComponentArg",
              "optional": true,
              "desc": "Number of days or column expression.",
              "resolvedType": "IntoExpr | number"
            },
            "hours": {
              "type": "DurationComponentArg",
              "optional": true,
              "desc": "Number of hours or column expression.",
              "resolvedType": "IntoExpr | number"
            },
            "microseconds": {
              "type": "DurationComponentArg",
              "optional": true,
              "desc": "Number of microseconds or column expression.",
              "resolvedType": "IntoExpr | number"
            },
            "milliseconds": {
              "type": "DurationComponentArg",
              "optional": true,
              "desc": "Number of milliseconds or column expression.",
              "resolvedType": "IntoExpr | number"
            },
            "minutes": {
              "type": "DurationComponentArg",
              "optional": true,
              "desc": "Number of minutes or column expression.",
              "resolvedType": "IntoExpr | number"
            },
            "nanoseconds": {
              "type": "DurationComponentArg",
              "optional": true,
              "desc": "Number of nanoseconds or column expression.",
              "resolvedType": "IntoExpr | number"
            },
            "seconds": {
              "type": "DurationComponentArg",
              "optional": true,
              "desc": "Number of seconds or column expression.",
              "resolvedType": "IntoExpr | number"
            },
            "weeks": {
              "type": "DurationComponentArg",
              "optional": true,
              "desc": "Number of weeks or column expression.",
              "resolvedType": "IntoExpr | number"
            }
          }
        }
      }
    },
    "element": {
      "desc": "Creates an expression referencing the current element(s) of an array during evaluation. Primarily used inside array operations like `filter`, `map`, or `eval`.",
      "examples": [
        "// 1. Filter elements within array cells:\n>>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.select($df.col(\"a\").arr.filter($df.element().gt(2)).alias(\"filtered\"))\nshape: (2, 1)\n+----------+\n| filtered |\n+----------+\n| [3]      |\n| [4, 5]   |\n+----------+",
        "// 2. Perform element-wise calculation across array cells:\n>>> const df = $df.data({ a: [[1, 2, 3], [4, 5]] })\n>>> df\nshape: (2, 1)\n+-----------+\n| a         |\n+-----------+\n| [1, 2, 3] |\n| [4, 5]    |\n+-----------+\n>>> df.select($df.col(\"a\").arr.eval($df.element().mul(10)).alias(\"scaled\"))\nshape: (2, 1)\n+--------------+\n| scaled       |\n+--------------+\n| [10, 20, 30] |\n| [40, 50]     |\n+--------------+"
      ],
      "returns": "ColumnExpr<T>",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "element",
      "callExpression": "element()",
      "signature": "$df.element<T = any>(): ColumnExpr<T>",
      "signatureDetailed": "$df.element<T = any>(): ColumnExpr<T>",
      "filePath": "functions/element.ts",
      "lineStart": 37,
      "lineEnd": 39
    },
    "exclude": {
      "desc": "Creates an expression targeting all columns except the specified ones.",
      "examples": [
        "// 1. Exclude a single column by name:\n>>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.select($df.exclude(\"a\"))\nshape: (2, 1)\n+---+\n| b |\n+---+\n| x |\n| y |\n+---+",
        "// 2. Exclude a single column from a multi-column dataset:\n>>> const df = $df.data({ a: [1, 2, 3], b: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+---+----+\n| a | b  |\n+---+----+\n| 1 | 10 |\n| 2 | 20 |\n| 3 | 30 |\n+---+----+\n>>> df.select($df.exclude(\"a\"))\nshape: (3, 1)\n+----+\n| b  |\n+----+\n| 10 |\n| 20 |\n| 30 |\n+----+"
      ],
      "params": [
        {
          "name": "columns",
          "type": "ColumnKeyArg",
          "desc": "The name or names of columns to exclude."
        }
      ],
      "returns": "ColumnExpr<any>",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "exclude",
      "callExpression": "exclude()",
      "signature": "$df.exclude(columns: ColumnKeyArg): ColumnExpr<any>",
      "signatureDetailed": "$df.exclude(columns: string | string[]): ColumnExpr<any>",
      "filePath": "functions/exclude.ts",
      "lineStart": 39,
      "lineEnd": 43,
      "typeTree": {
        "columns": {
          "type": "ColumnKeyArg",
          "optional": false,
          "desc": "The name or names of columns to exclude.",
          "resolvedType": "string | string[]"
        }
      }
    },
    "horizontal": {
      "desc": "Combines multiple columns or expressions horizontally into an array per row, allowing expression evaluation with `.eval($df.element()...)`, direct horizontal aggregations (`.sum()`, `.min()`, `.max()`, `.mean()`), or `.arr` operations across columns.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.select($df.horizontal(\"a\", \"b\").sum().alias(\"row_sum\"))\nshape: (2, 1)\n+---------+\n| row_sum |\n+---------+\n| 1       |\n| 2       |\n+---------+"
      ],
      "params": [
        {
          "name": "exprs",
          "type": "...IntoExprArg",
          "desc": "Column names, expressions, selectors (e.g. `$df.all()`), or arrays of them."
        }
      ],
      "returns": "HorizontalExpr",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "horizontal",
      "callExpression": "horizontal()",
      "signature": "$df.horizontal(...exprs: IntoExprArg[]): HorizontalExpr",
      "signatureDetailed": "$df.horizontal(...exprs: (IntoExpr | IntoExpr[])[]): HorizontalExpr",
      "filePath": "functions/horizontal.ts",
      "lineStart": 29,
      "lineEnd": 75,
      "typeTree": {
        "exprs": {
          "type": "IntoExprArg[]",
          "optional": false,
          "variadic": true,
          "desc": "Column names, expressions, selectors (e.g. `$df.all()`), or arrays of them.",
          "resolvedType": "(IntoExpr | IntoExpr[])[]"
        }
      }
    },
    "implode": {
      "desc": "Aggregates values of a column into a list within each group.",
      "examples": [
        ">>> const df = $df.data({ group: [\"A\", \"A\", \"B\"], val: [10, 20, 30] })\n>>> df\nshape: (3, 2)\n+-------+-----+\n| group | val |\n+-------+-----+\n| A     | 10  |\n| A     | 20  |\n| B     | 30  |\n+-------+-----+\n>>> df.groupBy(\"group\").agg($df.implode(\"val\").alias(\"imploded\"))\nshape: (2, 2)\n+-------+----------+\n| group | imploded |\n+-------+----------+\n| A     | [10, 20] |\n| B     | [30]     |\n+-------+----------+"
      ],
      "params": [
        {
          "name": "column",
          "type": "IntoExprArg",
          "desc": "The column or expression to implode."
        }
      ],
      "returns": "ColumnExpr<any>",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "implode",
      "callExpression": "implode()",
      "signature": "$df.implode(column: IntoExprArg): ColumnExpr<any>",
      "signatureDetailed": "$df.implode(column: IntoExpr | IntoExpr[]): ColumnExpr<any>",
      "filePath": "functions/implode.ts",
      "lineStart": 24,
      "lineEnd": 26,
      "typeTree": {
        "column": {
          "type": "IntoExprArg",
          "optional": false,
          "desc": "The column or expression to implode.",
          "resolvedType": "IntoExpr | IntoExpr[]"
        }
      }
    },
    "lit": {
      "desc": "Creates a literal column expression that repeats the given value for all rows.",
      "examples": [
        "// 1. Literal number repeated for every row:\n>>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.select($df.lit(42).alias(\"answer\"))\nshape: (2, 1)\n+--------+\n| answer |\n+--------+\n| 42     |\n| 42     |\n+--------+",
        "// 2. Literal string repeated across rows:\n>>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.withColumns($df.lit(\"active\").alias(\"status\"))\nshape: (2, 3)\n+---+---+--------+\n| a | b | status |\n+---+---+--------+\n| 1 | x | active |\n| 2 | y | active |\n+---+---+--------+"
      ],
      "params": [
        {
          "name": "value",
          "desc": "The literal value (number, string, boolean, etc.)."
        },
        {
          "name": "[options]",
          "desc": "Configuration options."
        }
      ],
      "returns": "ColumnExpr<any>",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "lit",
      "callExpression": "lit()",
      "signature": "$df.lit(\n  value: any,\n  options: LitOptions = {}\n): ColumnExpr<any>",
      "signatureDetailed": "$df.lit(\n  value: any,\n  options: {\n    dtype?: Int8Type | Int16Type | Int32Type | Int64Type | UInt8Type | UInt16Type | UInt32Type | UInt64Type | Float32Type | Float64Type | DecimalType | BooleanType | Utf8Type | BinaryType | NullType | ObjectType | DateType | DatetimeType | TimeType | DurationType | ArrayType<any> | StructType<any>,\n    name?: string\n  } = {}\n): ColumnExpr<any>",
      "filePath": "functions/lit.ts",
      "lineStart": 39,
      "lineEnd": 44,
      "typeTree": {
        "value": {
          "type": "any",
          "optional": false,
          "desc": "The literal value (number, string, boolean, etc.)."
        },
        "options": {
          "type": "LitOptions",
          "optional": true,
          "default": "{}",
          "desc": "Configuration options.",
          "properties": {
            "dtype": {
              "type": "RegisteredDataType",
              "optional": true,
              "desc": "Registered data type to coerce and allocate for the literal column.",
              "resolvedType": "Int8Type | Int16Type | Int32Type | Int64Type | UInt8Type | UInt16Type | UInt32Type | UInt64Type | Float32Type | Float64Type | DecimalType | BooleanType | Utf8Type | BinaryType | NullType | ObjectType | DateType | DatetimeType | TimeType | DurationType | ArrayType<any> | StructType<any>"
            },
            "name": {
              "type": "string",
              "optional": true,
              "desc": "Output column name alias."
            }
          }
        }
      }
    },
    "readCsv": {
      "desc": "Reads a CSV string and constructs a DataFrame. Automatically infers column data types unless an explicit schema is provided.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> $df.readCsv(\"a,b\\n1,x\\n2,y\")\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+"
      ],
      "params": [
        {
          "name": "content",
          "desc": "The CSV content string."
        },
        {
          "name": "[options]",
          "desc": "Parse and configuration options."
        }
      ],
      "returns": "DataFrame",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "readCsv",
      "callExpression": "readCsv()",
      "signature": "$df.readCsv<T extends RowRecord = any>(\n  content: string,\n  options: ReadCSVOptions = {}\n): DataFrame<T>",
      "signatureDetailed": "$df.readCsv<T extends RowRecord = any>(\n  content: string,\n  options: {\n    hasHeader?: boolean = true,\n    inferSchema?: boolean = true,\n    nullValues?: string[] = [\"\", \"NA\", \"null\", \"NaN\"],\n    quoteChar?: string = '\"',\n    schema?: Record<string, RegisteredDataType>,\n    separator?: string = \",\"\n  } = {}\n): DataFrame<T>",
      "filePath": "functions/readCsv.ts",
      "lineStart": 26,
      "lineEnd": 59,
      "typeTree": {
        "content": {
          "type": "string",
          "optional": false,
          "desc": "The CSV content string."
        },
        "options": {
          "type": "ReadCSVOptions",
          "optional": true,
          "default": "{}",
          "desc": "Parse and configuration options.",
          "properties": {
            "hasHeader": {
              "type": "boolean",
              "optional": true,
              "desc": "Whether the CSV has a header row.",
              "default": "true"
            },
            "inferSchema": {
              "type": "boolean",
              "optional": true,
              "desc": "Try to infer types from values if no schema is provided.",
              "default": "true"
            },
            "nullValues": {
              "type": "string[]",
              "optional": true,
              "desc": "String representations of null values.",
              "default": "[\"\", \"NA\", \"null\", \"NaN\"]"
            },
            "quoteChar": {
              "type": "string",
              "optional": true,
              "desc": "The character used for quoting fields.",
              "default": "'\"'"
            },
            "schema": {
              "type": "DataFrameSchema",
              "optional": true,
              "desc": "Optional explicit schema mapping column names to their registered data types.",
              "resolvedType": "Record<string, RegisteredDataType>"
            },
            "separator": {
              "type": "string",
              "optional": true,
              "desc": "Character that separates fields.",
              "default": "\",\""
            }
          }
        }
      }
    },
    "readJson": {
      "desc": "Parses JSON content (JSON or NDJSON) and loads it into a new DataFrame.",
      "examples": [
        ">>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> $df.readJson('[{\"a\":1,\"b\":\"x\"},{\"a\":2,\"b\":\"y\"}]')\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+"
      ],
      "params": [
        {
          "name": "content",
          "desc": "The JSON or NDJSON content string."
        },
        {
          "name": "[options]",
          "desc": "Parse and configuration options."
        }
      ],
      "returns": "A new DataFrame instance populated with the parsed records.",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "readJson",
      "callExpression": "readJson()",
      "signature": "$df.readJson(\n  content: string,\n  {\n    format = \"json\",\n    trimBeforeParse = true,\n    schema,\n    ...parseOpts\n  }: ReadJSONOptions = {}\n): DataFrame<any>",
      "signatureDetailed": "$df.readJson(\n  content: string,\n  options: {\n    allowPrimitives?: boolean = false,\n    format?: \"json\" | \"ndjson\" = \"json\",\n    ndjson?: {\n      maxLines?: number,\n      skipInvalidLines?: boolean = false,\n      skipLines?: number = 0\n    },\n    reviver?: Parameters<typeof JSON.parse>[1],\n    schema?: Record<string, RegisteredDataType>,\n    trimBeforeParse?: boolean = false\n  } = {}\n): DataFrame<any>",
      "filePath": "functions/readJson.ts",
      "lineStart": 25,
      "lineEnd": 40,
      "typeTree": {
        "content": {
          "type": "string",
          "optional": false,
          "desc": "The JSON or NDJSON content string."
        },
        "options": {
          "type": "ReadJSONOptions",
          "optional": true,
          "default": "{}",
          "desc": "Parse and configuration options.",
          "properties": {
            "allowPrimitives": {
              "type": "boolean",
              "optional": true,
              "desc": "Whether to allow JSON primitive roots instead of requiring objects or arrays.",
              "default": "false"
            },
            "format": {
              "type": "JSONFormat",
              "optional": true,
              "desc": "Format of the JSON content: `\"json\"` (standard JSON) or `\"ndjson\"` (Newline Delimited JSON).",
              "default": "\"json\"",
              "resolvedType": "\"json\" | \"ndjson\""
            },
            "ndjson": {
              "type": "NDJSONParseOptions",
              "optional": true,
              "desc": "Options specific to NDJSON parsing when `format` is `\"ndjson\"`.",
              "properties": {
                "maxLines": {
                  "type": "number",
                  "optional": true,
                  "desc": "Maximum number of non-empty lines to validate or parse."
                },
                "skipInvalidLines": {
                  "type": "boolean",
                  "optional": true,
                  "desc": "Skip malformed or invalid lines instead of failing the entire parse.",
                  "default": "false"
                },
                "skipLines": {
                  "type": "number",
                  "optional": true,
                  "desc": "Number of non-empty lines to skip at the beginning of the content.",
                  "default": "0"
                }
              }
            },
            "reviver": {
              "type": "Parameters<typeof JSON.parse>[1]",
              "optional": true,
              "desc": "Reviver function passed to `JSON.parse` for custom value transformation."
            },
            "schema": {
              "type": "DataFrameSchema",
              "optional": true,
              "desc": "Optional explicit schema mapping column names to their registered data types.",
              "resolvedType": "Record<string, RegisteredDataType>"
            },
            "trimBeforeParse": {
              "type": "boolean",
              "optional": true,
              "desc": "Whether to trim leading and trailing whitespace before validating/parsing.",
              "default": "false"
            }
          }
        }
      }
    },
    "seqRange": {
      "desc": "Creates a column expression that generates a range of values. If mode is \"cumulative\" (default) or \"independent\", it generates a sequence. If mode is \"constant\", it repeats the given value.",
      "examples": [
        "// 1. Ascending stepping sequence:\n>>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.seqRange(1, { step: 2 }).alias(\"odd\"))\nshape: (3, 1)\n+-----+\n| odd |\n+-----+\n| 1   |\n| 3   |\n| 5   |\n+-----+",
        "// 2. Descending stepping sequence:\n>>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select($df.seqRange(10, { step: -1 }).alias(\"countdown\"))\nshape: (3, 1)\n+-----------+\n| countdown |\n+-----------+\n| 10        |\n| 9         |\n| 8         |\n+-----------+"
      ],
      "params": [
        {
          "name": "value",
          "desc": "The initial value to start the sequence or the constant value to repeat."
        },
        {
          "name": "[options]",
          "desc": "Configuration options."
        }
      ],
      "returns": "ColumnExpr<any>",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "seqRange",
      "callExpression": "seqRange()",
      "signature": "$df.seqRange(\n  value: any,\n  options: SeqRangeOptions = { strict: true }\n): ColumnExpr<any>",
      "signatureDetailed": "$df.seqRange(\n  value: any,\n  options: {\n    dtype?: Int8Type | Int16Type | Int32Type | Int64Type | UInt8Type | UInt16Type | UInt32Type | UInt64Type | Float32Type | Float64Type | DecimalType | BooleanType | Utf8Type | BinaryType | NullType | ObjectType | DateType | DatetimeType | TimeType | DurationType | ArrayType<any> | StructType<any>,\n    endIndex?: number,\n    mode?: \"constant\" | \"cumulative\" | \"independent\" = \"cumulative\",\n    n?: number = the slice or DataFrame height,\n    name?: string,\n    pad?: boolean = false,\n    padValue?: any = null,\n    startIndex?: number = 0,\n    step?: number | ((context: CumulativeStepContext & IndependentStepContext) => any) = 1,\n    strict?: boolean = true,\n    truncate?: boolean = false\n  } = { strict: true }\n): ColumnExpr<any>",
      "filePath": "functions/seqRange.ts",
      "lineStart": 46,
      "lineEnd": 105,
      "typeTree": {
        "value": {
          "type": "any",
          "optional": false,
          "desc": "The initial value to start the sequence or the constant value to repeat."
        },
        "options": {
          "type": "SeqRangeOptions",
          "optional": true,
          "default": "{ strict: true }",
          "desc": "Configuration options.",
          "properties": {
            "dtype": {
              "type": "RegisteredDataType",
              "optional": true,
              "desc": "Registered data type to coerce and allocate for the generated sequence.",
              "resolvedType": "Int8Type | Int16Type | Int32Type | Int64Type | UInt8Type | UInt16Type | UInt32Type | UInt64Type | Float32Type | Float64Type | DecimalType | BooleanType | Utf8Type | BinaryType | NullType | ObjectType | DateType | DatetimeType | TimeType | DurationType | ArrayType<any> | StructType<any>"
            },
            "endIndex": {
              "type": "number",
              "optional": true,
              "desc": "Ending row index (exclusive) in the DataFrame to insert the sequence (non-strict mode)."
            },
            "mode": {
              "type": "\"constant\" | \"cumulative\" | \"independent\"",
              "optional": true,
              "desc": "Sequence generation mode: `\"constant\"` repeats the initial value, `\"cumulative\"` increments from the previous value, and `\"independent\"` computes each element from its row index.",
              "default": "\"cumulative\""
            },
            "n": {
              "type": "number",
              "optional": true,
              "desc": "Number of values to generate. Defaults to the slice or DataFrame height.",
              "default": "the slice or DataFrame height"
            },
            "name": {
              "type": "string",
              "optional": true,
              "desc": "Output column name alias."
            },
            "pad": {
              "type": "boolean",
              "optional": true,
              "desc": "Pads the sequence with `padValue` if shorter than target slice range (non-strict mode).",
              "default": "false"
            },
            "padValue": {
              "type": "any",
              "optional": true,
              "desc": "Value used for padding in non-strict mode.",
              "default": "null"
            },
            "startIndex": {
              "type": "number",
              "optional": true,
              "desc": "Starting row index in the DataFrame to insert the sequence (non-strict mode).",
              "default": "0"
            },
            "step": {
              "type": "number | ((context: CumulativeStepContext & IndependentStepContext) => any)",
              "optional": true,
              "desc": "Step increment/multiplier value or step callback function.",
              "default": "1"
            },
            "strict": {
              "type": "boolean",
              "optional": true,
              "desc": "When `true`, throws a `ShapeError` if the generated sequence height does not match the target height. When `false`, allows padding, truncation, and slice bounds.",
              "default": "true"
            },
            "truncate": {
              "type": "boolean",
              "optional": true,
              "desc": "Truncates the sequence if it exceeds target slice range (non-strict mode).",
              "default": "false"
            }
          }
        }
      }
    },
    "struct": {
      "desc": "Packages multiple expressions into a structured object column.",
      "examples": [
        "// 1. Package fields using an object property mapping:\n>>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.select($df.struct({ x: \"a\", y: \"b\" }).alias(\"coord\"))\nshape: (2, 1)\n+------------------+\n| coord            |\n+------------------+\n| { x: 1, y: \"x\" } |\n| { x: 2, y: \"y\" } |\n+------------------+",
        "// 2. Package positional column expressions directly into a struct:\n>>> const df = $df.data({ a: [1, 2], b: [\"x\", \"y\"] })\n>>> df\nshape: (2, 2)\n+---+---+\n| a | b |\n+---+---+\n| 1 | x |\n| 2 | y |\n+---+---+\n>>> df.select($df.struct($df.col(\"a\"), $df.col(\"b\")).alias(\"pair\"))\nshape: (2, 1)\n+------------------+\n| pair             |\n+------------------+\n| { a: 1, b: \"x\" } |\n| { a: 2, b: \"y\" } |\n+------------------+"
      ],
      "params": [
        {
          "name": "fields",
          "type": "StructArg",
          "desc": "An array of expressions, a record of field names to expressions, or a single expression."
        },
        {
          "name": "moreFields",
          "type": "...IntoExpr[]",
          "desc": "Additional fields when a single expression is passed as the first parameter."
        }
      ],
      "returns": "ColumnExpr<any>",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "struct",
      "callExpression": "struct()",
      "signature": "$df.struct(\n  fields: StructArg,\n  ...moreFields: IntoExpr[]\n): ColumnExpr<any>",
      "signatureDetailed": "$df.struct(\n  fields: StructFieldsArg | IntoExpr,\n  ...moreFields: (RegexPatternArg | IExpr)[]\n): ColumnExpr<any>",
      "filePath": "functions/struct.ts",
      "lineStart": 41,
      "lineEnd": 61,
      "typeTree": {
        "fields": {
          "type": "StructArg",
          "optional": false,
          "desc": "An array of expressions, a record of field names to expressions, or a single expression.",
          "resolvedType": "StructFieldsArg | IntoExpr"
        },
        "moreFields": {
          "type": "IntoExpr[]",
          "optional": false,
          "variadic": true,
          "desc": "Additional fields when a single expression is passed as the first parameter.",
          "resolvedType": "(RegexPatternArg | IExpr)[]"
        }
      }
    },
    "when": {
      "desc": "Provides conditional branch evaluations inside column expressions.",
      "examples": [
        "// 1. Binary condition with otherwise fallback:\n>>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select(\n...   $df.when($df.col(\"a\").gt(2)).then(\"High\")\n...     .otherwise(\"Low\").alias(\"tier\")\n... )\nshape: (3, 1)\n+------+\n| tier |\n+------+\n| Low  |\n| Low  |\n| High |\n+------+",
        "// 2. Multi-case conditional chaining:\n>>> const df = $df.data({ a: [1, 2, 3] })\n>>> df\nshape: (3, 1)\n+---+\n| a |\n+---+\n| 1 |\n| 2 |\n| 3 |\n+---+\n>>> df.select(\n...   $df.when($df.col(\"a\").eq(1)).then(\"One\")\n...     .when($df.col(\"a\").eq(2)).then(\"Two\")\n...     .otherwise(\"Other\").alias(\"label\")\n... )\nshape: (3, 1)\n+-------+\n| label |\n+-------+\n| One   |\n| Two   |\n| Other |\n+-------+"
      ],
      "params": [
        {
          "name": "predicate",
          "type": "WhenArg",
          "desc": "The boolean condition or expression."
        }
      ],
      "returns": "WhenThenChain",
      "namespace": "$df",
      "category": "Function",
      "propertyAccess": "when",
      "callExpression": "when()",
      "signature": "$df.when(predicate: WhenArg): WhenThenChain",
      "signatureDetailed": "$df.when(predicate: ComparisonArg | RowRecord | any[]): WhenThenChain",
      "filePath": "functions/when.ts",
      "lineStart": 127,
      "lineEnd": 129,
      "typeTree": {
        "predicate": {
          "type": "WhenArg",
          "optional": false,
          "desc": "The boolean condition or expression.",
          "resolvedType": "ComparisonArg | RowRecord | any[]"
        }
      }
    }
  },
  "types": {
    "ColumnExpr": {
      "filePath": "columnExpressions/columnExpr.ts",
      "lineStart": 71,
      "lineEnd": 76,
      "signature": "export interface ColumnExpr<T> extends\n    StandardExpr,\n    StringExpr,\n    TemporalExpr,\n    ArrayExpr,\n    StructExpr { }"
    },
    "StructExprNamespace": {
      "filePath": "columnExpressions/mixins/structExpr.ts",
      "lineStart": 157,
      "lineEnd": 160,
      "desc": "Dynamic index signature allowing direct property access on `struct` expressions (delegating to `.struct.field(key)`).",
      "signature": "export interface StructExprNamespace {\n    /** Dynamic struct field accessor returning a `ColumnExpr` for the given property key. */\n    [key: string]: any;\n}",
      "properties": {
        "[key: string]": {
          "type": "any",
          "optional": false,
          "desc": "Dynamic struct field accessor returning a `ColumnExpr` for the given property key."
        }
      }
    },
    "ArrayArg": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 22,
      "lineEnd": 22,
      "desc": "Operand for array-level operations (containsAll, containsAny, etc.). Accepts an array of scalar values, a typed array, or another column expression.",
      "signature": "export type ArrayArg = IExpr | ValidScalarTypes[] | AnyTypedArray;"
    },
    "BetweenOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 27,
      "lineEnd": 37,
      "desc": "Configuration options for range boundary comparison (`$df.col().between()`).",
      "signature": "export interface BetweenOptions {\n    /**\n     * Controls boundary inclusivity:\n     * - `\"both\"`: `lower <= x <= upper` (default)\n     * - `\"left\"`: `lower <= x < upper`\n     * - `\"right\"`: `lower < x <= upper`\n     * - `\"none\"`: `lower < x < upper`\n     * @default \"both\"\n     */\n    closed?: ClosedBoundary;\n}",
      "properties": {
        "closed": {
          "type": "ClosedBoundary",
          "optional": true,
          "desc": "Controls boundary inclusivity: - `\"both\"`: `lower <= x <= upper` (default) - `\"left\"`: `lower <= x < upper` - `\"right\"`: `lower < x <= upper` - `\"none\"`: `lower < x < upper`",
          "default": "\"both\"",
          "resolvedType": "\"both\" | \"left\" | \"right\" | \"none\""
        }
      }
    },
    "BooleanArg": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 43,
      "lineEnd": 43,
      "desc": "Operand for boolean logical operations (and, or, xor). Accepts a boolean literal, boolean array, another column expression, or null.",
      "signature": "export type BooleanArg = ColumnKeyArg<boolean> | IExpr | null | undefined;"
    },
    "ComparisonArg": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 49,
      "lineEnd": 49,
      "desc": "Operand for equality and comparison expressions (eq, ne, eqMissing, neMissing). Accepts another column expression, valid primitive scalar, or an array of scalar values.",
      "signature": "export type ComparisonArg = ScalarArg | ArrayArg;"
    },
    "CountMatchesOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 54,
      "lineEnd": 60,
      "desc": "Configuration options for counting matching pattern occurrences in a string.",
      "signature": "export interface CountMatchesOptions {\n    /**\n     * If true, treats the pattern as a literal string rather than a regular expression.\n     * @default false\n     */\n    literal?: boolean;\n}",
      "properties": {
        "literal": {
          "type": "boolean",
          "optional": true,
          "desc": "If true, treats the pattern as a literal string rather than a regular expression.",
          "default": "false"
        }
      }
    },
    "CountOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 65,
      "lineEnd": 72,
      "desc": "Configuration options for counting elements (`$df.col().count()`).",
      "signature": "export interface CountOptions {\n    /**\n     * Whether to include `null`, `undefined`, or `NaN` values in the count.\n     * When `false`, counts only non-null, valid elements.\n     * @default false\n     */\n    includeNulls?: boolean;\n}",
      "properties": {
        "includeNulls": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to include `null`, `undefined`, or `NaN` values in the count. When `false`, counts only non-null, valid elements.",
          "default": "false"
        }
      }
    },
    "EwmKurtOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 77,
      "lineEnd": 77,
      "desc": "Configuration options for exponentially weighted moving kurtosis (`$df.col().ewmKurt()`).",
      "signature": "export type EwmKurtOptions = EwmOptions;",
      "properties": {
        "adjust": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, divides by the decaying adjustment factor in beginning periods to account for imbalance in relative weightings.",
          "default": "true"
        },
        "alpha": {
          "type": "number",
          "optional": true,
          "desc": "Smoothing factor `alpha` directly in `(0, 1]`. Mutually exclusive with `span`, `halfLife`, and `com`."
        },
        "bias": {
          "type": "boolean",
          "optional": true,
          "desc": "When `false`, applies sample bias correction; when `true`, computes population moments without bias correction.",
          "default": "false"
        },
        "by": {
          "type": "ColumnOrExprArg",
          "optional": true,
          "desc": "Optional timestamp/index column name or expression used to scale `halfLife` decay by elapsed time deltas.",
          "resolvedType": "string | IExpr"
        },
        "com": {
          "type": "number",
          "optional": true,
          "desc": "Decay in terms of center of mass (`alpha = 1 / (1 + com)`), where `com >= 0`."
        },
        "fisher": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true` (default), computes excess kurtosis (Fisher's definition, subtracting 3.0); when `false`, computes Pearson's kurtosis.",
          "default": "true"
        },
        "halfLife": {
          "type": "DurationValueArg",
          "optional": true,
          "desc": "Decay in terms of half-life (`alpha = 1 - exp(-ln(2) / halfLife)`), as a positive number or duration string.",
          "resolvedType": "number | string"
        },
        "ignoreNulls": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, ignores missing/null values when calculating weights; when `false`, weights decay across null positions.",
          "default": "false"
        },
        "minSamples": {
          "type": "number",
          "optional": true,
          "desc": "Minimum number of non-null observations in window required to produce a value (otherwise `null`).",
          "default": "1"
        },
        "span": {
          "type": "number",
          "optional": true,
          "desc": "Decay in terms of span (`alpha = 2 / (span + 1)`), where `span >= 1`."
        }
      }
    },
    "EwmMeanOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 82,
      "lineEnd": 82,
      "desc": "Configuration options for exponentially weighted moving mean (`$df.col().ewmMean()`).",
      "signature": "export type EwmMeanOptions = Omit<EwmOptions, \"bias\" | \"fisher\">;",
      "properties": {
        "adjust": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, divides by the decaying adjustment factor in beginning periods to account for imbalance in relative weightings.",
          "default": "true"
        },
        "alpha": {
          "type": "number",
          "optional": true,
          "desc": "Smoothing factor `alpha` directly in `(0, 1]`. Mutually exclusive with `span`, `halfLife`, and `com`."
        },
        "by": {
          "type": "ColumnOrExprArg",
          "optional": true,
          "desc": "Optional timestamp/index column name or expression used to scale `halfLife` decay by elapsed time deltas.",
          "resolvedType": "string | IExpr"
        },
        "com": {
          "type": "number",
          "optional": true,
          "desc": "Decay in terms of center of mass (`alpha = 1 / (1 + com)`), where `com >= 0`."
        },
        "halfLife": {
          "type": "DurationValueArg",
          "optional": true,
          "desc": "Decay in terms of half-life (`alpha = 1 - exp(-ln(2) / halfLife)`), as a positive number or duration string.",
          "resolvedType": "number | string"
        },
        "ignoreNulls": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, ignores missing/null values when calculating weights; when `false`, weights decay across null positions.",
          "default": "false"
        },
        "minSamples": {
          "type": "number",
          "optional": true,
          "desc": "Minimum number of non-null observations in window required to produce a value (otherwise `null`).",
          "default": "1"
        },
        "span": {
          "type": "number",
          "optional": true,
          "desc": "Decay in terms of span (`alpha = 2 / (span + 1)`), where `span >= 1`."
        }
      }
    },
    "EwmOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 87,
      "lineEnd": 133,
      "desc": "Configuration options for Exponentially Weighted Moving (EWM) window operations.",
      "signature": "export interface EwmOptions extends CentralMomentsOptions, KurtosisOptions {\n    /**\n     * When `true`, divides by the decaying adjustment factor in beginning periods to account for imbalance in relative weightings.\n     * @default true\n     */\n    adjust?: boolean;\n    /**\n     * Smoothing factor `alpha` directly in `(0, 1]`. Mutually exclusive with `span`, `halfLife`, and `com`.\n     */\n    alpha?: number;\n    /**\n     * When `false`, applies sample bias correction; when `true`, computes population moments without bias correction.\n     * @default false\n     */\n    bias?: boolean;\n    /**\n     * Optional timestamp/index column name or expression used to scale `halfLife` decay by elapsed time deltas.\n     */\n    by?: ColumnOrExprArg;\n    /**\n     * Decay in terms of center of mass (`alpha = 1 / (1 + com)`), where `com >= 0`.\n     */\n    com?: number;\n    /**\n     * When `true` (default), computes excess kurtosis (Fisher's definition, subtracting 3.0); when `false`, computes Pearson's kurtosis.\n     * @default true\n     */\n    fisher?: boolean;\n    /**\n     * Decay in terms of half-life (`alpha = 1 - exp(-ln(2) / halfLife)`), as a positive number or duration string.\n     */\n    halfLife?: DurationValueArg;\n    /**\n     * When `true`, ignores missing/null values when calculating weights; when `false`, weights decay across null positions.\n     * @default false\n     */\n    ignoreNulls?: boolean;\n    /**\n     * Minimum number of non-null observations in window required to produce a value (otherwise `null`).\n     * @default 1\n     */\n    minSamples?: number;\n    /**\n     * Decay in terms of span (`alpha = 2 / (span + 1)`), where `span >= 1`.\n     */\n    span?: number;\n}",
      "properties": {
        "adjust": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, divides by the decaying adjustment factor in beginning periods to account for imbalance in relative weightings.",
          "default": "true"
        },
        "alpha": {
          "type": "number",
          "optional": true,
          "desc": "Smoothing factor `alpha` directly in `(0, 1]`. Mutually exclusive with `span`, `halfLife`, and `com`."
        },
        "bias": {
          "type": "boolean",
          "optional": true,
          "desc": "When `false`, applies sample bias correction; when `true`, computes population moments without bias correction.",
          "default": "false"
        },
        "by": {
          "type": "ColumnOrExprArg",
          "optional": true,
          "desc": "Optional timestamp/index column name or expression used to scale `halfLife` decay by elapsed time deltas.",
          "resolvedType": "string | IExpr"
        },
        "com": {
          "type": "number",
          "optional": true,
          "desc": "Decay in terms of center of mass (`alpha = 1 / (1 + com)`), where `com >= 0`."
        },
        "fisher": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true` (default), computes excess kurtosis (Fisher's definition, subtracting 3.0); when `false`, computes Pearson's kurtosis.",
          "default": "true"
        },
        "halfLife": {
          "type": "DurationValueArg",
          "optional": true,
          "desc": "Decay in terms of half-life (`alpha = 1 - exp(-ln(2) / halfLife)`), as a positive number or duration string.",
          "resolvedType": "number | string"
        },
        "ignoreNulls": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, ignores missing/null values when calculating weights; when `false`, weights decay across null positions.",
          "default": "false"
        },
        "minSamples": {
          "type": "number",
          "optional": true,
          "desc": "Minimum number of non-null observations in window required to produce a value (otherwise `null`).",
          "default": "1"
        },
        "span": {
          "type": "number",
          "optional": true,
          "desc": "Decay in terms of span (`alpha = 2 / (span + 1)`), where `span >= 1`."
        }
      }
    },
    "EwmSkewOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 138,
      "lineEnd": 138,
      "desc": "Configuration options for exponentially weighted moving skewness (`$df.col().ewmSkew()`).",
      "signature": "export type EwmSkewOptions = Omit<EwmOptions, \"fisher\">;",
      "properties": {
        "adjust": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, divides by the decaying adjustment factor in beginning periods to account for imbalance in relative weightings.",
          "default": "true"
        },
        "alpha": {
          "type": "number",
          "optional": true,
          "desc": "Smoothing factor `alpha` directly in `(0, 1]`. Mutually exclusive with `span`, `halfLife`, and `com`."
        },
        "bias": {
          "type": "boolean",
          "optional": true,
          "desc": "When `false`, applies sample bias correction; when `true`, computes population moments without bias correction.",
          "default": "false"
        },
        "by": {
          "type": "ColumnOrExprArg",
          "optional": true,
          "desc": "Optional timestamp/index column name or expression used to scale `halfLife` decay by elapsed time deltas.",
          "resolvedType": "string | IExpr"
        },
        "com": {
          "type": "number",
          "optional": true,
          "desc": "Decay in terms of center of mass (`alpha = 1 / (1 + com)`), where `com >= 0`."
        },
        "halfLife": {
          "type": "DurationValueArg",
          "optional": true,
          "desc": "Decay in terms of half-life (`alpha = 1 - exp(-ln(2) / halfLife)`), as a positive number or duration string.",
          "resolvedType": "number | string"
        },
        "ignoreNulls": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, ignores missing/null values when calculating weights; when `false`, weights decay across null positions.",
          "default": "false"
        },
        "minSamples": {
          "type": "number",
          "optional": true,
          "desc": "Minimum number of non-null observations in window required to produce a value (otherwise `null`).",
          "default": "1"
        },
        "span": {
          "type": "number",
          "optional": true,
          "desc": "Decay in terms of span (`alpha = 2 / (span + 1)`), where `span >= 1`."
        }
      }
    },
    "EwmStdOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 143,
      "lineEnd": 143,
      "desc": "Configuration options for exponentially weighted moving standard deviation (`$df.col().ewmStd()`).",
      "signature": "export type EwmStdOptions = Omit<EwmOptions, \"bias\" | \"fisher\">;",
      "properties": {
        "adjust": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, divides by the decaying adjustment factor in beginning periods to account for imbalance in relative weightings.",
          "default": "true"
        },
        "alpha": {
          "type": "number",
          "optional": true,
          "desc": "Smoothing factor `alpha` directly in `(0, 1]`. Mutually exclusive with `span`, `halfLife`, and `com`."
        },
        "by": {
          "type": "ColumnOrExprArg",
          "optional": true,
          "desc": "Optional timestamp/index column name or expression used to scale `halfLife` decay by elapsed time deltas.",
          "resolvedType": "string | IExpr"
        },
        "com": {
          "type": "number",
          "optional": true,
          "desc": "Decay in terms of center of mass (`alpha = 1 / (1 + com)`), where `com >= 0`."
        },
        "halfLife": {
          "type": "DurationValueArg",
          "optional": true,
          "desc": "Decay in terms of half-life (`alpha = 1 - exp(-ln(2) / halfLife)`), as a positive number or duration string.",
          "resolvedType": "number | string"
        },
        "ignoreNulls": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, ignores missing/null values when calculating weights; when `false`, weights decay across null positions.",
          "default": "false"
        },
        "minSamples": {
          "type": "number",
          "optional": true,
          "desc": "Minimum number of non-null observations in window required to produce a value (otherwise `null`).",
          "default": "1"
        },
        "span": {
          "type": "number",
          "optional": true,
          "desc": "Decay in terms of span (`alpha = 2 / (span + 1)`), where `span >= 1`."
        }
      }
    },
    "EwmSumOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 148,
      "lineEnd": 148,
      "desc": "Configuration options for exponentially weighted moving sum (`$df.col().ewmSum()`).",
      "signature": "export type EwmSumOptions = Omit<EwmOptions, \"adjust\" | \"bias\" | \"fisher\">;",
      "properties": {
        "alpha": {
          "type": "number",
          "optional": true,
          "desc": "Smoothing factor `alpha` directly in `(0, 1]`. Mutually exclusive with `span`, `halfLife`, and `com`."
        },
        "by": {
          "type": "ColumnOrExprArg",
          "optional": true,
          "desc": "Optional timestamp/index column name or expression used to scale `halfLife` decay by elapsed time deltas.",
          "resolvedType": "string | IExpr"
        },
        "com": {
          "type": "number",
          "optional": true,
          "desc": "Decay in terms of center of mass (`alpha = 1 / (1 + com)`), where `com >= 0`."
        },
        "halfLife": {
          "type": "DurationValueArg",
          "optional": true,
          "desc": "Decay in terms of half-life (`alpha = 1 - exp(-ln(2) / halfLife)`), as a positive number or duration string.",
          "resolvedType": "number | string"
        },
        "ignoreNulls": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, ignores missing/null values when calculating weights; when `false`, weights decay across null positions.",
          "default": "false"
        },
        "minSamples": {
          "type": "number",
          "optional": true,
          "desc": "Minimum number of non-null observations in window required to produce a value (otherwise `null`).",
          "default": "1"
        },
        "span": {
          "type": "number",
          "optional": true,
          "desc": "Decay in terms of span (`alpha = 2 / (span + 1)`), where `span >= 1`."
        }
      }
    },
    "EwmVarOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 153,
      "lineEnd": 153,
      "desc": "Configuration options for exponentially weighted moving variance (`$df.col().ewmVar()`).",
      "signature": "export type EwmVarOptions = Omit<EwmOptions, \"bias\" | \"fisher\">;",
      "properties": {
        "adjust": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, divides by the decaying adjustment factor in beginning periods to account for imbalance in relative weightings.",
          "default": "true"
        },
        "alpha": {
          "type": "number",
          "optional": true,
          "desc": "Smoothing factor `alpha` directly in `(0, 1]`. Mutually exclusive with `span`, `halfLife`, and `com`."
        },
        "by": {
          "type": "ColumnOrExprArg",
          "optional": true,
          "desc": "Optional timestamp/index column name or expression used to scale `halfLife` decay by elapsed time deltas.",
          "resolvedType": "string | IExpr"
        },
        "com": {
          "type": "number",
          "optional": true,
          "desc": "Decay in terms of center of mass (`alpha = 1 / (1 + com)`), where `com >= 0`."
        },
        "halfLife": {
          "type": "DurationValueArg",
          "optional": true,
          "desc": "Decay in terms of half-life (`alpha = 1 - exp(-ln(2) / halfLife)`), as a positive number or duration string.",
          "resolvedType": "number | string"
        },
        "ignoreNulls": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, ignores missing/null values when calculating weights; when `false`, weights decay across null positions.",
          "default": "false"
        },
        "minSamples": {
          "type": "number",
          "optional": true,
          "desc": "Minimum number of non-null observations in window required to produce a value (otherwise `null`).",
          "default": "1"
        },
        "span": {
          "type": "number",
          "optional": true,
          "desc": "Decay in terms of span (`alpha = 2 / (span + 1)`), where `span >= 1`."
        }
      }
    },
    "IsCloseOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 158,
      "lineEnd": 174,
      "desc": "Configuration options for approximate floating-point equality comparison (`$df.col().isClose()`).",
      "signature": "export interface IsCloseOptions {\n    /**\n     * Non-negative absolute tolerance threshold.\n     * @default 1e-8\n     */\n    absTol?: number;\n    /**\n     * When `true`, two `NaN` values are treated as close (`true`).\n     * @default false\n     */\n    nansEqual?: boolean;\n    /**\n     * Non-negative relative tolerance threshold scaled by operand magnitude.\n     * @default 1e-8\n     */\n    relTol?: number;\n}",
      "properties": {
        "absTol": {
          "type": "number",
          "optional": true,
          "desc": "Non-negative absolute tolerance threshold.",
          "default": "1e-8"
        },
        "nansEqual": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, two `NaN` values are treated as close (`true`).",
          "default": "false"
        },
        "relTol": {
          "type": "number",
          "optional": true,
          "desc": "Non-negative relative tolerance threshold scaled by operand magnitude.",
          "default": "1e-8"
        }
      }
    },
    "IsNDistinctOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 179,
      "lineEnd": 186,
      "desc": "Configuration options for checking whether column values match the N-th distinct value (`$df.col().isNDistinct()`).",
      "signature": "export interface IsNDistinctOptions {\n    /**\n     * If true (default), returns null when index is out of bounds.\n     * If false, throws an error if index is out of bounds.\n     * @default true\n     */\n    nullOnOob?: boolean;\n}",
      "properties": {
        "nullOnOob": {
          "type": "boolean",
          "optional": true,
          "desc": "If true (default), returns null when index is out of bounds. If false, throws an error if index is out of bounds.",
          "default": "true"
        }
      }
    },
    "NumericArg": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 192,
      "lineEnd": 192,
      "desc": "Operand for arithmetic expressions. Accepts a literal number, bigint, another column expression, or null.",
      "signature": "export type NumericArg = number | bigint | IExpr | null;"
    },
    "NumericSeriesArg": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 198,
      "lineEnd": 198,
      "desc": "Operand for bivariate or series-level operations (corr, cov, dot, etc.). Accepts a numeric column expression, numeric literal, numeric array, or numeric typed array.",
      "signature": "export type NumericSeriesArg = NumericArg | number[] | AnyTypedArray;"
    },
    "ProxyPropertyResolver": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 203,
      "lineEnd": 203,
      "desc": "Callback function for resolving dynamic property access on a delegating Proxy (`createDelegatingProxy`).",
      "signature": "export type ProxyPropertyResolver<T extends object> = (prop: string, target: T) => any;"
    },
    "RandomOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 208,
      "lineEnd": 224,
      "desc": "Configuration options for pseudo-random number generation (`$df.col().rand()`).",
      "signature": "export interface RandomOptions {\n    /**\n     * When `true`, generates random integers in `[min, max]`. When `false`, generates floating-point numbers in `[min, max)`.\n     * @default false\n     */\n    integer?: boolean;\n    /**\n     * Maximum bound (exclusive for floats, inclusive for integers) for generated random values.\n     * @default 1\n     */\n    max?: number;\n    /**\n     * Minimum bound (inclusive) for generated random values.\n     * @default 0\n     */\n    min?: number;\n}",
      "properties": {
        "integer": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, generates random integers in `[min, max]`. When `false`, generates floating-point numbers in `[min, max)`.",
          "default": "false"
        },
        "max": {
          "type": "number",
          "optional": true,
          "desc": "Maximum bound (exclusive for floats, inclusive for integers) for generated random values.",
          "default": "1"
        },
        "min": {
          "type": "number",
          "optional": true,
          "desc": "Minimum bound (inclusive) for generated random values.",
          "default": "0"
        }
      }
    },
    "RankOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 229,
      "lineEnd": 236,
      "desc": "Configuration options for window rank calculation (`$df.col().rank()`).",
      "signature": "export interface RankOptions {\n    /**\n     * When true, ranks are consecutive integers without gaps between tied values (1, 2, 2, 3).\n     * When false (default), ranks have gaps for tied values (1, 2, 2, 4).\n     * @default false\n     */\n    dense?: boolean;\n}",
      "properties": {
        "dense": {
          "type": "boolean",
          "optional": true,
          "desc": "When true, ranks are consecutive integers without gaps between tied values (1, 2, 2, 3). When false (default), ranks have gaps for tied values (1, 2, 2, 4).",
          "default": "false"
        }
      }
    },
    "ReplaceAllOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 242,
      "lineEnd": 242,
      "desc": "Configuration options for replacing all matching occurrences in a string. Omits the count limit `n` option present in `ReplaceOptions`.",
      "signature": "export type ReplaceAllOptions = Omit<ReplaceOptions, \"n\">;",
      "properties": {
        "asciiCaseInsensitive": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether matching should be case-insensitive for ASCII characters.",
          "default": "false"
        },
        "global": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to replace all matches globally.",
          "default": "false"
        },
        "literal": {
          "type": "boolean",
          "optional": true,
          "desc": "Treat pattern as a literal substring instead of a regular expression.",
          "default": "false"
        },
        "mode": {
          "type": "EscapeRegexMode",
          "optional": true,
          "desc": "Escaping mode when `literal` is `true`.",
          "default": "\"tc39\"",
          "resolvedType": "\"tc39\" | \"nonAlphanumericAscii\""
        }
      }
    },
    "RollingOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 247,
      "lineEnd": 252,
      "desc": "Configuration options for rolling window aggregations (`rollingMean`, `rollingSum`, `rollingMin`, `rollingMax`, `rollingStd`, `rollingVar`, etc.).",
      "signature": "export interface RollingOptions {\n    /**\n     * Number of consecutive elements in the moving window.\n     */\n    windowSize: number;\n}",
      "properties": {
        "windowSize": {
          "type": "number",
          "optional": false,
          "desc": "Number of consecutive elements in the moving window."
        }
      }
    },
    "ShiftOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 257,
      "lineEnd": 263,
      "desc": "Configuration options for shifting column or array elements (`shift`, `lag`, `lead`).",
      "signature": "export interface ShiftOptions {\n    /**\n     * Fallback fill value for empty slots introduced by shift/lag/lead.\n     * @default null\n     */\n    fillValue?: any;\n}",
      "properties": {
        "fillValue": {
          "type": "any",
          "optional": true,
          "desc": "Fallback fill value for empty slots introduced by shift/lag/lead.",
          "default": "null"
        }
      }
    },
    "StringArg": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 269,
      "lineEnd": 269,
      "desc": "Operand for string concatenation or text operations. Accepts a string literal or another column expression.",
      "signature": "export type StringArg = ColumnOrExprArg<string>;"
    },
    "StringDecodeOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 274,
      "lineEnd": 280,
      "desc": "Configuration options for decoding encoded string values (`$df.col().str.decode()`).",
      "signature": "export interface StringDecodeOptions extends StringEncodeOptions {\n    /**\n     * Whether invalid encoded sequences should throw an error (`true`) or return `null` (`false`).\n     * @default true\n     */\n    strict?: boolean;\n}",
      "properties": {
        "encoding": {
          "type": "StringEncoding",
          "optional": false,
          "desc": "Target string encoding format (`\"hex\"` or `\"base64\"`).",
          "resolvedType": "\"hex\" | \"base64\""
        },
        "strict": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether invalid encoded sequences should throw an error (`true`) or return `null` (`false`).",
          "default": "true"
        }
      }
    },
    "StringEncodeOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 285,
      "lineEnd": 290,
      "desc": "Configuration options for encoding string values (`$df.col().str.encode()`).",
      "signature": "export interface StringEncodeOptions {\n    /**\n     * Target string encoding format (`\"hex\"` or `\"base64\"`).\n     */\n    encoding: StringEncoding;\n}",
      "properties": {
        "encoding": {
          "type": "StringEncoding",
          "optional": false,
          "desc": "Target string encoding format (`\"hex\"` or `\"base64\"`).",
          "resolvedType": "\"hex\" | \"base64\""
        }
      }
    },
    "StringReplacementArg": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 296,
      "lineEnd": 296,
      "desc": "Operand for string replacement operations (replace, replaceAll). Accepts a static replacement string or a dynamic replacer callback function.",
      "signature": "export type StringReplacementArg = string | StringReplacerFn;"
    },
    "StringReplacementSeriesArg": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 302,
      "lineEnd": 302,
      "desc": "Operand for multiple string replacements (replaceMany). Accepts an array of replacement strings or dynamic replacer callback functions.",
      "signature": "export type StringReplacementSeriesArg = StringReplacementArg[];"
    },
    "StringReplacerArg": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 308,
      "lineEnd": 308,
      "desc": "Arguments passed to an ECMAScript string replacer callback after the matched substring. Reuses RowRecord for named groups object, with scalar types for capture strings and offsets.",
      "signature": "export type StringReplacerArg = ValidScalarTypes | RowRecord;"
    },
    "StringReplacerFn": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 313,
      "lineEnd": 313,
      "desc": "Dynamic callback for string replacements following ECMAScript String.prototype.replace standards.",
      "signature": "export type StringReplacerFn = (match: string, ...args: StringReplacerArg[]) => string;"
    },
    "ToStructOptions": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 318,
      "lineEnd": 327,
      "desc": "Configuration options for converting array/list elements into struct objects (`$df.col().arr.toStruct()`).",
      "signature": "export interface ToStructOptions {\n    /**\n     * Explicit array of struct field names or a callback `(idx: number) => string` generating field names by element index. Defaults to `\"field_0\"`, `\"field_1\"`, etc.\n     */\n    fields?: string[] | ((idx: number) => string);\n    /**\n     * Maximum number of array elements to extract into struct fields when `fields` is not an array. Defaults to the maximum array length in the column.\n     */\n    upperBound?: number;\n}",
      "properties": {
        "fields": {
          "type": "string[] | ((idx: number) => string)",
          "optional": true,
          "desc": "Explicit array of struct field names or a callback `(idx: number) => string` generating field names by element index. Defaults to `\"field_0\"`, `\"field_1\"`, etc.",
          "default": "`\"field_0\"`, `\"field_1\"`, etc"
        },
        "upperBound": {
          "type": "number",
          "optional": true,
          "desc": "Maximum number of array elements to extract into struct fields when `fields` is not an array. Defaults to the maximum array length in the column.",
          "default": "the maximum array length in the column"
        }
      }
    },
    "UnicodeNormalizeForm": {
      "filePath": "columnExpressions/types.ts",
      "lineStart": 336,
      "lineEnd": 336,
      "desc": "Unicode normalization form. - `\"NFC\"`: Canonical Decomposition, followed by Canonical Composition (default) - `\"NFD\"`: Canonical Decomposition - `\"NFKC\"`: Compatibility Decomposition, followed by Canonical Composition - `\"NFKD\"`: Compatibility Decomposition",
      "signature": "export type UnicodeNormalizeForm = \"NFC\" | \"NFD\" | \"NFKC\" | \"NFKD\";"
    },
    "GroupedData": {
      "filePath": "dataframe/grouped.ts",
      "lineStart": 11,
      "lineEnd": 11,
      "desc": "Grouped DataFrame interface including delegated aggregation shorthand methods.",
      "signature": "export interface GroupedData<T extends RowRecord = any, K extends keyof T = keyof T> extends GroupedAggDelegatedOps<T> { }"
    },
    "CastTargetArg": {
      "filePath": "dataframe/types.ts",
      "lineStart": 28,
      "lineEnd": 28,
      "desc": "Target data type specification for `DataFrame.cast()`. Accepts a single `RegisteredDataType` to cast all columns, or a schema dictionary mapping column names to data types.",
      "signature": "export type CastTargetArg = RegisteredDataType | DataFrameSchema;"
    },
    "DataFrameColumns": {
      "filePath": "dataframe/types.ts",
      "lineStart": 33,
      "lineEnd": 38,
      "desc": "Mapped column dictionary storing a `ColumnData` sequence for each key in row record `T`.",
      "signature": "export type DataFrameColumns<T extends RowRecord> = {\n    /**\n     * Column data array or typed array for column `K`.\n     */\n    [K in keyof T]: ColumnData<T[K]>;\n};",
      "properties": {
        "[K in keyof T]": {
          "type": "ColumnData<T[K]>",
          "optional": false,
          "desc": "Column data array or typed array for column `K`."
        }
      }
    },
    "DataFrameShape": {
      "filePath": "dataframe/types.ts",
      "lineStart": 43,
      "lineEnd": 43,
      "desc": "Tuple representing DataFrame dimensions as `[height, width]`.",
      "signature": "export type DataFrameShape = [number, number];"
    },
    "DynamicIndexColumnArg": {
      "filePath": "dataframe/types.ts",
      "lineStart": 48,
      "lineEnd": 48,
      "desc": "Target index column or expression for `DataFrame.groupByDynamic()`.",
      "signature": "export type DynamicIndexColumnArg<K extends string = string> = K | IntoExpr;"
    },
    "DynamicLabel": {
      "filePath": "dataframe/types.ts",
      "lineStart": 53,
      "lineEnd": 53,
      "desc": "Window boundary used to label each dynamic group window in `DataFrame.groupByDynamic()`.",
      "signature": "export type DynamicLabel = \"left\" | \"right\" | \"datapoint\";"
    },
    "DynamicStartBy": {
      "filePath": "dataframe/types.ts",
      "lineStart": 58,
      "lineEnd": 58,
      "desc": "Strategy for determining the initial window boundary alignment in `DataFrame.groupByDynamic()`.",
      "signature": "export type DynamicStartBy = \"window\" | \"datapoint\" | \"monday\" | \"tuesday\" | \"wednesday\" | \"thursday\" | \"friday\" | \"saturday\" | \"sunday\";"
    },
    "EqualsOptions": {
      "filePath": "dataframe/types.ts",
      "lineStart": 63,
      "lineEnd": 69,
      "desc": "Configuration options for checking equality between two DataFrames (`DataFrame.equals()`).",
      "signature": "export interface EqualsOptions {\n    /**\n     * Whether nulls and NaNs compare as equal.\n     * @default true\n     */\n    nullsEqual?: boolean;\n}",
      "properties": {
        "nullsEqual": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether nulls and NaNs compare as equal.",
          "default": "true"
        }
      }
    },
    "FilterPredicate": {
      "filePath": "dataframe/types.ts",
      "lineStart": 74,
      "lineEnd": 74,
      "desc": "Single filter condition: a boolean column expression or a row-level predicate function.",
      "signature": "export type FilterPredicate<T extends RowRecord = RowRecord> = IExpr | RowPredicateFn<T>;"
    },
    "FilterPredicateArg": {
      "filePath": "dataframe/types.ts",
      "lineStart": 80,
      "lineEnd": 80,
      "desc": "Operand for `DataFrame.filter()`. Accepts a single filter predicate or an array of filter predicates.",
      "signature": "export type FilterPredicateArg<T extends RowRecord = RowRecord> = ColumnKeyArg<FilterPredicate<T>>;"
    },
    "GroupByDynamicOptions": {
      "filePath": "dataframe/types.ts",
      "lineStart": 85,
      "lineEnd": 137,
      "desc": "Configuration options for rolling/dynamic temporal or index window grouping (`DataFrame.groupByDynamic()`).",
      "signature": "export interface GroupByDynamicOptions<T = any> {\n    /**\n     * Additional columns to partition / group by before dynamic windowing.\n     */\n    by?: ColumnKeyArg<keyof T>;\n    /**\n     * Verify whether index column is sorted in ascending order.\n     * @default true\n     */\n    checkSorted?: boolean;\n    /**\n     * Which boundary of the window interval is closed (`\"left\"`, `\"right\"`, `\"both\"`, `\"none\"`).\n     * @default \"left\"\n     */\n    closed?: ClosedBoundary;\n    /**\n     * Time interval window step period (e.g. `\"1d\"`, `\"1h\"`, `1000`).\n     */\n    every: DurationValueArg;\n    /**\n     * Polars alias for `by`.\n     */\n    groupBy?: ColumnKeyArg<keyof T>;\n    /**\n     * Include the lower and upper window boundaries (`_lower_boundary`, `_upper_boundary`).\n     * @default false\n     */\n    includeBoundaries?: boolean;\n    /**\n     * Which window boundary to use as the timestamp label (`\"left\"`, `\"right\"`, `\"datapoint\"`).\n     * @default \"left\"\n     */\n    label?: DynamicLabel;\n    /**\n     * Offset window start by a duration.\n     * @default 0\n     */\n    offset?: DurationValueArg;\n    /**\n     * Time period duration window width. Defaults to `every` if omitted.\n     */\n    period?: DurationValueArg;\n    /**\n     * Strategy to determine window start (`\"window\"`, `\"datapoint\"`, or day of week).\n     * @default \"window\"\n     */\n    startBy?: DynamicStartBy;\n    /**\n     * Truncate the index column values to the window start.\n     * @default true\n     */\n    truncate?: boolean;\n}",
      "properties": {
        "by": {
          "type": "ColumnKeyArg<keyof any>",
          "optional": true,
          "desc": "Additional columns to partition / group by before dynamic windowing.",
          "resolvedType": "keyof any | keyof any[]"
        },
        "checkSorted": {
          "type": "boolean",
          "optional": true,
          "desc": "Verify whether index column is sorted in ascending order.",
          "default": "true"
        },
        "closed": {
          "type": "ClosedBoundary",
          "optional": true,
          "desc": "Which boundary of the window interval is closed (`\"left\"`, `\"right\"`, `\"both\"`, `\"none\"`).",
          "default": "\"left\"",
          "resolvedType": "\"both\" | \"left\" | \"right\" | \"none\""
        },
        "every": {
          "type": "DurationValueArg",
          "optional": false,
          "desc": "Time interval window step period (e.g. `\"1d\"`, `\"1h\"`, `1000`).",
          "resolvedType": "number | string"
        },
        "groupBy": {
          "type": "ColumnKeyArg<keyof any>",
          "optional": true,
          "desc": "Polars alias for `by`.",
          "resolvedType": "keyof any | keyof any[]"
        },
        "includeBoundaries": {
          "type": "boolean",
          "optional": true,
          "desc": "Include the lower and upper window boundaries (`_lower_boundary`, `_upper_boundary`).",
          "default": "false"
        },
        "label": {
          "type": "DynamicLabel",
          "optional": true,
          "desc": "Which window boundary to use as the timestamp label (`\"left\"`, `\"right\"`, `\"datapoint\"`).",
          "default": "\"left\"",
          "resolvedType": "\"left\" | \"right\" | \"datapoint\""
        },
        "offset": {
          "type": "DurationValueArg",
          "optional": true,
          "desc": "Offset window start by a duration.",
          "default": "0",
          "resolvedType": "number | string"
        },
        "period": {
          "type": "DurationValueArg",
          "optional": true,
          "desc": "Time period duration window width. Defaults to `every` if omitted.",
          "default": "`every` if omitted",
          "resolvedType": "number | string"
        },
        "startBy": {
          "type": "DynamicStartBy",
          "optional": true,
          "desc": "Strategy to determine window start (`\"window\"`, `\"datapoint\"`, or day of week).",
          "default": "\"window\"",
          "resolvedType": "\"window\" | \"datapoint\" | \"monday\" | \"tuesday\" | \"wednesday\" | \"thursday\" | \"friday\" | \"saturday\" | \"sunday\""
        },
        "truncate": {
          "type": "boolean",
          "optional": true,
          "desc": "Truncate the index column values to the window start.",
          "default": "true"
        }
      }
    },
    "GroupedAggDelegatedMethodNames": {
      "filePath": "dataframe/types.ts",
      "lineStart": 142,
      "lineEnd": 157,
      "desc": "Method names of `ColumnExpr` aggregation operations automatically delegated onto `GroupedData`.",
      "signature": "export type GroupedAggDelegatedMethodNames =\n    | \"all\"\n    | \"avg\"\n    | \"count\"\n    | \"first\"\n    | \"kurtosis\"\n    | \"last\"\n    | \"max\"\n    | \"mean\"\n    | \"median\"\n    | \"min\"\n    | \"nUnique\"\n    | \"skew\"\n    | \"std\"\n    | \"sum\"\n    | \"variance\";"
    },
    "GroupedAggDelegatedOps": {
      "filePath": "dataframe/types.ts",
      "lineStart": 162,
      "lineEnd": 167,
      "desc": "Mapped interface of aggregation shorthand methods available directly on `GroupedData`.",
      "signature": "export type GroupedAggDelegatedOps<T extends RowRecord = any> = {\n    /**\n     * Executes aggregation `K` across all non-key columns in each group.\n     */\n    [K in GroupedAggDelegatedMethodNames]: (...args: Parameters<ColumnExpr<any>[K]>) => DataFrame<T>;\n};",
      "properties": {
        "[K in GroupedAggDelegatedMethodNames]": {
          "type": "(...args: Parameters<ColumnExpr<any>[K]>) => DataFrame<T>",
          "optional": false,
          "desc": "Executes aggregation `K` across all non-key columns in each group."
        }
      }
    },
    "GroupMap": {
      "filePath": "dataframe/types.ts",
      "lineStart": 172,
      "lineEnd": 172,
      "desc": "Internal hash map associating serialized group key strings with arrays of matching 0-based row indices.",
      "signature": "export type GroupMap = Map<string, number[]>;"
    },
    "InsertColumnArg": {
      "filePath": "dataframe/types.ts",
      "lineStart": 178,
      "lineEnd": 178,
      "desc": "Value operand for `DataFrame.insertColumn()`. Accepts a column expression selector or a raw array-like sequence of column values.",
      "signature": "export type InsertColumnArg = IntoExpr | ArrayLike<any>;"
    },
    "IterRowResult": {
      "filePath": "dataframe/types.ts",
      "lineStart": 183,
      "lineEnd": 183,
      "desc": "Single row yielded by `DataFrame.iterRows()`, either as a positional value array or a named row record.",
      "signature": "export type IterRowResult<T extends RowRecord = RowRecord> = any[] | T;"
    },
    "IterRowsOptions": {
      "filePath": "dataframe/types.ts",
      "lineStart": 188,
      "lineEnd": 195,
      "desc": "Configuration options for `DataFrame.iterRows()`.",
      "signature": "export interface IterRowsOptions {\n    /**\n     * When `true`, yields row objects with column keys (`{ col: val }`).\n     * When `false` (default), yields positional arrays (`[val1, val2]`).\n     * @default false\n     */\n    named?: boolean;\n}",
      "properties": {
        "named": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, yields row objects with column keys (`{ col: val }`). When `false` (default), yields positional arrays (`[val1, val2]`).",
          "default": "false"
        }
      }
    },
    "JoinAsofOptions": {
      "filePath": "dataframe/types.ts",
      "lineStart": 200,
      "lineEnd": 254,
      "desc": "Configuration options for as-of proximity joins (`DataFrame.joinAsof()`).",
      "signature": "export interface JoinAsofOptions<T = any, U extends RowRecord = any> {\n    /**\n     * Whether exact key matches are permitted.\n     * @default true\n     */\n    allowExactMatches?: boolean;\n    /**\n     * Optional exact-match group column(s) present in both DataFrames.\n     */\n    by?: ColumnKeyArg<keyof T & keyof U>;\n    /**\n     * Whether to verify that join keys are sorted ascending prior to matching.\n     * @default true\n     */\n    checkSorted?: boolean;\n    /**\n     * Coalescing behavior for join key columns.\n     * @default true\n     */\n    coalesce?: boolean;\n    /**\n     * Group column(s) for exact key matching in left DataFrame.\n     */\n    leftBy?: ColumnKeyArg<keyof T>;\n    /**\n     * Left DataFrame join key column name.\n     */\n    leftOn?: (keyof T);\n    /**\n     * Column name to join on (must exist in both DataFrames and be sorted ascending).\n     */\n    on?: (keyof T & keyof U);\n    /**\n     * Group column(s) for exact key matching in right DataFrame.\n     */\n    rightBy?: ColumnKeyArg<keyof U>;\n    /**\n     * Right DataFrame join key column name.\n     */\n    rightOn?: (keyof U);\n    /**\n     * Match search strategy (`\"backward\"`, `\"forward\"`, or `\"nearest\"`).\n     * @default \"backward\"\n     */\n    strategy?: JoinAsofStrategy;\n    /**\n     * Column name suffixes `[leftSuffix, rightSuffix]` to resolve name collisions.\n     * @default [\"\", \"_right\"]\n     */\n    suffixes?: JoinSuffixes;\n    /**\n     * Maximum allowed distance between left key and right key.\n     */\n    tolerance?: DurationValueArg;\n}",
      "properties": {
        "allowExactMatches": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether exact key matches are permitted.",
          "default": "true"
        },
        "by": {
          "type": "ColumnKeyArg<keyof any & keyof any>",
          "optional": true,
          "desc": "Optional exact-match group column(s) present in both DataFrames.",
          "resolvedType": "keyof any & keyof any | (keyof any & keyof any)[]"
        },
        "checkSorted": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to verify that join keys are sorted ascending prior to matching.",
          "default": "true"
        },
        "coalesce": {
          "type": "boolean",
          "optional": true,
          "desc": "Coalescing behavior for join key columns.",
          "default": "true"
        },
        "leftBy": {
          "type": "ColumnKeyArg<keyof any>",
          "optional": true,
          "desc": "Group column(s) for exact key matching in left DataFrame.",
          "resolvedType": "keyof any | keyof any[]"
        },
        "leftOn": {
          "type": "(keyof any)",
          "optional": true,
          "desc": "Left DataFrame join key column name."
        },
        "on": {
          "type": "(keyof any & keyof any)",
          "optional": true,
          "desc": "Column name to join on (must exist in both DataFrames and be sorted ascending)."
        },
        "rightBy": {
          "type": "ColumnKeyArg<keyof any>",
          "optional": true,
          "desc": "Group column(s) for exact key matching in right DataFrame.",
          "resolvedType": "keyof any | keyof any[]"
        },
        "rightOn": {
          "type": "(keyof any)",
          "optional": true,
          "desc": "Right DataFrame join key column name."
        },
        "strategy": {
          "type": "JoinAsofStrategy",
          "optional": true,
          "desc": "Match search strategy (`\"backward\"`, `\"forward\"`, or `\"nearest\"`).",
          "default": "\"backward\"",
          "resolvedType": "\"backward\" | \"forward\" | \"nearest\""
        },
        "suffixes": {
          "type": "JoinSuffixes",
          "optional": true,
          "desc": "Column name suffixes `[leftSuffix, rightSuffix]` to resolve name collisions.",
          "default": "[\"\", \"_right\"]",
          "resolvedType": "[string, string]"
        },
        "tolerance": {
          "type": "DurationValueArg",
          "optional": true,
          "desc": "Maximum allowed distance between left key and right key.",
          "resolvedType": "number | string"
        }
      }
    },
    "JoinAsofStrategy": {
      "filePath": "dataframe/types.ts",
      "lineStart": 259,
      "lineEnd": 259,
      "desc": "Search direction strategy for `DataFrame.joinAsof()`.",
      "signature": "export type JoinAsofStrategy = \"backward\" | \"forward\" | \"nearest\";"
    },
    "JoinMaintainOrder": {
      "filePath": "dataframe/types.ts",
      "lineStart": 264,
      "lineEnd": 264,
      "desc": "Row order preservation mode for `DataFrame.join()`.",
      "signature": "export type JoinMaintainOrder = \"none\" | \"left\" | \"right\" | \"left_right\" | \"right_left\";"
    },
    "JoinOptions": {
      "filePath": "dataframe/types.ts",
      "lineStart": 269,
      "lineEnd": 307,
      "desc": "Configuration options for joining two DataFrames (`DataFrame.join()`).",
      "signature": "export interface JoinOptions<T = any, U extends RowRecord = any> {\n    /**\n     * Coalescing behavior for join key columns. If `true`, coalesces join key values into left key columns and drops right key columns.\n     * @default true\n     */\n    coalesce?: boolean;\n    /**\n     * Join strategy (`\"inner\"`, `\"left\"`, `\"right\"`, `\"outer\"`, `\"semi\"`, `\"anti\"`, or `\"cross\"`).\n     * @default \"inner\"\n     */\n    how?: JoinType;\n    /**\n     * If `true`, null key values are treated as equal and match each other across DataFrames.\n     * @default false\n     */\n    joinNulls?: boolean;\n    /**\n     * Join key column(s) in the left DataFrame when key names differ.\n     */\n    leftOn?: ColumnKeyArg<keyof T>;\n    /**\n     * Row order preservation strategy (`\"none\"`, `\"left\"`, `\"right\"`, `\"left_right\"`, `\"right_left\"`, or boolean).\n     * @default \"none\"\n     */\n    maintainOrder?: JoinMaintainOrder | boolean;\n    /**\n     * Join key column name or array of key column names that exist in both DataFrames.\n     */\n    on?: ColumnKeyArg<keyof T & keyof U>;\n    /**\n     * Join key column(s) in the right DataFrame when key names differ.\n     */\n    rightOn?: ColumnKeyArg<keyof U>;\n    /**\n     * Suffix tuple `[leftSuffix, rightSuffix]` appended to overlapping non-key column names. Ignored for `\"semi\"` and `\"anti\"` joins.\n     * @default [\"\", \"_right\"]\n     */\n    suffixes?: JoinSuffixes;\n}",
      "properties": {
        "coalesce": {
          "type": "boolean",
          "optional": true,
          "desc": "Coalescing behavior for join key columns. If `true`, coalesces join key values into left key columns and drops right key columns.",
          "default": "true"
        },
        "how": {
          "type": "JoinType",
          "optional": true,
          "desc": "Join strategy (`\"inner\"`, `\"left\"`, `\"right\"`, `\"outer\"`, `\"semi\"`, `\"anti\"`, or `\"cross\"`).",
          "default": "\"inner\"",
          "resolvedType": "\"inner\" | \"outer\" | \"left\" | \"right\" | \"semi\" | \"anti\" | \"cross\""
        },
        "joinNulls": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, null key values are treated as equal and match each other across DataFrames.",
          "default": "false"
        },
        "leftOn": {
          "type": "ColumnKeyArg<keyof any>",
          "optional": true,
          "desc": "Join key column(s) in the left DataFrame when key names differ.",
          "resolvedType": "keyof any | keyof any[]"
        },
        "maintainOrder": {
          "type": "JoinMaintainOrder | boolean",
          "optional": true,
          "desc": "Row order preservation strategy (`\"none\"`, `\"left\"`, `\"right\"`, `\"left_right\"`, `\"right_left\"`, or boolean).",
          "default": "\"none\""
        },
        "on": {
          "type": "ColumnKeyArg<keyof any & keyof any>",
          "optional": true,
          "desc": "Join key column name or array of key column names that exist in both DataFrames.",
          "resolvedType": "keyof any & keyof any | (keyof any & keyof any)[]"
        },
        "rightOn": {
          "type": "ColumnKeyArg<keyof any>",
          "optional": true,
          "desc": "Join key column(s) in the right DataFrame when key names differ.",
          "resolvedType": "keyof any | keyof any[]"
        },
        "suffixes": {
          "type": "JoinSuffixes",
          "optional": true,
          "desc": "Suffix tuple `[leftSuffix, rightSuffix]` appended to overlapping non-key column names. Ignored for `\"semi\"` and `\"anti\"` joins.",
          "default": "[\"\", \"_right\"]",
          "resolvedType": "[string, string]"
        }
      }
    },
    "JoinSuffixes": {
      "filePath": "dataframe/types.ts",
      "lineStart": 312,
      "lineEnd": 312,
      "desc": "Tuple of `[leftSuffix, rightSuffix]` appended to colliding non-key column names during joins.",
      "signature": "export type JoinSuffixes = [string, string];"
    },
    "JoinType": {
      "filePath": "dataframe/types.ts",
      "lineStart": 317,
      "lineEnd": 317,
      "desc": "Relational join strategy for `DataFrame.join()`.",
      "signature": "export type JoinType = \"inner\" | \"outer\" | \"left\" | \"right\" | \"semi\" | \"anti\" | \"cross\";"
    },
    "JoinWhereArg": {
      "filePath": "dataframe/types.ts",
      "lineStart": 323,
      "lineEnd": 323,
      "desc": "Variadic argument accepted by `DataFrame.joinWhere()`. Accepts a predicate expression, an array of predicate expressions, or a `JoinWhereOptions` configuration object.",
      "signature": "export type JoinWhereArg = IntoExprArg | JoinWhereOptions;",
      "properties": {
        "how": {
          "type": "JoinWhereStrategy",
          "optional": true,
          "desc": "Join strategy: `\"inner\"`, `\"left\"`, or `\"right\"`.",
          "default": "\"inner\"",
          "resolvedType": "\"inner\" | \"left\" | \"right\""
        },
        "suffixes": {
          "type": "JoinSuffixes",
          "optional": true,
          "desc": "Column name suffixes `[leftSuffix, rightSuffix]` to resolve duplicate column names.",
          "default": "[\"\", \"_right\"]",
          "resolvedType": "[string, string]"
        }
      }
    },
    "JoinWhereOptions": {
      "filePath": "dataframe/types.ts",
      "lineStart": 328,
      "lineEnd": 339,
      "desc": "Configuration options for conditional inequality/predicate joins (`DataFrame.joinWhere()`).",
      "signature": "export interface JoinWhereOptions {\n    /**\n     * Join strategy: `\"inner\"`, `\"left\"`, or `\"right\"`.\n     * @default \"inner\"\n     */\n    how?: JoinWhereStrategy;\n    /**\n     * Column name suffixes `[leftSuffix, rightSuffix]` to resolve duplicate column names.\n     * @default [\"\", \"_right\"]\n     */\n    suffixes?: JoinSuffixes;\n}",
      "properties": {
        "how": {
          "type": "JoinWhereStrategy",
          "optional": true,
          "desc": "Join strategy: `\"inner\"`, `\"left\"`, or `\"right\"`.",
          "default": "\"inner\"",
          "resolvedType": "\"inner\" | \"left\" | \"right\""
        },
        "suffixes": {
          "type": "JoinSuffixes",
          "optional": true,
          "desc": "Column name suffixes `[leftSuffix, rightSuffix]` to resolve duplicate column names.",
          "default": "[\"\", \"_right\"]",
          "resolvedType": "[string, string]"
        }
      }
    },
    "JoinWhereStrategy": {
      "filePath": "dataframe/types.ts",
      "lineStart": 344,
      "lineEnd": 344,
      "desc": "Join strategy for predicate-based conditional joins (`DataFrame.joinWhere()`).",
      "signature": "export type JoinWhereStrategy = \"inner\" | \"left\" | \"right\";"
    },
    "LimitOptions": {
      "filePath": "dataframe/types.ts",
      "lineStart": 349,
      "lineEnd": 360,
      "desc": "Configuration options for slicing rows from a DataFrame (`DataFrame.limit()`).",
      "signature": "export interface LimitOptions {\n    /**\n     * Slice direction starting point (`\"start\"` or `\"end\"`).\n     * @default \"start\"\n     */\n    from?: LimitPosition;\n    /**\n     * Number of rows to skip before taking `n` rows.\n     * @default 0\n     */\n    offset?: number;\n}",
      "properties": {
        "from": {
          "type": "LimitPosition",
          "optional": true,
          "desc": "Slice direction starting point (`\"start\"` or `\"end\"`).",
          "default": "\"start\"",
          "resolvedType": "\"start\" | \"end\""
        },
        "offset": {
          "type": "number",
          "optional": true,
          "desc": "Number of rows to skip before taking `n` rows.",
          "default": "0"
        }
      }
    },
    "LimitPosition": {
      "filePath": "dataframe/types.ts",
      "lineStart": 365,
      "lineEnd": 365,
      "desc": "Slice direction starting point for `DataFrame.limit()`.",
      "signature": "export type LimitPosition = \"start\" | \"end\";"
    },
    "PartitionByKey": {
      "filePath": "dataframe/types.ts",
      "lineStart": 370,
      "lineEnd": 370,
      "desc": "Column name or expression key for `DataFrame.partitionBy()`.",
      "signature": "export type PartitionByKey<T extends RowRecord = RowRecord> = ColumnOrExprArg<keyof T & string>;"
    },
    "PartitionByOptions": {
      "filePath": "dataframe/types.ts",
      "lineStart": 375,
      "lineEnd": 387,
      "desc": "Configuration options for splitting a DataFrame into partitions (`DataFrame.partitionBy()`).",
      "signature": "export interface PartitionByOptions {\n    /**\n     * If true, returns a Record/dictionary mapping each partition key string to its DataFrame.\n     * If false (default), returns an array of DataFrames.\n     * @default false\n     */\n    asDict?: boolean;\n    /**\n     * If true (default), maintain original encounter order of partitions.\n     * @default true\n     */\n    maintainOrder?: boolean;\n}",
      "properties": {
        "asDict": {
          "type": "boolean",
          "optional": true,
          "desc": "If true, returns a Record/dictionary mapping each partition key string to its DataFrame. If false (default), returns an array of DataFrames.",
          "default": "false"
        },
        "maintainOrder": {
          "type": "boolean",
          "optional": true,
          "desc": "If true (default), maintain original encounter order of partitions.",
          "default": "true"
        }
      }
    },
    "PartitionByResult": {
      "filePath": "dataframe/types.ts",
      "lineStart": 392,
      "lineEnd": 392,
      "desc": "Return value of `DataFrame.partitionBy()`, either an array of partitioned DataFrames or a dictionary keyed by partition string.",
      "signature": "export type PartitionByResult<T extends RowRecord = RowRecord> = DataFrame<T>[] | Record<string, DataFrame<T>>;"
    },
    "PivotOptions": {
      "filePath": "dataframe/types.ts",
      "lineStart": 397,
      "lineEnd": 414,
      "desc": "Configuration options for reshaping a DataFrame from long to wide format (`DataFrame.pivot()`).",
      "signature": "export interface PivotOptions<T> {\n    /**\n     * Aggregation function to apply when multiple values exist for a cell.\n     */\n    agg?: AggFn<any> | string;\n    /**\n     * Column whose distinct values become new wide column headers.\n     */\n    columns: keyof T;\n    /**\n     * Key column(s) to use as new DataFrame rows.\n     */\n    index: ColumnKeyArg<keyof T>;\n    /**\n     * Column whose cell values populate the pivoted grid cells.\n     */\n    values: keyof T;\n}",
      "properties": {
        "agg": {
          "type": "AggFn<any> | string",
          "optional": true,
          "desc": "Aggregation function to apply when multiple values exist for a cell.",
          "resolvedType": "(values: any[]) => any | string"
        },
        "columns": {
          "type": "keyof T",
          "optional": false,
          "desc": "Column whose distinct values become new wide column headers."
        },
        "index": {
          "type": "ColumnKeyArg<keyof T>",
          "optional": false,
          "desc": "Key column(s) to use as new DataFrame rows.",
          "resolvedType": "keyof T | keyof T[]"
        },
        "values": {
          "type": "keyof T",
          "optional": false,
          "desc": "Column whose cell values populate the pivoted grid cells."
        }
      }
    },
    "RowPredicateFn": {
      "filePath": "dataframe/types.ts",
      "lineStart": 419,
      "lineEnd": 419,
      "desc": "Row-level predicate callback function for `DataFrame.filter()`.",
      "signature": "export type RowPredicateFn<T extends RowRecord = RowRecord> = (row: T) => any;"
    },
    "SelectArg": {
      "filePath": "dataframe/types.ts",
      "lineStart": 425,
      "lineEnd": 425,
      "desc": "Variadic argument for `DataFrame.select()`, `DataFrame.withColumns()`, and `GroupedData.agg()`. Accepts a single selection item or an array of selection items.",
      "signature": "export type SelectArg = ColumnKeyArg<SelectItem>;"
    },
    "SelectItem": {
      "filePath": "dataframe/types.ts",
      "lineStart": 431,
      "lineEnd": 431,
      "desc": "Single column selection or expression item for `select()` and `withColumns()`. Accepts a column name, column expression, or dictionary mapping output column names to expressions/literals.",
      "signature": "export type SelectItem = ColumnOrExprArg | RowRecord;"
    },
    "SortOptions": {
      "filePath": "dataframe/types.ts",
      "lineStart": 436,
      "lineEnd": 455,
      "desc": "Configuration options for sorting a DataFrame (`DataFrame.sort()`).",
      "signature": "export interface SortOptions<T = any> extends SortArrayOptions<T> {\n    /**\n     * Column name(s) or expression(s) to sort by.\n     */\n    by: ColumnKeyArg<keyof T> | ColumnKeyArg<IExpr>;\n    /**\n     * Optional comparator function or dictionary mapping column names to custom comparator functions.\n     */\n    customComp?: ((a: any, b: any) => number) | Partial<Record<keyof T, (a: any, b: any) => number>> | null;\n    /**\n     * Sort order boolean or array of booleans per key.\n     * @default false\n     */\n    descending?: ColumnKeyArg<boolean>;\n    /**\n     * When `true`, places nulls at the end of sorted output.\n     * @default true\n     */\n    nullsLast?: boolean;\n}",
      "properties": {
        "by": {
          "type": "ColumnKeyArg<keyof any> | ColumnKeyArg<IExpr>",
          "optional": false,
          "desc": "Column name(s) or expression(s) to sort by.",
          "resolvedType": "keyof any | keyof any[] | IExpr | IExpr[]"
        },
        "customComp": {
          "type": "((a: any, b: any) => number) | Partial<Record<keyof any, (a: any, b: any) => number>> | null",
          "optional": true,
          "desc": "Optional comparator function or dictionary mapping column names to custom comparator functions."
        },
        "descending": {
          "type": "ColumnKeyArg<boolean>",
          "optional": true,
          "desc": "Sort order boolean or array of booleans per key.",
          "default": "false",
          "resolvedType": "boolean | boolean[]"
        },
        "nullsLast": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, places nulls at the end of sorted output.",
          "default": "true"
        }
      }
    },
    "TransposeColumnNamesArg": {
      "filePath": "dataframe/types.ts",
      "lineStart": 461,
      "lineEnd": 461,
      "desc": "Column header source for `DataFrame.transpose()`. Accepts the name of an existing column whose values become headers, or an iterable of header strings.",
      "signature": "export type TransposeColumnNamesArg = string | Iterable<string>;"
    },
    "TransposeOptions": {
      "filePath": "dataframe/types.ts",
      "lineStart": 466,
      "lineEnd": 481,
      "desc": "Configuration options for transposing rows and columns (`DataFrame.transpose()`).",
      "signature": "export interface TransposeOptions {\n    /**\n     * Column name or iterable of strings to use as transposed column headers.\n     */\n    columnNames?: TransposeColumnNamesArg;\n    /**\n     * Name of the header column when `includeHeader` is `true`.\n     * @default \"column\"\n     */\n    headerName?: string;\n    /**\n     * When `true`, includes original column names as a new header column.\n     * @default false\n     */\n    includeHeader?: boolean;\n}",
      "properties": {
        "columnNames": {
          "type": "TransposeColumnNamesArg",
          "optional": true,
          "desc": "Column name or iterable of strings to use as transposed column headers.",
          "resolvedType": "string | Iterable<string>"
        },
        "headerName": {
          "type": "string",
          "optional": true,
          "desc": "Name of the header column when `includeHeader` is `true`.",
          "default": "\"column\""
        },
        "includeHeader": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, includes original column names as a new header column.",
          "default": "false"
        }
      }
    },
    "UnpivotOptions": {
      "filePath": "dataframe/types.ts",
      "lineStart": 486,
      "lineEnd": 505,
      "desc": "Configuration options for unpivoting a DataFrame from wide to long format (`DataFrame.unpivot()`).",
      "signature": "export interface UnpivotOptions<T> {\n    /**\n     * Key column(s) to retain as identifier variables.\n     */\n    idVars: ColumnKeyArg<keyof T>;\n    /**\n     * Name for the new value column holding cell values.\n     * @default \"value\"\n     */\n    valueName?: string;\n    /**\n     * Column(s) to unpivot into variable-value pairs.\n     */\n    valueVars: ColumnKeyArg<keyof T>;\n    /**\n     * Name for the new variable column holding old column headers.\n     * @default \"variable\"\n     */\n    varName?: string;\n}",
      "properties": {
        "idVars": {
          "type": "ColumnKeyArg<keyof T>",
          "optional": false,
          "desc": "Key column(s) to retain as identifier variables.",
          "resolvedType": "keyof T | keyof T[]"
        },
        "valueName": {
          "type": "string",
          "optional": true,
          "desc": "Name for the new value column holding cell values.",
          "default": "\"value\""
        },
        "valueVars": {
          "type": "ColumnKeyArg<keyof T>",
          "optional": false,
          "desc": "Column(s) to unpivot into variable-value pairs.",
          "resolvedType": "keyof T | keyof T[]"
        },
        "varName": {
          "type": "string",
          "optional": true,
          "desc": "Name for the new variable column holding old column headers.",
          "default": "\"variable\""
        }
      }
    },
    "UnstackDirection": {
      "filePath": "dataframe/types.ts",
      "lineStart": 510,
      "lineEnd": 510,
      "desc": "Reshaping direction for `DataFrame.unstack()`.",
      "signature": "export type UnstackDirection = \"vertical\" | \"horizontal\";"
    },
    "UnstackOptions": {
      "filePath": "dataframe/types.ts",
      "lineStart": 515,
      "lineEnd": 532,
      "desc": "Configuration options for reshaping columns into wider multi-column blocks (`DataFrame.unstack()`).",
      "signature": "export interface UnstackOptions {\n    /**\n     * Value to fill in empty cells when length is not evenly divisible by step.\n     * @default null\n     */\n    fillValues?: any;\n    /**\n     * Reshaping direction:\n     * - \"vertical\" (default): fills down the new columns first before moving to the next column.\n     * - \"horizontal\": fills across row-by-row before moving to the next row.\n     * @default \"vertical\"\n     */\n    how?: UnstackDirection;\n    /**\n     * Number of columns to reshape each input column into.\n     */\n    step: number;\n}",
      "properties": {
        "fillValues": {
          "type": "any",
          "optional": true,
          "desc": "Value to fill in empty cells when length is not evenly divisible by step.",
          "default": "null"
        },
        "how": {
          "type": "UnstackDirection",
          "optional": true,
          "desc": "Reshaping direction: - \"vertical\" (default): fills down the new columns first before moving to the next column. - \"horizontal\": fills across row-by-row before moving to the next row.",
          "default": "\"vertical\"",
          "resolvedType": "\"vertical\" | \"horizontal\""
        },
        "step": {
          "type": "number",
          "optional": false,
          "desc": "Number of columns to reshape each input column into."
        }
      }
    },
    "WritableStreamTarget": {
      "filePath": "dataframe/types.ts",
      "lineStart": 537,
      "lineEnd": 542,
      "desc": "Minimal writable stream interface accepting string chunks.",
      "signature": "export interface WritableStreamTarget {\n    /**\n     * Writes a serialized string chunk to the underlying stream target.\n     */\n    write: (str: string) => void;\n}",
      "properties": {
        "write": {
          "type": "(str: string) => void",
          "optional": false,
          "desc": "Writes a serialized string chunk to the underlying stream target."
        }
      }
    },
    "WriteFileTargetArg": {
      "filePath": "dataframe/types.ts",
      "lineStart": 548,
      "lineEnd": 548,
      "desc": "Output destination for `writeCsv()` and `writeJson()`. Accepts a file system path string or a writable stream object.",
      "signature": "export type WriteFileTargetArg = string | WritableStreamTarget;",
      "properties": {
        "write": {
          "type": "(str: string) => void",
          "optional": false,
          "desc": "Writes a serialized string chunk to the underlying stream target."
        }
      }
    },
    "WriteJSONOptions": {
      "filePath": "dataframe/types.ts",
      "lineStart": 553,
      "lineEnd": 563,
      "desc": "Configuration options for serializing a DataFrame to JSON or NDJSON (`DataFrame.writeJson()`).",
      "signature": "export interface WriteJSONOptions {\n    /**\n     * The format of the JSON output (`\"json\"` or `\"ndjson\"`).\n     * @default \"json\"\n     */\n    format?: JSONFormat;\n    /**\n     * Options for the safe JSON replacer.\n     */\n    replacerOptions?: SafeJsonReplacerOptions;\n}",
      "properties": {
        "format": {
          "type": "JSONFormat",
          "optional": true,
          "desc": "The format of the JSON output (`\"json\"` or `\"ndjson\"`).",
          "default": "\"json\"",
          "resolvedType": "\"json\" | \"ndjson\""
        },
        "replacerOptions": {
          "type": "SafeJsonReplacerOptions",
          "optional": true,
          "desc": "Options for the safe JSON replacer.",
          "properties": {
            "bigintStrategy": {
              "type": "\"string\" | \"number\"",
              "optional": true,
              "desc": "Strategy for serializing `BigInt` values: `\"string\"` or `\"number\"`.",
              "default": "\"string\""
            },
            "formatDate": {
              "type": "(v: Date) => string",
              "optional": true,
              "desc": "Custom formatter function for `Date` objects (ignored if `onDate` is specified)."
            },
            "handleCircular": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, replaces circular references instead of throwing.",
              "default": "false"
            },
            "onBigInt": {
              "type": "(v: bigint) => any",
              "optional": true,
              "desc": "Custom serialization override for `BigInt` values."
            },
            "onCircular": {
              "type": "(this: any, k: string, v: any) => any",
              "optional": true,
              "desc": "Custom callback invoked when a circular reference is encountered."
            },
            "onCustom": {
              "type": "(this: any, k: string, v: any) => any",
              "optional": true,
              "desc": "Catch-all serialization override for custom types, executed after native type checks."
            },
            "onDate": {
              "type": "(v: Date) => any",
              "optional": true,
              "desc": "Custom serialization override for `Date` objects (takes precedence over `formatDate`)."
            },
            "onError": {
              "type": "(v: Error) => any",
              "optional": true,
              "desc": "Custom serialization override for `Error` objects."
            },
            "onMap": {
              "type": "(v: Map<any, any>) => any",
              "optional": true,
              "desc": "Custom serialization override for `Map` objects."
            },
            "onRegExp": {
              "type": "(v: RegExp) => any",
              "optional": true,
              "desc": "Custom serialization override for `RegExp` objects."
            },
            "onSet": {
              "type": "(v: Set<any>) => any",
              "optional": true,
              "desc": "Custom serialization override for `Set` objects."
            },
            "onTypedArray": {
              "type": "(v: any) => any",
              "optional": true,
              "desc": "Custom serialization override for `TypedArray` values."
            },
            "onURLSearchParams": {
              "type": "(v: URLSearchParams) => any",
              "optional": true,
              "desc": "Custom serialization override for `URLSearchParams` objects."
            },
            "replacer": {
              "type": "((this: any, k: string, v: any) => any) | (string | number)[] | null",
              "optional": true,
              "desc": "Custom `JSON.stringify` replacer function or property whitelist array applied first."
            },
            "voidBigIntReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `BigInt` values.",
              "default": "false"
            },
            "voidDateReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `Date` objects.",
              "default": "false"
            },
            "voidMapReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `Map` objects.",
              "default": "false"
            },
            "voidRegExpReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `RegExp` objects.",
              "default": "false"
            },
            "voidSetReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `Set` objects.",
              "default": "false"
            },
            "voidTypedArrayReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `TypedArray` values.",
              "default": "false"
            }
          }
        }
      }
    },
    "RegisteredDataType": {
      "filePath": "datatypes/types.ts",
      "lineStart": 352,
      "lineEnd": 358,
      "desc": "Union of all concrete registered DataType instances supported in a DataFrame schema.",
      "signature": "export type RegisteredDataType =\n    | Int8Type | Int16Type | Int32Type | Int64Type\n    | UInt8Type | UInt16Type | UInt32Type | UInt64Type\n    | Float32Type | Float64Type | DecimalType\n    | BooleanType | Utf8Type | BinaryType | NullType | ObjectType\n    | DateType | DatetimeType | TimeType | DurationType\n    | ArrayType<any> | StructType<any>;"
    },
    "CoalesceArg": {
      "filePath": "functions/types.ts",
      "lineStart": 19,
      "lineEnd": 19,
      "desc": "Variadic operand for `$df.coalesce()`. Accepts a scalar/column expression or an array of scalar/column expressions.",
      "signature": "export type CoalesceArg = ColumnKeyArg<ScalarArg>;"
    },
    "DurationArg": {
      "filePath": "functions/types.ts",
      "lineStart": 25,
      "lineEnd": 25,
      "desc": "Operand for `$df.duration()`. Accepts a duration component options object or a duration interval string (e.g. `\"1d 12h\"`).",
      "signature": "export type DurationArg = DurationOptions | string;",
      "properties": {
        "days": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of days or column expression.",
          "resolvedType": "IntoExpr | number"
        },
        "hours": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of hours or column expression.",
          "resolvedType": "IntoExpr | number"
        },
        "microseconds": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of microseconds or column expression.",
          "resolvedType": "IntoExpr | number"
        },
        "milliseconds": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of milliseconds or column expression.",
          "resolvedType": "IntoExpr | number"
        },
        "minutes": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of minutes or column expression.",
          "resolvedType": "IntoExpr | number"
        },
        "nanoseconds": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of nanoseconds or column expression.",
          "resolvedType": "IntoExpr | number"
        },
        "seconds": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of seconds or column expression.",
          "resolvedType": "IntoExpr | number"
        },
        "weeks": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of weeks or column expression.",
          "resolvedType": "IntoExpr | number"
        }
      }
    },
    "DurationComponentArg": {
      "filePath": "functions/types.ts",
      "lineStart": 30,
      "lineEnd": 30,
      "desc": "Numeric value or column expression representing a duration component.",
      "signature": "export type DurationComponentArg = IntoExpr | number;"
    },
    "DurationOptions": {
      "filePath": "functions/types.ts",
      "lineStart": 35,
      "lineEnd": 52,
      "desc": "Configuration options for constructing a duration in `$df.duration()`.",
      "signature": "export interface DurationOptions {\n    /** Number of days or column expression. */\n    days?: DurationComponentArg;\n    /** Number of hours or column expression. */\n    hours?: DurationComponentArg;\n    /** Number of microseconds or column expression. */\n    microseconds?: DurationComponentArg;\n    /** Number of milliseconds or column expression. */\n    milliseconds?: DurationComponentArg;\n    /** Number of minutes or column expression. */\n    minutes?: DurationComponentArg;\n    /** Number of nanoseconds or column expression. */\n    nanoseconds?: DurationComponentArg;\n    /** Number of seconds or column expression. */\n    seconds?: DurationComponentArg;\n    /** Number of weeks or column expression. */\n    weeks?: DurationComponentArg;\n}",
      "properties": {
        "days": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of days or column expression.",
          "resolvedType": "IntoExpr | number"
        },
        "hours": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of hours or column expression.",
          "resolvedType": "IntoExpr | number"
        },
        "microseconds": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of microseconds or column expression.",
          "resolvedType": "IntoExpr | number"
        },
        "milliseconds": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of milliseconds or column expression.",
          "resolvedType": "IntoExpr | number"
        },
        "minutes": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of minutes or column expression.",
          "resolvedType": "IntoExpr | number"
        },
        "nanoseconds": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of nanoseconds or column expression.",
          "resolvedType": "IntoExpr | number"
        },
        "seconds": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of seconds or column expression.",
          "resolvedType": "IntoExpr | number"
        },
        "weeks": {
          "type": "DurationComponentArg",
          "optional": true,
          "desc": "Number of weeks or column expression.",
          "resolvedType": "IntoExpr | number"
        }
      }
    },
    "HorizontalExpr": {
      "filePath": "functions/types.ts",
      "lineStart": 57,
      "lineEnd": 57,
      "desc": "Return expression type of `$df.horizontal()`, combining `ColumnExpr` and `ArrayExprNamespace` methods.",
      "signature": "export type HorizontalExpr = ColumnExpr<any[]> & ArrayExprNamespace;"
    },
    "LitOptions": {
      "filePath": "functions/types.ts",
      "lineStart": 62,
      "lineEnd": 71,
      "desc": "Configuration options for `$df.lit()`.",
      "signature": "export interface LitOptions {\n    /**\n     * Registered data type to coerce and allocate for the literal column.\n     */\n    dtype?: RegisteredDataType;\n    /**\n     * Output column name alias.\n     */\n    name?: string;\n}",
      "properties": {
        "dtype": {
          "type": "RegisteredDataType",
          "optional": true,
          "desc": "Registered data type to coerce and allocate for the literal column.",
          "resolvedType": "Int8Type | Int16Type | Int32Type | Int64Type | UInt8Type | UInt16Type | UInt32Type | UInt64Type | Float32Type | Float64Type | DecimalType | BooleanType | Utf8Type | BinaryType | NullType | ObjectType | DateType | DatetimeType | TimeType | DurationType | ArrayType<any> | StructType<any>"
        },
        "name": {
          "type": "string",
          "optional": true,
          "desc": "Output column name alias."
        }
      }
    },
    "SeqRangeOptions": {
      "filePath": "functions/types.ts",
      "lineStart": 76,
      "lineEnd": 128,
      "desc": "Configuration options for `$df.seqRange()`.",
      "signature": "export interface SeqRangeOptions {\n    /**\n     * Registered data type to coerce and allocate for the generated sequence.\n     */\n    dtype?: RegisteredDataType;\n    /**\n     * Ending row index (exclusive) in the DataFrame to insert the sequence (non-strict mode).\n     */\n    endIndex?: number;\n    /**\n     * Sequence generation mode: `\"constant\"` repeats the initial value, `\"cumulative\"` increments from the previous value, and `\"independent\"` computes each element from its row index.\n     * @default \"cumulative\"\n     */\n    mode?: \"constant\" | \"cumulative\" | \"independent\";\n    /**\n     * Number of values to generate. Defaults to the slice or DataFrame height.\n     */\n    n?: number;\n    /**\n     * Output column name alias.\n     */\n    name?: string;\n    /**\n     * Pads the sequence with `padValue` if shorter than target slice range (non-strict mode).\n     * @default false\n     */\n    pad?: boolean;\n    /**\n     * Value used for padding in non-strict mode.\n     * @default null\n     */\n    padValue?: any;\n    /**\n     * Starting row index in the DataFrame to insert the sequence (non-strict mode).\n     * @default 0\n     */\n    startIndex?: number;\n    /**\n     * Step increment/multiplier value or step callback function.\n     * @default 1\n     */\n    step?: number | ((context: CumulativeStepContext & IndependentStepContext) => any);\n    /**\n     * When `true`, throws a `ShapeError` if the generated sequence height does not match the target height. When `false`, allows padding, truncation, and slice bounds.\n     * @default true\n     */\n    strict?: boolean;\n    /**\n     * Truncates the sequence if it exceeds target slice range (non-strict mode).\n     * @default false\n     */\n    truncate?: boolean;\n}",
      "properties": {
        "dtype": {
          "type": "RegisteredDataType",
          "optional": true,
          "desc": "Registered data type to coerce and allocate for the generated sequence.",
          "resolvedType": "Int8Type | Int16Type | Int32Type | Int64Type | UInt8Type | UInt16Type | UInt32Type | UInt64Type | Float32Type | Float64Type | DecimalType | BooleanType | Utf8Type | BinaryType | NullType | ObjectType | DateType | DatetimeType | TimeType | DurationType | ArrayType<any> | StructType<any>"
        },
        "endIndex": {
          "type": "number",
          "optional": true,
          "desc": "Ending row index (exclusive) in the DataFrame to insert the sequence (non-strict mode)."
        },
        "mode": {
          "type": "\"constant\" | \"cumulative\" | \"independent\"",
          "optional": true,
          "desc": "Sequence generation mode: `\"constant\"` repeats the initial value, `\"cumulative\"` increments from the previous value, and `\"independent\"` computes each element from its row index.",
          "default": "\"cumulative\""
        },
        "n": {
          "type": "number",
          "optional": true,
          "desc": "Number of values to generate. Defaults to the slice or DataFrame height.",
          "default": "the slice or DataFrame height"
        },
        "name": {
          "type": "string",
          "optional": true,
          "desc": "Output column name alias."
        },
        "pad": {
          "type": "boolean",
          "optional": true,
          "desc": "Pads the sequence with `padValue` if shorter than target slice range (non-strict mode).",
          "default": "false"
        },
        "padValue": {
          "type": "any",
          "optional": true,
          "desc": "Value used for padding in non-strict mode.",
          "default": "null"
        },
        "startIndex": {
          "type": "number",
          "optional": true,
          "desc": "Starting row index in the DataFrame to insert the sequence (non-strict mode).",
          "default": "0"
        },
        "step": {
          "type": "number | ((context: CumulativeStepContext & IndependentStepContext) => any)",
          "optional": true,
          "desc": "Step increment/multiplier value or step callback function.",
          "default": "1"
        },
        "strict": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, throws a `ShapeError` if the generated sequence height does not match the target height. When `false`, allows padding, truncation, and slice bounds.",
          "default": "true"
        },
        "truncate": {
          "type": "boolean",
          "optional": true,
          "desc": "Truncates the sequence if it exceeds target slice range (non-strict mode).",
          "default": "false"
        }
      }
    },
    "StructArg": {
      "filePath": "functions/types.ts",
      "lineStart": 134,
      "lineEnd": 134,
      "desc": "First parameter operand for `$df.struct()`. Accepts a single expression, an array of expressions, or a dictionary mapping field names to expressions.",
      "signature": "export type StructArg = StructFieldsArg | IntoExpr;"
    },
    "WhenArg": {
      "filePath": "functions/types.ts",
      "lineStart": 140,
      "lineEnd": 140,
      "desc": "Condition or branch operand for `$df.when().then().otherwise()`. Accepts a column expression, scalar literal, array, or record object.",
      "signature": "export type WhenArg = ComparisonArg | RowRecord | any[];"
    },
    "AggFn": {
      "filePath": "types.ts",
      "lineStart": 10,
      "lineEnd": 10,
      "desc": "Aggregation function mapping an array of column values to a single scalar or summary value.",
      "signature": "export type AggFn<V, R = any> = (values: V[]) => R;"
    },
    "AnyTypedArray": {
      "filePath": "types.ts",
      "lineStart": 15,
      "lineEnd": 26,
      "desc": "Union of all standard JavaScript TypedArray instances.",
      "signature": "export type AnyTypedArray =\n    | Int8Array\n    | Uint8Array\n    | Uint8ClampedArray\n    | Int16Array\n    | Uint16Array\n    | Int32Array\n    | Uint32Array\n    | Float32Array\n    | Float64Array\n    | BigInt64Array\n    | BigUint64Array;"
    },
    "BusinessDayRollType": {
      "filePath": "types.ts",
      "lineStart": 31,
      "lineEnd": 31,
      "desc": "Roll strategy when a starting date falls on a non-business day in `dt.addBusinessDays()`.",
      "signature": "export type BusinessDayRollType = \"raise\" | \"forward\" | \"backward\";"
    },
    "CastOptions": {
      "filePath": "types.ts",
      "lineStart": 36,
      "lineEnd": 42,
      "desc": "Configuration options for data type casting (`expr.cast`, `df.cast`).",
      "signature": "export interface CastOptions {\n    /**\n     * Whether cast errors should throw or produce `null` values.\n     * @default true\n     */\n    strict?: boolean;\n}",
      "properties": {
        "strict": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether cast errors should throw or produce `null` values.",
          "default": "true"
        }
      }
    },
    "CentralMomentsOptions": {
      "filePath": "types.ts",
      "lineStart": 47,
      "lineEnd": 58,
      "desc": "Configuration options for `computeCentralMoments()`.",
      "signature": "export interface CentralMomentsOptions {\n    /**\n     * Whether to apply exponentially weighted bias adjustment.\n     * @default true\n     */\n    adjust?: boolean;\n    /**\n     * Minimum number of valid observations required to return a non-null result.\n     * @default 1\n     */\n    minSamples?: number;\n}",
      "properties": {
        "adjust": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to apply exponentially weighted bias adjustment.",
          "default": "true"
        },
        "minSamples": {
          "type": "number",
          "optional": true,
          "desc": "Minimum number of valid observations required to return a non-null result.",
          "default": "1"
        }
      }
    },
    "CentralMomentsResult": {
      "filePath": "types.ts",
      "lineStart": 63,
      "lineEnd": 82,
      "desc": "Result object returned by `computeCentralMoments()`, containing weighted central moments up to 4th order.",
      "signature": "export interface CentralMomentsResult {\n    /** Number of valid numeric observations processed. */\n    count: number;\n    /** Weighted 2nd central moment sum ($\\sum w_i (x_i - \\mu)^2$). */\n    m2Sum: number;\n    /** Weighted 3rd central moment sum ($\\sum w_i (x_i - \\mu)^3$). */\n    m3Sum: number;\n    /** Weighted 4th central moment sum ($\\sum w_i (x_i - \\mu)^4$). */\n    m4Sum: number;\n    /** Weighted arithmetic mean, or `null` if `count < minSamples`. */\n    mean: number | null;\n    /** Sample or weighted standard deviation, or `null` if insufficient samples. */\n    std: number | null;\n    /** Sum of weights across valid observations. */\n    sumW: number;\n    /** Sample or weighted variance, or `null` if insufficient samples. */\n    variance: number | null;\n    /** Weighted sum of observation values. */\n    weightedSum: number;\n}",
      "properties": {
        "count": {
          "type": "number",
          "optional": false,
          "desc": "Number of valid numeric observations processed."
        },
        "m2Sum": {
          "type": "number",
          "optional": false,
          "desc": "Weighted 2nd central moment sum ($\\sum w_i (x_i - \\mu)^2$)."
        },
        "m3Sum": {
          "type": "number",
          "optional": false,
          "desc": "Weighted 3rd central moment sum ($\\sum w_i (x_i - \\mu)^3$)."
        },
        "m4Sum": {
          "type": "number",
          "optional": false,
          "desc": "Weighted 4th central moment sum ($\\sum w_i (x_i - \\mu)^4$)."
        },
        "mean": {
          "type": "number | null",
          "optional": false,
          "desc": "Weighted arithmetic mean, or `null` if `count < minSamples`."
        },
        "std": {
          "type": "number | null",
          "optional": false,
          "desc": "Sample or weighted standard deviation, or `null` if insufficient samples."
        },
        "sumW": {
          "type": "number",
          "optional": false,
          "desc": "Sum of weights across valid observations."
        },
        "variance": {
          "type": "number | null",
          "optional": false,
          "desc": "Sample or weighted variance, or `null` if insufficient samples."
        },
        "weightedSum": {
          "type": "number",
          "optional": false,
          "desc": "Weighted sum of observation values."
        }
      }
    },
    "ClosedBoundary": {
      "filePath": "types.ts",
      "lineStart": 87,
      "lineEnd": 87,
      "desc": "Inclusivity mode for interval boundaries.",
      "signature": "export type ClosedBoundary = \"both\" | \"left\" | \"right\" | \"none\";"
    },
    "ColumnData": {
      "filePath": "types.ts",
      "lineStart": 92,
      "lineEnd": 92,
      "desc": "Array-like and iterable container holding a column's sequence of values.",
      "signature": "export type ColumnData<T = any> = ArrayLike<T> & Iterable<T>;"
    },
    "ColumnDict": {
      "filePath": "types.ts",
      "lineStart": 97,
      "lineEnd": 97,
      "desc": "Dictionary mapping column names to their underlying `ColumnData` arrays.",
      "signature": "export type ColumnDict = Record<string, ColumnData>;"
    },
    "ColumnIndexOrNameArg": {
      "filePath": "types.ts",
      "lineStart": 102,
      "lineEnd": 102,
      "desc": "0-based numeric index or string identifier (used for column lookup and regex capture group indexing).",
      "signature": "export type ColumnIndexOrNameArg = number | string;"
    },
    "ColumnKeyArg": {
      "filePath": "types.ts",
      "lineStart": 107,
      "lineEnd": 107,
      "desc": "Single column key or array of column keys.",
      "signature": "export type ColumnKeyArg<K = string> = K | K[];"
    },
    "ColumnOrExprArg": {
      "filePath": "types.ts",
      "lineStart": 112,
      "lineEnd": 112,
      "desc": "Target column key or column expression.",
      "signature": "export type ColumnOrExprArg<K = string> = K | IExpr;"
    },
    "ColumnSelector": {
      "filePath": "types.ts",
      "lineStart": 117,
      "lineEnd": 119,
      "desc": "Selector for matching one or more DataFrame columns by name, regex pattern, or `DataType` class/instance.",
      "signature": "export type ColumnSelector<T = any> =\n    | ColumnKeyArg<keyof T | RegexPatternArg>\n    | ColumnKeyArg<DataType | Function>;"
    },
    "ConcatHow": {
      "filePath": "types.ts",
      "lineStart": 124,
      "lineEnd": 124,
      "desc": "Layout direction for DataFrame concatenation (`\"vertical\"`, `\"horizontal\"`, or `\"diagonal\"`).",
      "signature": "export type ConcatHow = \"vertical\" | \"horizontal\" | \"diagonal\";"
    },
    "ConcatItem": {
      "filePath": "types.ts",
      "lineStart": 129,
      "lineEnd": 129,
      "desc": "Single item accepted by `df.concat()` and `$df.concat()`: a `DataFrame` instance, array of row records, or column dictionary.",
      "signature": "export type ConcatItem = DataFrame<any> | DataFrameDataArg;"
    },
    "ConcatItemsArg": {
      "filePath": "types.ts",
      "lineStart": 135,
      "lineEnd": 135,
      "desc": "Operand for concatenation operations (`df.concat`, `$df.concat`). Accepts a single concatenable item or an array of concatenable items.",
      "signature": "export type ConcatItemsArg = ColumnKeyArg<ConcatItem>;"
    },
    "ConcatOptions": {
      "filePath": "types.ts",
      "lineStart": 140,
      "lineEnd": 150,
      "desc": "Configuration options for `df.concat()` and `$df.concat()`.",
      "signature": "export interface ConcatOptions {\n    /**\n     * Configuration options specific to horizontal concatenation.\n     */\n    horizontal?: HorizontalConcatOptions;\n    /**\n     * Layout strategy: `\"vertical\"` (appends rows top-to-bottom), `\"horizontal\"` (joins unique columns side-by-side), or `\"diagonal\"` (concatenates mismatched columns with null padding).\n     * @default \"vertical\"\n     */\n    how?: ConcatHow;\n}",
      "properties": {
        "horizontal": {
          "type": "HorizontalConcatOptions",
          "optional": true,
          "desc": "Configuration options specific to horizontal concatenation.",
          "properties": {
            "strict": {
              "type": "boolean",
              "optional": true,
              "desc": "When `true`, throws an error if row counts mismatch in horizontal concatenation. Set `false` to pad shorter DataFrames with `null`.",
              "default": "true"
            }
          }
        },
        "how": {
          "type": "ConcatHow",
          "optional": true,
          "desc": "Layout strategy: `\"vertical\"` (appends rows top-to-bottom), `\"horizontal\"` (joins unique columns side-by-side), or `\"diagonal\"` (concatenates mismatched columns with null padding).",
          "default": "\"vertical\"",
          "resolvedType": "\"vertical\" | \"horizontal\" | \"diagonal\""
        }
      }
    },
    "DataFrameDataArg": {
      "filePath": "types.ts",
      "lineStart": 156,
      "lineEnd": 156,
      "desc": "Input data accepted by the `DataFrame` constructor and `$df.data()`. Accepts an array of row record objects or a column dictionary mapping column names to arrays.",
      "signature": "export type DataFrameDataArg<T extends RowRecord = RowRecord> = T[] | ColumnDict;"
    },
    "DataFrameSchema": {
      "filePath": "types.ts",
      "lineStart": 161,
      "lineEnd": 161,
      "desc": "Dictionary mapping column names to their `RegisteredDataType` definitions.",
      "signature": "export type DataFrameSchema = Record<string, RegisteredDataType>;"
    },
    "DateTimeParts": {
      "filePath": "types.ts",
      "lineStart": 166,
      "lineEnd": 185,
      "desc": "Decomposed calendar and wall-clock date/time components.",
      "signature": "export interface DateTimeParts {\n    /** 1-indexed day of the month from 1 to 31. */\n    day: number;\n    /** 0-indexed day of week (0 = Sunday, 6 = Saturday). */\n    dayOfWeek?: number;\n    /** 0-indexed hour of day from 0 to 23 (0 = Midnight). */\n    hour: number;\n    /** 0-indexed minute of hour from 0 to 59. */\n    minute: number;\n    /** 1-indexed calendar month from 1 to 12 (1 = January, 12 = December). */\n    month: number;\n    /** 0-indexed millisecond from 0 to 999. */\n    ms: number;\n    /** 0-indexed second of minute from 0 to 59. */\n    second: number;\n    /** Optional target timezone identifier (e.g. \"UTC\", \"America/New_York\"). */\n    timeZone?: string | null;\n    /** Calendar year (e.g. 2026). */\n    year: number;\n}",
      "properties": {
        "day": {
          "type": "number",
          "optional": false,
          "desc": "1-indexed day of the month from 1 to 31."
        },
        "dayOfWeek": {
          "type": "number",
          "optional": true,
          "desc": "0-indexed day of week (0 = Sunday, 6 = Saturday)."
        },
        "hour": {
          "type": "number",
          "optional": false,
          "desc": "0-indexed hour of day from 0 to 23 (0 = Midnight)."
        },
        "minute": {
          "type": "number",
          "optional": false,
          "desc": "0-indexed minute of hour from 0 to 59."
        },
        "month": {
          "type": "number",
          "optional": false,
          "desc": "1-indexed calendar month from 1 to 12 (1 = January, 12 = December)."
        },
        "ms": {
          "type": "number",
          "optional": false,
          "desc": "0-indexed millisecond from 0 to 999."
        },
        "second": {
          "type": "number",
          "optional": false,
          "desc": "0-indexed second of minute from 0 to 59."
        },
        "timeZone": {
          "type": "string | null",
          "optional": true,
          "desc": "Optional target timezone identifier (e.g. \"UTC\", \"America/New_York\")."
        },
        "year": {
          "type": "number",
          "optional": false,
          "desc": "Calendar year (e.g. 2026)."
        }
      }
    },
    "DatetimeTimeUnit": {
      "filePath": "types.ts",
      "lineStart": 190,
      "lineEnd": 190,
      "desc": "Sub-second time unit resolution for `Datetime` and `Duration` data types (`\"ms\"`, `\"us\"`, `\"ns\"`).",
      "signature": "export type DatetimeTimeUnit = \"ms\" | \"us\" | \"ns\";"
    },
    "DayOffsetOptions": {
      "filePath": "types.ts",
      "lineStart": 195,
      "lineEnd": 210,
      "desc": "Configuration options for `dt.addBusinessDays()` and `addBusinessDays()`.",
      "signature": "export interface DayOffsetOptions extends IsBusinessDayOptions {\n    /**\n     * ISO weekday numbers (`1 = Monday` ... `7 = Sunday`) considered non-business weekend days.\n     * @default [6, 7]\n     */\n    excludeWeekdays?: number[];\n    /**\n     * List or set of holiday dates (`Date`, ISO date string, or UTC timestamp) to exclude as business days.\n     */\n    holidays?: (Date | string | number)[] | Set<number>;\n    /**\n     * How to handle a starting date that falls on a non-business day: `\"raise\"`, `\"forward\"`, or `\"backward\"`.\n     * @default \"raise\"\n     */\n    roll?: BusinessDayRollType;\n}",
      "properties": {
        "excludeWeekdays": {
          "type": "number[]",
          "optional": true,
          "desc": "ISO weekday numbers (`1 = Monday` ... `7 = Sunday`) considered non-business weekend days.",
          "default": "[6, 7]"
        },
        "holidays": {
          "type": "(Date | string | number)[] | Set<number>",
          "optional": true,
          "desc": "List or set of holiday dates (`Date`, ISO date string, or UTC timestamp) to exclude as business days."
        },
        "roll": {
          "type": "BusinessDayRollType",
          "optional": true,
          "desc": "How to handle a starting date that falls on a non-business day: `\"raise\"`, `\"forward\"`, or `\"backward\"`.",
          "default": "\"raise\"",
          "resolvedType": "\"raise\" | \"forward\" | \"backward\""
        }
      }
    },
    "DurationValueArg": {
      "filePath": "types.ts",
      "lineStart": 215,
      "lineEnd": 215,
      "desc": "Duration value represented as a numeric step/millisecond count or a duration interval string (e.g. `\"1d\"`, `\"1h\"`).",
      "signature": "export type DurationValueArg = number | string;"
    },
    "EntropyOptions": {
      "filePath": "types.ts",
      "lineStart": 220,
      "lineEnd": 231,
      "desc": "Configuration options for Shannon entropy (`expr.entropy`, `computeEntropy`).",
      "signature": "export interface EntropyOptions {\n    /**\n     * Logarithm base used to compute entropy.\n     * @default Math.E\n     */\n    base?: number;\n    /**\n     * If `true`, normalizes categorical value frequencies; if `false`, treats numeric values directly as discrete probabilities.\n     * @default true\n     */\n    normalize?: boolean;\n}",
      "properties": {
        "base": {
          "type": "number",
          "optional": true,
          "desc": "Logarithm base used to compute entropy.",
          "default": "Math.E"
        },
        "normalize": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, normalizes categorical value frequencies; if `false`, treats numeric values directly as discrete probabilities.",
          "default": "true"
        }
      }
    },
    "EscapeRegexMode": {
      "filePath": "types.ts",
      "lineStart": 236,
      "lineEnd": 236,
      "desc": "Escaping mode for `escapeRegExp()` and `str.escapeRegex()`.",
      "signature": "export type EscapeRegexMode = \"tc39\" | \"nonAlphanumericAscii\";"
    },
    "EscapeRegexOptions": {
      "filePath": "types.ts",
      "lineStart": 241,
      "lineEnd": 247,
      "desc": "Configuration options for `escapeRegExp()` and `str.escapeRegex()`.",
      "signature": "export interface EscapeRegexOptions {\n    /**\n     * Escaping mode: `\"tc39\"` (ECMAScript `RegExp.escape` specification) or `\"nonAlphanumericAscii\"` (escapes all `[^A-Za-z0-9]`).\n     * @default \"tc39\"\n     */\n    mode?: EscapeRegexMode;\n}",
      "properties": {
        "mode": {
          "type": "EscapeRegexMode",
          "optional": true,
          "desc": "Escaping mode: `\"tc39\"` (ECMAScript `RegExp.escape` specification) or `\"nonAlphanumericAscii\"` (escapes all `[^A-Za-z0-9]`).",
          "default": "\"tc39\"",
          "resolvedType": "\"tc39\" | \"nonAlphanumericAscii\""
        }
      }
    },
    "ExplodeOptions": {
      "filePath": "types.ts",
      "lineStart": 252,
      "lineEnd": 263,
      "desc": "Configuration options for `df.explode()`, `expr.explode()`, and `arr.explode()`.",
      "signature": "export interface ExplodeOptions {\n    /**\n     * When `true`, converts empty arrays to `null` rows.\n     * @default true\n     */\n    emptyAsNull?: boolean;\n    /**\n     * When `true`, retains `null` array values during explosion.\n     * @default true\n     */\n    keepNulls?: boolean;\n}",
      "properties": {
        "emptyAsNull": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, converts empty arrays to `null` rows.",
          "default": "true"
        },
        "keepNulls": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, retains `null` array values during explosion.",
          "default": "true"
        }
      }
    },
    "ExprDict": {
      "filePath": "types.ts",
      "lineStart": 268,
      "lineEnd": 268,
      "desc": "Dictionary mapping field or column names to column expressions.",
      "signature": "export type ExprDict = Record<string, IntoExpr>;"
    },
    "ExtractManyOptions": {
      "filePath": "types.ts",
      "lineStart": 273,
      "lineEnd": 299,
      "desc": "Configuration options for `str.extractMany()` and `extractRegexMany()`.",
      "signature": "export interface ExtractManyOptions extends ExtractRegexEngineOptions {\n    /**\n     * Whether matching should be case-insensitive for ASCII characters.\n     * @default false\n     */\n    asciiCaseInsensitive?: boolean;\n    /**\n     * Whether to return all matches (global flag).\n     * @default false\n     */\n    global?: boolean;\n    /**\n     * 0-based index or name of the capture group to extract.\n     * @default 0\n     */\n    groupIndex?: ColumnIndexOrNameArg;\n    /**\n     * Guarantees that the leftmost match is selected when multiple patterns match. Cannot be combined with `overlapping: true`.\n     * @default false\n     */\n    leftmost?: boolean;\n    /**\n     * Whether overlapping matches across patterns are allowed.\n     * @default false\n     */\n    overlapping?: boolean;\n}",
      "properties": {
        "asciiCaseInsensitive": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether matching should be case-insensitive for ASCII characters.",
          "default": "false"
        },
        "global": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to return all matches (global flag).",
          "default": "false"
        },
        "groupIndex": {
          "type": "ColumnIndexOrNameArg",
          "optional": true,
          "desc": "0-based index or name of the capture group to extract.",
          "default": "0",
          "resolvedType": "number | string"
        },
        "leftmost": {
          "type": "boolean",
          "optional": true,
          "desc": "Guarantees that the leftmost match is selected when multiple patterns match. Cannot be combined with `overlapping: true`.",
          "default": "false"
        },
        "overlapping": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether overlapping matches across patterns are allowed.",
          "default": "false"
        }
      }
    },
    "ExtractRegexEngineOptions": {
      "filePath": "types.ts",
      "lineStart": 304,
      "lineEnd": 320,
      "desc": "Configuration options for regex extraction (`str.extract`, `str.extractAll`, `extractRegexEngine`).",
      "signature": "export interface ExtractRegexEngineOptions {\n    /**\n     * Whether matching should be case-insensitive for ASCII characters.\n     * @default false\n     */\n    asciiCaseInsensitive?: boolean;\n    /**\n     * Whether to return all matches (global flag).\n     * @default false\n     */\n    global?: boolean;\n    /**\n     * 0-based index or name of the capture group to extract.\n     * @default 1\n     */\n    groupIndex?: ColumnIndexOrNameArg;\n}",
      "properties": {
        "asciiCaseInsensitive": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether matching should be case-insensitive for ASCII characters.",
          "default": "false"
        },
        "global": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to return all matches (global flag).",
          "default": "false"
        },
        "groupIndex": {
          "type": "ColumnIndexOrNameArg",
          "optional": true,
          "desc": "0-based index or name of the capture group to extract.",
          "default": "1",
          "resolvedType": "number | string"
        }
      }
    },
    "FillNullOptions": {
      "filePath": "types.ts",
      "lineStart": 325,
      "lineEnd": 325,
      "desc": "Alias of `FillOptions` for `fillNull()` operations.",
      "signature": "export type FillNullOptions = FillOptions;",
      "properties": {
        "limit": {
          "type": "number",
          "optional": true,
          "desc": "Maximum number of consecutive target values to fill when using directional strategies (`\"forward\"`, `\"backward\"`)."
        },
        "strategy": {
          "type": "FillNullStrategy",
          "optional": true,
          "desc": "Filling strategy to calculate or propagate replacement values (`\"forward\"`, `\"backward\"`, `\"min\"`, `\"max\"`, `\"mean\"`, `\"zero\"`, `\"one\"`).",
          "resolvedType": "\"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\""
        },
        "value": {
          "type": "ScalarArg",
          "optional": true,
          "desc": "Replacement scalar value or column expression to substitute in place of target values.",
          "resolvedType": "IExpr | ValidScalarTypes"
        }
      }
    },
    "FillNullStrategy": {
      "filePath": "types.ts",
      "lineStart": 330,
      "lineEnd": 330,
      "desc": "Strategy for filling missing or targeted values in a column or DataFrame.",
      "signature": "export type FillNullStrategy = \"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\";"
    },
    "FillOptions": {
      "filePath": "types.ts",
      "lineStart": 335,
      "lineEnd": 348,
      "desc": "Configuration options for `df.fill()`, `df.fillNull()`, `df.fillNan()`, `expr.fill()`, `expr.fillNull()`, and `expr.fillNan()`.",
      "signature": "export interface FillOptions {\n    /**\n     * Maximum number of consecutive target values to fill when using directional strategies (`\"forward\"`, `\"backward\"`).\n     */\n    limit?: number;\n    /**\n     * Filling strategy to calculate or propagate replacement values (`\"forward\"`, `\"backward\"`, `\"min\"`, `\"max\"`, `\"mean\"`, `\"zero\"`, `\"one\"`).\n     */\n    strategy?: FillNullStrategy;\n    /**\n     * Replacement scalar value or column expression to substitute in place of target values.\n     */\n    value?: ScalarArg;\n}",
      "properties": {
        "limit": {
          "type": "number",
          "optional": true,
          "desc": "Maximum number of consecutive target values to fill when using directional strategies (`\"forward\"`, `\"backward\"`)."
        },
        "strategy": {
          "type": "FillNullStrategy",
          "optional": true,
          "desc": "Filling strategy to calculate or propagate replacement values (`\"forward\"`, `\"backward\"`, `\"min\"`, `\"max\"`, `\"mean\"`, `\"zero\"`, `\"one\"`).",
          "resolvedType": "\"forward\" | \"backward\" | \"min\" | \"max\" | \"mean\" | \"zero\" | \"one\""
        },
        "value": {
          "type": "ScalarArg",
          "optional": true,
          "desc": "Replacement scalar value or column expression to substitute in place of target values.",
          "resolvedType": "IExpr | ValidScalarTypes"
        }
      }
    },
    "FillTarget": {
      "filePath": "types.ts",
      "lineStart": 353,
      "lineEnd": 353,
      "desc": "Target value selector for `df.fill()` and `expr.fill()`: `\"null\"`, `\"nan\"`, `\"all\"`, or a custom scalar/expression.",
      "signature": "export type FillTarget = \"null\" | \"nan\" | \"all\" | ScalarArg;"
    },
    "FindManyOptions": {
      "filePath": "types.ts",
      "lineStart": 358,
      "lineEnd": 394,
      "desc": "Configuration options for `str.findMany()` and `findManyRegex()`.",
      "signature": "export interface FindManyOptions extends ExtractManyOptions, EscapeRegexOptions {\n    /**\n     * Whether matching should be case-insensitive for ASCII characters.\n     * @default false\n     */\n    asciiCaseInsensitive?: boolean;\n    /**\n     * Whether to return all matches (global flag).\n     * @default false\n     */\n    global?: boolean;\n    /**\n     * 0-based index or name of the capture group to locate.\n     * @default 0\n     */\n    groupIndex?: ColumnIndexOrNameArg;\n    /**\n     * Guarantees that the leftmost match is selected when multiple patterns match.\n     * @default false\n     */\n    leftmost?: boolean;\n    /**\n     * Treat patterns as literal substrings instead of regular expressions.\n     * @default false\n     */\n    literal?: boolean;\n    /**\n     * Escaping mode when `literal` is `true`.\n     * @default \"tc39\"\n     */\n    mode?: EscapeRegexMode;\n    /**\n     * Whether overlapping matches across patterns are allowed.\n     * @default false\n     */\n    overlapping?: boolean;\n}",
      "properties": {
        "asciiCaseInsensitive": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether matching should be case-insensitive for ASCII characters.",
          "default": "false"
        },
        "global": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to return all matches (global flag).",
          "default": "false"
        },
        "groupIndex": {
          "type": "ColumnIndexOrNameArg",
          "optional": true,
          "desc": "0-based index or name of the capture group to locate.",
          "default": "0",
          "resolvedType": "number | string"
        },
        "leftmost": {
          "type": "boolean",
          "optional": true,
          "desc": "Guarantees that the leftmost match is selected when multiple patterns match.",
          "default": "false"
        },
        "literal": {
          "type": "boolean",
          "optional": true,
          "desc": "Treat patterns as literal substrings instead of regular expressions.",
          "default": "false"
        },
        "mode": {
          "type": "EscapeRegexMode",
          "optional": true,
          "desc": "Escaping mode when `literal` is `true`.",
          "default": "\"tc39\"",
          "resolvedType": "\"tc39\" | \"nonAlphanumericAscii\""
        },
        "overlapping": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether overlapping matches across patterns are allowed.",
          "default": "false"
        }
      }
    },
    "FindOptions": {
      "filePath": "types.ts",
      "lineStart": 399,
      "lineEnd": 425,
      "desc": "Configuration options for `str.find()` and `findRegex()`.",
      "signature": "export interface FindOptions extends ExtractRegexEngineOptions, EscapeRegexOptions {\n    /**\n     * Whether matching should be case-insensitive for ASCII characters.\n     * @default false\n     */\n    asciiCaseInsensitive?: boolean;\n    /**\n     * Whether to return all matches (global flag).\n     * @default false\n     */\n    global?: boolean;\n    /**\n     * 0-based index or name of the capture group to locate.\n     * @default 0\n     */\n    groupIndex?: ColumnIndexOrNameArg;\n    /**\n     * Treat pattern as a literal substring instead of a regular expression.\n     * @default false\n     */\n    literal?: boolean;\n    /**\n     * Escaping mode when `literal` is `true`.\n     * @default \"tc39\"\n     */\n    mode?: EscapeRegexMode;\n}",
      "properties": {
        "asciiCaseInsensitive": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether matching should be case-insensitive for ASCII characters.",
          "default": "false"
        },
        "global": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to return all matches (global flag).",
          "default": "false"
        },
        "groupIndex": {
          "type": "ColumnIndexOrNameArg",
          "optional": true,
          "desc": "0-based index or name of the capture group to locate.",
          "default": "0",
          "resolvedType": "number | string"
        },
        "literal": {
          "type": "boolean",
          "optional": true,
          "desc": "Treat pattern as a literal substring instead of a regular expression.",
          "default": "false"
        },
        "mode": {
          "type": "EscapeRegexMode",
          "optional": true,
          "desc": "Escaping mode when `literal` is `true`.",
          "default": "\"tc39\"",
          "resolvedType": "\"tc39\" | \"nonAlphanumericAscii\""
        }
      }
    },
    "HorizontalConcatOptions": {
      "filePath": "types.ts",
      "lineStart": 430,
      "lineEnd": 436,
      "desc": "Configuration options specific to horizontal DataFrame concatenation.",
      "signature": "export interface HorizontalConcatOptions {\n    /**\n     * When `true`, throws an error if row counts mismatch in horizontal concatenation. Set `false` to pad shorter DataFrames with `null`.\n     * @default true\n     */\n    strict?: boolean;\n}",
      "properties": {
        "strict": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, throws an error if row counts mismatch in horizontal concatenation. Set `false` to pad shorter DataFrames with `null`.",
          "default": "true"
        }
      }
    },
    "IExpr": {
      "filePath": "types.ts",
      "lineStart": 442,
      "lineEnd": 491,
      "desc": "Core internal and public interface implemented by all column expressions (`ExprBase`, `ColumnExpr`).",
      "internal": true,
      "signature": "export interface IExpr {\n    /** Aggregation reducer function registered on the expression, or `null`. */\n    _aggFn?: AggFn<any> | null;\n    /** Parent base expression for struct field extraction or unnesting. */\n    _baseExpr?: IExpr;\n    /** Left and right operand metadata for binary expressions. */\n    _binaryMeta?: { _left: any; _right: any };\n    /** Branch operands collected by `$df.when().then().otherwise()` chains. */\n    _branchOperands?: any[];\n    /** Target `RegisteredDataType` registered via `.cast()`. */\n    _castType?: RegisteredDataType;\n    /** Source column name or expression selector marker. */\n    _colName?: string;\n    /** Logs intermediate column state during expression evaluation and returns `this`. */\n    _debug(label?: string): this;\n    /** Evaluates the full expression pipeline against `columns`. */\n    _evaluate(columns: ColumnDict, height: number): ColumnData;\n    /** Evaluates post-aggregation or post-partition operations starting after `opsIndex`. */\n    _evaluatePost(opsIndex: number | undefined, aggregatedArray: any[], columns: ColumnDict): ColumnData;\n    /** Evaluates pre-aggregation or pre-partition operations up to `opsIndex`. */\n    _evaluatePre(opsIndex: number | undefined, columns: ColumnDict, height: number): ColumnData;\n    /** Evaluates a row-wise window operation over a partition slice. */\n    _evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;\n    /** Struct field name targeted by `.struct.field()`. */\n    _fieldName?: string;\n    /** Pipeline index marking the boundary of an `.agg()` reduction. */\n    _groupingOpsIndex?: number;\n    /** Returns `true` if the expression performs a full-column reduction without window partitioning. */\n    _isGlobalAgg?(): boolean;\n    /** Flag indicating whether the expression represents a constant literal value. */\n    _isLiteral?: boolean;\n    /** Flag indicating whether the expression expands struct fields via `.struct.unnest()`. */\n    _isUnnest?: boolean;\n    /** Flag indicating whether the expression requires window-function evaluation. */\n    _isWindow?: boolean;\n    /** Raw literal value when `_isLiteral` is `true`. */\n    _literalValue?: any;\n    /** Ordered pipeline of vectorized transformation functions. */\n    _ops: OpFn[];\n    /** Explicit output alias name assigned via `.alias()`. */\n    _outputName?: string;\n    /** Partitioning column keys or expressions supplied to `.over()`. */\n    _partitionBy?: ColumnOrExprArg[] | null;\n    /** Pipeline index marking the boundary of an `.over()` window partition. */\n    _partitionOpsIndex?: number;\n    /** Resolves an operand into an evaluated column array or scalar value. */\n    _resolve(val: any, columns: ColumnDict, height: number): ColumnData | any;\n    /** Window operation metadata descriptor when `_isWindow` is `true`. */\n    _windowOp?: { type: string;[key: string]: any } | null;\n}",
      "properties": {
        "_aggFn": {
          "type": "AggFn<any> | null",
          "optional": true,
          "desc": "Aggregation reducer function registered on the expression, or `null`."
        },
        "_baseExpr": {
          "type": "IExpr",
          "optional": true,
          "desc": "Parent base expression for struct field extraction or unnesting."
        },
        "_binaryMeta": {
          "type": "{ _left: any; _right: any }",
          "optional": true,
          "desc": "Left and right operand metadata for binary expressions."
        },
        "_branchOperands": {
          "type": "any[]",
          "optional": true,
          "desc": "Branch operands collected by `$df.when().then().otherwise()` chains."
        },
        "_castType": {
          "type": "RegisteredDataType",
          "optional": true,
          "desc": "Target `RegisteredDataType` registered via `.cast()`."
        },
        "_colName": {
          "type": "string",
          "optional": true,
          "desc": "Source column name or expression selector marker."
        },
        "_fieldName": {
          "type": "string",
          "optional": true,
          "desc": "Struct field name targeted by `.struct.field()`."
        },
        "_groupingOpsIndex": {
          "type": "number",
          "optional": true,
          "desc": "Pipeline index marking the boundary of an `.agg()` reduction."
        },
        "_isLiteral": {
          "type": "boolean",
          "optional": true,
          "desc": "Flag indicating whether the expression represents a constant literal value."
        },
        "_isUnnest": {
          "type": "boolean",
          "optional": true,
          "desc": "Flag indicating whether the expression expands struct fields via `.struct.unnest()`."
        },
        "_isWindow": {
          "type": "boolean",
          "optional": true,
          "desc": "Flag indicating whether the expression requires window-function evaluation."
        },
        "_literalValue": {
          "type": "any",
          "optional": true,
          "desc": "Raw literal value when `_isLiteral` is `true`."
        },
        "_ops": {
          "type": "OpFn[]",
          "optional": false,
          "desc": "Ordered pipeline of vectorized transformation functions."
        },
        "_outputName": {
          "type": "string",
          "optional": true,
          "desc": "Explicit output alias name assigned via `.alias()`."
        },
        "_partitionBy": {
          "type": "ColumnOrExprArg[] | null",
          "optional": true,
          "desc": "Partitioning column keys or expressions supplied to `.over()`."
        },
        "_partitionOpsIndex": {
          "type": "number",
          "optional": true,
          "desc": "Pipeline index marking the boundary of an `.over()` window partition."
        },
        "_windowOp": {
          "type": "{ type: string;[key: string]: any } | null",
          "optional": true,
          "desc": "Window operation metadata descriptor when `_isWindow` is `true`."
        }
      }
    },
    "IntoExpr": {
      "filePath": "types.ts",
      "lineStart": 496,
      "lineEnd": 496,
      "desc": "Value that can be converted into a column expression: a column name, `RegExp` selector, or `IExpr` instance.",
      "signature": "export type IntoExpr = RegexPatternArg | IExpr;"
    },
    "IntoExprArg": {
      "filePath": "types.ts",
      "lineStart": 501,
      "lineEnd": 501,
      "desc": "Operand accepting either a single column expression selector or an array of selectors.",
      "signature": "export type IntoExprArg = ColumnKeyArg<IntoExpr>;"
    },
    "IntoExprSeriesArg": {
      "filePath": "types.ts",
      "lineStart": 507,
      "lineEnd": 507,
      "desc": "Operand for multiple column expressions. Accepts an array of column expressions, names, or regex selectors.",
      "signature": "export type IntoExprSeriesArg = IntoExpr[];"
    },
    "IsBusinessDayOptions": {
      "filePath": "types.ts",
      "lineStart": 512,
      "lineEnd": 522,
      "desc": "Configuration options for `dt.isBusinessDay()` and `isBusinessDay()`.",
      "signature": "export interface IsBusinessDayOptions {\n    /**\n     * ISO weekday numbers (`1 = Monday` ... `7 = Sunday`) considered non-business weekend days.\n     * @default [6, 7]\n     */\n    excludeWeekdays?: number[];\n    /**\n     * List or set of holiday dates (`Date`, ISO date string, or UTC timestamp) to exclude as business days.\n     */\n    holidays?: (Date | string | number)[] | Set<number>;\n}",
      "properties": {
        "excludeWeekdays": {
          "type": "number[]",
          "optional": true,
          "desc": "ISO weekday numbers (`1 = Monday` ... `7 = Sunday`) considered non-business weekend days.",
          "default": "[6, 7]"
        },
        "holidays": {
          "type": "(Date | string | number)[] | Set<number>",
          "optional": true,
          "desc": "List or set of holiday dates (`Date`, ISO date string, or UTC timestamp) to exclude as business days."
        }
      }
    },
    "JSONFormat": {
      "filePath": "types.ts",
      "lineStart": 527,
      "lineEnd": 531,
      "desc": "Supported JSON serialization and parsing format.",
      "signature": "export type JSONFormat =\n    /** Standard JSON format. */\n    | \"json\"\n    /** Newline Delimited JSON format. */\n    | \"ndjson\";"
    },
    "KurtosisOptions": {
      "filePath": "types.ts",
      "lineStart": 536,
      "lineEnd": 547,
      "desc": "Configuration options for sample/population kurtosis (`expr.kurtosis`, `computeKurtosis`).",
      "signature": "export interface KurtosisOptions extends SkewOptions {\n    /**\n     * If `true`, computes biased population kurtosis; if `false`, applies sample bias correction.\n     * @default true\n     */\n    bias?: boolean;\n    /**\n     * If `true`, computes Fisher's excess kurtosis (subtracts 3 so a normal distribution equals 0); if `false`, computes Pearson's kurtosis.\n     * @default true\n     */\n    fisher?: boolean;\n}",
      "properties": {
        "bias": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, computes biased population kurtosis; if `false`, applies sample bias correction.",
          "default": "true"
        },
        "fisher": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, computes Fisher's excess kurtosis (subtracts 3 so a normal distribution equals 0); if `false`, computes Pearson's kurtosis.",
          "default": "true"
        }
      }
    },
    "OpFn": {
      "filePath": "types.ts",
      "lineStart": 552,
      "lineEnd": 552,
      "desc": "Vectorized column operation function transforming `ColumnData` in the expression pipeline.",
      "signature": "export type OpFn = (vals: ColumnData, columns: ColumnDict) => ColumnData;"
    },
    "ReadCSVOptions": {
      "filePath": "types.ts",
      "lineStart": 557,
      "lineEnd": 587,
      "desc": "Configuration options for `$df.readCsv()` and `parseCSV()`.",
      "signature": "export interface ReadCSVOptions {\n    /**\n     * Whether the CSV has a header row.\n     * @default true\n     */\n    hasHeader?: boolean;\n    /**\n     * Try to infer types from values if no schema is provided.\n     * @default true\n     */\n    inferSchema?: boolean;\n    /**\n     * String representations of null values.\n     * @default [\"\", \"NA\", \"null\", \"NaN\"]\n     */\n    nullValues?: string[];\n    /**\n     * The character used for quoting fields.\n     * @default '\"'\n     */\n    quoteChar?: string;\n    /**\n     * Optional explicit schema mapping column names to their registered data types.\n     */\n    schema?: DataFrameSchema;\n    /**\n     * Character that separates fields.\n     * @default \",\"\n     */\n    separator?: string;\n}",
      "properties": {
        "hasHeader": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether the CSV has a header row.",
          "default": "true"
        },
        "inferSchema": {
          "type": "boolean",
          "optional": true,
          "desc": "Try to infer types from values if no schema is provided.",
          "default": "true"
        },
        "nullValues": {
          "type": "string[]",
          "optional": true,
          "desc": "String representations of null values.",
          "default": "[\"\", \"NA\", \"null\", \"NaN\"]"
        },
        "quoteChar": {
          "type": "string",
          "optional": true,
          "desc": "The character used for quoting fields.",
          "default": "'\"'"
        },
        "schema": {
          "type": "DataFrameSchema",
          "optional": true,
          "desc": "Optional explicit schema mapping column names to their registered data types.",
          "resolvedType": "Record<string, RegisteredDataType>"
        },
        "separator": {
          "type": "string",
          "optional": true,
          "desc": "Character that separates fields.",
          "default": "\",\""
        }
      }
    },
    "ReadJSONOptions": {
      "filePath": "types.ts",
      "lineStart": 592,
      "lineEnd": 620,
      "desc": "Configuration options for `$df.readJson()`.",
      "signature": "export interface ReadJSONOptions extends JSONParseOptions {\n    /**\n     * Whether to allow JSON primitive roots instead of requiring objects or arrays.\n     * @default false\n     */\n    allowPrimitives?: boolean;\n    /**\n     * Format of the JSON content: `\"json\"` (standard JSON) or `\"ndjson\"` (Newline Delimited JSON).\n     * @default \"json\"\n     */\n    format?: JSONFormat;\n    /**\n     * Options specific to NDJSON parsing when `format` is `\"ndjson\"`.\n     */\n    ndjson?: NDJSONParseOptions;\n    /**\n     * Reviver function passed to `JSON.parse` for custom value transformation.\n     */\n    reviver?: Parameters<typeof JSON.parse>[1];\n    /**\n     * Optional explicit schema mapping column names to their registered data types.\n     */\n    schema?: DataFrameSchema;\n    /**\n     * Whether to trim leading and trailing whitespace before validating/parsing.\n     * @default false\n     */\n    trimBeforeParse?: boolean;\n}",
      "properties": {
        "allowPrimitives": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to allow JSON primitive roots instead of requiring objects or arrays.",
          "default": "false"
        },
        "format": {
          "type": "JSONFormat",
          "optional": true,
          "desc": "Format of the JSON content: `\"json\"` (standard JSON) or `\"ndjson\"` (Newline Delimited JSON).",
          "default": "\"json\"",
          "resolvedType": "\"json\" | \"ndjson\""
        },
        "ndjson": {
          "type": "NDJSONParseOptions",
          "optional": true,
          "desc": "Options specific to NDJSON parsing when `format` is `\"ndjson\"`.",
          "properties": {
            "maxLines": {
              "type": "number",
              "optional": true,
              "desc": "Maximum number of non-empty lines to validate or parse."
            },
            "skipInvalidLines": {
              "type": "boolean",
              "optional": true,
              "desc": "Skip malformed or invalid lines instead of failing the entire parse.",
              "default": "false"
            },
            "skipLines": {
              "type": "number",
              "optional": true,
              "desc": "Number of non-empty lines to skip at the beginning of the content.",
              "default": "0"
            }
          }
        },
        "reviver": {
          "type": "Parameters<typeof JSON.parse>[1]",
          "optional": true,
          "desc": "Reviver function passed to `JSON.parse` for custom value transformation."
        },
        "schema": {
          "type": "DataFrameSchema",
          "optional": true,
          "desc": "Optional explicit schema mapping column names to their registered data types.",
          "resolvedType": "Record<string, RegisteredDataType>"
        },
        "trimBeforeParse": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to trim leading and trailing whitespace before validating/parsing.",
          "default": "false"
        }
      }
    },
    "RegexEngineOptions": {
      "filePath": "types.ts",
      "lineStart": 625,
      "lineEnd": 636,
      "desc": "Configuration options for regex matching without capture group indexing.",
      "signature": "export interface RegexEngineOptions {\n    /**\n     * Whether matching should be case-insensitive for ASCII characters.\n     * @default false\n     */\n    asciiCaseInsensitive?: boolean;\n    /**\n     * Whether to return all matches (global flag).\n     * @default false\n     */\n    global?: boolean;\n}",
      "properties": {
        "asciiCaseInsensitive": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether matching should be case-insensitive for ASCII characters.",
          "default": "false"
        },
        "global": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to return all matches (global flag).",
          "default": "false"
        }
      }
    },
    "RegexPatternArg": {
      "filePath": "types.ts",
      "lineStart": 642,
      "lineEnd": 642,
      "desc": "Operand for substring matching or regular expression evaluation. Accepts a substring string or a compiled `RegExp` object.",
      "signature": "export type RegexPatternArg = string | RegExp;"
    },
    "RegexPatternSeriesArg": {
      "filePath": "types.ts",
      "lineStart": 648,
      "lineEnd": 648,
      "desc": "Operand for multi-pattern regular expression matching. Accepts an array of substring strings or compiled `RegExp` objects.",
      "signature": "export type RegexPatternSeriesArg = RegexPatternArg[];"
    },
    "RenameMappingArg": {
      "filePath": "types.ts",
      "lineStart": 653,
      "lineEnd": 653,
      "desc": "Dictionary mapping existing column or field names to new names.",
      "signature": "export type RenameMappingArg<T extends RowRecord = RowRecord> = Partial<Record<keyof T, string>>;"
    },
    "ReplaceDateOptions": {
      "filePath": "types.ts",
      "lineStart": 658,
      "lineEnd": 675,
      "desc": "Configuration options for `dt.replace()` and `replaceDateParts()`.",
      "signature": "export interface ReplaceDateOptions {\n    /** Replacement 1-indexed day of the month (1 to 31). */\n    day?: number;\n    /** Replacement 0-indexed hour of day (0 to 23). */\n    hour?: number;\n    /** Replacement 0-indexed minute of hour (0 to 59). */\n    minute?: number;\n    /** Replacement 1-indexed calendar month (1 to 12). */\n    month?: number;\n    /** Replacement 0-indexed millisecond (0 to 999). */\n    ms?: number;\n    /** Replacement 0-indexed second of minute (0 to 59). */\n    second?: number;\n    /** Target timezone identifier used to interpret and re-project the replaced components. */\n    timeZone?: string | null;\n    /** Replacement calendar year. */\n    year?: number;\n}",
      "properties": {
        "day": {
          "type": "number",
          "optional": true,
          "desc": "Replacement 1-indexed day of the month (1 to 31)."
        },
        "hour": {
          "type": "number",
          "optional": true,
          "desc": "Replacement 0-indexed hour of day (0 to 23)."
        },
        "minute": {
          "type": "number",
          "optional": true,
          "desc": "Replacement 0-indexed minute of hour (0 to 59)."
        },
        "month": {
          "type": "number",
          "optional": true,
          "desc": "Replacement 1-indexed calendar month (1 to 12)."
        },
        "ms": {
          "type": "number",
          "optional": true,
          "desc": "Replacement 0-indexed millisecond (0 to 999)."
        },
        "second": {
          "type": "number",
          "optional": true,
          "desc": "Replacement 0-indexed second of minute (0 to 59)."
        },
        "timeZone": {
          "type": "string | null",
          "optional": true,
          "desc": "Target timezone identifier used to interpret and re-project the replaced components."
        },
        "year": {
          "type": "number",
          "optional": true,
          "desc": "Replacement calendar year."
        }
      }
    },
    "ReplaceManyOptions": {
      "filePath": "types.ts",
      "lineStart": 680,
      "lineEnd": 716,
      "desc": "Configuration options for `str.replaceMany()` and `replaceManyString()`.",
      "signature": "export interface ReplaceManyOptions extends FindManyOptions {\n    /**\n     * Whether matching should be case-insensitive for ASCII characters.\n     * @default false\n     */\n    asciiCaseInsensitive?: boolean;\n    /**\n     * Whether to replace all matches globally.\n     * @default false\n     */\n    global?: boolean;\n    /**\n     * 0-based index or name of the capture group to replace.\n     * @default 0\n     */\n    groupIndex?: ColumnIndexOrNameArg;\n    /**\n     * Guarantees that the leftmost match is selected when multiple patterns match.\n     * @default false\n     */\n    leftmost?: boolean;\n    /**\n     * Treat patterns as literal substrings instead of regular expressions.\n     * @default false\n     */\n    literal?: boolean;\n    /**\n     * Escaping mode when `literal` is `true`.\n     * @default \"tc39\"\n     */\n    mode?: EscapeRegexMode;\n    /**\n     * Whether overlapping matches across patterns are allowed.\n     * @default false\n     */\n    overlapping?: boolean;\n}",
      "properties": {
        "asciiCaseInsensitive": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether matching should be case-insensitive for ASCII characters.",
          "default": "false"
        },
        "global": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to replace all matches globally.",
          "default": "false"
        },
        "groupIndex": {
          "type": "ColumnIndexOrNameArg",
          "optional": true,
          "desc": "0-based index or name of the capture group to replace.",
          "default": "0",
          "resolvedType": "number | string"
        },
        "leftmost": {
          "type": "boolean",
          "optional": true,
          "desc": "Guarantees that the leftmost match is selected when multiple patterns match.",
          "default": "false"
        },
        "literal": {
          "type": "boolean",
          "optional": true,
          "desc": "Treat patterns as literal substrings instead of regular expressions.",
          "default": "false"
        },
        "mode": {
          "type": "EscapeRegexMode",
          "optional": true,
          "desc": "Escaping mode when `literal` is `true`.",
          "default": "\"tc39\"",
          "resolvedType": "\"tc39\" | \"nonAlphanumericAscii\""
        },
        "overlapping": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether overlapping matches across patterns are allowed.",
          "default": "false"
        }
      }
    },
    "ReplaceOptions": {
      "filePath": "types.ts",
      "lineStart": 721,
      "lineEnd": 747,
      "desc": "Configuration options for `str.replace()` and `replaceString()`.",
      "signature": "export interface ReplaceOptions extends RegexEngineOptions, EscapeRegexOptions {\n    /**\n     * Whether matching should be case-insensitive for ASCII characters.\n     * @default false\n     */\n    asciiCaseInsensitive?: boolean;\n    /**\n     * Whether to replace all matches globally.\n     * @default false\n     */\n    global?: boolean;\n    /**\n     * Treat pattern as a literal substring instead of a regular expression.\n     * @default false\n     */\n    literal?: boolean;\n    /**\n     * Escaping mode when `literal` is `true`.\n     * @default \"tc39\"\n     */\n    mode?: EscapeRegexMode;\n    /**\n     * Maximum number of occurrences to replace (`-1` or `Infinity` replaces all).\n     * @default 1\n     */\n    n?: number;\n}",
      "properties": {
        "asciiCaseInsensitive": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether matching should be case-insensitive for ASCII characters.",
          "default": "false"
        },
        "global": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to replace all matches globally.",
          "default": "false"
        },
        "literal": {
          "type": "boolean",
          "optional": true,
          "desc": "Treat pattern as a literal substring instead of a regular expression.",
          "default": "false"
        },
        "mode": {
          "type": "EscapeRegexMode",
          "optional": true,
          "desc": "Escaping mode when `literal` is `true`.",
          "default": "\"tc39\"",
          "resolvedType": "\"tc39\" | \"nonAlphanumericAscii\""
        },
        "n": {
          "type": "number",
          "optional": true,
          "desc": "Maximum number of occurrences to replace (`-1` or `Infinity` replaces all).",
          "default": "1"
        }
      }
    },
    "RowRecord": {
      "filePath": "types.ts",
      "lineStart": 752,
      "lineEnd": 752,
      "desc": "Dictionary representing a single row record in a DataFrame, mapping column names to values.",
      "signature": "export type RowRecord = Record<string, any>;"
    },
    "ScalarArg": {
      "filePath": "types.ts",
      "lineStart": 758,
      "lineEnd": 758,
      "desc": "Operand for scalar-level operations (`contains`, `countMatches`, `coalesce`, etc.). Accepts another column expression or any valid scalar value.",
      "signature": "export type ScalarArg = IExpr | ValidScalarTypes;"
    },
    "SkewOptions": {
      "filePath": "types.ts",
      "lineStart": 763,
      "lineEnd": 769,
      "desc": "Configuration options for sample/population skewness (`expr.skew`, `computeSkew`).",
      "signature": "export interface SkewOptions {\n    /**\n     * If `true`, computes biased population skewness; if `false`, applies the Fisher-Pearson sample bias correction.\n     * @default true\n     */\n    bias?: boolean;\n}",
      "properties": {
        "bias": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, computes biased population skewness; if `false`, applies the Fisher-Pearson sample bias correction.",
          "default": "true"
        }
      }
    },
    "SortArrayOptions": {
      "filePath": "types.ts",
      "lineStart": 774,
      "lineEnd": 789,
      "desc": "Configuration options for sorting arrays and columns (`arr.sort`, `sortArray`).",
      "signature": "export interface SortArrayOptions<T = any> {\n    /**\n     * Optional comparator function or dictionary mapping column names to custom comparator functions.\n     */\n    customComp?: ((a: any, b: any) => number) | Partial<Record<keyof T, (a: any, b: any) => number>> | null;\n    /**\n     * Sort order boolean or array of booleans per key.\n     * @default false\n     */\n    descending?: ColumnKeyArg<boolean>;\n    /**\n     * When `true`, places nulls at the end of sorted output.\n     * @default true\n     */\n    nullsLast?: boolean;\n}",
      "properties": {
        "customComp": {
          "type": "((a: any, b: any) => number) | Partial<Record<keyof any, (a: any, b: any) => number>> | null",
          "optional": true,
          "desc": "Optional comparator function or dictionary mapping column names to custom comparator functions."
        },
        "descending": {
          "type": "ColumnKeyArg<boolean>",
          "optional": true,
          "desc": "Sort order boolean or array of booleans per key.",
          "default": "false",
          "resolvedType": "boolean | boolean[]"
        },
        "nullsLast": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, places nulls at the end of sorted output.",
          "default": "true"
        }
      }
    },
    "SplitOptions": {
      "filePath": "types.ts",
      "lineStart": 794,
      "lineEnd": 834,
      "desc": "Configuration options for `str.split()` and `splitString()`.",
      "signature": "export interface SplitOptions extends RegexEngineOptions, EscapeRegexOptions {\n    /**\n     * Whether matching should be case-insensitive for ASCII characters.\n     * @default false\n     */\n    asciiCaseInsensitive?: boolean;\n    /**\n     * If `true`, pads missing splits with `null` to guarantee `limit + 1` elements.\n     * @default false\n     */\n    exact?: boolean;\n    /**\n     * Whether to match globally.\n     * @default false\n     */\n    global?: boolean;\n    /**\n     * Include matched delimiter substrings in the split output array.\n     * @default false\n     */\n    inclusive?: boolean;\n    /**\n     * Maximum number of splits to perform.\n     */\n    limit?: number;\n    /**\n     * Treat delimiter as a literal substring (`true`) or regular expression (`false`).\n     * @default true\n     */\n    literal?: boolean;\n    /**\n     * Escaping mode when `literal` is `true`.\n     * @default \"tc39\"\n     */\n    mode?: EscapeRegexMode;\n    /**\n     * If `true`, throws an `InvalidArgumentError` when the split yields fewer than `limit + 1` elements.\n     * @default false\n     */\n    strict?: boolean;\n}",
      "properties": {
        "asciiCaseInsensitive": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether matching should be case-insensitive for ASCII characters.",
          "default": "false"
        },
        "exact": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, pads missing splits with `null` to guarantee `limit + 1` elements.",
          "default": "false"
        },
        "global": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to match globally.",
          "default": "false"
        },
        "inclusive": {
          "type": "boolean",
          "optional": true,
          "desc": "Include matched delimiter substrings in the split output array.",
          "default": "false"
        },
        "limit": {
          "type": "number",
          "optional": true,
          "desc": "Maximum number of splits to perform."
        },
        "literal": {
          "type": "boolean",
          "optional": true,
          "desc": "Treat delimiter as a literal substring (`true`) or regular expression (`false`).",
          "default": "true"
        },
        "mode": {
          "type": "EscapeRegexMode",
          "optional": true,
          "desc": "Escaping mode when `literal` is `true`.",
          "default": "\"tc39\"",
          "resolvedType": "\"tc39\" | \"nonAlphanumericAscii\""
        },
        "strict": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, throws an `InvalidArgumentError` when the split yields fewer than `limit + 1` elements.",
          "default": "false"
        }
      }
    },
    "StrftimeOptions": {
      "filePath": "types.ts",
      "lineStart": 839,
      "lineEnd": 854,
      "desc": "Configuration options for `dt.strftime()` and `strftime()`.",
      "signature": "export interface StrftimeOptions {\n    /**\n     * Format string containing `%` date/time directives (e.g. `\"%Y-%m-%d\"`).\n     */\n    format: string;\n    /**\n     * BCP 47 locale tag used for localized month and weekday names.\n     * @default \"en-US\"\n     */\n    locale?: string;\n    /**\n     * Target IANA timezone identifier used when formatting date/time parts.\n     * @default \"UTC\"\n     */\n    timeZone?: string;\n}",
      "properties": {
        "format": {
          "type": "string",
          "optional": false,
          "desc": "Format string containing `%` date/time directives (e.g. `\"%Y-%m-%d\"`)."
        },
        "locale": {
          "type": "string",
          "optional": true,
          "desc": "BCP 47 locale tag used for localized month and weekday names.",
          "default": "\"en-US\""
        },
        "timeZone": {
          "type": "string",
          "optional": true,
          "desc": "Target IANA timezone identifier used when formatting date/time parts.",
          "default": "\"UTC\""
        }
      }
    },
    "StringEncoding": {
      "filePath": "types.ts",
      "lineStart": 859,
      "lineEnd": 859,
      "desc": "Binary-to-text encoding scheme (`\"hex\"` or `\"base64\"`).",
      "signature": "export type StringEncoding = \"hex\" | \"base64\";"
    },
    "StrptimeOptions": {
      "filePath": "types.ts",
      "lineStart": 864,
      "lineEnd": 879,
      "desc": "Configuration options for `str.strptime()` and `strptime()`.",
      "signature": "export interface StrptimeOptions {\n    /**\n     * Default IANA timezone or UTC offset applied when the parsed string has no `%z`/`%Z` directive.\n     * @default \"UTC\"\n     */\n    defaultTimeZone?: string;\n    /**\n     * Format string containing `%` date/time directives (e.g. `\"%Y-%m-%d %H:%M:%S\"`).\n     */\n    format: string;\n    /**\n     * If `true`, throws an error when a string fails to match `format`; if `false`, returns `null`.\n     * @default true\n     */\n    strict?: boolean;\n}",
      "properties": {
        "defaultTimeZone": {
          "type": "string",
          "optional": true,
          "desc": "Default IANA timezone or UTC offset applied when the parsed string has no `%z`/`%Z` directive.",
          "default": "\"UTC\""
        },
        "format": {
          "type": "string",
          "optional": false,
          "desc": "Format string containing `%` date/time directives (e.g. `\"%Y-%m-%d %H:%M:%S\"`)."
        },
        "strict": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, throws an error when a string fails to match `format`; if `false`, returns `null`.",
          "default": "true"
        }
      }
    },
    "StructFieldsArg": {
      "filePath": "types.ts",
      "lineStart": 885,
      "lineEnd": 885,
      "desc": "Operand for struct field updates and additions (`struct.withFields`, `$df.struct`). Accepts an array of named expressions or an object dictionary mapping field names to expressions.",
      "signature": "export type StructFieldsArg = IntoExprSeriesArg | ExprDict;"
    },
    "TimeUnit": {
      "filePath": "types.ts",
      "lineStart": 890,
      "lineEnd": 890,
      "desc": "Time unit resolution for epoch conversions (`\"s\"`, `\"ms\"`, `\"us\"`, `\"ns\"`).",
      "signature": "export type TimeUnit = \"s\" | \"ms\" | \"us\" | \"ns\";"
    },
    "UtcOffsetFormat": {
      "filePath": "types.ts",
      "lineStart": 895,
      "lineEnd": 895,
      "desc": "Output unit or string format for UTC timezone offset calculations.",
      "signature": "export type UtcOffsetFormat = \"milliseconds\" | \"minutes\" | \"hours\" | \"iso\" | \"basic\";"
    },
    "UtcOffsetOptions": {
      "filePath": "types.ts",
      "lineStart": 900,
      "lineEnd": 911,
      "desc": "Configuration options for `dt.utcOffset()` and `getUtcOffset()`.",
      "signature": "export interface UtcOffsetOptions {\n    /**\n     * Output format: `\"milliseconds\"`, `\"minutes\"`, `\"hours\"`, `\"iso\"` (`\"+HH:MM\"`), or `\"basic\"` (`\"+HHMM\"`).\n     * @default \"milliseconds\"\n     */\n    format?: UtcOffsetFormat;\n    /**\n     * Which offset component to compute: `\"base\"` (standard offset), `\"total\"` (wall-clock offset), or `\"daylightSavingTime\"` (DST delta).\n     * @default \"total\"\n     */\n    type?: UtcOffsetType;\n}",
      "properties": {
        "format": {
          "type": "UtcOffsetFormat",
          "optional": true,
          "desc": "Output format: `\"milliseconds\"`, `\"minutes\"`, `\"hours\"`, `\"iso\"` (`\"+HH:MM\"`), or `\"basic\"` (`\"+HHMM\"`).",
          "default": "\"milliseconds\"",
          "resolvedType": "\"milliseconds\" | \"minutes\" | \"hours\" | \"iso\" | \"basic\""
        },
        "type": {
          "type": "UtcOffsetType",
          "optional": true,
          "desc": "Which offset component to compute: `\"base\"` (standard offset), `\"total\"` (wall-clock offset), or `\"daylightSavingTime\"` (DST delta).",
          "default": "\"total\"",
          "resolvedType": "\"base\" | \"total\" | \"daylightSavingTime\""
        }
      }
    },
    "UtcOffsetType": {
      "filePath": "types.ts",
      "lineStart": 916,
      "lineEnd": 916,
      "desc": "Component of the UTC timezone offset to compute (`\"base\"`, `\"total\"`, or `\"daylightSavingTime\"`).",
      "signature": "export type UtcOffsetType = \"base\" | \"total\" | \"daylightSavingTime\";"
    },
    "ValidPrimitiveTypes": {
      "filePath": "types.ts",
      "lineStart": 921,
      "lineEnd": 921,
      "desc": "Union of JavaScript primitive value types.",
      "signature": "export type ValidPrimitiveTypes = string | number | boolean | bigint | symbol | null | undefined;"
    },
    "ValidScalarTypes": {
      "filePath": "types.ts",
      "lineStart": 926,
      "lineEnd": 926,
      "desc": "Union of valid scalar cell values supported in DataFrame columns and expressions.",
      "signature": "export type ValidScalarTypes = Exclude<ValidPrimitiveTypes, symbol> | Date | AnyTypedArray;"
    },
    "ArrayCheckMode": {
      "filePath": "utils/types.ts",
      "lineStart": 8,
      "lineEnd": 8,
      "desc": "Quantifier mode for array element type checking.",
      "signature": "export type ArrayCheckMode = \"every\" | \"some\";"
    },
    "ArrayItemType": {
      "filePath": "utils/types.ts",
      "lineStart": 13,
      "lineEnd": 29,
      "desc": "Target item type descriptor or predicate for `isArrayOfType()` and `toArrayOfType()`.",
      "signature": "export type ArrayItemType =\n    | \"string\"\n    | \"number\"\n    | \"int\"\n    | \"boolean\"\n    | \"bigint\"\n    | \"object\"\n    | \"plainObject\"\n    | \"date\"\n    | \"regexp\"\n    | \"array\"\n    | \"any\"\n    | \"null\"\n    | \"undefined\"\n    | \"nullish\"\n    | (new (...args: any[]) => any)\n    | ((v: unknown) => any);"
    },
    "BigIntRange": {
      "filePath": "utils/types.ts",
      "lineStart": 34,
      "lineEnd": 41,
      "desc": "BigInt bounds specification: either a predefined `BigIntRangeType` name or an explicit `{ min, max }` object.",
      "signature": "export type BigIntRange =\n    | {\n        /** Minimum inclusive BigInt value. */\n        min: bigint;\n        /** Maximum inclusive BigInt value. */\n        max: bigint;\n    }\n    | BigIntRangeType;",
      "properties": {
        "max": {
          "type": "bigint",
          "optional": false,
          "desc": "Maximum inclusive BigInt value."
        },
        "min": {
          "type": "bigint",
          "optional": false,
          "desc": "Minimum inclusive BigInt value."
        }
      }
    },
    "BigIntRangeType": {
      "filePath": "utils/types.ts",
      "lineStart": 46,
      "lineEnd": 46,
      "desc": "Predefined 64-bit BigInt range identifier (`\"Int64\"` or `\"UInt64\"`).",
      "signature": "export type BigIntRangeType = keyof typeof BIGINT_RANGES;"
    },
    "BinarySearchOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 51,
      "lineEnd": 61,
      "desc": "Configuration options for `binarySearch()`.",
      "signature": "export interface BinarySearchOptions<T = any> {\n    /**\n     * Optional accessor function `(index, item) => number` for indirect searching.\n     */\n    getValue?: (index: number, item: T) => number;\n    /**\n     * Search side: `\"left\"` (first index `>= target`) or `\"right\"` (first index `> target`).\n     * @default \"left\"\n     */\n    side?: BinarySearchSide;\n}",
      "properties": {
        "getValue": {
          "type": "(index: number, item: any) => number",
          "optional": true,
          "desc": "Optional accessor function `(index, item) => number` for indirect searching."
        },
        "side": {
          "type": "BinarySearchSide",
          "optional": true,
          "desc": "Search side: `\"left\"` (first index `>= target`) or `\"right\"` (first index `> target`).",
          "default": "\"left\"",
          "resolvedType": "\"left\" | \"right\""
        }
      }
    },
    "BinarySearchSide": {
      "filePath": "utils/types.ts",
      "lineStart": 66,
      "lineEnd": 66,
      "desc": "Search boundary side for `binarySearch()`.",
      "signature": "export type BinarySearchSide = \"left\" | \"right\";"
    },
    "BinaryValidationOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 71,
      "lineEnd": 77,
      "desc": "Configuration options for binary buffer validation utilities.",
      "signature": "export interface BinaryValidationOptions {\n    /**\n     * When `true`, requires strict binary buffer type matching.\n     * @default false\n     */\n    strict?: boolean;\n}",
      "properties": {
        "strict": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, requires strict binary buffer type matching.",
          "default": "false"
        }
      }
    },
    "CandidateMatch": {
      "filePath": "utils/types.ts",
      "lineStart": 83,
      "lineEnd": 92,
      "desc": "Internal regex match candidate used during multi-pattern string matching and replacement.",
      "internal": true,
      "signature": "export interface CandidateMatch<T = unknown> {\n    /** Match end offset (exclusive) in the input string. */\n    _end: number;\n    /** Pattern index in the input pattern array. */\n    _i: number;\n    /** Extracted payload associated with the match. */\n    _payload: T;\n    /** Match start offset (inclusive) in the input string. */\n    _start: number;\n}",
      "properties": {
        "_end": {
          "type": "number",
          "optional": false,
          "desc": "Match end offset (exclusive) in the input string."
        },
        "_i": {
          "type": "number",
          "optional": false,
          "desc": "Pattern index in the input pattern array."
        },
        "_payload": {
          "type": "T",
          "optional": false,
          "desc": "Extracted payload associated with the match."
        },
        "_start": {
          "type": "number",
          "optional": false,
          "desc": "Match start offset (inclusive) in the input string."
        }
      }
    },
    "ChangeCaseOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 97,
      "lineEnd": 102,
      "desc": "Configuration options for `changeCase()`.",
      "signature": "export interface ChangeCaseOptions {\n    /**\n     * Target casing format: `\"camel\"`, `\"kebab\"`, `\"pascal\"`, `\"snake\"`, or `\"title\"`.\n     */\n    format: \"camel\" | \"kebab\" | \"pascal\" | \"snake\" | \"title\";\n}",
      "properties": {
        "format": {
          "type": "\"camel\" | \"kebab\" | \"pascal\" | \"snake\" | \"title\"",
          "optional": false,
          "desc": "Target casing format: `\"camel\"`, `\"kebab\"`, `\"pascal\"`, `\"snake\"`, or `\"title\"`."
        }
      }
    },
    "CumulativeStepContext": {
      "filePath": "utils/types.ts",
      "lineStart": 107,
      "lineEnd": 118,
      "desc": "Callback context passed to cumulative step functions in `fillSequence()` and `$df.seqRange()`.",
      "signature": "export interface CumulativeStepContext {\n    /** The absolute index of the current element in the parent array. */\n    absoluteIndex: number;\n    /** The relative iteration counter of the stepping process (starts at 1). */\n    index: number;\n    /** The original value at the current index in the target array. */\n    originalValue: any;\n    /** The accumulated value returned by the step function from the previous stepped index. */\n    prev: any;\n    /** The entire target array being populated/modified. */\n    targetArray: any;\n}",
      "properties": {
        "absoluteIndex": {
          "type": "number",
          "optional": false,
          "desc": "The absolute index of the current element in the parent array."
        },
        "index": {
          "type": "number",
          "optional": false,
          "desc": "The relative iteration counter of the stepping process (starts at 1)."
        },
        "originalValue": {
          "type": "any",
          "optional": false,
          "desc": "The original value at the current index in the target array."
        },
        "prev": {
          "type": "any",
          "optional": false,
          "desc": "The accumulated value returned by the step function from the previous stepped index."
        },
        "targetArray": {
          "type": "any",
          "optional": false,
          "desc": "The entire target array being populated/modified."
        }
      }
    },
    "DateDirective": {
      "filePath": "utils/types.ts",
      "lineStart": 124,
      "lineEnd": 133,
      "desc": "Internal date/time format and parse directive descriptor used by `strftime()` and `strptime()`.",
      "internal": true,
      "signature": "export interface DateDirective {\n    /** Formats a `Date` and decomposed `DateTimeParts` into the directive's string representation. */\n    _format: (d: Date, locale: string, timeZone: string, parts: import(\"../types\").DateTimeParts) => string;\n    /** Target date/time component field populated when this directive is parsed. */\n    _parseField?: \"year\" | \"month\" | \"day\" | \"hour\" | \"minute\" | \"second\" | \"ms\" | \"ampm\" | \"offset\";\n    /** Optional normalizer converting the matched substring into a numeric or string component value. */\n    _parseNormalize?: (valStr: string) => number | string;\n    /** Regular expression pattern source used to match the directive during `strptime()`. */\n    _parseRegex?: string;\n}",
      "properties": {
        "_format": {
          "type": "(d: Date, locale: string, timeZone: string, parts: import(\"../types\").DateTimeParts) => string",
          "optional": false,
          "desc": "Formats a `Date` and decomposed `DateTimeParts` into the directive's string representation."
        },
        "_parseField": {
          "type": "\"year\" | \"month\" | \"day\" | \"hour\" | \"minute\" | \"second\" | \"ms\" | \"ampm\" | \"offset\"",
          "optional": true,
          "desc": "Target date/time component field populated when this directive is parsed."
        },
        "_parseNormalize": {
          "type": "(valStr: string) => number | string",
          "optional": true,
          "desc": "Optional normalizer converting the matched substring into a numeric or string component value."
        },
        "_parseRegex": {
          "type": "string",
          "optional": true,
          "desc": "Regular expression pattern source used to match the directive during `strptime()`."
        }
      }
    },
    "DecimalOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 138,
      "lineEnd": 149,
      "desc": "Configuration options for fixed-point decimal validation and coercion (`isValidDecimal()`, `toValidDecimal()`).",
      "signature": "export interface DecimalOptions {\n    /**\n     * Total maximum number of significant digits (1 to 38).\n     * @default 38\n     */\n    precision?: number;\n    /**\n     * Number of digits to the right of the decimal point (`0 <= scale <= precision`).\n     * @default 9\n     */\n    scale?: number;\n}",
      "properties": {
        "precision": {
          "type": "number",
          "optional": true,
          "desc": "Total maximum number of significant digits (1 to 38).",
          "default": "38"
        },
        "scale": {
          "type": "number",
          "optional": true,
          "desc": "Number of digits to the right of the decimal point (`0 <= scale <= precision`).",
          "default": "9"
        }
      }
    },
    "DurationInterval": {
      "filePath": "utils/types.ts",
      "lineStart": 154,
      "lineEnd": 167,
      "desc": "Parsed calendar/clock/index duration interval components returned by `parseDurationInterval()`.",
      "signature": "export interface DurationInterval {\n    /** Number of calendar days (`d`, `w`). */\n    days: number;\n    /** Number of row index units (`i`). */\n    indexUnits: number;\n    /** `true` if the interval contains calendar units (`months > 0` or `days > 0`). */\n    isCalendar: boolean;\n    /** `true` if the interval is measured in row index units (`i`). */\n    isIndex: boolean;\n    /** Number of calendar months (`mo`, `q`, `y`). */\n    months: number;\n    /** Number of sub-day milliseconds (`h`, `m`, `s`, `ms`, `us`, `ns`). */\n    ms: number;\n}",
      "properties": {
        "days": {
          "type": "number",
          "optional": false,
          "desc": "Number of calendar days (`d`, `w`)."
        },
        "indexUnits": {
          "type": "number",
          "optional": false,
          "desc": "Number of row index units (`i`)."
        },
        "isCalendar": {
          "type": "boolean",
          "optional": false,
          "desc": "`true` if the interval contains calendar units (`months > 0` or `days > 0`)."
        },
        "isIndex": {
          "type": "boolean",
          "optional": false,
          "desc": "`true` if the interval is measured in row index units (`i`)."
        },
        "months": {
          "type": "number",
          "optional": false,
          "desc": "Number of calendar months (`mo`, `q`, `y`)."
        },
        "ms": {
          "type": "number",
          "optional": false,
          "desc": "Number of sub-day milliseconds (`h`, `m`, `s`, `ms`, `us`, `ns`)."
        }
      }
    },
    "DurationUnit": {
      "filePath": "utils/types.ts",
      "lineStart": 172,
      "lineEnd": 172,
      "desc": "Duration conversion target unit for `parseDurationString()` and `toDuration()`.",
      "signature": "export type DurationUnit = \"ns\" | \"us\" | \"ms\" | \"s\" | \"m\" | \"h\" | \"d\" | \"w\" | \"mo\" | \"q\" | \"y\" | \"i\";"
    },
    "FillSeqBaseOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 177,
      "lineEnd": 200,
      "desc": "Base configuration options for `fillSequence()`.",
      "signature": "export interface FillSeqBaseOptions {\n    /**\n     * Type coercion helper applied to each generated value before writing.\n     */\n    coerce?: (v: any) => any;\n    /**\n     * Conditional predicate determining if a value should be written at a given index.\n     */\n    condition?: (v: any, index: number, array: any[]) => boolean;\n    /**\n     * Exclusive boundary index at which iteration and writing stops.\n     */\n    endIndex?: number;\n    /**\n     * If `true`, iterates and populates in reverse from `startIndex` down to `endIndex`.\n     * @default false\n     */\n    reverse?: boolean;\n    /**\n     * Index at which array iteration and writing begins.\n     * @default 0\n     */\n    startIndex?: number;\n}",
      "properties": {
        "coerce": {
          "type": "(v: any) => any",
          "optional": true,
          "desc": "Type coercion helper applied to each generated value before writing."
        },
        "condition": {
          "type": "(v: any, index: number, array: any[]) => boolean",
          "optional": true,
          "desc": "Conditional predicate determining if a value should be written at a given index."
        },
        "endIndex": {
          "type": "number",
          "optional": true,
          "desc": "Exclusive boundary index at which iteration and writing stops."
        },
        "reverse": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, iterates and populates in reverse from `startIndex` down to `endIndex`.",
          "default": "false"
        },
        "startIndex": {
          "type": "number",
          "optional": true,
          "desc": "Index at which array iteration and writing begins.",
          "default": "0"
        }
      }
    },
    "FillSeqOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 205,
      "lineEnd": 238,
      "desc": "Configuration options for `fillSequence()`.",
      "signature": "export interface FillSeqOptions extends FillSeqBaseOptions {\n    /**\n     * Type coercion helper applied to each generated value before writing.\n     */\n    coerce?: (v: any) => any;\n    /**\n     * Conditional predicate determining if a value should be written at a given index.\n     */\n    condition?: (v: any, index: number, array: any[]) => boolean;\n    /**\n     * Exclusive boundary index at which iteration and writing stops.\n     */\n    endIndex?: number;\n    /**\n     * Sequence generation mode: `\"constant\"`, `\"cumulative\"`, or `\"independent\"`.\n     * @default \"cumulative\"\n     */\n    mode?: \"constant\" | \"cumulative\" | \"independent\";\n    /**\n     * If `true`, iterates and populates in reverse from `startIndex` down to `endIndex`.\n     * @default false\n     */\n    reverse?: boolean;\n    /**\n     * Index at which array iteration and writing begins.\n     * @default 0\n     */\n    startIndex?: number;\n    /**\n     * Step increment value or callback function.\n     * @default 1\n     */\n    step?: number | ((context: CumulativeStepContext & IndependentStepContext) => any);\n}",
      "properties": {
        "coerce": {
          "type": "(v: any) => any",
          "optional": true,
          "desc": "Type coercion helper applied to each generated value before writing."
        },
        "condition": {
          "type": "(v: any, index: number, array: any[]) => boolean",
          "optional": true,
          "desc": "Conditional predicate determining if a value should be written at a given index."
        },
        "endIndex": {
          "type": "number",
          "optional": true,
          "desc": "Exclusive boundary index at which iteration and writing stops."
        },
        "mode": {
          "type": "\"constant\" | \"cumulative\" | \"independent\"",
          "optional": true,
          "desc": "Sequence generation mode: `\"constant\"`, `\"cumulative\"`, or `\"independent\"`.",
          "default": "\"cumulative\""
        },
        "reverse": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, iterates and populates in reverse from `startIndex` down to `endIndex`.",
          "default": "false"
        },
        "startIndex": {
          "type": "number",
          "optional": true,
          "desc": "Index at which array iteration and writing begins.",
          "default": "0"
        },
        "step": {
          "type": "number | ((context: CumulativeStepContext & IndependentStepContext) => any)",
          "optional": true,
          "desc": "Step increment value or callback function.",
          "default": "1"
        }
      }
    },
    "FilterByMaskOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 243,
      "lineEnd": 249,
      "desc": "Configuration options for `filterByMask()`.",
      "signature": "export interface FilterByMaskOptions {\n    /**\n     * If `true`, non-matching elements are replaced with `null` while preserving array length; if `false`, they are omitted.\n     * @default false\n     */\n    nullify?: boolean;\n}",
      "properties": {
        "nullify": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, non-matching elements are replaced with `null` while preserving array length; if `false`, they are omitted.",
          "default": "false"
        }
      }
    },
    "FloatOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 254,
      "lineEnd": 279,
      "desc": "Configuration options for `isValidFloat()` and `toValidFloat()`.",
      "signature": "export interface FloatOptions extends ParseNumberOptions {\n    /**\n     * Whether `NaN` is considered a valid number.\n     * @default false\n     */\n    allowNaN?: boolean;\n    /**\n     * Whether `Infinity` and `-Infinity` are considered valid numbers.\n     * @default false\n     */\n    allowNonFiniteNumbers?: boolean;\n    /**\n     * Floating-point precision target (`\"Float32\"` or `\"Float64\"`).\n     */\n    floatPrecision?: FloatPrecision;\n    /**\n     * When `true`, allows scientific notation (e.g. `\"1.5e3\"`) when parsing numeric strings.\n     * @default true\n     */\n    floatScientific?: boolean;\n    /**\n     * When `true`, rejects strings containing currency symbols, percent signs, or non-standard formatting.\n     * @default false\n     */\n    strictNumericString?: boolean;\n}",
      "properties": {
        "allowNaN": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether `NaN` is considered a valid number.",
          "default": "false"
        },
        "allowNonFiniteNumbers": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether `Infinity` and `-Infinity` are considered valid numbers.",
          "default": "false"
        },
        "floatPrecision": {
          "type": "FloatPrecision",
          "optional": true,
          "desc": "Floating-point precision target (`\"Float32\"` or `\"Float64\"`).",
          "resolvedType": "\"Float32\" | \"Float64\""
        },
        "floatScientific": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, allows scientific notation (e.g. `\"1.5e3\"`) when parsing numeric strings.",
          "default": "true"
        },
        "strictNumericString": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, rejects strings containing currency symbols, percent signs, or non-standard formatting.",
          "default": "false"
        }
      }
    },
    "FloatPrecision": {
      "filePath": "utils/types.ts",
      "lineStart": 284,
      "lineEnd": 284,
      "desc": "Floating-point bit precision target.",
      "signature": "export type FloatPrecision = \"Float32\" | \"Float64\";"
    },
    "FormatCSVValueOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 289,
      "lineEnd": 315,
      "desc": "Configuration options for `formatCSVValue()`.",
      "signature": "export interface FormatCSVValueOptions {\n    /**\n     * Custom `strftime` format string for `Date` values (e.g. `\"%Y-%m-%d\"`).\n     */\n    dateFormat?: string;\n    /**\n     * Custom `strftime` format string for `Datetime` values (e.g. `\"%Y-%m-%d %H:%M:%S\"`).\n     */\n    datetimeFormat?: string;\n    /**\n     * String representation to use for `null` or missing values.\n     * @default \"\"\n     */\n    nullValue?: string;\n    /**\n     * Options for numeric formatting (floats, ints, bigints).\n     */\n    numericFormatOptions?: NumericFormatOptions;\n    /**\n     * Options for the safe JSON replacer used when formatting objects and arrays.\n     */\n    replacerOptions?: SafeJsonReplacerOptions;\n    /**\n     * Custom `strftime` format string for `Time` values (e.g. `\"%H:%M:%S\"`).\n     */\n    timeFormat?: string;\n}",
      "properties": {
        "dateFormat": {
          "type": "string",
          "optional": true,
          "desc": "Custom `strftime` format string for `Date` values (e.g. `\"%Y-%m-%d\"`)."
        },
        "datetimeFormat": {
          "type": "string",
          "optional": true,
          "desc": "Custom `strftime` format string for `Datetime` values (e.g. `\"%Y-%m-%d %H:%M:%S\"`)."
        },
        "nullValue": {
          "type": "string",
          "optional": true,
          "desc": "String representation to use for `null` or missing values.",
          "default": "\"\""
        },
        "numericFormatOptions": {
          "type": "NumericFormatOptions",
          "optional": true,
          "desc": "Options for numeric formatting (floats, ints, bigints).",
          "properties": {
            "accountingNegatives": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, formats negative numbers in accounting parentheses (e.g. `(1.23)`).",
              "default": "false"
            },
            "fallback": {
              "type": "string",
              "optional": true,
              "desc": "Fallback string returned when the value cannot be parsed into a formattable number.",
              "default": "\"NaN\""
            },
            "formatNonFinite": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, returns `fallback` for `Infinity` and `-Infinity` values.",
              "default": "false"
            },
            "locale": {
              "type": "string",
              "optional": true,
              "desc": "BCP 47 language tag (e.g. `\"en-US\"`, `\"de-DE\"`).",
              "default": "\"en-US\""
            }
          }
        },
        "replacerOptions": {
          "type": "SafeJsonReplacerOptions",
          "optional": true,
          "desc": "Options for the safe JSON replacer used when formatting objects and arrays.",
          "properties": {
            "bigintStrategy": {
              "type": "\"string\" | \"number\"",
              "optional": true,
              "desc": "Strategy for serializing `BigInt` values: `\"string\"` or `\"number\"`.",
              "default": "\"string\""
            },
            "formatDate": {
              "type": "(v: Date) => string",
              "optional": true,
              "desc": "Custom formatter function for `Date` objects (ignored if `onDate` is specified)."
            },
            "handleCircular": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, replaces circular references instead of throwing.",
              "default": "false"
            },
            "onBigInt": {
              "type": "(v: bigint) => any",
              "optional": true,
              "desc": "Custom serialization override for `BigInt` values."
            },
            "onCircular": {
              "type": "(this: any, k: string, v: any) => any",
              "optional": true,
              "desc": "Custom callback invoked when a circular reference is encountered."
            },
            "onCustom": {
              "type": "(this: any, k: string, v: any) => any",
              "optional": true,
              "desc": "Catch-all serialization override for custom types, executed after native type checks."
            },
            "onDate": {
              "type": "(v: Date) => any",
              "optional": true,
              "desc": "Custom serialization override for `Date` objects (takes precedence over `formatDate`)."
            },
            "onError": {
              "type": "(v: Error) => any",
              "optional": true,
              "desc": "Custom serialization override for `Error` objects."
            },
            "onMap": {
              "type": "(v: Map<any, any>) => any",
              "optional": true,
              "desc": "Custom serialization override for `Map` objects."
            },
            "onRegExp": {
              "type": "(v: RegExp) => any",
              "optional": true,
              "desc": "Custom serialization override for `RegExp` objects."
            },
            "onSet": {
              "type": "(v: Set<any>) => any",
              "optional": true,
              "desc": "Custom serialization override for `Set` objects."
            },
            "onTypedArray": {
              "type": "(v: any) => any",
              "optional": true,
              "desc": "Custom serialization override for `TypedArray` values."
            },
            "onURLSearchParams": {
              "type": "(v: URLSearchParams) => any",
              "optional": true,
              "desc": "Custom serialization override for `URLSearchParams` objects."
            },
            "replacer": {
              "type": "((this: any, k: string, v: any) => any) | (string | number)[] | null",
              "optional": true,
              "desc": "Custom `JSON.stringify` replacer function or property whitelist array applied first."
            },
            "voidBigIntReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `BigInt` values.",
              "default": "false"
            },
            "voidDateReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `Date` objects.",
              "default": "false"
            },
            "voidMapReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `Map` objects.",
              "default": "false"
            },
            "voidRegExpReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `RegExp` objects.",
              "default": "false"
            },
            "voidSetReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `Set` objects.",
              "default": "false"
            },
            "voidTypedArrayReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `TypedArray` values.",
              "default": "false"
            }
          }
        },
        "timeFormat": {
          "type": "string",
          "optional": true,
          "desc": "Custom `strftime` format string for `Time` values (e.g. `\"%H:%M:%S\"`)."
        }
      }
    },
    "IndependentStepContext": {
      "filePath": "utils/types.ts",
      "lineStart": 320,
      "lineEnd": 331,
      "desc": "Callback context passed to independent step functions in `fillSequence()` and `$df.seqRange()`.",
      "signature": "export interface IndependentStepContext {\n    /** The absolute index of the current element in the parent array. */\n    absoluteIndex: number;\n    /** The relative iteration counter of the generation process (starts at 0). */\n    index: number;\n    /** The static starting value passed to the sequence generator. */\n    initialValue: any;\n    /** The original value at the current index in the target array. */\n    originalValue: any;\n    /** The entire target array being populated/modified. */\n    targetArray: any;\n}",
      "properties": {
        "absoluteIndex": {
          "type": "number",
          "optional": false,
          "desc": "The absolute index of the current element in the parent array."
        },
        "index": {
          "type": "number",
          "optional": false,
          "desc": "The relative iteration counter of the generation process (starts at 0)."
        },
        "initialValue": {
          "type": "any",
          "optional": false,
          "desc": "The static starting value passed to the sequence generator."
        },
        "originalValue": {
          "type": "any",
          "optional": false,
          "desc": "The original value at the current index in the target array."
        },
        "targetArray": {
          "type": "any",
          "optional": false,
          "desc": "The entire target array being populated/modified."
        }
      }
    },
    "IntCoerceType": {
      "filePath": "utils/types.ts",
      "lineStart": 336,
      "lineEnd": 336,
      "desc": "Rounding strategy for coercing floating-point numbers to integers.",
      "signature": "export type IntCoerceType = \"round\" | \"floor\" | \"ceil\" | \"truncate\";"
    },
    "IntOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 341,
      "lineEnd": 350,
      "desc": "Configuration options for `isValidInt()` and `toValidInt()`.",
      "signature": "export interface IntOptions {\n    /**\n     * Rounding strategy used by `toValidInt()` when coercing fractional numbers.\n     */\n    coerce?: IntCoerceType;\n    /**\n     * Integer range bounds to validate against.\n     */\n    range?: IntRange;\n}",
      "properties": {
        "coerce": {
          "type": "IntCoerceType",
          "optional": true,
          "desc": "Rounding strategy used by `toValidInt()` when coercing fractional numbers.",
          "resolvedType": "\"round\" | \"floor\" | \"ceil\" | \"truncate\""
        },
        "range": {
          "type": "IntRange",
          "optional": true,
          "desc": "Integer range bounds to validate against.",
          "properties": {
            "max": {
              "type": "number",
              "optional": false,
              "desc": "Maximum inclusive integer value."
            },
            "min": {
              "type": "number",
              "optional": false,
              "desc": "Minimum inclusive integer value."
            }
          }
        }
      }
    },
    "IntRange": {
      "filePath": "utils/types.ts",
      "lineStart": 355,
      "lineEnd": 362,
      "desc": "Integer bounds specification: either a predefined `IntRangeType` name or an explicit `{ min, max }` object.",
      "signature": "export type IntRange =\n    | {\n        /** Minimum inclusive integer value. */\n        min: number;\n        /** Maximum inclusive integer value. */\n        max: number;\n    }\n    | IntRangeType;",
      "properties": {
        "max": {
          "type": "number",
          "optional": false,
          "desc": "Maximum inclusive integer value."
        },
        "min": {
          "type": "number",
          "optional": false,
          "desc": "Minimum inclusive integer value."
        }
      }
    },
    "IntRangeType": {
      "filePath": "utils/types.ts",
      "lineStart": 367,
      "lineEnd": 367,
      "desc": "Predefined integer range identifier (`\"Int8\"`, `\"Int16\"`, `\"Int32\"`, `\"UInt8\"`, `\"UInt16\"`, `\"UInt32\"`).",
      "signature": "export type IntRangeType = keyof typeof INT_RANGES;"
    },
    "IsArrayOfTypeOptionsParams": {
      "filePath": "utils/types.ts",
      "lineStart": 372,
      "lineEnd": 392,
      "desc": "Configuration options for `isArrayOfType()` and `toArrayOfType()`.",
      "signature": "export interface IsArrayOfTypeOptionsParams {\n    /**\n     * Whether an empty array is considered valid.\n     * @default true\n     */\n    allowEmpty?: boolean;\n    /**\n     * Whether `null` and `undefined` elements are permitted without failing validation.\n     * @default false\n     */\n    allowNulls?: boolean;\n    /**\n     * Optional custom coercion function applied to each element in `toArrayOfType()`.\n     */\n    coerce?: (v: unknown) => any;\n    /**\n     * Quantifier mode: `\"every\"` requires all elements to match; `\"some\"` requires at least one element to match.\n     * @default \"every\"\n     */\n    mode?: ArrayCheckMode;\n}",
      "properties": {
        "allowEmpty": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether an empty array is considered valid.",
          "default": "true"
        },
        "allowNulls": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether `null` and `undefined` elements are permitted without failing validation.",
          "default": "false"
        },
        "coerce": {
          "type": "(v: unknown) => any",
          "optional": true,
          "desc": "Optional custom coercion function applied to each element in `toArrayOfType()`."
        },
        "mode": {
          "type": "ArrayCheckMode",
          "optional": true,
          "desc": "Quantifier mode: `\"every\"` requires all elements to match; `\"some\"` requires at least one element to match.",
          "default": "\"every\"",
          "resolvedType": "\"every\" | \"some\""
        }
      }
    },
    "IsUnicodeSurrogateOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 397,
      "lineEnd": 403,
      "desc": "Configuration options for `_isUnicodeSurrogate()`.",
      "signature": "export interface IsUnicodeSurrogateOptions {\n    /**\n     * Which surrogate code units to match: `\"all\"`, `\"high\"` (`0xD800..0xDBFF`), or `\"low\"` (`0xDC00..0xDFFF`).\n     * @default \"all\"\n     */\n    type?: UnicodeSurrogateType;\n}",
      "properties": {
        "type": {
          "type": "UnicodeSurrogateType",
          "optional": true,
          "desc": "Which surrogate code units to match: `\"all\"`, `\"high\"` (`0xD800..0xDBFF`), or `\"low\"` (`0xDC00..0xDFFF`).",
          "default": "\"all\"",
          "resolvedType": "\"all\" | \"high\" | \"low\""
        }
      }
    },
    "IsValidBigIntOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 408,
      "lineEnd": 414,
      "desc": "Configuration options for `isValidBigInt()`.",
      "signature": "export interface IsValidBigIntOptions {\n    /**\n     * 64-bit integer range bounds to validate against.\n     * @default \"Int64\"\n     */\n    range?: BigIntRange;\n}",
      "properties": {
        "range": {
          "type": "BigIntRange",
          "optional": true,
          "desc": "64-bit integer range bounds to validate against.",
          "default": "\"Int64\"",
          "properties": {
            "max": {
              "type": "bigint",
              "optional": false,
              "desc": "Maximum inclusive BigInt value."
            },
            "min": {
              "type": "bigint",
              "optional": false,
              "desc": "Minimum inclusive BigInt value."
            }
          }
        }
      }
    },
    "JoinArrayOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 419,
      "lineEnd": 453,
      "desc": "Configuration options for `joinArray()`.",
      "signature": "export interface JoinArrayOptions {\n    /**\n     * If `true`, `null` and `undefined` elements are skipped during joining.\n     * @default false\n     */\n    ignoreNulls?: boolean;\n    /**\n     * Maximum number of array elements to join before truncating with `truncationMarker`.\n     */\n    limit?: number;\n    /**\n     * Custom string representation for `null` and `undefined` elements when `ignoreNulls` is `false`.\n     * @default \"\"\n     */\n    nullValue?: string;\n    /**\n     * Prefix string prepended to the joined result.\n     * @default \"\"\n     */\n    prefix?: string;\n    /**\n     * Suffix string appended to the joined result.\n     * @default \"\"\n     */\n    suffix?: string;\n    /**\n     * Placeholder string appended when `limit` truncation occurs.\n     * @default \"...\"\n     */\n    truncationMarker?: string;\n    /**\n     * Callback function used to format each non-null element to a string.\n     */\n    valueFormatter?: (val: any, index: number) => string;\n}",
      "properties": {
        "ignoreNulls": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, `null` and `undefined` elements are skipped during joining.",
          "default": "false"
        },
        "limit": {
          "type": "number",
          "optional": true,
          "desc": "Maximum number of array elements to join before truncating with `truncationMarker`."
        },
        "nullValue": {
          "type": "string",
          "optional": true,
          "desc": "Custom string representation for `null` and `undefined` elements when `ignoreNulls` is `false`.",
          "default": "\"\""
        },
        "prefix": {
          "type": "string",
          "optional": true,
          "desc": "Prefix string prepended to the joined result.",
          "default": "\"\""
        },
        "suffix": {
          "type": "string",
          "optional": true,
          "desc": "Suffix string appended to the joined result.",
          "default": "\"\""
        },
        "truncationMarker": {
          "type": "string",
          "optional": true,
          "desc": "Placeholder string appended when `limit` truncation occurs.",
          "default": "\"...\""
        },
        "valueFormatter": {
          "type": "(val: any, index: number) => string",
          "optional": true,
          "desc": "Callback function used to format each non-null element to a string."
        }
      }
    },
    "JSONParseOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 458,
      "lineEnd": 482,
      "desc": "Configuration options for JSON and NDJSON parsing.",
      "signature": "export interface JSONParseOptions {\n    /**\n     * Whether to allow JSON primitive roots (numbers, booleans, strings, `null`) instead of requiring objects or arrays.\n     * @default false\n     */\n    allowPrimitives?: boolean;\n    /**\n     * Format of the JSON content: `\"json\"` (standard JSON) or `\"ndjson\"` (Newline Delimited JSON).\n     * @default \"json\"\n     */\n    format?: JSONFormat;\n    /**\n     * Options specific to NDJSON parsing when `format` is `\"ndjson\"`.\n     */\n    ndjson?: NDJSONParseOptions;\n    /**\n     * Reviver function passed to `JSON.parse` for custom value transformation.\n     */\n    reviver?: Parameters<typeof JSON.parse>[1];\n    /**\n     * Whether to trim leading and trailing whitespace before validating/parsing.\n     * @default false\n     */\n    trimBeforeParse?: boolean;\n}",
      "properties": {
        "allowPrimitives": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to allow JSON primitive roots (numbers, booleans, strings, `null`) instead of requiring objects or arrays.",
          "default": "false"
        },
        "format": {
          "type": "JSONFormat",
          "optional": true,
          "desc": "Format of the JSON content: `\"json\"` (standard JSON) or `\"ndjson\"` (Newline Delimited JSON).",
          "default": "\"json\"",
          "resolvedType": "\"json\" | \"ndjson\""
        },
        "ndjson": {
          "type": "NDJSONParseOptions",
          "optional": true,
          "desc": "Options specific to NDJSON parsing when `format` is `\"ndjson\"`.",
          "properties": {
            "maxLines": {
              "type": "number",
              "optional": true,
              "desc": "Maximum number of non-empty lines to validate or parse."
            },
            "skipInvalidLines": {
              "type": "boolean",
              "optional": true,
              "desc": "Skip malformed or invalid lines instead of failing the entire parse.",
              "default": "false"
            },
            "skipLines": {
              "type": "number",
              "optional": true,
              "desc": "Number of non-empty lines to skip at the beginning of the content.",
              "default": "0"
            }
          }
        },
        "reviver": {
          "type": "Parameters<typeof JSON.parse>[1]",
          "optional": true,
          "desc": "Reviver function passed to `JSON.parse` for custom value transformation."
        },
        "trimBeforeParse": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to trim leading and trailing whitespace before validating/parsing.",
          "default": "false"
        }
      }
    },
    "JsonToken": {
      "filePath": "utils/types.ts",
      "lineStart": 488,
      "lineEnd": 501,
      "desc": "Parsed AST token representing a single evaluation step in a JSONPath expression.",
      "internal": true,
      "signature": "export interface JsonToken {\n    /** Ending array index (exclusive). Used by `\"slice\"` tokens. */\n    end?: number;\n    /** Target index position. Used by `\"idx\"` tokens. Supports negative indices. */\n    idx?: number;\n    /** Property name or recursive search key. Used by `\"prop\"` and `\"rec\"` tokens. */\n    key?: string;\n    /** Starting array index (inclusive). Used by `\"slice\"` tokens. */\n    start?: number;\n    /** Increment step value. Used by `\"slice\"` tokens. Cannot be 0. */\n    step?: number;\n    /** The evaluation operation type. */\n    type: JsonTokenType;\n}",
      "properties": {
        "end": {
          "type": "number",
          "optional": true,
          "desc": "Ending array index (exclusive). Used by `\"slice\"` tokens."
        },
        "idx": {
          "type": "number",
          "optional": true,
          "desc": "Target index position. Used by `\"idx\"` tokens. Supports negative indices."
        },
        "key": {
          "type": "string",
          "optional": true,
          "desc": "Property name or recursive search key. Used by `\"prop\"` and `\"rec\"` tokens."
        },
        "start": {
          "type": "number",
          "optional": true,
          "desc": "Starting array index (inclusive). Used by `\"slice\"` tokens."
        },
        "step": {
          "type": "number",
          "optional": true,
          "desc": "Increment step value. Used by `\"slice\"` tokens. Cannot be 0."
        },
        "type": {
          "type": "JsonTokenType",
          "optional": false,
          "desc": "The evaluation operation type."
        }
      }
    },
    "JsonTokenType": {
      "filePath": "utils/types.ts",
      "lineStart": 506,
      "lineEnd": 516,
      "desc": "JSONPath AST token operation kind.",
      "signature": "export type JsonTokenType =\n    /** Selects an object property by name (e.g., `.foo` or `['foo']`). */\n    | \"prop\"\n    /** Selects a zero-based or negative array index (e.g., `[0]` or `[-1]`). */\n    | \"idx\"\n    /** Selects a range or stepped slice of an array (e.g., `[1:5:2]`). */\n    | \"slice\"\n    /** Selects all immediate properties of an object or elements of an array (e.g., `.*` or `[*]`). */\n    | \"wildcard\"\n    /** Recursively searches and collects matching keys down the hierarchy (e.g., `..foo`). */\n    | \"rec\";"
    },
    "NDJSONParseOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 521,
      "lineEnd": 536,
      "desc": "Configuration options for NDJSON (Newline Delimited JSON) parsing.",
      "signature": "export interface NDJSONParseOptions {\n    /**\n     * Maximum number of non-empty lines to validate or parse.\n     */\n    maxLines?: number;\n    /**\n     * Skip malformed or invalid lines instead of failing the entire parse.\n     * @default false\n     */\n    skipInvalidLines?: boolean;\n    /**\n     * Number of non-empty lines to skip at the beginning of the content.\n     * @default 0\n     */\n    skipLines?: number;\n}",
      "properties": {
        "maxLines": {
          "type": "number",
          "optional": true,
          "desc": "Maximum number of non-empty lines to validate or parse."
        },
        "skipInvalidLines": {
          "type": "boolean",
          "optional": true,
          "desc": "Skip malformed or invalid lines instead of failing the entire parse.",
          "default": "false"
        },
        "skipLines": {
          "type": "number",
          "optional": true,
          "desc": "Number of non-empty lines to skip at the beginning of the content.",
          "default": "0"
        }
      }
    },
    "NumericFormatOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 541,
      "lineEnd": 562,
      "desc": "Configuration options for `formatNumber()`.",
      "signature": "export interface NumericFormatOptions extends Intl.NumberFormatOptions {\n    /**\n     * If `true`, formats negative numbers in accounting parentheses (e.g. `(1.23)`).\n     * @default false\n     */\n    accountingNegatives?: boolean;\n    /**\n     * Fallback string returned when the value cannot be parsed into a formattable number.\n     * @default \"NaN\"\n     */\n    fallback?: string;\n    /**\n     * If `true`, returns `fallback` for `Infinity` and `-Infinity` values.\n     * @default false\n     */\n    formatNonFinite?: boolean;\n    /**\n     * BCP 47 language tag (e.g. `\"en-US\"`, `\"de-DE\"`).\n     * @default \"en-US\"\n     */\n    locale?: string;\n}",
      "properties": {
        "accountingNegatives": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, formats negative numbers in accounting parentheses (e.g. `(1.23)`).",
          "default": "false"
        },
        "fallback": {
          "type": "string",
          "optional": true,
          "desc": "Fallback string returned when the value cannot be parsed into a formattable number.",
          "default": "\"NaN\""
        },
        "formatNonFinite": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, returns `fallback` for `Infinity` and `-Infinity` values.",
          "default": "false"
        },
        "locale": {
          "type": "string",
          "optional": true,
          "desc": "BCP 47 language tag (e.g. `\"en-US\"`, `\"de-DE\"`).",
          "default": "\"en-US\""
        }
      }
    },
    "NumericValidationOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 567,
      "lineEnd": 578,
      "desc": "Configuration options for `isValidNumber()`.",
      "signature": "export interface NumericValidationOptions {\n    /**\n     * Whether `NaN` is considered a valid number.\n     * @default false\n     */\n    allowNaN?: boolean;\n    /**\n     * Whether `Infinity` and `-Infinity` are considered valid numbers.\n     * @default false\n     */\n    allowNonFiniteNumbers?: boolean;\n}",
      "properties": {
        "allowNaN": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether `NaN` is considered a valid number.",
          "default": "false"
        },
        "allowNonFiniteNumbers": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether `Infinity` and `-Infinity` are considered valid numbers.",
          "default": "false"
        }
      }
    },
    "ParseDurationStringOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 583,
      "lineEnd": 589,
      "desc": "Configuration options for `parseDurationString()`.",
      "signature": "export interface ParseDurationStringOptions {\n    /**\n     * Target unit to convert the parsed duration into.\n     * @default \"ms\"\n     */\n    to?: DurationUnit;\n}",
      "properties": {
        "to": {
          "type": "DurationUnit",
          "optional": true,
          "desc": "Target unit to convert the parsed duration into.",
          "default": "\"ms\"",
          "resolvedType": "\"ns\" | \"us\" | \"ms\" | \"s\" | \"m\" | \"h\" | \"d\" | \"w\" | \"mo\" | \"q\" | \"y\" | \"i\""
        }
      }
    },
    "ParseNumberOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 594,
      "lineEnd": 615,
      "desc": "Configuration options for `toValidNumber()`.",
      "signature": "export interface ParseNumberOptions extends NumericValidationOptions {\n    /**\n     * Whether `NaN` is considered a valid number.\n     * @default false\n     */\n    allowNaN?: boolean;\n    /**\n     * Whether `Infinity` and `-Infinity` are considered valid numbers.\n     * @default false\n     */\n    allowNonFiniteNumbers?: boolean;\n    /**\n     * When `true`, allows scientific notation (e.g. `\"1.5e3\"`) when parsing numeric strings.\n     * @default true\n     */\n    floatScientific?: boolean;\n    /**\n     * When `true`, rejects strings containing currency symbols, percent signs, or non-standard formatting.\n     * @default false\n     */\n    strictNumericString?: boolean;\n}",
      "properties": {
        "allowNaN": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether `NaN` is considered a valid number.",
          "default": "false"
        },
        "allowNonFiniteNumbers": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether `Infinity` and `-Infinity` are considered valid numbers.",
          "default": "false"
        },
        "floatScientific": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, allows scientific notation (e.g. `\"1.5e3\"`) when parsing numeric strings.",
          "default": "true"
        },
        "strictNumericString": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, rejects strings containing currency symbols, percent signs, or non-standard formatting.",
          "default": "false"
        }
      }
    },
    "SafeJsonParseOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 620,
      "lineEnd": 656,
      "desc": "Configuration options for `safeJsonParse()`.",
      "signature": "export interface SafeJsonParseOptions<T = unknown, F = T> extends JSONParseOptions {\n    /**\n     * Whether to allow JSON primitive roots (numbers, booleans, strings, `null`) instead of requiring objects or arrays.\n     * @default false\n     */\n    allowPrimitives?: boolean;\n    /**\n     * Fallback value returned when parsing or guard validation fails.\n     */\n    fallback?: F;\n    /**\n     * Format of the JSON content: `\"json\"` (standard JSON) or `\"ndjson\"` (Newline Delimited JSON).\n     * @default \"json\"\n     */\n    format?: JSONFormat;\n    /**\n     * Guard predicate to validate the parsed value. If it returns `false`, `onError` is called and `fallback` is returned.\n     */\n    guard?: ((value: unknown) => value is T) | ((value: unknown) => boolean);\n    /**\n     * Options specific to NDJSON parsing when `format` is `\"ndjson\"`.\n     */\n    ndjson?: NDJSONParseOptions;\n    /**\n     * Callback invoked when parsing fails or the `guard` check returns `false`.\n     */\n    onError?: (err: unknown) => void;\n    /**\n     * Reviver function passed to `JSON.parse` for custom value transformation.\n     */\n    reviver?: Parameters<typeof JSON.parse>[1];\n    /**\n     * Whether to trim leading and trailing whitespace before validating/parsing.\n     * @default false\n     */\n    trimBeforeParse?: boolean;\n}",
      "properties": {
        "allowPrimitives": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to allow JSON primitive roots (numbers, booleans, strings, `null`) instead of requiring objects or arrays.",
          "default": "false"
        },
        "fallback": {
          "type": "T",
          "optional": true,
          "desc": "Fallback value returned when parsing or guard validation fails."
        },
        "format": {
          "type": "JSONFormat",
          "optional": true,
          "desc": "Format of the JSON content: `\"json\"` (standard JSON) or `\"ndjson\"` (Newline Delimited JSON).",
          "default": "\"json\"",
          "resolvedType": "\"json\" | \"ndjson\""
        },
        "guard": {
          "type": "((value: unknown) => value is unknown) | ((value: unknown) => boolean)",
          "optional": true,
          "desc": "Guard predicate to validate the parsed value. If it returns `false`, `onError` is called and `fallback` is returned."
        },
        "ndjson": {
          "type": "NDJSONParseOptions",
          "optional": true,
          "desc": "Options specific to NDJSON parsing when `format` is `\"ndjson\"`.",
          "properties": {
            "maxLines": {
              "type": "number",
              "optional": true,
              "desc": "Maximum number of non-empty lines to validate or parse."
            },
            "skipInvalidLines": {
              "type": "boolean",
              "optional": true,
              "desc": "Skip malformed or invalid lines instead of failing the entire parse.",
              "default": "false"
            },
            "skipLines": {
              "type": "number",
              "optional": true,
              "desc": "Number of non-empty lines to skip at the beginning of the content.",
              "default": "0"
            }
          }
        },
        "onError": {
          "type": "(err: unknown) => void",
          "optional": true,
          "desc": "Callback invoked when parsing fails or the `guard` check returns `false`."
        },
        "reviver": {
          "type": "Parameters<typeof JSON.parse>[1]",
          "optional": true,
          "desc": "Reviver function passed to `JSON.parse` for custom value transformation."
        },
        "trimBeforeParse": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to trim leading and trailing whitespace before validating/parsing.",
          "default": "false"
        }
      }
    },
    "SafeJsonReplacerOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 661,
      "lineEnd": 726,
      "desc": "Configuration options for `createSafeJsonReplacer()`.",
      "signature": "export interface SafeJsonReplacerOptions {\n    /**\n     * Strategy for serializing `BigInt` values: `\"string\"` or `\"number\"`.\n     * @default \"string\"\n     */\n    bigintStrategy?: \"string\" | \"number\";\n    /** Custom formatter function for `Date` objects (ignored if `onDate` is specified). */\n    formatDate?: (v: Date) => string;\n    /**\n     * If `true`, replaces circular references instead of throwing.\n     * @default false\n     */\n    handleCircular?: boolean;\n    /** Custom serialization override for `BigInt` values. */\n    onBigInt?: (v: bigint) => any;\n    /** Custom callback invoked when a circular reference is encountered. */\n    onCircular?: (this: any, k: string, v: any) => any;\n    /** Catch-all serialization override for custom types, executed after native type checks. */\n    onCustom?: (this: any, k: string, v: any) => any;\n    /** Custom serialization override for `Date` objects (takes precedence over `formatDate`). */\n    onDate?: (v: Date) => any;\n    /** Custom serialization override for `Error` objects. */\n    onError?: (v: Error) => any;\n    /** Custom serialization override for `Map` objects. */\n    onMap?: (v: Map<any, any>) => any;\n    /** Custom serialization override for `RegExp` objects. */\n    onRegExp?: (v: RegExp) => any;\n    /** Custom serialization override for `Set` objects. */\n    onSet?: (v: Set<any>) => any;\n    /** Custom serialization override for `TypedArray` values. */\n    onTypedArray?: (v: any) => any;\n    /** Custom serialization override for `URLSearchParams` objects. */\n    onURLSearchParams?: (v: URLSearchParams) => any;\n    /** Custom `JSON.stringify` replacer function or property whitelist array applied first. */\n    replacer?: ((this: any, k: string, v: any) => any) | (string | number)[] | null;\n    /**\n     * If `true`, disables default safe serialization for `BigInt` values.\n     * @default false\n     */\n    voidBigIntReplacement?: boolean;\n    /**\n     * If `true`, disables default safe serialization for `Date` objects.\n     * @default false\n     */\n    voidDateReplacement?: boolean;\n    /**\n     * If `true`, disables default safe serialization for `Map` objects.\n     * @default false\n     */\n    voidMapReplacement?: boolean;\n    /**\n     * If `true`, disables default safe serialization for `RegExp` objects.\n     * @default false\n     */\n    voidRegExpReplacement?: boolean;\n    /**\n     * If `true`, disables default safe serialization for `Set` objects.\n     * @default false\n     */\n    voidSetReplacement?: boolean;\n    /**\n     * If `true`, disables default safe serialization for `TypedArray` values.\n     * @default false\n     */\n    voidTypedArrayReplacement?: boolean;\n}",
      "properties": {
        "bigintStrategy": {
          "type": "\"string\" | \"number\"",
          "optional": true,
          "desc": "Strategy for serializing `BigInt` values: `\"string\"` or `\"number\"`.",
          "default": "\"string\""
        },
        "formatDate": {
          "type": "(v: Date) => string",
          "optional": true,
          "desc": "Custom formatter function for `Date` objects (ignored if `onDate` is specified)."
        },
        "handleCircular": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, replaces circular references instead of throwing.",
          "default": "false"
        },
        "onBigInt": {
          "type": "(v: bigint) => any",
          "optional": true,
          "desc": "Custom serialization override for `BigInt` values."
        },
        "onCircular": {
          "type": "(this: any, k: string, v: any) => any",
          "optional": true,
          "desc": "Custom callback invoked when a circular reference is encountered."
        },
        "onCustom": {
          "type": "(this: any, k: string, v: any) => any",
          "optional": true,
          "desc": "Catch-all serialization override for custom types, executed after native type checks."
        },
        "onDate": {
          "type": "(v: Date) => any",
          "optional": true,
          "desc": "Custom serialization override for `Date` objects (takes precedence over `formatDate`)."
        },
        "onError": {
          "type": "(v: Error) => any",
          "optional": true,
          "desc": "Custom serialization override for `Error` objects."
        },
        "onMap": {
          "type": "(v: Map<any, any>) => any",
          "optional": true,
          "desc": "Custom serialization override for `Map` objects."
        },
        "onRegExp": {
          "type": "(v: RegExp) => any",
          "optional": true,
          "desc": "Custom serialization override for `RegExp` objects."
        },
        "onSet": {
          "type": "(v: Set<any>) => any",
          "optional": true,
          "desc": "Custom serialization override for `Set` objects."
        },
        "onTypedArray": {
          "type": "(v: any) => any",
          "optional": true,
          "desc": "Custom serialization override for `TypedArray` values."
        },
        "onURLSearchParams": {
          "type": "(v: URLSearchParams) => any",
          "optional": true,
          "desc": "Custom serialization override for `URLSearchParams` objects."
        },
        "replacer": {
          "type": "((this: any, k: string, v: any) => any) | (string | number)[] | null",
          "optional": true,
          "desc": "Custom `JSON.stringify` replacer function or property whitelist array applied first."
        },
        "voidBigIntReplacement": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, disables default safe serialization for `BigInt` values.",
          "default": "false"
        },
        "voidDateReplacement": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, disables default safe serialization for `Date` objects.",
          "default": "false"
        },
        "voidMapReplacement": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, disables default safe serialization for `Map` objects.",
          "default": "false"
        },
        "voidRegExpReplacement": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, disables default safe serialization for `RegExp` objects.",
          "default": "false"
        },
        "voidSetReplacement": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, disables default safe serialization for `Set` objects.",
          "default": "false"
        },
        "voidTypedArrayReplacement": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, disables default safe serialization for `TypedArray` values.",
          "default": "false"
        }
      }
    },
    "StepSliceArrayOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 731,
      "lineEnd": 755,
      "desc": "Configuration options for `stepSliceArray()`.",
      "signature": "export interface StepSliceArrayOptions {\n    /**\n     * Maximum number of items to gather in the sliced result array.\n     */\n    maxItemsGathered?: number;\n    /**\n     * If `true`, returns `null` when the starting offset is out of bounds; if `false`, throws an error.\n     * @default true\n     */\n    nullOnOob?: boolean;\n    /**\n     * Ending index (exclusive). Supports negative indices relative to array length.\n     */\n    offsetEnd?: number;\n    /**\n     * Starting index (inclusive). Supports negative indices relative to array length.\n     * @default 0\n     */\n    offsetStart?: number;\n    /**\n     * Step size to slice the array by (non-zero). Positive slices forward; negative slices backward.\n     * @default 1\n     */\n    step?: number;\n}",
      "properties": {
        "maxItemsGathered": {
          "type": "number",
          "optional": true,
          "desc": "Maximum number of items to gather in the sliced result array."
        },
        "nullOnOob": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, returns `null` when the starting offset is out of bounds; if `false`, throws an error.",
          "default": "true"
        },
        "offsetEnd": {
          "type": "number",
          "optional": true,
          "desc": "Ending index (exclusive). Supports negative indices relative to array length."
        },
        "offsetStart": {
          "type": "number",
          "optional": true,
          "desc": "Starting index (inclusive). Supports negative indices relative to array length.",
          "default": "0"
        },
        "step": {
          "type": "number",
          "optional": true,
          "desc": "Step size to slice the array by (non-zero). Positive slices forward; negative slices backward.",
          "default": "1"
        }
      }
    },
    "StripCharsOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 760,
      "lineEnd": 807,
      "desc": "Configuration options for `stripChars()`.",
      "signature": "export interface StripCharsOptions {\n    /**\n     * Maximum number of non-contiguous matching blocks allowed to be stripped from the end (`-1` or `null` strips all).\n     */\n    maxMatchesEnd?: number | null;\n    /**\n     * Maximum number of non-contiguous matching blocks allowed to be stripped from the start (`-1` or `null` strips all).\n     */\n    maxMatchesStart?: number | null;\n    /**\n     * Maximum number of non-matching characters allowed to be skipped from the end before a match block is found (`-1` or `null` scans full length).\n     */\n    maxScanEnd?: number | null;\n    /**\n     * Maximum number of non-matching characters allowed to be skipped from the start before a match block is found (`-1` or `null` scans full length).\n     */\n    maxScanStart?: number | null;\n    /**\n     * Boundary strip mode: `\"both\"`, `\"start\"`, or `\"end\"`.\n     * @default \"both\"\n     */\n    mode?: StripMode;\n    /**\n     * If `true`, returns `\"\"` instead of `null` when the stripped result is empty or input is `null`.\n     * @default false\n     */\n    returnStringOnNull?: boolean;\n    /**\n     * Options that apply only when `characters` is a string (and not a `RegExp`).\n     */\n    stringOptions?: {\n        /**\n         * If `true`, treats `characters` as a literal substring rather than a set of characters.\n         * @default false\n         */\n        literal?: boolean;\n        /**\n         * If `true`, performs case-insensitive character and substring matching.\n         * @default false\n         */\n        caseInsensitive?: boolean;\n    };\n    /**\n     * If `true`, trims standard whitespace first before performing character stripping.\n     * @default false\n     */\n    trimFirst?: boolean;\n}",
      "properties": {
        "maxMatchesEnd": {
          "type": "number | null",
          "optional": true,
          "desc": "Maximum number of non-contiguous matching blocks allowed to be stripped from the end (`-1` or `null` strips all)."
        },
        "maxMatchesStart": {
          "type": "number | null",
          "optional": true,
          "desc": "Maximum number of non-contiguous matching blocks allowed to be stripped from the start (`-1` or `null` strips all)."
        },
        "maxScanEnd": {
          "type": "number | null",
          "optional": true,
          "desc": "Maximum number of non-matching characters allowed to be skipped from the end before a match block is found (`-1` or `null` scans full length)."
        },
        "maxScanStart": {
          "type": "number | null",
          "optional": true,
          "desc": "Maximum number of non-matching characters allowed to be skipped from the start before a match block is found (`-1` or `null` scans full length)."
        },
        "mode": {
          "type": "StripMode",
          "optional": true,
          "desc": "Boundary strip mode: `\"both\"`, `\"start\"`, or `\"end\"`.",
          "default": "\"both\"",
          "resolvedType": "\"both\" | \"start\" | \"end\""
        },
        "returnStringOnNull": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, returns `\"\"` instead of `null` when the stripped result is empty or input is `null`.",
          "default": "false"
        },
        "stringOptions": {
          "type": "object",
          "optional": true,
          "desc": "Options that apply only when `characters` is a string (and not a `RegExp`).",
          "properties": {
            "caseInsensitive": {
              "type": "boolean",
              "optional": true,
              "desc": "* If `true`, performs case-insensitive character and substring matching. * @default false",
              "default": "false"
            },
            "literal": {
              "type": "boolean",
              "optional": true,
              "desc": "* If `true`, treats `characters` as a literal substring rather than a set of characters. * @default false",
              "default": "false"
            }
          }
        },
        "trimFirst": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, trims standard whitespace first before performing character stripping.",
          "default": "false"
        }
      }
    },
    "StripMode": {
      "filePath": "utils/types.ts",
      "lineStart": 812,
      "lineEnd": 812,
      "desc": "Boundary side for `stripChars()`.",
      "signature": "export type StripMode = \"both\" | \"start\" | \"end\";"
    },
    "ToDurationOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 817,
      "lineEnd": 827,
      "desc": "Configuration options for `toDuration()`.",
      "signature": "export interface ToDurationOptions extends ParseDurationStringOptions {\n    /**\n     * Fallback numeric value returned when the input cannot be parsed as a valid duration.\n     */\n    fallback?: number;\n    /**\n     * Target unit to convert the parsed duration into.\n     * @default \"ms\"\n     */\n    to?: DurationUnit;\n}",
      "properties": {
        "fallback": {
          "type": "number",
          "optional": true,
          "desc": "Fallback numeric value returned when the input cannot be parsed as a valid duration."
        },
        "to": {
          "type": "DurationUnit",
          "optional": true,
          "desc": "Target unit to convert the parsed duration into.",
          "default": "\"ms\"",
          "resolvedType": "\"ns\" | \"us\" | \"ms\" | \"s\" | \"m\" | \"h\" | \"d\" | \"w\" | \"mo\" | \"q\" | \"y\" | \"i\""
        }
      }
    },
    "ToValidArrayOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 832,
      "lineEnd": 843,
      "desc": "Configuration options for `toValidArray()`.",
      "signature": "export interface ToValidArrayOptions {\n    /**\n     * If `true`, returns a shallow copy of an existing array. If `false`, returns the input array directly without cloning.\n     * @default true\n     */\n    clone?: boolean;\n    /**\n     * If `true`, wraps `null` or `undefined` into a single-element array. If `false`, returns an empty array `[]`.\n     * @default false\n     */\n    wrapNull?: boolean;\n}",
      "properties": {
        "clone": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, returns a shallow copy of an existing array. If `false`, returns the input array directly without cloning.",
          "default": "true"
        },
        "wrapNull": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, wraps `null` or `undefined` into a single-element array. If `false`, returns an empty array `[]`.",
          "default": "false"
        }
      }
    },
    "toValidBigIntOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 848,
      "lineEnd": 859,
      "desc": "Configuration options for `toValidBigInt()`.",
      "signature": "export interface toValidBigIntOptions extends IsValidBigIntOptions {\n    /**\n     * 64-bit integer range bounds to validate against.\n     * @default \"Int64\"\n     */\n    range?: BigIntRange;\n    /**\n     * When `true`, truncates fractional numbers/strings toward zero before converting to `bigint`.\n     * @default false\n     */\n    truncate?: boolean;\n}",
      "properties": {
        "range": {
          "type": "BigIntRange",
          "optional": true,
          "desc": "64-bit integer range bounds to validate against.",
          "default": "\"Int64\"",
          "properties": {
            "max": {
              "type": "bigint",
              "optional": false,
              "desc": "Maximum inclusive BigInt value."
            },
            "min": {
              "type": "bigint",
              "optional": false,
              "desc": "Minimum inclusive BigInt value."
            }
          }
        },
        "truncate": {
          "type": "boolean",
          "optional": true,
          "desc": "When `true`, truncates fractional numbers/strings toward zero before converting to `bigint`.",
          "default": "false"
        }
      }
    },
    "TypedArrayConstructor": {
      "filePath": "utils/types.ts",
      "lineStart": 864,
      "lineEnd": 864,
      "desc": "Constructor signature for a JavaScript TypedArray.",
      "signature": "export type TypedArrayConstructor<T extends AnyTypedArray = AnyTypedArray> = new (length: number) => T;"
    },
    "UnicodeSurrogateType": {
      "filePath": "utils/types.ts",
      "lineStart": 869,
      "lineEnd": 869,
      "desc": "Surrogate half selector for `_isUnicodeSurrogate()`.",
      "signature": "export type UnicodeSurrogateType = \"all\" | \"high\" | \"low\";"
    },
    "UniqueArrayStatsOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 874,
      "lineEnd": 884,
      "desc": "Configuration options for `getUniqueArrayStats()`.",
      "signature": "export interface UniqueArrayStatsOptions {\n    /**\n     * Custom function to extract a unique comparison key from each element.\n     */\n    keySelector?: (val: any) => any;\n    /**\n     * If `true`, uses canonical serialization to group nested structures (Arrays, Sets, Maps, Dates) by value instead of reference.\n     * @default false\n     */\n    strict?: boolean;\n}",
      "properties": {
        "keySelector": {
          "type": "(val: any) => any",
          "optional": true,
          "desc": "Custom function to extract a unique comparison key from each element."
        },
        "strict": {
          "type": "boolean",
          "optional": true,
          "desc": "If `true`, uses canonical serialization to group nested structures (Arrays, Sets, Maps, Dates) by value instead of reference.",
          "default": "false"
        }
      }
    },
    "WriteCSVOptions": {
      "filePath": "utils/types.ts",
      "lineStart": 889,
      "lineEnd": 945,
      "desc": "Configuration options for `writeCSV()` and `df.writeCsv()`.",
      "signature": "export interface WriteCSVOptions extends FormatCSVValueOptions {\n    /**\n     * Custom `strftime` format string for `Date` values (e.g. `\"%Y-%m-%d\"`).\n     */\n    dateFormat?: string;\n    /**\n     * Custom `strftime` format string for `Datetime` values (e.g. `\"%Y-%m-%d %H:%M:%S\"`).\n     */\n    datetimeFormat?: string;\n    /**\n     * Whether to include a UTF-8 Byte Order Mark (BOM) at the start of the output.\n     * @default false\n     */\n    includeBom?: boolean;\n    /**\n     * Whether to write the header row.\n     * @default true\n     */\n    includeHeader?: boolean;\n    /**\n     * String used to terminate each row.\n     * @default \"\\n\"\n     */\n    lineTerminator?: string;\n    /**\n     * String representation to use for `null` or missing values.\n     * @default \"\"\n     */\n    nullValue?: string;\n    /**\n     * Options for numeric formatting (floats, ints, bigints).\n     */\n    numericFormatOptions?: NumericFormatOptions;\n    /**\n     * Single-character quote symbol used for quoting fields.\n     * @default '\"'\n     */\n    quoteChar?: string;\n    /**\n     * Quoting strategy for CSV fields: `\"necessary\"`, `\"always\"`, `\"never\"`, or `\"non_numeric\"`.\n     * @default \"necessary\"\n     */\n    quoteStyle?: \"necessary\" | \"always\" | \"never\" | \"non_numeric\";\n    /**\n     * Options for the safe JSON replacer used when formatting objects and arrays.\n     */\n    replacerOptions?: SafeJsonReplacerOptions;\n    /**\n     * Single-character delimiter that separates fields.\n     * @default \",\"\n     */\n    separator?: string;\n    /**\n     * Custom `strftime` format string for `Time` values (e.g. `\"%H:%M:%S\"`).\n     */\n    timeFormat?: string;\n}",
      "properties": {
        "dateFormat": {
          "type": "string",
          "optional": true,
          "desc": "Custom `strftime` format string for `Date` values (e.g. `\"%Y-%m-%d\"`)."
        },
        "datetimeFormat": {
          "type": "string",
          "optional": true,
          "desc": "Custom `strftime` format string for `Datetime` values (e.g. `\"%Y-%m-%d %H:%M:%S\"`)."
        },
        "includeBom": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to include a UTF-8 Byte Order Mark (BOM) at the start of the output.",
          "default": "false"
        },
        "includeHeader": {
          "type": "boolean",
          "optional": true,
          "desc": "Whether to write the header row.",
          "default": "true"
        },
        "lineTerminator": {
          "type": "string",
          "optional": true,
          "desc": "String used to terminate each row.",
          "default": "\"\\n\""
        },
        "nullValue": {
          "type": "string",
          "optional": true,
          "desc": "String representation to use for `null` or missing values.",
          "default": "\"\""
        },
        "numericFormatOptions": {
          "type": "NumericFormatOptions",
          "optional": true,
          "desc": "Options for numeric formatting (floats, ints, bigints).",
          "properties": {
            "accountingNegatives": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, formats negative numbers in accounting parentheses (e.g. `(1.23)`).",
              "default": "false"
            },
            "fallback": {
              "type": "string",
              "optional": true,
              "desc": "Fallback string returned when the value cannot be parsed into a formattable number.",
              "default": "\"NaN\""
            },
            "formatNonFinite": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, returns `fallback` for `Infinity` and `-Infinity` values.",
              "default": "false"
            },
            "locale": {
              "type": "string",
              "optional": true,
              "desc": "BCP 47 language tag (e.g. `\"en-US\"`, `\"de-DE\"`).",
              "default": "\"en-US\""
            }
          }
        },
        "quoteChar": {
          "type": "string",
          "optional": true,
          "desc": "Single-character quote symbol used for quoting fields.",
          "default": "'\"'"
        },
        "quoteStyle": {
          "type": "\"necessary\" | \"always\" | \"never\" | \"non_numeric\"",
          "optional": true,
          "desc": "Quoting strategy for CSV fields: `\"necessary\"`, `\"always\"`, `\"never\"`, or `\"non_numeric\"`.",
          "default": "\"necessary\""
        },
        "replacerOptions": {
          "type": "SafeJsonReplacerOptions",
          "optional": true,
          "desc": "Options for the safe JSON replacer used when formatting objects and arrays.",
          "properties": {
            "bigintStrategy": {
              "type": "\"string\" | \"number\"",
              "optional": true,
              "desc": "Strategy for serializing `BigInt` values: `\"string\"` or `\"number\"`.",
              "default": "\"string\""
            },
            "formatDate": {
              "type": "(v: Date) => string",
              "optional": true,
              "desc": "Custom formatter function for `Date` objects (ignored if `onDate` is specified)."
            },
            "handleCircular": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, replaces circular references instead of throwing.",
              "default": "false"
            },
            "onBigInt": {
              "type": "(v: bigint) => any",
              "optional": true,
              "desc": "Custom serialization override for `BigInt` values."
            },
            "onCircular": {
              "type": "(this: any, k: string, v: any) => any",
              "optional": true,
              "desc": "Custom callback invoked when a circular reference is encountered."
            },
            "onCustom": {
              "type": "(this: any, k: string, v: any) => any",
              "optional": true,
              "desc": "Catch-all serialization override for custom types, executed after native type checks."
            },
            "onDate": {
              "type": "(v: Date) => any",
              "optional": true,
              "desc": "Custom serialization override for `Date` objects (takes precedence over `formatDate`)."
            },
            "onError": {
              "type": "(v: Error) => any",
              "optional": true,
              "desc": "Custom serialization override for `Error` objects."
            },
            "onMap": {
              "type": "(v: Map<any, any>) => any",
              "optional": true,
              "desc": "Custom serialization override for `Map` objects."
            },
            "onRegExp": {
              "type": "(v: RegExp) => any",
              "optional": true,
              "desc": "Custom serialization override for `RegExp` objects."
            },
            "onSet": {
              "type": "(v: Set<any>) => any",
              "optional": true,
              "desc": "Custom serialization override for `Set` objects."
            },
            "onTypedArray": {
              "type": "(v: any) => any",
              "optional": true,
              "desc": "Custom serialization override for `TypedArray` values."
            },
            "onURLSearchParams": {
              "type": "(v: URLSearchParams) => any",
              "optional": true,
              "desc": "Custom serialization override for `URLSearchParams` objects."
            },
            "replacer": {
              "type": "((this: any, k: string, v: any) => any) | (string | number)[] | null",
              "optional": true,
              "desc": "Custom `JSON.stringify` replacer function or property whitelist array applied first."
            },
            "voidBigIntReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `BigInt` values.",
              "default": "false"
            },
            "voidDateReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `Date` objects.",
              "default": "false"
            },
            "voidMapReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `Map` objects.",
              "default": "false"
            },
            "voidRegExpReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `RegExp` objects.",
              "default": "false"
            },
            "voidSetReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `Set` objects.",
              "default": "false"
            },
            "voidTypedArrayReplacement": {
              "type": "boolean",
              "optional": true,
              "desc": "If `true`, disables default safe serialization for `TypedArray` values.",
              "default": "false"
            }
          }
        },
        "separator": {
          "type": "string",
          "optional": true,
          "desc": "Single-character delimiter that separates fields.",
          "default": "\",\""
        },
        "timeFormat": {
          "type": "string",
          "optional": true,
          "desc": "Custom `strftime` format string for `Time` values (e.g. `\"%H:%M:%S\"`)."
        }
      }
    }
  }
}