df-script 1.5.0 → 1.6.0

package/README.md

@@ -1,11 +1,39 @@
 # 🚀 DFScript
 
+[![GitHub Repository](https://img.shields.io/badge/GitHub-Repository-blue?style=for-the-badge&logo=github)](https://github.com/trentamorris/df-script)
 [![Donate](https://img.shields.io/badge/Donate-Support-green?style=for-the-badge)](DONATIONS.md)
 
 DFScript is a lightweight, high-performance, and **zero-dependency** data analysis library for TypeScript and JavaScript. Heavily inspired by modern dataframe libraries like **Polars** and **Pandas**, DFScript brings a robust, expression-based columnar data processing engine directly to the JavaScript ecosystem.
 
 With optimized columnar storage under the hood, DFScript enables you to build clean, maintainable, and type-safe data pipelines using a declarative expression API.
 
+## 💡 Why DFScript?
+
+Like many developers, I spent years working on frontend codebases filled with deeply nested, unoptimized data processing loops. We've all seen them: chained `.map()`, `.filter()`, `.sort()`, and `.forEach()` loops processing arrays of objects. Each step in the chain allocates new intermediate arrays, triggers garbage collection thrashing, and operates on row-based layouts that slow down browser main threads.
+
+When you need to perform complex analytical transformations on the client-side—handling missing values, formatting timezone-aware datetimes, parsing decimals, or computing rolling averages—relying on standard JavaScript array methods quickly becomes a performance and maintenance nightmare. There had to be a better, cleaner, and faster way to express these pipelines. I realized that if nobody else had built a lightweight, zero-dependency columnar expression engine for the JavaScript ecosystem yet, why not roll up my sleeves and build it myself?
+
+DFScript was born from that frustration. It brings Polars-like columnar execution, strict domain namespaces (`.str`, `.dt`, `.arr`, `.struct`), and lazy/declarative expression compilation to JavaScript. Under the hood, it avoids intermediate array allocations and uses highly optimized loops with cached lengths, so your frontend code stays clean, type-safe, and incredibly fast.
+
+---
+
+## 🗺️ Table of Contents
+
+- [✨ Key Features](#-key-features)
+- [⚙️ Compatibility & Design Principles](#-compatibility--design-principles)
+- [🤝 Contributing & Collective Wisdom](#-contributing--collective-wisdom)
+- [📦 Installation](#-installation)
+- [🚀 Quick Start](#-quick-start)
+- [📖 Core Concepts](#-core-concepts)
+- [🛠️ DataFrame API Reference](#-dataframe-api-reference)
+- [📂 File / Data I/O](#-file--data-io)
+- [🧮 Expressions API Reference](#-expressions-api-reference)
+- [📂 Namespaces](#-namespaces)
+- [🪟 Window & Rolling Expressions](#-window--rolling-expressions)
+- [🛡️ Typing and Schema Registry](#-typing-and-schema-registry)
+- [🧑‍💻 Contributing & Development](#-contributing--development)
+- [📄 License](#-license)
+
 ---
 
 ## ✨ Key Features
@@ -16,7 +44,8 @@ With optimized columnar storage under the hood, DFScript enables you to build cl
 - 📂 **Strict Namespaces** — Clear API organization for specific domains:
   - `.str` for advanced string manipulations.
   - `.dt` for microsecond-precision datetimes, timezones, and duration calculations.
-  - `.list` for robust array/list column operations.
+  - `.arr` for robust array/list column operations.
+  - `.struct` for nested object and struct manipulation.
 - 🪟 **Analytical Window Functions** — Windowing (`over()`), cumulative aggregations (`cum_sum()`, `cum_max()`), and rolling metrics (`rolling_mean()`, `rolling_std()`).
 - 🛠️ **Relational Operations** — Rich, high-speed joins, pivots, unpivots, vertical/horizontal concatenations, and group-by aggregations.
 - 🛡️ **Defensive & Type-Safe** — Native type-coercion, robust null-safety, and strict schema validation.
@@ -35,6 +64,14 @@ DFScript is designed with a **low-abstraction, zero-dependency** philosophy to g
 
 ---
 
+## 🤝 Contributing & Collective Wisdom
+
+We don’t pretend to have encountered every localized date format, database quirk, or environment-specific edge case. DFScript is built on the belief that software correctness is a collective endeavor. 
+
+If you run into an unsupported edge case or unexpected behavior in any of our functions, we want to hear about it. Help us harden this engine by opening a GitHub Issue or submitting a PR—every report makes the library more robust for everyone.
+
+---
+
 ## 📦 Installation
 
 Install DFScript using your favorite package manager:
@@ -73,7 +110,7 @@ const processedDf = df.select(
   $df.col("name").str.upper().alias("NAME_UPPER"),
   $df.col("join_date").str.to_datetime().dt.year().alias("join_year"),
   $df.col("sales").add(500).alias("sales_adjusted"),
-  $df.col("tags").list.lengths().alias("tag_count")
+  $df.col("tags").arr.lengths().alias("tag_count")
 );
 
 console.log(processedDf.to_dicts());
@@ -93,12 +130,20 @@ console.log(processedDf.to_dicts());
 
 ### The `$df` Entry Point
 
-DFScript uses the `$df` namespace to bootstrap DataFrames, refer to columns, and access general types.
+DFScript uses the `$df` namespace to bootstrap DataFrames, refer to columns, build expressions, and access data types.
 
 - `$df.data(dataRowsOrCols, schema?)`: Instantiates a new `DataFrame`.
 - `$df.read_json(content, options?)`: Reads JSON/NDJSON content into a new `DataFrame`.
+- `$df.read_csv(content, options?)`: Reads CSV content into a new `DataFrame`.
 - `$df.col(name)`: Creates a column reference expression.
 - `$df.all()`: Selects all columns in the DataFrame.
+- `$df.exclude(columns)`: Creates an expression matching all columns except the specified ones.
+- `$df.coalesce(...exprs)`: Returns the first non-null value among columns or literal expressions.
+- `$df.lit(val)`: Explicitly wraps a raw value into a literal expression.
+- `$df.when(predicate).then(value)...otherwise(value)`: Constructs a conditional expression (when-then-otherwise chain).
+- `$df.implode(column)`: Aggregates a column's rows (or grouped values) into a list.
+- `$df.seq_range(value, options?)`: Generates a sequence range of values.
+- `$df.element()`: References the current array element within an `.arr.eval(...)` expression.
 - `$df.DataType`: Direct access to the `DataTypeRegistry` for schema specification.
 
 ### DataFrames vs. Columns
@@ -154,6 +199,17 @@ DFScript provides helpers to serialize and parse data formats like JSON and CSV.
   // Read Newline Delimited JSON (NDJSON)
   const dfNdjson = $df.read_json('{"id": 1}\n{"id": 2}', { format: "ndjson" });
   ```
+- **`$df.read_csv(content, options?)`**: Reads a CSV string and loads it into a new DataFrame, with automatic data type inference.
+  ```typescript
+  import { $df } from "df-script";
+
+  const csvContent = "id,name,active\n1,Alice,true\n2,Bob,false";
+  const df = $df.read_csv(csvContent, {
+    separator: ",",
+    hasHeader: true,
+    inferSchema: true
+  });
+  ```
 
 ### Writing Data
 - **`df.write_json(file?, options?)`**: Serializes a DataFrame into a JSON or NDJSON string. If a file path or writable stream/object (with a `.write` method) is provided, writes/streams the content as a side-effect. Always returns the serialized string.
@@ -197,6 +253,23 @@ Chained mathematical functions execute cleanly with built-in null-safety (Kleene
 - `.first()`, `.last()`
 - `.any()`, `.all()`, `.any_null()`, `.all_null()`, `.n_unique()`
 
+### 🔀 Control Flow & Conditionals
+Construct dynamic `CASE WHEN` branches using the `$df.when` API:
+```typescript
+import { $df } from "df-script";
+
+df.select(
+  $df.col("sales"),
+  $df.when($df.col("sales").gt(2000)).then("High Performance")
+     .when($df.col("sales").gt(1000)).then("Standard Performance")
+     .otherwise("Low Performance")
+     .alias("sales_category")
+);
+```
+- `$df.when(predicate).then(value)`: Starts a conditional evaluation.
+- `.when(predicate).then(value)`: Chains additional conditions.
+- `.otherwise(value)`: Specifies the fallback value when no conditions match (returns a complete `ColumnExpr`).
+
 ---
 
 ## 📂 Namespaces
@@ -222,13 +295,36 @@ $df.col("duration").dt.total_seconds()
 - **Datetime Methods**: `year()`, `month()`, `day()`, `hour()`, `minute()`, `second()`, `millisecond()`, `microsecond()`, `nanosecond()`, `weekday()`, `week()`, `quarter()`, `century()`, `millennium()`, `ordinal_day()`, `is_leap_year()`, `month_start()`, `month_end()`, `date()`, `time()`, `datetime()`, `epoch(unit)`, `timestamp(unit)`, `strftime(format, locale?)`.
 - **Duration Methods**: `total_days()`, `total_hours()`, `total_minutes()`, `total_seconds()`, `total_milliseconds()`, `total_microseconds()`, `total_nanoseconds()`.
 
-### 📊 List Operations (`.list`)
-Available on arrays or lists via `.list`:
+### 📊 Array/List Operations (`.arr`)
+Available on any array or list column expression via `.arr`:
+```typescript
+$df.col("tags").arr.contains("vip")
+$df.col("matrix").arr.get(2)
+
+// Element-wise manipulation inside arrays:
+$df.col("numbers").arr.eval(element().mul(2)).alias("numbers_doubled")
+$df.col("tags").arr.eval(element().str.to_uppercase()).alias("upper_tags")
+```
+- **Methods**: `lengths()`, `len()`, `get(idx, null_on_oob?)`, `first(null_on_oob?)`, `last(null_on_oob?)`, `gather(indices, null_on_oob?)`, `gather_every(n, offset?)`, `slice(offset, length?)`, `contains(item)`, `count_matches(item)`, `join(separator)`, `sort(descending?)`, `reverse()`, `unique()`, `sum()`, `mean()`, `median()`, `mode()`, `min()`, `max()`, `eval(expr)`.
+
+### 🗃️ Struct/Object Operations (`.struct`)
+Available on any struct or nested object column expression via `.struct`. You can access fields dynamically via properties or explicit methods:
 ```typescript
-$df.col("tags").list.contains("vip")
-$df.col("matrix").list.get(2)
+// Sibling fields access via Proxy
+$df.col("address").struct.city.alias("city")
+
+// Or using the explicit field method
+$df.col("address").struct.field("city")
 ```
-- **Methods**: `lengths()`, `len()`, `get(idx, null_on_oob?)`, `first(null_on_oob?)`, `last(null_on_oob?)`, `gather(indices, null_on_oob?)`, `gather_every(n, offset?)`, `slice(offset, length?)`, `contains(item)`, `count_matches(item)`, `join(separator)`, `sort(descending?)`, `reverse()`, `unique()`, `sum()`, `mean()`, `median()`, `mode()`, `min()`, `max()`.
+- **Methods**:
+  - `field(name)`: Accesses a field within the struct.
+  - `rename_fields(mapping)`: Renames fields in the struct based on a `{ oldKey: newKey }` mapping.
+  - `with_fields(fields)`: Adds or overrides fields in the struct. Accepts an array of aliased expressions or an object.
+  - `unnest()`: Expands the fields of the struct into individual top-level columns in a select projection.
+    ```typescript
+    // Flattens the address struct into "city", "state", etc. at the top-level
+    df.select($df.col("address").struct.unnest())
+    ```
 
 ---
 
@@ -291,6 +387,26 @@ const schema = {
 const df = $df.data(rawData, schema);
 ```
 
+### 🧠 TypeScript Type Inference & IDE Safety
+
+When you pass a schema to `$df.data()`, DFScript's types automatically infer the target types of the fields, turning dynamic dataframes into compile-safe records. Your IDE will auto-complete column names and validate that operations match the underlying types.
+
+```typescript
+import { $df } from "df-script";
+
+const schema = {
+  name: $df.DataType.Utf8,
+  age: $df.DataType.Int32,
+  is_active: $df.DataType.Boolean
+};
+
+// Inferred DataFrame type is DataFrame<{ name: string; age: number; is_active: boolean }>
+const df = $df.data(rawData, schema);
+
+// Full IDE autocomplete, type validation, and compiler safety!
+const activeUsers = df.filter($df.col("is_active").eq(true));
+```
+
 ### Supported Data Types
 - **Integers**: `Int8`, `Int16`, `Int32`, `Int64`, `UInt8`, `UInt16`, `UInt32`, `UInt64`
 - **Floats & Decimals**: `Float32`, `Float64`, `Decimal(precision?, scale?)`

package/dist/api.d.ts

@@ -40,7 +40,7 @@ export declare const $df: {
         Duration: import("./datatypes").DurationType;
         Object: import("./datatypes").ObjectType;
         Null: import("./datatypes").NullType;
-        List: <TInner>(inner: import("./datatypes").RegisteredDataType & DataType<TInner>) => import("./datatypes").ListType<TInner>;
+        Array: <TInner>(inner: import("./datatypes").RegisteredDataType & DataType<TInner>) => import("./datatypes").ArrayType<TInner>;
         Struct: <TFields extends RowRecord>(fields: { [K in keyof TFields]: import("./datatypes").RegisteredDataType & DataType<TFields[K]>; }) => import("./datatypes").StructType<TFields>;
     };
 };

package/dist/columnExpressions/ColumnExpr.d.ts

@@ -6,7 +6,7 @@ import { WindowExpr } from "./mixins/WindowExpr";
 import { StringExpr } from "./mixins/StringExpr";
 import { LogicalExpr } from "./mixins/LogicalExpr";
 import { TemporalExpr } from "./mixins/TemporalExpr";
-import { ListExpr } from "./mixins/ListExpr";
+import { ArrayExpr } from "./mixins/ArrayExpr";
 import { StructExpr } from "./mixins/StructExpr";
 import { ManipulationExpr } from "./mixins/ManipulationExpr";
 import { DataType } from "../datatypes";
@@ -21,7 +21,7 @@ export declare class ColumnExpr<T> extends ExprBase {
     static toColExpr(col: IntoExpr | IntoExpr[]): ColumnExpr<any>;
     constructor(colName: keyof T | string | (keyof T | string)[] | DataType | Function | (DataType | Function)[]);
 }
-export interface ColumnExpr<T> extends ArithmeticExpr, ComparisonExpr, AggregationExpr, WindowExpr, StringExpr, LogicalExpr, TemporalExpr, ListExpr, StructExpr, ManipulationExpr {
+export interface ColumnExpr<T> extends ArithmeticExpr, ComparisonExpr, AggregationExpr, WindowExpr, StringExpr, LogicalExpr, TemporalExpr, ArrayExpr, StructExpr, ManipulationExpr {
 }
 /**
  * Resolves column selectors, expanding wildcards, datatypes, and arrays of columns/types

package/dist/columnExpressions/functions/coalesce.d.ts

@@ -1,3 +1,3 @@
 import { ColumnExpr } from "../ColumnExpr";
-import type { IExpr, Scalar } from "../../types";
-export declare function coalesce(...exprs: (IExpr | Scalar | (IExpr | Scalar)[])[]): ColumnExpr<any>;
+import type { IExpr, ValidScalarTypes } from "../../types";
+export declare function coalesce(...exprs: (IExpr | ValidScalarTypes | (IExpr | ValidScalarTypes)[])[]): ColumnExpr<any>;

package/dist/columnExpressions/functions/element.d.ts

@@ -1,5 +1,5 @@
 import { ColumnExpr } from "../ColumnExpr";
 /**
- * Creates an expression referencing the current element(s) of a list during evaluation.
+ * Creates an expression referencing the current element(s) of an array during evaluation.
  */
 export declare function element<T = any>(): ColumnExpr<T>;

package/dist/columnExpressions/functions/when.d.ts

@@ -1,6 +1,6 @@
 import { ColumnExpr } from "../ColumnExpr";
-import type { IExpr, Scalar } from "../../types";
-type WhenArg = IExpr | Scalar;
+import type { IExpr, ValidScalarTypes } from "../../types";
+type WhenArg = IExpr | ValidScalarTypes;
 export declare class WhenThenChain {
     private predicates;
     private values;

package/dist/columnExpressions/index.d.ts

@@ -8,7 +8,7 @@ export * from "./mixins/StringExpr";
 export * from "./mixins/AggregationExpr";
 export * from "./mixins/WindowExpr";
 export * from "./mixins/TemporalExpr";
-export * from "./mixins/ListExpr";
+export * from "./mixins/ArrayExpr";
 export * from "./mixins/StructExpr";
 export * from "./ColumnExpr";
 export * from "./functions/lit";

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

@@ -1,4 +1,4 @@
-import type { AggFn, UniqueListStatsOptions } from "../../types";
+import type { AggFn, UniqueArrayStatsOptions } from "../../types";
 import { ExprBase } from "../ExprBase";
 export declare class AggregationExpr extends ExprBase {
     _deriveAgg(fn: AggFn<any>): this;
@@ -18,7 +18,7 @@ export declare class AggregationExpr extends ExprBase {
     median(): this;
     min(): this;
     mode(): this;
-    n_unique(options?: UniqueListStatsOptions): this;
+    n_unique(options?: UniqueArrayStatsOptions): this;
     quantile(q: number): this;
     std(): this;
     sum(): this;

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

@@ -1,33 +1,34 @@
-import type { IExpr } from "../../types";
-import type { RandomOptions } from "../types";
+import type { RandomOptions, NumericArg } from "../types";
 import { ExprBase } from "../ExprBase";
 export declare class ArithmeticExpr extends ExprBase {
     abs(): this;
     acos(): this;
     acosh(): this;
-    add(val: number | IExpr | null): this;
+    add(val: NumericArg): this;
     asin(): this;
     asinh(): this;
     atan(): this;
+    atan2(val: NumericArg): this;
     atanh(): this;
     cbrt(): this;
     ceil(): this;
     clip(lower?: number | null, upper?: number | null): this;
+    copysign(val: NumericArg): this;
     cos(): this;
     cosh(): this;
     degrees(): this;
-    div(val: number | IExpr | null): this;
+    div(val: NumericArg): this;
     exp(): this;
     expm1(): this;
     floor(): this;
-    floordiv(val: number | IExpr | null): this;
-    hypot(val: number | IExpr | null): this;
+    floordiv(val: NumericArg): this;
+    hypot(val: NumericArg): this;
     log(base?: number): this;
     log1p(): this;
-    mod(val: number | IExpr | null): this;
-    mul(val: number | IExpr | null): this;
+    mod(val: NumericArg): this;
+    mul(val: NumericArg): this;
     negate(): this;
-    pow(val: number | IExpr | null): this;
+    pow(val: NumericArg): this;
     radians(): this;
     rand(seed?: number, { min, max, integer }?: RandomOptions): this;
     round(decimals?: number): this;
@@ -35,7 +36,7 @@ export declare class ArithmeticExpr extends ExprBase {
     sin(): this;
     sinh(): this;
     sqrt(): this;
-    sub(val: number | IExpr | null): this;
+    sub(val: NumericArg): this;
     tan(): this;
     tanh(): this;
     trunc(): this;

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

@@ -0,0 +1,39 @@
+import { ExprBase } from "../ExprBase";
+import { SortArrayOptions, StepSliceArrayOptions } from "../../utils";
+import type { UniqueArrayStatsOptions, JoinArrayOptions, ExplodeOptions, IExpr } from "../../types";
+export declare class ArrayExprNamespace {
+    expr: any;
+    constructor(expr: any);
+    _deriveArray(fn: (arr: any[] | ArrayBufferView) => any): any;
+    all(): any;
+    any(): any;
+    contains(item: any): any;
+    contains_all(items: ArrayLike<any>): any;
+    contains_any(items: ArrayLike<any>): any;
+    count_matches(item: any): any;
+    drop_nulls(): any;
+    explode({ empty_as_null, keep_nulls }?: ExplodeOptions): any;
+    first(null_on_oob?: boolean): any;
+    gather(indices: number | ArrayLike<number>, null_on_oob?: boolean): any;
+    gather_every(options?: StepSliceArrayOptions): any;
+    get(index: number, null_on_oob?: boolean): any;
+    join(separator?: string, options?: JoinArrayOptions): any;
+    last(null_on_oob?: boolean): any;
+    len(): any;
+    lengths(): any;
+    max(): any;
+    mean(): any;
+    median(): any;
+    min(): any;
+    mode(): any;
+    n_unique(options?: UniqueArrayStatsOptions): any;
+    reverse(): any;
+    slice(offset: number, length?: number): any;
+    sort(options?: SortArrayOptions): any;
+    sum(): any;
+    unique(options?: UniqueArrayStatsOptions): any;
+    eval(expr: IExpr): any;
+}
+export declare class ArrayExpr extends ExprBase {
+    get arr(): ArrayExprNamespace;
+}

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

@@ -1,5 +1,5 @@
 import { ExprBase } from "../ExprBase";
-import { StepSliceListOptions } from "../../utils";
+import { SortListOptions, StepSliceListOptions } from "../../utils";
 import type { UniqueListStatsOptions, JoinListOptions, ExplodeOptions, IExpr } from "../../types";
 export declare class ListExprNamespace {
     expr: any;
@@ -29,7 +29,7 @@ export declare class ListExprNamespace {
     n_unique(options?: UniqueListStatsOptions): any;
     reverse(): any;
     slice(offset: number, length?: number): any;
-    sort(descending?: boolean): any;
+    sort(options?: SortListOptions): any;
     sum(): any;
     unique(options?: UniqueListStatsOptions): any;
     eval(expr: IExpr): any;

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

@@ -21,8 +21,8 @@ export declare class StringExprNamespace {
     lpad(width: number, fill?: string): any;
     pad_end(width: number, fill?: string): any;
     pad_start(width: number, fill?: string): any;
-    replace(pattern: string | RegExp, replacement: string): any;
-    replace_all(pattern: string | RegExp, replacement: string): any;
+    replace(pattern: string | RegExp, replacement: string | ((match: string, ...args: any[]) => string)): any;
+    replace_all(pattern: string | RegExp, replacement: string | ((match: string, ...args: any[]) => string)): any;
     reverse(): any;
     rpad(width: number, fill?: string): any;
     slice(offset: number, length?: number): any;

package/dist/columnExpressions/types.d.ts

@@ -5,3 +5,4 @@ export interface RandomOptions {
     max?: number;
     integer?: boolean;
 }
+export type NumericArg = number | IExpr | null;

package/dist/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const NEWLINE = "\n";
+export declare const CARRIAGE_RETURN = "\r";
+export declare const UTF8_BOM = "\uFEFF";
+export declare const MS_PER_SECOND = 1000;
+export declare const MS_PER_MINUTE = 60000;
+export declare const MS_PER_HOUR = 3600000;
+export declare const MS_PER_DAY = 86400000;
+export declare const US_PER_MS = 1000;
+export declare const NS_PER_MS = 1000000;
+export declare const US_PER_MS_BI = 1000n;
+export declare const NS_PER_MS_BI = 1000000n;

package/dist/dataframe/dataframe.d.ts

@@ -41,7 +41,7 @@ export declare class DataFrame<T extends RowRecord = any> {
     tail(n?: number): DataFrame<T>;
     to_dict(): DataFrameColumns<T>;
     to_dicts(): T[];
-    to_list<K extends keyof T>(nameOrExpr: K | IExpr): any[];
+    to_array<K extends keyof T>(nameOrExpr: K | IExpr): any[];
     transpose({ include_header: includeHeader, header_name: headerName, column_names: colNamesOpt }?: TransposeOptions): DataFrame<any>;
     unique<K extends keyof T>(columns?: K | K[]): DataFrame<T>;
     unpivot<U extends RowRecord = any>(config: UnpivotOptions<T>): DataFrame<U>;

package/dist/datatypes/index.d.ts

@@ -1,5 +1,5 @@
 import { DataType as BaseDataType } from "./DataType";
-import { DecimalType } from "./types";
+import { DecimalType, BooleanDataType as Boolean, DateDataType as Date, ObjectDataType as Object, ArrayDataType as Array } from "./types";
 export { BaseDataType as DataType };
 export declare const DataTypeRegistry: {
     Int8: import("./types").Int8Type;
@@ -22,8 +22,9 @@ export declare const DataTypeRegistry: {
     Duration: import("./types").DurationType;
     Object: import("./types").ObjectType;
     Null: import("./types").NullType;
-    List: <TInner>(inner: import("./types").RegisteredDataType & BaseDataType<TInner>) => import("./types").ListType<TInner>;
+    Array: <TInner>(inner: import("./types").RegisteredDataType & BaseDataType<TInner>) => import("./types").ArrayType<TInner>;
     Struct: <TFields extends import("..").RowRecord>(fields: { [K in keyof TFields]: import("./types").RegisteredDataType & BaseDataType<TFields[K]>; }) => import("./types").StructType<TFields>;
 };
+export { Boolean, Date, Object, Array };
 export * from "./types";
 export * from "./DataType";

package/dist/datatypes/types.d.ts

@@ -86,7 +86,7 @@ export declare class BooleanType extends DataType<boolean | null> {
     equals(other: DataType): boolean;
     allocate(size: number): (boolean | null)[];
 }
-export declare const Boolean: BooleanType;
+export declare const BooleanDataType: BooleanType;
 export declare class Utf8Type extends DataType<string | null> {
     readonly name = "Utf8";
     get isString(): boolean;
@@ -119,14 +119,14 @@ export declare class ObjectType extends DataType {
     equals(other: DataType): boolean;
     allocate(size: number): any[];
 }
-export declare const Object: ObjectType;
+export declare const ObjectDataType: ObjectType;
 export declare class DateType extends TemporalDataType<Date | null> {
     readonly name = "Date";
     coerce(val: unknown): Date | null;
     equals(other: DataType): boolean;
     allocate(size: number): (Date | null)[];
 }
-export declare const Date: DateType;
+export declare const DateDataType: DateType;
 export declare class DatetimeType extends TemporalDataType<Date | null> {
     readonly name = "Datetime";
     coerce(val: unknown): Date | null;
@@ -148,15 +148,15 @@ export declare class DurationType extends TemporalDataType<number | null> {
     allocate(size: number): (number | null)[];
 }
 export declare const Duration: DurationType;
-export declare class ListType<TInner = any> extends NestedDataType<TInner[] | null> {
+export declare class ArrayType<TInner = any> extends NestedDataType<TInner[] | null> {
     readonly innerType: RegisteredDataType & DataType<TInner>;
-    readonly name = "List";
+    readonly name = "Array";
     constructor(innerType: RegisteredDataType & DataType<TInner>);
     coerce(val: unknown): TInner[] | null;
     equals(other: DataType): boolean;
     allocate(size: number): (TInner[] | null)[];
 }
-export declare const List: <TInner>(inner: RegisteredDataType & DataType<TInner>) => ListType<TInner>;
+export declare const ArrayDataType: <TInner>(inner: RegisteredDataType & DataType<TInner>) => ArrayType<TInner>;
 export declare class StructType<TFields extends RowRecord = any> extends NestedDataType<TFields | null> {
     readonly fields: {
         [K in keyof TFields]: RegisteredDataType & DataType<TFields[K]>;
@@ -170,4 +170,4 @@ export declare class StructType<TFields extends RowRecord = any> extends NestedD
     allocate(size: number): (TFields | null)[];
 }
 export declare const Struct: <TFields extends RowRecord>(fields: { [K in keyof TFields]: RegisteredDataType & DataType<TFields[K]>; }) => StructType<TFields>;
-export type RegisteredDataType = Int8Type | Int16Type | Int32Type | Int64Type | UInt8Type | UInt16Type | UInt32Type | UInt64Type | Float32Type | Float64Type | DecimalType | BooleanType | Utf8Type | BinaryType | NullType | ObjectType | DateType | DatetimeType | TimeType | DurationType | ListType<any> | StructType<any>;
+export type RegisteredDataType = Int8Type | Int16Type | Int32Type | Int64Type | UInt8Type | UInt16Type | UInt32Type | UInt64Type | Float32Type | Float64Type | DecimalType | BooleanType | Utf8Type | BinaryType | NullType | ObjectType | DateType | DatetimeType | TimeType | DurationType | ArrayType<any> | StructType<any>;