@web-ts-toolkit/json-frame 0.40.1 → 0.42.0

package/README.md

@@ -2,7 +2,7 @@
 
 Normalize pandas `DataFrame.to_json()` payloads into one immutable, column-major `DataFrame` API for TypeScript.
 
-`@web-ts-toolkit/json-frame` accepts a JSON string or parsed JSON value, ingests all six pandas DataFrame JSON orients, keeps row order and supported index labels intact, and exports back to every supported orient without adding runtime dependencies.
+`@web-ts-toolkit/json-frame` accepts a JSON string or parsed JSON value, ingests all six pandas DataFrame JSON orients, and exports back to every supported orient without adding runtime dependencies. `split` and `table` preserve source row order exactly; object-key orients use JavaScript property enumeration order, so integer-like keys can be reordered.
 
 ## Installation
 
@@ -18,15 +18,17 @@ import { fromOrient } from '@web-ts-toolkit/json-frame';
 
 The package exports named values and types from the package root. There is no default export and no supported deep import path.
 
+`JSON_FRAME_MAX_DEPTH` is `1000`. JSON arrays and objects are counted from the parsed root at depth `0`; an array or object reached at depth `1000` is accepted, and one reached at depth `1001` fails with `JsonFrameValidationError` before package traversal can exhaust the JavaScript stack.
+
 ## Quick Start
 
 ```ts
 import { fromOrient } from '@web-ts-toolkit/json-frame';
 
-type WeatherRow = {
+interface WeatherRow {
   city: string;
   temp: number;
-};
+}
 
 const frame = fromOrient<WeatherRow>('[{"city":"Paris","temp":21},{"city":"Rome","temp":30}]');
 const hottest = frame.sort((left, right) => right.temp - left.temp).row(0);
@@ -42,6 +44,8 @@ void [hottest, split];
 
 The returned `DataFrame` is immutable. `filter`, `sort`, `select`, `rename`, and `resetIndex` all return new frames.
 
+The `TRow` generic is a compile-time row model only. It improves `row()`, `rows()`, `filter()`, and `sort()` types for JSON-compatible domain interfaces, but it does not validate an application schema at runtime; payload validation follows the selected orient contract.
+
 ## Supported Orients
 
 All six pandas DataFrame JSON orients are supported.
@@ -88,22 +92,29 @@ const tablePayload = {
       { name: 'temp', type: 'integer' },
     ],
     primaryKey: ['row_id'],
-    pandas_version: '3.0.3',
+    pandas_version: '1.4.0',
   },
   data: [{ row_id: 'row_1', city: 'Paris', temp: 21 }],
 } satisfies TablePayload;
 
 const tableFrame = fromOrient(tablePayload, { orient: 'table' });
 
-void [recordsFrame, indexFrame, columnsFrame, valuesFrame, splitFrame, tableFrame];
+const splitRoundTrip = fromOrient(splitFrame.toSplit(), { orient: 'split' });
+const tableRoundTrip = fromOrient(tableFrame.toTable(), { orient: 'table' });
+
+void [recordsFrame, indexFrame, columnsFrame, valuesFrame, splitFrame, tableFrame, splitRoundTrip, tableRoundTrip];
 ```
 
 Orient notes:
 
 - `records` and `values` do not carry source index labels. They receive a synthetic numeric index `0..n-1`.
 - `index`, `columns`, `split`, and `table` preserve supported source index labels.
-- `values` always requires `options.columns`, including empty input.
+- `index` and `columns` derive row order from JavaScript object property enumeration. Integer-like keys such as `"10"` and `"2"` enumerate in numeric order after `JSON.parse()` or when supplied as parsed objects, even if the JSON text listed `"10"` first.
+- Use `split` or `table` when exact row order matters for integer-like index labels.
+- Non-empty `values` arrays are auto-detected, but `values` always requires `options.columns` because the payload carries no column labels.
+- Empty `values` input requires both `orient: 'values'` and `columns`.
 - `index` and `columns` are distinct supported payloads, but auto-detection cannot safely distinguish them from nested-object structure alone.
+- In Table Schema payloads, `schema.pandas_version` is the Table Schema format version emitted by pandas, commonly `"1.4.0"`; it is not the installed pandas package version.
 
 ## Auto Detection And Options
 
@@ -126,7 +137,7 @@ Pass an explicit orient for:
 
 Other `fromOrient` options:
 
-- `columns`: required for `orient: 'values'`
+- `columns`: required whenever the payload is `values`, including non-empty `values` arrays detected by `auto`
 - `columnTypes`: explicit logical types for non-table inputs
 - `packThreshold`: minimum length for internal numeric typed-array packing; `0` disables packing
 
@@ -189,11 +200,11 @@ Exporters:
 ```ts
 import { fromOrient } from '@web-ts-toolkit/json-frame';
 
-type WeatherRow = {
+interface WeatherRow {
   city: string;
   temp: number | null;
   coastal: boolean;
-};
+}
 
 const frame = fromOrient<WeatherRow>(
   [
@@ -231,7 +242,25 @@ Transform behavior:
 - filtering and sorting preserve index labels
 - `resetIndex()` is the only transform that replaces the current index with `0..n-1`
 - `rename` ignores keys that are not current columns and rejects duplicate results
-- exporters always return fresh JSON-compatible containers
+- exporters return fresh top-level JSON-compatible arrays/records for the exported orient
+
+Structural immutability is shallow. Frame-owned arrays, row records, exporter containers, table schema records, and internal maps are protected from direct mutation or are freshly allocated. Nested JSON object or array cell values are not deep-frozen or deep-cloned on every read/export; if caller code mutates one of those nested values after obtaining it from `row()`, `rows()`, or an exporter, another read of the same cell may observe that mutation.
+
+```ts
+import { fromOrient } from '@web-ts-toolkit/json-frame';
+
+const frame = fromOrient([{ city: 'Paris', details: { tags: ['capital'] } }], { orient: 'records' });
+const exported = frame.toRecords();
+const details = exported[0]!.details as { tags: string[] };
+
+details.tags.push('visited');
+
+const reread = frame.row(0).details as { tags: readonly string[] };
+
+void reread.tags;
+```
+
+Treat nested object/array cells as caller-owned mutable JSON values. Clone them at your application boundary if you need deep immutability.
 
 ## Logical Types And Packing
 
@@ -250,10 +279,16 @@ Supported logical types:
 
 Type rules:
 
-- Table Schema metadata is authoritative when `orient: 'table'` is used.
+- Table Schema metadata is preserved when `orient: 'table'` is used; pandas-authored field metadata remains caller/pandas responsibility.
 - Other orients infer the narrowest logical type by scanning the full column.
+- `options.columnTypes` supplies explicit logical types for non-table inputs. Declared types are validated against every non-null cell before packing; incompatible cells fail with `JsonFrameValidationError` carrying `path`, `row`, `column`, and `value` diagnostics.
+- Explicit `integer`, `float`, `string`, and `boolean` require matching JSON scalar cells. `float` accepts integer JSON numbers because Table Schema `number` accepts both integer and fractional JSON numbers.
+- Explicit `datetime` accepts pandas-style timezone-naive ISO date/datetime strings such as `2024-01-02T03:04:05.000`, `2024-01-02 03:04:05`, or `2024-01-02`. Numeric epoch cells are rejected because generated Table Schema has no unit metadata and pandas reads numeric `datetime` cells as nanoseconds.
+- Explicit `categorical` accepts non-null scalar JSON cells (`string`, `number`, or `boolean`) and generated table output emits `type: 'any'` with `extDtype: 'category'` unless source Table Schema field metadata is being preserved.
+- Explicit `mixed` and `unknown` accept any JSON-compatible cell value.
 - `null` marks a column as nullable without forcing an otherwise numeric column to become `mixed`.
-- ISO-looking strings are preserved as strings unless table metadata or explicit `columnTypes` says otherwise.
+- ISO-looking strings are preserved as strings unless table metadata or compatible explicit `columnTypes` says otherwise.
+- Values are never coerced to satisfy logical type metadata.
 
 Packing rules:
 
@@ -266,12 +301,16 @@ Packing rules:
 
 Round trips are semantic rather than byte-for-byte.
 
-- column order, row order, and cell JSON values are preserved
-- label-bearing orients preserve supported source index labels
+- column order and cell JSON values are preserved
+- `split` and `table` preserve row order exactly
+- `index` and `columns` row order follows JavaScript property enumeration for object keys; use `split` or `table` when exact order matters for integer-like labels
+- label-bearing orients preserve supported source index labels, subject to object-key stringification for `index`/`columns`
 - `records` and `values` use a synthetic numeric index because the wire format does not carry labels
 - `toRecords()` and `toValues()` never invent an `_index` column
 - `toIndex()` and `toColumns()` stringify index labels as JSON object keys and throw if distinct labels would collide after stringification
-- `toTable()` emits valid Table Schema and omits a synthetic index from table output
+- `toTable()` emits valid Table Schema, omits a synthetic index from table output, and rejects duplicate source index labels because emitted table primary keys must be unique
+- table primary-key equality uses JavaScript `Map`/SameValueZero semantics for supported string and finite-number labels, so numeric `1` and string `'1'` are distinct table labels even though object-key exporters reject them as stringification collisions
+- Table Schema metadata is cloned under the same `JSON_FRAME_MAX_DEPTH` policy used while parsing. `toTable()` and `toJSONString('table')` report over-depth metadata as `JsonFrameValidationError`.
 
 ## Errors
 
@@ -279,11 +318,31 @@ Structured runtime errors are exported from the package root.
 
 - `JsonFrameParseError`: invalid JSON string input; original `SyntaxError` is available as `cause`
 - `JsonFrameOptionError`: invalid options such as bad `packThreshold` or missing `columns` for `values`
-- `JsonFrameValidationError`: payload shape or JSON-value validation failure
+- `JsonFrameValidationError`: payload shape, transform argument, or JSON-value validation failure
 - `AmbiguousOrientError`: `auto` mode cannot distinguish between multiple valid orients
 - `UnsupportedFeatureError`: supported contract deliberately excludes the requested pandas feature
 - `ExportKeyCollisionError`: object-key exporters would collapse distinct index labels to the same JSON key
 
+`JsonFrameError` instances expose `orient`, `path`, `row`, `column`, and `value` when relevant. Scalar JSON diagnostic values (`string`, finite or non-finite `number`, `boolean`, `null`) are retained directly. Arrays, objects, functions, symbols, bigints, undefined values, and cyclic containers are replaced with small frozen summaries, so retaining an error does not retain caller-owned payloads and `JSON.stringify(error)` does not invoke user serialization hooks.
+
+Diagnostic summary shapes are:
+
+```ts
+type JsonFrameDiagnosticValue =
+  | string
+  | number
+  | boolean
+  | null
+  | { readonly kind: 'array'; readonly length: number }
+  | {
+      readonly kind: 'object';
+      readonly keyCount: number;
+      readonly keys: readonly string[];
+      readonly truncated: boolean;
+    }
+  | { readonly kind: 'undefined' | 'symbol' | 'bigint' | 'function' };
+```
+
 ## Unsupported Pandas Features In The Initial Release
 
 - MultiIndex input or output

package/index.d.mts

@@ -6,8 +6,29 @@ type JsonArray = readonly JsonValue[];
 interface JsonObject {
     readonly [key: string]: JsonValue;
 }
-/** Any JSON-compatible value accepted by `fromOrient` payloads and exporters. */
+/**
+ * Any JSON-compatible value accepted by `fromOrient` payloads and exporters.
+ * Arrays/objects may nest up to `JSON_FRAME_MAX_DEPTH` levels from the parsed
+ * root value; deeper containers fail with `JsonFrameValidationError`.
+ */
 type JsonValue = JsonPrimitive | JsonArray | JsonObject;
+/**
+ * Recursive compile-time JSON compatibility check for domain row interfaces.
+ *
+ * This lets ordinary interfaces with known JSON-compatible properties be used
+ * as `DataFrame` row models without requiring a string index signature. It is
+ * only a TypeScript constraint; runtime validation still follows the selected
+ * orient and does not validate application schemas from `TRow`.
+ */
+type JsonCompatible<T> = T extends JsonPrimitive ? T : T extends (...args: never[]) => unknown ? never : T extends readonly (infer TItem)[] ? readonly JsonCompatible<TItem>[] : T extends object ? {
+    readonly [K in keyof T]: JsonCompatible<T[K]>;
+} : never;
+/** Object-shaped row model whose known properties are JSON-compatible. */
+type JsonCompatibleRow<TRow extends object> = {
+    readonly [K in keyof TRow]: JsonCompatible<TRow[K]>;
+};
+/** Default row shape used when callers do not provide a domain row model. */
+type JsonRow = Record<string, JsonValue>;
 /** pandas orient names supported by `fromOrient`. */
 type ResolvedOrient = 'records' | 'index' | 'columns' | 'values' | 'split' | 'table';
 /** Orient selection for `fromOrient`. `auto` performs structural detection when possible. */
@@ -20,27 +41,39 @@ type IndexLabel = string | number;
 type IndexKind = 'source' | 'synthetic';
 /** Parsed payload for `orient='records'`. */
 type RecordsPayload = readonly JsonObject[];
-/** Parsed payload for `orient='index'`. */
+/**
+ * Parsed payload for `orient='index'`.
+ *
+ * Row order follows JavaScript property enumeration for object keys, including
+ * numeric ordering of integer-like keys. Use `SplitPayload` or `TablePayload`
+ * when exact row order matters for integer-like index labels.
+ */
 type IndexPayload = Readonly<Record<string, JsonObject>>;
-/** Parsed payload for `orient='columns'`. */
+/**
+ * Parsed payload for `orient='columns'`.
+ *
+ * Row order follows JavaScript property enumeration for each column object's
+ * index keys, including numeric ordering of integer-like keys. Use
+ * `SplitPayload` or `TablePayload` when exact row order matters for
+ * integer-like index labels.
+ */
 type ColumnsPayload = Readonly<Record<string, JsonObject>>;
 /** Parsed payload for `orient='values'`. */
 type ValuesPayload = readonly JsonArray[];
 /** Parsed payload for `orient='split'`. */
-interface SplitPayload {
+interface SplitPayload extends JsonObject {
     readonly columns: readonly ColumnLabel[];
     readonly index: readonly IndexLabel[];
     readonly data: readonly JsonArray[];
 }
 /** Known Frictionless/Table Schema field types emitted by pandas. */
 type TableSchemaFieldType = 'any' | 'array' | 'boolean' | 'date' | 'datetime' | 'duration' | 'geojson' | 'integer' | 'number' | 'object' | 'string' | 'year' | 'yearmonth' | (string & {});
+type JsonMetadata = Readonly<Record<string, JsonValue>>;
 /** Table Schema constraint metadata preserved when present. */
-interface TableSchemaConstraints {
+type TableSchemaConstraints = JsonMetadata & {
     /** Enumerated allowed scalar values, commonly used for pandas categoricals. */
     readonly enum?: readonly JsonPrimitive[];
-    readonly [key: string]: JsonValue | undefined;
-}
-type JsonMetadata = Readonly<Record<string, JsonValue | undefined>>;
+};
 /** Table Schema field metadata preserved during table ingestion and export. */
 type TableSchemaField = JsonMetadata & {
     readonly name: string;
@@ -56,14 +89,25 @@ type TableSchemaField = JsonMetadata & {
 type TableSchema = JsonMetadata & {
     readonly fields: readonly TableSchemaField[];
     readonly primaryKey?: readonly string[];
+    /** Table Schema format version emitted by pandas, not the installed pandas package version. */
     readonly pandas_version?: string;
 };
 /** Parsed payload for `orient='table'`. */
-interface TablePayload {
+interface TablePayload extends JsonObject {
     readonly schema: TableSchema;
     readonly data: readonly JsonObject[];
 }
-/** Logical column types inferred or preserved by the frame. */
+/**
+ * Logical column types inferred, preserved from Table Schema, or supplied with
+ * `options.columnTypes`.
+ *
+ * Explicit non-table `columnTypes` are validated against non-null cells without
+ * coercion. `datetime` accepts pandas-style timezone-naive ISO date/datetime
+ * strings for generated Table Schema output, not numeric epoch values.
+ * `categorical` accepts non-null scalar JSON values and exports as Table Schema
+ * `type: 'any'` with `extDtype: 'category'` when no source field metadata is
+ * available. `mixed` and `unknown` accept any JSON-compatible cell value.
+ */
 type ColumnType = 'integer' | 'float' | 'string' | 'boolean' | 'datetime' | 'categorical' | 'mixed' | 'unknown';
 /** Public logical type metadata for a stored column. */
 interface ColumnInfo {
@@ -75,16 +119,21 @@ interface ColumnInfo {
 /**
  * Options for `fromOrient`.
  *
- * `columns` is required only for explicit `values` input because that orient
- * carries no column labels. `columnTypes` supplies explicit logical metadata
- * for label-preserving orients that do not carry Table Schema field types.
+ * `columns` is required whenever the payload is `values`, including non-empty
+ * `values` arrays detected by `auto`, because that orient carries no column
+ * labels. `columnTypes` supplies explicit logical metadata for label-preserving
+ * orients that do not carry Table Schema field types.
  */
 interface FromOrientOptions {
     /** Explicit orient, or `auto` to detect only structurally unambiguous shapes. */
     readonly orient?: Orient;
-    /** Explicit column names used when parsing `orient='values'`. */
+    /** Explicit column names used whenever parsing a `values` payload. */
     readonly columns?: readonly ColumnLabel[];
-    /** Explicit logical column types applied after parsing when no Table Schema is present. */
+    /**
+     * Explicit logical column types applied after parsing when no Table Schema is
+     * present. Non-null cells must already be compatible; values are never
+     * coerced to satisfy the declared logical type.
+     */
     readonly columnTypes?: Readonly<Partial<Record<ColumnLabel, ColumnType>>>;
     /** Packing threshold for typed-array storage. `0` disables packing. */
     readonly packThreshold?: number;
@@ -101,9 +150,12 @@ type ToJSONStringOptions = ToTableOptions;
  *
  * Instances are created by `fromOrient()`. The generic row type improves row
  * and callback ergonomics only; runtime validation still follows the JSON
- * Frame contracts for the selected orient.
+ * Frame contracts for the selected orient. Immutability is structural and
+ * shallow: frame-owned arrays, records, and maps are protected, but nested JSON
+ * cell objects/arrays returned from rows or exporters may retain identity and
+ * remain caller-mutable.
  */
-interface DataFrame<TRow extends Record<string, JsonValue> = Record<string, JsonValue>> {
+interface DataFrame<TRow extends JsonCompatibleRow<TRow> = JsonRow> {
     readonly columns: readonly string[];
     readonly index: readonly IndexLabel[];
     readonly columnInfo: ReadonlyMap<string, ColumnInfo>;
@@ -113,31 +165,53 @@ interface DataFrame<TRow extends Record<string, JsonValue> = Record<string, Json
     toColumns(): ColumnsPayload;
     toValues(): ValuesPayload;
     toSplit(): SplitPayload;
+    /** Exports Table Schema JSON; source index labels must be unique primary-key values. */
     toTable(options?: ToTableOptions): TablePayload;
+    /** Serializes an exported orient, including table metadata, within `JSON_FRAME_MAX_DEPTH`. */
     toJSONString(orient: ResolvedOrient, options?: ToJSONStringOptions): string;
     row(position: number): Readonly<TRow>;
     rows(): readonly Readonly<TRow>[];
     filter(predicate: (row: Readonly<TRow>, index: IndexLabel, position: number) => boolean): DataFrame<TRow>;
     sort(compare: (left: Readonly<TRow>, right: Readonly<TRow>, leftIndex: IndexLabel, rightIndex: IndexLabel, leftPosition: number, rightPosition: number) => number): DataFrame<TRow>;
-    select(...columns: readonly string[]): DataFrame<Record<string, JsonValue>>;
-    rename(mapping: Readonly<Record<string, string>>): DataFrame<Record<string, JsonValue>>;
+    select(...columns: readonly string[]): DataFrame<JsonRow>;
+    rename(mapping: Readonly<Record<string, string>>): DataFrame<JsonRow>;
     resetIndex(): DataFrame<TRow>;
 }
 
 /**
  * Parses pandas-compatible JSON into an immutable `DataFrame`.
  *
- * `auto` detection recognizes only structurally unambiguous payloads. Pass an
- * explicit `options.orient` for `index`, `columns`, empty arrays, empty
- * objects, and all `values` payloads. The generic row type is for TypeScript
- * ergonomics and is not runtime-validated beyond the documented JSON-orient
- * contracts.
+ * `auto` detection recognizes only structurally unambiguous payloads, including
+ * non-empty `values` arrays. Every `values` payload still requires
+ * `options.columns` because that orient carries no column labels; empty
+ * `values` input also requires explicit `options.orient: 'values'`. Pass an
+ * explicit `options.orient` for `index`, `columns`, empty arrays, and empty
+ * objects. The generic row type is for TypeScript ergonomics and is not
+ * runtime-validated beyond the documented JSON-orient contracts. `index` and
+ * `columns` object-key payloads follow JavaScript property enumeration order
+ * for integer-like keys; use `split` or `table` when exact row order must be
+ * preserved for those labels. JSON arrays/objects may nest up to
+ * `JSON_FRAME_MAX_DEPTH` levels from the parsed root value. Explicit non-table
+ * `columnTypes` are validated against non-null cells and never coerce values.
  */
-declare function fromOrient<TRow extends Record<string, JsonValue> = Record<string, JsonValue>>(input: string, options?: FromOrientOptions): DataFrame<TRow>;
-declare function fromOrient<TRow extends Record<string, JsonValue>>(input: readonly TRow[], options?: FromOrientOptions & {
+declare function fromOrient<TRow extends JsonCompatibleRow<TRow> = JsonRow>(input: string, options?: FromOrientOptions): DataFrame<TRow>;
+declare function fromOrient<TRow extends JsonCompatibleRow<TRow>>(input: readonly TRow[], options?: FromOrientOptions & {
     readonly orient?: 'auto' | 'records';
 }): DataFrame<TRow>;
-declare function fromOrient<TRow extends Record<string, JsonValue> = Record<string, JsonValue>>(input: JsonValue, options?: FromOrientOptions): DataFrame<TRow>;
+declare function fromOrient<TRow extends JsonCompatibleRow<TRow> = JsonRow>(input: SplitPayload, options: FromOrientOptions & {
+    readonly orient: 'split';
+}): DataFrame<TRow>;
+declare function fromOrient<TRow extends JsonCompatibleRow<TRow> = JsonRow>(input: TablePayload, options: FromOrientOptions & {
+    readonly orient: 'table';
+}): DataFrame<TRow>;
+declare function fromOrient<TRow extends JsonCompatibleRow<TRow> = JsonRow>(input: JsonValue, options?: FromOrientOptions): DataFrame<TRow>;
+
+/**
+ * Maximum supported nesting for JSON arrays/objects traversed by the package.
+ * The parsed root is depth 0; an array/object at depth 1000 is accepted, while
+ * an array/object at depth 1001 fails with `JsonFrameValidationError`.
+ */
+declare const JSON_FRAME_MAX_DEPTH = 1000;
 
 type JsonFrameErrorContext = {
     readonly orient?: Orient;
@@ -146,13 +220,25 @@ type JsonFrameErrorContext = {
     readonly column?: string;
     readonly value?: unknown;
 };
+/** Bounded value stored on structured errors instead of caller-owned containers. */
+type JsonFrameDiagnosticValue = string | number | boolean | null | Readonly<{
+    readonly kind: 'array';
+    readonly length: number;
+}> | Readonly<{
+    readonly kind: 'object';
+    readonly keyCount: number;
+    readonly keys: readonly string[];
+    readonly truncated: boolean;
+}> | Readonly<{
+    readonly kind: 'undefined' | 'symbol' | 'bigint' | 'function';
+}>;
 /** Base class for all structured `@web-ts-toolkit/json-frame` runtime failures. */
 declare class JsonFrameError extends Error {
     readonly orient?: Orient;
     readonly path?: string;
     readonly row?: number;
     readonly column?: string;
-    readonly value?: unknown;
+    readonly value?: JsonFrameDiagnosticValue;
     constructor(message: string, context?: JsonFrameErrorContext);
 }
 /** Raised when a JSON string cannot be parsed before orient validation begins. */
@@ -193,4 +279,4 @@ declare class ExportKeyCollisionError extends JsonFrameError {
     constructor(message: string, orient: ResolvedOrient, key: string, labels: readonly (string | number)[]);
 }
 
-export { AmbiguousOrientError, type ColumnInfo, type ColumnLabel, type ColumnType, type ColumnsPayload, type DataFrame, ExportKeyCollisionError, type FromOrientOptions, type IndexKind, type IndexLabel, type IndexPayload, type JsonArray, JsonFrameError, JsonFrameOptionError, JsonFrameParseError, JsonFrameValidationError, type JsonObject, type JsonPrimitive, type JsonValue, type Orient, type RecordsPayload, type ResolvedOrient, type SplitPayload, type TablePayload, type TableSchema, type TableSchemaConstraints, type TableSchemaField, type TableSchemaFieldType, type ToJSONStringOptions, type ToTableOptions, UnsupportedFeatureError, type ValuesPayload, fromOrient };
+export { AmbiguousOrientError, type ColumnInfo, type ColumnLabel, type ColumnType, type ColumnsPayload, type DataFrame, ExportKeyCollisionError, type FromOrientOptions, type IndexKind, type IndexLabel, type IndexPayload, JSON_FRAME_MAX_DEPTH, type JsonArray, type JsonCompatible, type JsonCompatibleRow, type JsonFrameDiagnosticValue, JsonFrameError, JsonFrameOptionError, JsonFrameParseError, JsonFrameValidationError, type JsonObject, type JsonPrimitive, type JsonRow, type JsonValue, type Orient, type RecordsPayload, type ResolvedOrient, type SplitPayload, type TablePayload, type TableSchema, type TableSchemaConstraints, type TableSchemaField, type TableSchemaFieldType, type ToJSONStringOptions, type ToTableOptions, UnsupportedFeatureError, type ValuesPayload, fromOrient };