@loaders.gl/parquet 4.4.2 → 5.0.0-alpha.1

package/src/parquetjs/utils/uint8-array-compact-protocol-writer.ts

@@ -0,0 +1,254 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import * as thrift from 'thrift';
+import {concatUint8Arrays, encodeUtf8, toUint8Array, writeDoubleLE} from './binary-utils';
+
+const COMPACT_TYPE_STOP = 0x00;
+const COMPACT_TYPE_BOOLEAN_TRUE = 0x01;
+const COMPACT_TYPE_BOOLEAN_FALSE = 0x02;
+const COMPACT_TYPE_BYTE = 0x03;
+const COMPACT_TYPE_I16 = 0x04;
+const COMPACT_TYPE_I32 = 0x05;
+const COMPACT_TYPE_I64 = 0x06;
+const COMPACT_TYPE_DOUBLE = 0x07;
+const COMPACT_TYPE_BINARY = 0x08;
+const COMPACT_TYPE_LIST = 0x09;
+const COMPACT_TYPE_SET = 0x0a;
+const COMPACT_TYPE_MAP = 0x0b;
+const COMPACT_TYPE_STRUCT = 0x0c;
+
+type Int64Like = number | bigint | {toString(radix?: number): string; valueOf?: () => number};
+
+/** Write-only Thrift compact protocol that assembles exact Uint8Array output. */
+export class Uint8ArrayCompactProtocolWriter {
+  /** Serialized byte chunks accumulated by thrift write calls. */
+  private readonly chunks: Uint8Array[] = [];
+
+  /** Field id at the current nesting depth, used to emit compact field-id deltas. */
+  private lastFieldId = 0;
+
+  /** Parent struct field ids restored when nested structs end. */
+  private readonly lastFieldIds: number[] = [];
+
+  /** Boolean field header waiting for the following boolean payload. */
+  private pendingBooleanField: {fid: number} | null = null;
+
+  /** Enter a struct and reset the delta-encoded field id state. */
+  writeStructBegin(_name: string): void {
+    this.lastFieldIds.push(this.lastFieldId);
+    this.lastFieldId = 0;
+  }
+
+  /** Exit a struct and restore the parent field id state. */
+  writeStructEnd(): void {
+    this.lastFieldId = this.lastFieldIds.pop() || 0;
+  }
+
+  /** Write a field header, deferring boolean fields until their value is known. */
+  writeFieldBegin(_name: string, fieldType: thrift.Thrift.Type, fid: number): void {
+    if (fieldType === thrift.Thrift.Type.BOOL) {
+      this.pendingBooleanField = {fid};
+      return;
+    }
+
+    this.writeFieldHeader(this.getCompactType(fieldType), fid);
+  }
+
+  /** Complete the current field; compact protocol has no field-end bytes. */
+  writeFieldEnd(): void {}
+
+  /** Write the stop marker that terminates a thrift struct. */
+  writeFieldStop(): void {
+    this.writeByteDirect(COMPACT_TYPE_STOP);
+  }
+
+  /** Write a map header with compact key/value element types. */
+  writeMapBegin(keyType: thrift.Thrift.Type, valueType: thrift.Thrift.Type, size: number): void {
+    if (size === 0) {
+      this.writeByteDirect(0);
+      return;
+    }
+
+    this.writeVarint32(size);
+    this.writeByteDirect((this.getCompactType(keyType) << 4) | this.getCompactType(valueType));
+  }
+
+  /** Complete the current map; compact protocol has no map-end bytes. */
+  writeMapEnd(): void {}
+
+  /** Write a list header with compact element type and element count. */
+  writeListBegin(elementType: thrift.Thrift.Type, size: number): void {
+    this.writeCollectionBegin(elementType, size);
+  }
+
+  /** Complete the current list; compact protocol has no list-end bytes. */
+  writeListEnd(): void {}
+
+  /** Write a set header with compact element type and element count. */
+  writeSetBegin(elementType: thrift.Thrift.Type, size: number): void {
+    this.writeCollectionBegin(elementType, size);
+  }
+
+  /** Complete the current set; compact protocol has no set-end bytes. */
+  writeSetEnd(): void {}
+
+  /** Write a boolean, either inline in its field header or as a value byte. */
+  writeBool(value: boolean): void {
+    const compactType = value ? COMPACT_TYPE_BOOLEAN_TRUE : COMPACT_TYPE_BOOLEAN_FALSE;
+    if (this.pendingBooleanField) {
+      this.writeFieldHeader(compactType, this.pendingBooleanField.fid);
+      this.pendingBooleanField = null;
+      return;
+    }
+
+    this.writeByteDirect(compactType);
+  }
+
+  /** Write a signed byte. */
+  writeByte(value: number): void {
+    this.writeByteDirect(value);
+  }
+
+  /** Write a signed 16-bit integer as zig-zag varint. */
+  writeI16(value: number): void {
+    this.writeI32(value);
+  }
+
+  /** Write a signed 32-bit integer as zig-zag varint. */
+  writeI32(value: number): void {
+    this.writeVarint32(this.encodeZigZag32(value));
+  }
+
+  /** Write a signed 64-bit-like value as zig-zag varint. */
+  writeI64(value: Int64Like): void {
+    this.writeVarint64(this.encodeZigZag64(this.toBigInt(value)));
+  }
+
+  /** Write a little-endian 64-bit float. */
+  writeDouble(value: number): void {
+    const bytes = new Uint8Array(8);
+    writeDoubleLE(bytes, value, 0);
+    this.writeBytes(bytes);
+  }
+
+  /** Write a length-prefixed UTF-8 string. */
+  writeString(value: string): void {
+    this.writeBinary(encodeUtf8(value));
+  }
+
+  /** Write a length-prefixed binary payload from any typed-array view. */
+  writeBinary(value: ArrayBuffer | ArrayBufferView): void {
+    const bytes = toUint8Array(value);
+    this.writeVarint32(bytes.length);
+    this.writeBytes(bytes);
+  }
+
+  /** Return all serialized chunks as one contiguous byte array. */
+  getBytes(): Uint8Array {
+    return concatUint8Arrays(this.chunks);
+  }
+
+  /** Write a compact collection header for list or set values. */
+  private writeCollectionBegin(elementType: thrift.Thrift.Type, size: number): void {
+    const compactType = this.getCompactType(elementType);
+    if (size <= 14) {
+      this.writeByteDirect((size << 4) | compactType);
+      return;
+    }
+
+    this.writeByteDirect(0xf0 | compactType);
+    this.writeVarint32(size);
+  }
+
+  /** Write a compact field header using a field-id delta when possible. */
+  private writeFieldHeader(compactType: number, fid: number): void {
+    const fieldIdDelta = fid - this.lastFieldId;
+    if (fieldIdDelta > 0 && fieldIdDelta <= 15) {
+      this.writeByteDirect((fieldIdDelta << 4) | compactType);
+    } else {
+      this.writeByteDirect(compactType);
+      this.writeI16(fid);
+    }
+    this.lastFieldId = fid;
+  }
+
+  /** Append an already serialized byte range without copying. */
+  private writeBytes(bytes: Uint8Array): void {
+    this.chunks.push(bytes);
+  }
+
+  /** Append one byte to the serialized output. */
+  private writeByteDirect(value: number): void {
+    this.chunks.push(new Uint8Array([value & 0xff]));
+  }
+
+  /** Write an unsigned 32-bit value as a compact varint. */
+  private writeVarint32(value: number): void {
+    this.writeVarint64(BigInt(value >>> 0));
+  }
+
+  /** Write an unsigned 64-bit value as a compact varint. */
+  private writeVarint64(value: bigint): void {
+    let nextValue = value;
+    while (true) {
+      if ((nextValue & ~0x7fn) === 0n) {
+        this.writeByteDirect(Number(nextValue));
+        return;
+      }
+
+      this.writeByteDirect(Number((nextValue & 0x7fn) | 0x80n));
+      nextValue >>= 7n;
+    }
+  }
+
+  /** Encode a signed 32-bit integer as an unsigned zig-zag value. */
+  private encodeZigZag32(value: number): number {
+    return ((value << 1) ^ (value >> 31)) >>> 0;
+  }
+
+  /** Encode a signed 64-bit integer as an unsigned zig-zag value. */
+  private encodeZigZag64(value: bigint): bigint {
+    return (value << 1n) ^ (value >> 63n);
+  }
+
+  /** Normalize thrift int64-like values to bigint before zig-zag encoding. */
+  private toBigInt(value: Int64Like): bigint {
+    return typeof value === 'bigint' || typeof value === 'number'
+      ? BigInt(value)
+      : BigInt(value.toString());
+  }
+
+  /** Convert a generated-thrift type to a compact protocol wire type. */
+  private getCompactType(thriftType: thrift.Thrift.Type): number {
+    switch (thriftType) {
+      case thrift.Thrift.Type.STOP:
+        return COMPACT_TYPE_STOP;
+      case thrift.Thrift.Type.BOOL:
+        return COMPACT_TYPE_BOOLEAN_TRUE;
+      case thrift.Thrift.Type.BYTE:
+        return COMPACT_TYPE_BYTE;
+      case thrift.Thrift.Type.I16:
+        return COMPACT_TYPE_I16;
+      case thrift.Thrift.Type.I32:
+        return COMPACT_TYPE_I32;
+      case thrift.Thrift.Type.I64:
+        return COMPACT_TYPE_I64;
+      case thrift.Thrift.Type.DOUBLE:
+        return COMPACT_TYPE_DOUBLE;
+      case thrift.Thrift.Type.STRING:
+        return COMPACT_TYPE_BINARY;
+      case thrift.Thrift.Type.LIST:
+        return COMPACT_TYPE_LIST;
+      case thrift.Thrift.Type.SET:
+        return COMPACT_TYPE_SET;
+      case thrift.Thrift.Type.MAP:
+        return COMPACT_TYPE_MAP;
+      case thrift.Thrift.Type.STRUCT:
+        return COMPACT_TYPE_STRUCT;
+      default:
+        throw new Error(`Unsupported thrift type: ${thriftType}`);
+    }
+  }
+}

package/src/parquetjs/utils/uint8-array-compact-protocol.ts

@@ -0,0 +1,322 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import * as thrift from 'thrift';
+import {readDoubleLE} from './binary-utils';
+import {Uint8ArrayTransport} from './uint8-array-transport';
+
+const COMPACT_TYPE_STOP = 0x00;
+const COMPACT_TYPE_BOOLEAN_TRUE = 0x01;
+const COMPACT_TYPE_BOOLEAN_FALSE = 0x02;
+const COMPACT_TYPE_BYTE = 0x03;
+const COMPACT_TYPE_I16 = 0x04;
+const COMPACT_TYPE_I32 = 0x05;
+const COMPACT_TYPE_I64 = 0x06;
+const COMPACT_TYPE_DOUBLE = 0x07;
+const COMPACT_TYPE_BINARY = 0x08;
+const COMPACT_TYPE_LIST = 0x09;
+const COMPACT_TYPE_SET = 0x0a;
+const COMPACT_TYPE_MAP = 0x0b;
+const COMPACT_TYPE_STRUCT = 0x0c;
+
+/** Number-like replacement for node-int64 used by the compact protocol. */
+export class CompactInt64 {
+  /** Signed integer payload represented without precision loss. */
+  private readonly value: bigint;
+
+  /** Create a compact-protocol int64 wrapper from a bigint. */
+  constructor(value: bigint) {
+    this.value = value;
+  }
+
+  /** Return the payload as a JavaScript number. */
+  toNumber(): number {
+    return Number(this.value);
+  }
+
+  /** Return the payload as a JavaScript number for generated thrift arithmetic. */
+  valueOf(): number {
+    return this.toNumber();
+  }
+
+  /** Format the payload as a string. */
+  toString(radix?: number): string {
+    return this.value.toString(radix);
+  }
+}
+
+/** Read-only Thrift compact protocol backed by Uint8Array. */
+export class Uint8ArrayCompactProtocol {
+  /** Byte transport that provides thrift-compatible read, borrow, and consume methods. */
+  private readonly transport: Uint8ArrayTransport;
+
+  /** Field id at the current nesting depth, used for compact field-id deltas. */
+  private lastFieldId = 0;
+
+  /** Parent struct field ids restored when nested structs end. */
+  private readonly lastFieldIds: number[] = [];
+
+  /** Boolean payload encoded in a compact field header. */
+  private boolValue: boolean | null = null;
+
+  /** Create a compact protocol reader over a Uint8Array-backed transport. */
+  constructor(transport: Uint8ArrayTransport) {
+    this.transport = transport;
+  }
+
+  /** Enter a struct and reset the delta-encoded field id state. */
+  readStructBegin(): thrift.TStruct {
+    this.lastFieldIds.push(this.lastFieldId);
+    this.lastFieldId = 0;
+    return {fname: ''};
+  }
+
+  readStructEnd(): void {
+    this.lastFieldId = this.lastFieldIds.pop() || 0;
+  }
+
+  /** Read a compact field header and expand it to a thrift field descriptor. */
+  readFieldBegin(): thrift.TField {
+    const fieldHeader = this.transport.readByte();
+    const compactType = fieldHeader & 0x0f;
+
+    if (compactType === COMPACT_TYPE_STOP) {
+      return {fname: null!, ftype: thrift.Thrift.Type.STOP, fid: 0};
+    }
+
+    const fieldIdDelta = (fieldHeader & 0xf0) >>> 4;
+    const fieldId = fieldIdDelta === 0 ? this.readI16() : this.lastFieldId + fieldIdDelta;
+    const fieldType = this.getThriftType(compactType);
+
+    if (compactType === COMPACT_TYPE_BOOLEAN_TRUE || compactType === COMPACT_TYPE_BOOLEAN_FALSE) {
+      this.boolValue = compactType === COMPACT_TYPE_BOOLEAN_TRUE;
+    }
+
+    this.lastFieldId = fieldId;
+    return {fname: null!, ftype: fieldType, fid: fieldId};
+  }
+
+  readFieldEnd(): void {}
+
+  /** Read a map header, including element compact types when the map is non-empty. */
+  readMapBegin(): thrift.TMap {
+    const size = this.readVarint32();
+    const keyAndValueType = size === 0 ? 0 : this.transport.readByte();
+    return {
+      ktype: this.getThriftType((keyAndValueType & 0xf0) >>> 4),
+      vtype: this.getThriftType(keyAndValueType & 0x0f),
+      size
+    };
+  }
+
+  readMapEnd(): void {}
+
+  /** Read a list header and expand the inline or varint element count. */
+  readListBegin(): thrift.TList {
+    const sizeAndType = this.transport.readByte();
+    let size = (sizeAndType >>> 4) & 0x0f;
+    if (size === 15) {
+      size = this.readVarint32();
+    }
+
+    return {
+      etype: this.getThriftType(sizeAndType & 0x0f),
+      size
+    };
+  }
+
+  readListEnd(): void {}
+
+  /** Read a set header; compact protocol encodes sets and lists the same way. */
+  readSetBegin(): thrift.TSet {
+    return this.readListBegin();
+  }
+
+  readSetEnd(): void {}
+
+  /** Read a boolean from the field header or from the next compact boolean byte. */
+  readBool(): boolean {
+    if (this.boolValue !== null) {
+      const value = this.boolValue;
+      this.boolValue = null;
+      return value;
+    }
+
+    return this.transport.readByte() === COMPACT_TYPE_BOOLEAN_TRUE;
+  }
+
+  /** Read a signed byte from the transport. */
+  readByte(): number {
+    return this.transport.readByte();
+  }
+
+  /** Read a signed 16-bit integer encoded as zig-zag varint. */
+  readI16(): number {
+    return this.readI32();
+  }
+
+  /** Read a signed 32-bit integer encoded as zig-zag varint. */
+  readI32(): number {
+    return this.decodeZigZag32(this.readVarint32());
+  }
+
+  /** Read a signed 64-bit integer encoded as zig-zag varint. */
+  readI64(): CompactInt64 {
+    return new CompactInt64(this.decodeZigZag64(this.readVarint64()));
+  }
+
+  /** Read a little-endian 64-bit float. */
+  readDouble(): number {
+    return readDoubleLE(this.transport.read(8), 0);
+  }
+
+  /** Read a length-prefixed binary payload as an exact Uint8Array. */
+  readBinary(): Uint8Array {
+    const size = this.readVarint32();
+    return size === 0 ? new Uint8Array(0) : this.transport.read(size);
+  }
+
+  /** Read a length-prefixed UTF-8 string. */
+  readString(): string {
+    const size = this.readVarint32();
+    return size === 0 ? '' : this.transport.readString(size);
+  }
+
+  /** Consume and discard a value with the supplied thrift type. */
+  skip(type: thrift.Thrift.Type): void {
+    switch (type) {
+      case thrift.Thrift.Type.STOP:
+        return;
+      case thrift.Thrift.Type.BOOL:
+        this.readBool();
+        return;
+      case thrift.Thrift.Type.BYTE:
+        this.readByte();
+        return;
+      case thrift.Thrift.Type.I16:
+        this.readI16();
+        return;
+      case thrift.Thrift.Type.I32:
+        this.readI32();
+        return;
+      case thrift.Thrift.Type.I64:
+        this.readI64();
+        return;
+      case thrift.Thrift.Type.DOUBLE:
+        this.readDouble();
+        return;
+      case thrift.Thrift.Type.STRING:
+        this.readBinary();
+        return;
+      case thrift.Thrift.Type.STRUCT:
+        this.skipStruct();
+        return;
+      case thrift.Thrift.Type.MAP:
+        this.skipMap();
+        return;
+      case thrift.Thrift.Type.SET:
+      case thrift.Thrift.Type.LIST:
+        this.skipList();
+        return;
+      default:
+        throw new Error(`Unsupported thrift type: ${type}`);
+    }
+  }
+
+  /** Read an unsigned 32-bit compact varint. */
+  private readVarint32(): number {
+    return Number(this.readVarint64());
+  }
+
+  /** Read an unsigned 64-bit compact varint. */
+  private readVarint64(): bigint {
+    let value = 0n;
+    let shift = 0n;
+
+    while (true) {
+      const byte = BigInt(this.transport.readByte() & 0xff);
+      value |= (byte & 0x7fn) << shift;
+      if ((byte & 0x80n) === 0n) {
+        return value;
+      }
+      shift += 7n;
+    }
+  }
+
+  /** Decode a zig-zag 32-bit integer to a signed integer. */
+  private decodeZigZag32(value: number): number {
+    return (value >>> 1) ^ -(value & 1);
+  }
+
+  /** Decode a zig-zag 64-bit integer to a signed integer. */
+  private decodeZigZag64(value: bigint): bigint {
+    return (value >> 1n) ^ -(value & 1n);
+  }
+
+  /** Convert a compact wire type to a generated-thrift type. */
+  private getThriftType(compactType: number): thrift.Thrift.Type {
+    switch (compactType) {
+      case COMPACT_TYPE_STOP:
+        return thrift.Thrift.Type.STOP;
+      case COMPACT_TYPE_BOOLEAN_TRUE:
+      case COMPACT_TYPE_BOOLEAN_FALSE:
+        return thrift.Thrift.Type.BOOL;
+      case COMPACT_TYPE_BYTE:
+        return thrift.Thrift.Type.BYTE;
+      case COMPACT_TYPE_I16:
+        return thrift.Thrift.Type.I16;
+      case COMPACT_TYPE_I32:
+        return thrift.Thrift.Type.I32;
+      case COMPACT_TYPE_I64:
+        return thrift.Thrift.Type.I64;
+      case COMPACT_TYPE_DOUBLE:
+        return thrift.Thrift.Type.DOUBLE;
+      case COMPACT_TYPE_BINARY:
+        return thrift.Thrift.Type.STRING;
+      case COMPACT_TYPE_LIST:
+        return thrift.Thrift.Type.LIST;
+      case COMPACT_TYPE_SET:
+        return thrift.Thrift.Type.SET;
+      case COMPACT_TYPE_MAP:
+        return thrift.Thrift.Type.MAP;
+      case COMPACT_TYPE_STRUCT:
+        return thrift.Thrift.Type.STRUCT;
+      default:
+        throw new Error(`Unknown compact thrift type: ${compactType}`);
+    }
+  }
+
+  /** Skip every field in the current struct. */
+  private skipStruct(): void {
+    this.readStructBegin();
+    while (true) {
+      const field = this.readFieldBegin();
+      if (field.ftype === thrift.Thrift.Type.STOP) {
+        break;
+      }
+      this.skip(field.ftype);
+      this.readFieldEnd();
+    }
+    this.readStructEnd();
+  }
+
+  /** Skip every key and value in the current map. */
+  private skipMap(): void {
+    const map = this.readMapBegin();
+    for (let index = 0; index < map.size; index++) {
+      this.skip(map.ktype);
+      this.skip(map.vtype);
+    }
+    this.readMapEnd();
+  }
+
+  /** Skip every element in the current list or set. */
+  private skipList(): void {
+    const list = this.readListBegin();
+    for (let index = 0; index < list.size; index++) {
+      this.skip(list.etype);
+    }
+    this.readListEnd();
+  }
+}

package/src/parquetjs/utils/uint8-array-transport.ts

@@ -0,0 +1,79 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {decodeString, toUint8Array} from './binary-utils';
+
+/** Thrift compact-protocol read transport backed by Uint8Array. */
+export class Uint8ArrayTransport {
+  public readPos = 0;
+
+  private readonly buffer: Uint8Array;
+
+  constructor(buffer: Uint8Array) {
+    this.buffer = toUint8Array(buffer);
+  }
+
+  commitPosition(): void {}
+
+  rollbackPosition(): void {}
+
+  isOpen(): boolean {
+    return true;
+  }
+
+  open(): boolean {
+    return true;
+  }
+
+  close(): boolean {
+    return true;
+  }
+
+  setCurrSeqId(_sequenceId: number): void {}
+
+  ensureAvailable(byteLength: number): void {
+    if (this.readPos + byteLength > this.buffer.length) {
+      throw new Error('Input buffer underrun');
+    }
+  }
+
+  read(byteLength: number): Uint8Array {
+    this.ensureAvailable(byteLength);
+    const end = this.readPos + byteLength;
+    const value = this.buffer.subarray(this.readPos, end);
+    this.readPos = end;
+    return value;
+  }
+
+  readByte(): number {
+    this.ensureAvailable(1);
+    const value = this.buffer[this.readPos++];
+    return value > 127 ? value - 256 : value;
+  }
+
+  readString(byteLength: number): string {
+    this.ensureAvailable(byteLength);
+    const value = decodeString(this.buffer, this.readPos, this.readPos + byteLength);
+    this.readPos += byteLength;
+    return value;
+  }
+
+  borrow(): {buf: Uint8Array; readIndex: number; writeIndex: number} {
+    return {
+      buf: this.buffer,
+      readIndex: this.readPos,
+      writeIndex: this.buffer.length
+    };
+  }
+
+  consume(bytesConsumed: number): void {
+    this.readPos += bytesConsumed;
+  }
+
+  write(): never {
+    throw new Error('Uint8ArrayTransport is read-only');
+  }
+
+  flush(): void {}
+}

package/src/unbundled.ts

@@ -0,0 +1,9 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export type {ParquetLoaderOptions} from './parquet-loader';
+export type {GeoParquetLoaderOptions} from './geoparquet-loader';
+export {ParquetLoader} from './parquet-loader';
+export {GeoParquetLoader} from './geoparquet-loader';
+export {ParquetJSLoader} from './parquet-js-loader';

package/dist/parquet-arrow-loader.d.ts

@@ -1,43 +0,0 @@
-import type { ArrowTable, ArrowTableBatch } from '@loaders.gl/schema';
-import type { LoaderOptions } from '@loaders.gl/loader-utils';
-/** Parquet WASM loader options */
-export type ParquetArrowLoaderOptions = LoaderOptions & {
-    parquet?: {
-        limit?: number;
-        offset?: number;
-        batchSize?: number;
-        columns?: string[];
-        rowGroups?: number[];
-        concurrency?: number;
-        wasmUrl?: string;
-    };
-};
-/** Parquet WASM table loader */
-export declare const ParquetArrowWorkerLoader: {
-    readonly dataType: ArrowTable;
-    readonly batchType: ArrowTableBatch;
-    readonly name: "Apache Parquet";
-    readonly id: "parquet-wasm";
-    readonly module: "parquet";
-    readonly version: any;
-    readonly worker: false;
-    readonly category: "table";
-    readonly extensions: ["parquet"];
-    readonly mimeTypes: ["application/octet-stream"];
-    readonly binary: true;
-    readonly tests: ["PAR1", "PARE"];
-    readonly options: {
-        readonly parquet: {
-            readonly limit: undefined;
-            readonly offset: 0;
-            readonly batchSize: undefined;
-            readonly columns: undefined;
-            readonly rowGroups: undefined;
-            readonly concurrency: undefined;
-            readonly wasmUrl: "https://unpkg.com/parquet-wasm@0.6.1/esm/parquet_wasm_bg.wasm";
-        };
-    };
-};
-/** Parquet WASM table loader */
-export declare const ParquetArrowLoader: any;
-//# sourceMappingURL=parquet-arrow-loader.d.ts.map