df-script 1.4.0 → 1.5.0

package/dist/dataframe/grouped/grouped.d.ts

@@ -1,7 +1,6 @@
 import { DataFrame } from "../dataframe";
 import type { GroupMap } from "../types";
-import { DataType } from "../../datatypes";
-import type { IExpr, ColumnDict, RowRecord } from "../../types";
+import type { IExpr, ColumnDict, RowRecord, DataFrameSchema } from "../../types";
 export declare class GroupedData<T, K extends keyof T> {
     private groups;
     private keys;
@@ -9,7 +8,7 @@ export declare class GroupedData<T, K extends keyof T> {
     private parentColumns;
     private parentHeight;
     private parentSchema;
-    constructor(groups: GroupMap, keys: K[], allKeys: (keyof T)[], parentColumns: ColumnDict, parentHeight: number, parentSchema: Record<string, DataType>);
+    constructor(groups: GroupMap, keys: K[], allKeys: (keyof T)[], parentColumns: ColumnDict, parentHeight: number, parentSchema: DataFrameSchema);
     to_dataframe<U extends RowRecord = any>(): DataFrame<U>;
     agg<U extends RowRecord = any>(...exprs: (IExpr | any)[]): DataFrame<U>;
 }

package/dist/dataframe/grouped/grouped.js

@@ -46,7 +46,7 @@ class GroupedData {
         for (const k of keysStr) {
             outSchema[k] = this.parentSchema[k];
         }
-        return new dataframe_1.DataFrame(newColumns, outSchema, groupIdx);
+        return dataframe_1.DataFrame._createDirect(newColumns, outSchema, groupIdx);
     }
     agg(...exprs) {
         const allKeysLen = this.allKeys.length;
@@ -59,7 +59,7 @@ class GroupedData {
         for (let i = 0; i < keysLen; i++) {
             keysStr[i] = String(this.keys[i]);
         }
-        const expandedExprs = (0, columnExpressions_1.resolveColumnSelectors)(exprs.flat(), allKeysStr, keysStr);
+        const expandedExprs = (0, columnExpressions_1.resolveColumnSelectors)(exprs.flat(), allKeysStr, keysStr, this.parentSchema, this.parentColumns);
         const numGroups = this.groups.size;
         const newColumns = {};
         for (let i = 0; i < keysStr.length; i++) {
@@ -82,22 +82,23 @@ class GroupedData {
             const targetKey = e.outputName || e.colName || columnExpressions_1.ALL_COLUMNS_MARKER;
             if (!e.aggFn) {
                 newColumns[targetKey] = e.evaluate(newColumns, numGroups);
-                continue;
             }
-            const preGroupedCol = e.evaluatePreGrouping(this.parentColumns, this.parentHeight);
-            const aggregatedGroupValues = new Array(numGroups);
-            let gIdx = 0;
-            for (const indices of this.groups.values()) {
-                if (indices.length === 0)
-                    continue;
-                const groupValues = new Array(indices.length);
-                for (let k = 0; k < indices.length; k++) {
-                    groupValues[k] = preGroupedCol[indices[k]];
+            else {
+                const preGroupedCol = e.evaluatePre(e.groupingOpsIndex, this.parentColumns, this.parentHeight);
+                const aggregatedGroupValues = new Array(numGroups);
+                let gIdx = 0;
+                for (const indices of this.groups.values()) {
+                    if (indices.length === 0)
+                        continue;
+                    const groupValues = new Array(indices.length);
+                    for (let k = 0; k < indices.length; k++) {
+                        groupValues[k] = preGroupedCol[indices[k]];
+                    }
+                    aggregatedGroupValues[gIdx] = e.aggFn(groupValues);
+                    gIdx++;
                 }
-                aggregatedGroupValues[gIdx] = e.aggFn(groupValues);
-                gIdx++;
+                newColumns[targetKey] = e.evaluatePost(e.groupingOpsIndex, aggregatedGroupValues, newColumns);
             }
-            newColumns[targetKey] = e.evaluatePostGrouping(aggregatedGroupValues, newColumns);
         }
         const outSchema = {};
         for (const k of keysStr) {
@@ -107,7 +108,7 @@ class GroupedData {
             const targetKey = e.outputName || e.colName || columnExpressions_1.ALL_COLUMNS_MARKER;
             outSchema[targetKey] = (0, utils_1.inferColumnType)(newColumns[targetKey]);
         }
-        return new dataframe_1.DataFrame(newColumns, outSchema, groupIdx);
+        return dataframe_1.DataFrame._createDirect(newColumns, outSchema, groupIdx);
     }
 }
 exports.GroupedData = GroupedData;

package/dist/dataframe/types.d.ts

@@ -1,5 +1,7 @@
-import type { IExpr, AggFn, RowRecord } from "../types";
+import type { IExpr, AggFn, RowRecord, DataFrameSchema, JSONFormat } from "../types";
 import type { DataFrame } from "./dataframe";
+import type { JSONParseOptions, SafeJsonReplacerOptions, NDJSONParseOptions } from "../utils";
+export type { JSONParseOptions, SafeJsonReplacerOptions, NDJSONParseOptions };
 export type JoinType = "inner" | "left" | "outer" | "right";
 export type LimitPosition = "start" | "end";
 export type GroupMap = Map<string, number[]>;
@@ -31,3 +33,65 @@ export interface UnpivotOptions<T> {
     varName?: string;
     valueName?: string;
 }
+export interface TransposeOptions {
+    include_header?: boolean;
+    header_name?: string;
+    column_names?: string | Iterable<string>;
+}
+export interface ReadJSONOptions extends JSONParseOptions {
+    /**
+     * Optional explicit schema mapping column names to their registered data types.
+     */
+    schema?: DataFrameSchema;
+}
+/**
+ * The `replacer` argument type extracted directly from the overloads of the built-in `JSON.stringify`.
+ * Hover or Go-to-Definition on `JSON.stringify` below to inspect the standard library signatures.
+ */
+export type JSONStringifyReplacer = typeof JSON.stringify extends {
+    (value: any, replacer?: infer R1, space?: any): string;
+    (value: any, replacer?: infer R2, space?: any): string;
+} ? R1 | R2 : never;
+export interface WriteJSONOptions {
+    /**
+     * The format of the JSON output.
+     * @default "json"
+     */
+    format?: JSONFormat;
+    /**
+     * Options for the safe JSON replacer.
+     */
+    replacerOptions?: SafeJsonReplacerOptions;
+}
+export type { WriteCSVOptions } from "../utils";
+export interface ReadCSVOptions {
+    /**
+     * Whether the CSV has a header row.
+     * @default true
+     */
+    hasHeader?: boolean;
+    /**
+     * Character that separates fields.
+     * @default ","
+     */
+    separator?: string;
+    /**
+     * The character used for quoting fields.
+     * @default '"'
+     */
+    quoteChar?: string;
+    /**
+     * String representations of null values.
+     * @default ["", "NA", "null", "NaN"]
+     */
+    nullValues?: string[];
+    /**
+     * Optional explicit schema mapping column names to their registered data types.
+     */
+    schema?: DataFrameSchema;
+    /**
+     * Try to infer types from values if no schema is provided.
+     * @default true
+     */
+    inferSchema?: boolean;
+}

package/dist/dataframe/utils.d.ts

@@ -1,5 +1,4 @@
-import type { IExpr, ColumnData, ColumnDict } from "../types";
-import { DataType } from "../datatypes";
+import type { IExpr, ColumnData, ColumnDict, RegisteredDataType } from "../types";
 export declare function resolveWindowExpr(expr: IExpr, columns: ColumnDict, height: number): ColumnData;
 export declare function rowsToColumns(rows: any[]): {
     columns: ColumnDict;
@@ -7,5 +6,14 @@ export declare function rowsToColumns(rows: any[]): {
 };
 export declare function columnsToRows(columns: ColumnDict, height: number): any[];
 export declare function getRowFromColumns(columns: ColumnDict, idx: number, keys: string[]): any;
-export declare function inferColumnType(col: ColumnData): DataType;
+export declare function inferColumnType(col: ColumnData): RegisteredDataType;
 export declare function gatherColumnsByIndices(columns: ColumnDict, indices: number[]): ColumnDict;
+/**
+ * Computes a hash string for a row at the given index, using one or more column keys.
+ * Includes a single-key fast path to avoid array allocation and join overhead.
+ */
+export declare function computeRowHash(columns: ColumnDict, keys: string[], rowIndex: number): string;
+export declare function coerceColumn(col: ColumnData, type: RegisteredDataType, height: number): ColumnData;
+export declare function writeStringToFileOrStream(file: string | {
+    write: (str: string) => void;
+} | undefined, content: string): void;

package/dist/dataframe/utils.js

@@ -6,6 +6,9 @@ exports.columnsToRows = columnsToRows;
 exports.getRowFromColumns = getRowFromColumns;
 exports.inferColumnType = inferColumnType;
 exports.gatherColumnsByIndices = gatherColumnsByIndices;
+exports.computeRowHash = computeRowHash;
+exports.coerceColumn = coerceColumn;
+exports.writeStringToFileOrStream = writeStringToFileOrStream;
 const datatypes_1 = require("../datatypes");
 const constants_1 = require("./constants");
 const utils_1 = require("../utils");
@@ -24,11 +27,25 @@ function partition_by_columns(columns, height, partitionKeys) {
             keyColumns[i] = pKey.evaluate(columns, height);
         }
     }
+    if (pKeysLen === 1) {
+        const keyCol = keyColumns[0];
+        for (let i = 0; i < height; i++) {
+            const val = keyCol[i];
+            const hash = val == null ? "" : (0, utils_1.toCanonicalString)(val);
+            let group = partitionMap.get(hash);
+            if (group === undefined) {
+                group = [];
+                partitionMap.set(hash, group);
+            }
+            group.push(i);
+        }
+        return partitionMap;
+    }
     for (let i = 0; i < height; i++) {
-        const keyValues = new Array(keyColumns.length);
-        for (let j = 0; j < keyColumns.length; j++) {
+        const keyValues = new Array(pKeysLen);
+        for (let j = 0; j < pKeysLen; j++) {
             const val = keyColumns[j][i];
-            keyValues[j] = val == null ? "" : String(val);
+            keyValues[j] = val == null ? "" : (0, utils_1.toCanonicalString)(val);
         }
         const hash = keyValues.join(constants_1.KEY_SEPARATOR);
         let group = partitionMap.get(hash);
@@ -46,7 +63,7 @@ function resolveWindowExpr(expr, columns, height) {
         return results;
     const partitionKeys = expr.partitionBy || [];
     const partitionGroups = partition_by_columns(columns, height, partitionKeys);
-    const prePartitionArray = expr.evaluatePrePartition(columns, height);
+    const prePartitionArray = expr.evaluatePre(expr.partitionOpsIndex, columns, height);
     for (const indices of partitionGroups.values()) {
         const groupLen = indices.length;
         const groupPreValues = new Array(groupLen);
@@ -70,7 +87,7 @@ function resolveWindowExpr(expr, columns, height) {
             results[indices[k]] = prePartitionArray[indices[k]];
         }
     }
-    return expr.evaluatePostPartition(results, columns);
+    return expr.evaluatePost(expr.partitionOpsIndex, results, columns);
 }
 function rowsToColumns(rows) {
     if (!Array.isArray(rows) || rows.length === 0) {
@@ -134,6 +151,8 @@ function inferColumnType(col) {
     let isBigInt = true;
     let isDate = true;
     let isList = true;
+    let isBinary = true;
+    let isObject = true;
     let hasDateObj = false;
     let hasNonNull = false;
     const allListElements = [];
@@ -142,12 +161,17 @@ function inferColumnType(col) {
         if (val == null)
             continue;
         hasNonNull = true;
-        if (!Array.isArray(val)) {
+        if (!(val instanceof Uint8Array)) {
+            isBinary = false;
+        }
+        if (!(0, utils_1.isArrayOrTypedArray)(val) || val instanceof Uint8Array) {
             isList = false;
         }
         else {
-            for (let j = 0; j < val.length; j++) {
-                allListElements.push(val[j]);
+            const valArr = val;
+            const subLen = valArr.length;
+            for (let j = 0; j < subLen; j++) {
+                allListElements.push(valArr[j]);
             }
         }
         if (val instanceof Date)
@@ -167,9 +191,14 @@ function inferColumnType(col) {
         if (!(val instanceof Date) && (typeof val !== "string" || isNaN(Date.parse(val)))) {
             isDate = false;
         }
+        if (!(0, utils_1.isObj)(val) || val instanceof Date || val instanceof Uint8Array || Array.isArray(val)) {
+            isObject = false;
+        }
     }
     if (!hasNonNull)
         return datatypes_1.DataTypeRegistry.Utf8;
+    if (isBinary)
+        return datatypes_1.DataTypeRegistry.Binary;
     if (isList) {
         const innerType = inferColumnType(allListElements);
         return datatypes_1.DataTypeRegistry.List(innerType);
@@ -195,6 +224,8 @@ function inferColumnType(col) {
     }
     if (isDate && hasDateObj)
         return datatypes_1.DataTypeRegistry.Datetime;
+    if (isObject)
+        return datatypes_1.DataTypeRegistry.Object;
     return datatypes_1.DataTypeRegistry.Utf8;
 }
 function gatherColumnsByIndices(columns, indices) {
@@ -205,7 +236,9 @@ function gatherColumnsByIndices(columns, indices) {
     for (let j = 0; j < numKeys; j++) {
         const k = keys[j];
         const oldCol = columns[k];
-        const newCol = new Array(newHeight);
+        const newCol = (0, utils_1.isTypedArray)(oldCol)
+            ? new oldCol.constructor(newHeight)
+            : new Array(newHeight);
         for (let idx = 0; idx < newHeight; idx++) {
             newCol[idx] = oldCol[indices[idx]];
         }
@@ -213,3 +246,62 @@ function gatherColumnsByIndices(columns, indices) {
     }
     return res;
 }
+/**
+ * Computes a hash string for a row at the given index, using one or more column keys.
+ * Includes a single-key fast path to avoid array allocation and join overhead.
+ */
+function computeRowHash(columns, keys, rowIndex) {
+    const len = keys.length;
+    if (len === 1) {
+        const val = columns[keys[0]][rowIndex];
+        return val == null ? "" : (0, utils_1.toCanonicalString)(val);
+    }
+    const vals = new Array(len);
+    for (let i = 0; i < len; i++) {
+        const val = columns[keys[i]][rowIndex];
+        vals[i] = val == null ? "" : (0, utils_1.toCanonicalString)(val);
+    }
+    return vals.join(constants_1.KEY_SEPARATOR);
+}
+function coerceColumn(col, type, height) {
+    let newCol = type.allocate ? type.allocate(height) : new Array(height);
+    const isTyped = (0, utils_1.isTypedArray)(newCol);
+    if (isTyped) {
+        const typedCol = newCol;
+        for (let i = 0; i < height; i++) {
+            const coerced = type.coerce(col[i]);
+            if (coerced == null) {
+                const fallback = new Array(height);
+                for (let j = 0; j < i; j++) {
+                    fallback[j] = typedCol[j];
+                }
+                fallback[i] = null;
+                for (let j = i + 1; j < height; j++) {
+                    fallback[j] = type.coerce(col[j]);
+                }
+                return fallback;
+            }
+            typedCol[i] = coerced;
+        }
+    }
+    else {
+        for (let i = 0; i < height; i++) {
+            newCol[i] = type.coerce(col[i]);
+        }
+    }
+    return newCol;
+}
+function writeStringToFileOrStream(file, content) {
+    if (!file)
+        return;
+    if (typeof file === "string") {
+        const fs = require("fs");
+        fs.writeFileSync(file, content, "utf8");
+    }
+    else if (typeof file === "object" && typeof file.write === "function") {
+        file.write(content);
+    }
+    else {
+        throw new TypeError("Invalid file argument. Expected a file path string or a writable stream/object with a write method.");
+    }
+}

package/dist/datatypes/DataType.d.ts

@@ -1,8 +1,9 @@
 export declare abstract class DataType<T = any> {
     abstract readonly name: string;
-    abstract coerce(val: any): T;
+    abstract coerce(val: unknown): T;
     abstract equals(other: DataType): boolean;
     abstract allocate(size: number): ArrayLike<T>;
+    matches(selector: any): boolean;
     get isNumeric(): boolean;
     get isInteger(): boolean;
     get isFloat(): boolean;

package/dist/datatypes/DataType.js

@@ -2,6 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NestedDataType = exports.TemporalDataType = exports.FloatDataType = exports.UnsignedIntegerType = exports.SignedIntegerType = exports.IntegerDataType = exports.NumericDataType = exports.DataType = void 0;
 class DataType {
+    matches(selector) {
+        if (selector == null)
+            return false;
+        if (selector instanceof DataType) {
+            if (this.equals(selector))
+                return true;
+            if (this.name.startsWith("Decimal") && selector.name.startsWith("Decimal")) {
+                if (selector.precision === undefined && selector.scale === undefined) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if (typeof selector === "function") {
+            if (selector.prototype instanceof DataType) {
+                return this instanceof selector;
+            }
+            try {
+                const dummy = selector();
+                if (dummy instanceof DataType) {
+                    return this.constructor === dummy.constructor;
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return false;
+    }
     get isNumeric() { return false; }
     get isInteger() { return false; }
     get isFloat() { return false; }

package/dist/datatypes/index.d.ts

@@ -22,8 +22,8 @@ export declare const DataTypeRegistry: {
     Duration: import("./types").DurationType;
     Object: import("./types").ObjectType;
     Null: import("./types").NullType;
-    List: <TInner>(inner: BaseDataType<TInner>) => import("./types").ListType<TInner>;
-    Struct: <TFields extends import("..").RowRecord>(fields: { [K in keyof TFields]: BaseDataType<TFields[K]>; }) => import("./types").StructType<TFields>;
+    List: <TInner>(inner: import("./types").RegisteredDataType & BaseDataType<TInner>) => import("./types").ListType<TInner>;
+    Struct: <TFields extends import("..").RowRecord>(fields: { [K in keyof TFields]: import("./types").RegisteredDataType & BaseDataType<TFields[K]>; }) => import("./types").StructType<TFields>;
 };
 export * from "./types";
 export * from "./DataType";

package/dist/datatypes/types.d.ts

@@ -2,70 +2,70 @@ import { DataType, SignedIntegerType, UnsignedIntegerType, FloatDataType, Tempor
 import type { RowRecord } from "../types";
 export declare class Int8Type extends SignedIntegerType {
     readonly name = "Int8";
-    coerce(val: any): number | null;
+    coerce(val: unknown): number | null;
     equals(other: DataType): boolean;
     allocate(size: number): Int8Array;
 }
 export declare const Int8: Int8Type;
 export declare class Int16Type extends SignedIntegerType {
     readonly name = "Int16";
-    coerce(val: any): number | null;
+    coerce(val: unknown): number | null;
     equals(other: DataType): boolean;
     allocate(size: number): Int16Array;
 }
 export declare const Int16: Int16Type;
 export declare class Int32Type extends SignedIntegerType {
     readonly name = "Int32";
-    coerce(val: any): number | null;
+    coerce(val: unknown): number | null;
     equals(other: DataType): boolean;
     allocate(size: number): Int32Array;
 }
 export declare const Int32: Int32Type;
 export declare class Int64Type extends SignedIntegerType<bigint | null> {
     readonly name = "Int64";
-    coerce(val: any): bigint | null;
+    coerce(val: unknown): bigint | null;
     equals(other: DataType): boolean;
     allocate(size: number): BigInt64Array;
 }
 export declare const Int64: Int64Type;
 export declare class UInt8Type extends UnsignedIntegerType {
     readonly name = "UInt8";
-    coerce(val: any): number | null;
+    coerce(val: unknown): number | null;
     equals(other: DataType): boolean;
     allocate(size: number): Uint8Array;
 }
 export declare const UInt8: UInt8Type;
 export declare class UInt16Type extends UnsignedIntegerType {
     readonly name = "UInt16";
-    coerce(val: any): number | null;
+    coerce(val: unknown): number | null;
     equals(other: DataType): boolean;
     allocate(size: number): Uint16Array;
 }
 export declare const UInt16: UInt16Type;
 export declare class UInt32Type extends UnsignedIntegerType {
     readonly name = "UInt32";
-    coerce(val: any): number | null;
+    coerce(val: unknown): number | null;
     equals(other: DataType): boolean;
     allocate(size: number): Uint32Array;
 }
 export declare const UInt32: UInt32Type;
 export declare class UInt64Type extends UnsignedIntegerType<bigint | null> {
     readonly name = "UInt64";
-    coerce(val: any): bigint | null;
+    coerce(val: unknown): bigint | null;
     equals(other: DataType): boolean;
     allocate(size: number): BigUint64Array;
 }
 export declare const UInt64: UInt64Type;
 export declare class Float32Type extends FloatDataType {
     readonly name = "Float32";
-    coerce(val: any): number | null;
+    coerce(val: unknown): number | null;
     equals(other: DataType): boolean;
     allocate(size: number): Float32Array;
 }
 export declare const Float32: Float32Type;
 export declare class Float64Type extends FloatDataType {
     readonly name = "Float64";
-    coerce(val: any): number | null;
+    coerce(val: unknown): number | null;
     equals(other: DataType): boolean;
     allocate(size: number): Float64Array;
 }
@@ -75,39 +75,39 @@ export declare class DecimalType extends NumericDataType {
     readonly scale?: number | undefined;
     readonly name: string;
     constructor(precision?: number | undefined, scale?: number | undefined);
-    coerce(val: any): number | null;
+    coerce(val: unknown): number | null;
     equals(other: DataType): boolean;
     allocate(size: number): (number | null)[];
 }
-export declare class BooleanType extends DataType {
+export declare class BooleanType extends DataType<boolean | null> {
     readonly name = "Boolean";
     get isBoolean(): boolean;
-    coerce(val: any): boolean | null;
+    coerce(val: unknown): boolean | null;
     equals(other: DataType): boolean;
     allocate(size: number): (boolean | null)[];
 }
 export declare const Boolean: BooleanType;
-export declare class Utf8Type extends DataType {
+export declare class Utf8Type extends DataType<string | null> {
     readonly name = "Utf8";
     get isString(): boolean;
     get isUtf8(): boolean;
-    coerce(val: any): string | null;
+    coerce(val: unknown): string | null;
     equals(other: DataType): boolean;
     allocate(size: number): (string | null)[];
 }
 export declare const Utf8: Utf8Type;
-export declare class BinaryType extends DataType {
+export declare class BinaryType extends DataType<Uint8Array | null> {
     readonly name = "Binary";
     get isBinary(): boolean;
-    coerce(val: any): Uint8Array | null;
+    coerce(val: unknown): Uint8Array | null;
     equals(other: DataType): boolean;
     allocate(size: number): (Uint8Array | null)[];
 }
 export declare const Binary: BinaryType;
-export declare class NullType extends DataType {
+export declare class NullType extends DataType<null> {
     readonly name = "Null";
     get isNull(): boolean;
-    coerce(_val: any): null;
+    coerce(_val: unknown): null;
     equals(other: DataType): boolean;
     allocate(size: number): null[];
 }
@@ -115,58 +115,59 @@ export declare const Null: NullType;
 export declare class ObjectType extends DataType {
     readonly name = "Object";
     get isObject(): boolean;
-    coerce(val: any): any;
+    coerce(val: unknown): any;
     equals(other: DataType): boolean;
     allocate(size: number): any[];
 }
 export declare const Object: ObjectType;
-export declare class DateType extends TemporalDataType {
+export declare class DateType extends TemporalDataType<Date | null> {
     readonly name = "Date";
-    coerce(val: any): Date | null;
+    coerce(val: unknown): Date | null;
     equals(other: DataType): boolean;
     allocate(size: number): (Date | null)[];
 }
 export declare const Date: DateType;
-export declare class DatetimeType extends TemporalDataType {
+export declare class DatetimeType extends TemporalDataType<Date | null> {
     readonly name = "Datetime";
-    coerce(val: any): Date | null;
+    coerce(val: unknown): Date | null;
     equals(other: DataType): boolean;
     allocate(size: number): (Date | null)[];
 }
 export declare const Datetime: DatetimeType;
-export declare class TimeType extends TemporalDataType {
+export declare class TimeType extends TemporalDataType<string | null> {
     readonly name = "Time";
-    coerce(val: any): string | null;
+    coerce(val: unknown): string | null;
     equals(other: DataType): boolean;
     allocate(size: number): (string | null)[];
 }
 export declare const Time: TimeType;
-export declare class DurationType extends TemporalDataType {
+export declare class DurationType extends TemporalDataType<number | null> {
     readonly name = "Duration";
-    coerce(val: any): number | null;
+    coerce(val: unknown): number | null;
     equals(other: DataType): boolean;
     allocate(size: number): (number | null)[];
 }
 export declare const Duration: DurationType;
 export declare class ListType<TInner = any> extends NestedDataType<TInner[] | null> {
-    readonly innerType: DataType<TInner>;
+    readonly innerType: RegisteredDataType & DataType<TInner>;
     readonly name = "List";
-    constructor(innerType: DataType<TInner>);
-    coerce(val: any): TInner[] | null;
+    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: DataType<TInner>) => ListType<TInner>;
+export declare const List: <TInner>(inner: RegisteredDataType & DataType<TInner>) => ListType<TInner>;
 export declare class StructType<TFields extends RowRecord = any> extends NestedDataType<TFields | null> {
     readonly fields: {
-        [K in keyof TFields]: DataType<TFields[K]>;
+        [K in keyof TFields]: RegisteredDataType & DataType<TFields[K]>;
     };
     readonly name = "Struct";
     constructor(fields: {
-        [K in keyof TFields]: DataType<TFields[K]>;
+        [K in keyof TFields]: RegisteredDataType & DataType<TFields[K]>;
     });
-    coerce(val: any): TFields | null;
+    coerce(val: unknown): TFields | null;
     equals(other: DataType): boolean;
     allocate(size: number): (TFields | null)[];
 }
-export declare const Struct: <TFields extends RowRecord>(fields: { [K in keyof TFields]: DataType<TFields[K]>; }) => StructType<TFields>;
+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>;