@loaders.gl/parquet 4.5.3 → 5.0.0-alpha.10

package/src/parquetjs/parquet-thrift/BoundingBox.ts

@@ -0,0 +1,108 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/* eslint-disable camelcase */
+import * as thrift from '../utils/thrift-runtime';
+
+/** Constructor arguments for the Parquet geospatial bounding-box Thrift structure. */
+export interface IBoundingBoxArgs {
+  xmin: number;
+  xmax: number;
+  ymin: number;
+  ymax: number;
+  zmin?: number;
+  zmax?: number;
+  mmin?: number;
+  mmax?: number;
+}
+
+/** Parquet geospatial bounding-box Thrift structure. */
+export class BoundingBox {
+  public xmin: number;
+  public xmax: number;
+  public ymin: number;
+  public ymax: number;
+  public zmin?: number;
+  public zmax?: number;
+  public mmin?: number;
+  public mmax?: number;
+
+  constructor(args: IBoundingBoxArgs) {
+    this.xmin = getRequiredCoordinate(args.xmin, 'xmin');
+    this.xmax = getRequiredCoordinate(args.xmax, 'xmax');
+    this.ymin = getRequiredCoordinate(args.ymin, 'ymin');
+    this.ymax = getRequiredCoordinate(args.ymax, 'ymax');
+    this.zmin = args.zmin;
+    this.zmax = args.zmax;
+    this.mmin = args.mmin;
+    this.mmax = args.mmax;
+  }
+
+  /** Writes this bounding box to a Thrift protocol. */
+  public write(output: thrift.TProtocol): void {
+    output.writeStructBegin('BoundingBox');
+    writeCoordinate(output, 'xmin', 1, this.xmin);
+    writeCoordinate(output, 'xmax', 2, this.xmax);
+    writeCoordinate(output, 'ymin', 3, this.ymin);
+    writeCoordinate(output, 'ymax', 4, this.ymax);
+    writeCoordinate(output, 'zmin', 5, this.zmin);
+    writeCoordinate(output, 'zmax', 6, this.zmax);
+    writeCoordinate(output, 'mmin', 7, this.mmin);
+    writeCoordinate(output, 'mmax', 8, this.mmax);
+    output.writeFieldStop();
+    output.writeStructEnd();
+  }
+
+  /** Reads a bounding box from a Thrift protocol. */
+  public static read(input: thrift.TProtocol): BoundingBox {
+    input.readStructBegin();
+    const args: Partial<IBoundingBoxArgs> = {};
+    while (true) {
+      const field = input.readFieldBegin();
+      if (field.ftype === thrift.Thrift.Type.STOP) break;
+      if (field.fid >= 1 && field.fid <= 8 && field.ftype === thrift.Thrift.Type.DOUBLE) {
+        const coordinateNames: Array<keyof IBoundingBoxArgs> = [
+          'xmin',
+          'xmax',
+          'ymin',
+          'ymax',
+          'zmin',
+          'zmax',
+          'mmin',
+          'mmax'
+        ];
+        args[coordinateNames[field.fid - 1]] = input.readDouble();
+      } else {
+        input.skip(field.ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    return new BoundingBox(args as IBoundingBoxArgs);
+  }
+}
+
+/** Writes one optional coordinate to a Thrift protocol. */
+function writeCoordinate(
+  output: thrift.TProtocol,
+  name: string,
+  fieldId: number,
+  value: number | undefined
+): void {
+  if (value === undefined) return;
+  output.writeFieldBegin(name, thrift.Thrift.Type.DOUBLE, fieldId);
+  output.writeDouble(value);
+  output.writeFieldEnd();
+}
+
+/** Validates one required coordinate reported by the Thrift structure. */
+function getRequiredCoordinate(value: number | undefined, name: string): number {
+  if (value === undefined) {
+    throw new thrift.Thrift.TProtocolException(
+      thrift.Thrift.TProtocolExceptionType.UNKNOWN,
+      `Required field[${name}] is unset!`
+    );
+  }
+  return value;
+}

package/src/parquetjs/parquet-thrift/BsonType.ts

@@ -10,7 +10,7 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import * as thrift from 'thrift';
+import * as thrift from '../utils/thrift-runtime';
 export interface IBsonTypeArgs {}
 export class BsonType {
   constructor() {}

package/src/parquetjs/parquet-thrift/ColumnChunk.ts

@@ -10,9 +10,10 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import Int64 from 'node-int64';
-import * as thrift from 'thrift';
+import {CompactInt64 as Int64} from '../utils/uint8-array-compact-protocol';
+import * as thrift from '../utils/thrift-runtime';
 import * as ColumnMetaData from './ColumnMetaData';
+import * as ColumnCryptoMetaData from './ColumnCryptoMetaData';
 export interface IColumnChunkArgs {
   file_path?: string;
   file_offset: number | Int64;
@@ -21,6 +22,8 @@ export interface IColumnChunkArgs {
   offset_index_length?: number;
   column_index_offset?: number | Int64;
   column_index_length?: number;
+  crypto_metadata?: ColumnCryptoMetaData.ColumnCryptoMetaData;
+  encrypted_column_metadata?: Uint8Array;
 }
 export class ColumnChunk {
   public file_path?: string;
@@ -30,6 +33,8 @@ export class ColumnChunk {
   public offset_index_length?: number;
   public column_index_offset?: Int64;
   public column_index_length?: number;
+  public crypto_metadata?: ColumnCryptoMetaData.ColumnCryptoMetaData;
+  public encrypted_column_metadata?: Uint8Array;
   constructor(args: IColumnChunkArgs) {
     if (args != null && args.file_path != null) {
       this.file_path = args.file_path;
@@ -69,6 +74,12 @@ export class ColumnChunk {
     if (args != null && args.column_index_length != null) {
       this.column_index_length = args.column_index_length;
     }
+    if (args != null && args.crypto_metadata != null) {
+      this.crypto_metadata = args.crypto_metadata;
+    }
+    if (args != null && args.encrypted_column_metadata != null) {
+      this.encrypted_column_metadata = args.encrypted_column_metadata;
+    }
   }
   public write(output: thrift.TProtocol): void {
     output.writeStructBegin('ColumnChunk');
@@ -107,6 +118,16 @@ export class ColumnChunk {
       output.writeI32(this.column_index_length);
       output.writeFieldEnd();
     }
+    if (this.crypto_metadata != null) {
+      output.writeFieldBegin('crypto_metadata', thrift.Thrift.Type.STRUCT, 8);
+      this.crypto_metadata.write(output);
+      output.writeFieldEnd();
+    }
+    if (this.encrypted_column_metadata != null) {
+      output.writeFieldBegin('encrypted_column_metadata', thrift.Thrift.Type.STRING, 9);
+      output.writeBinary(this.encrypted_column_metadata);
+      output.writeFieldEnd();
+    }
     output.writeFieldStop();
     output.writeStructEnd();
     return;
@@ -179,6 +200,20 @@ export class ColumnChunk {
             input.skip(fieldType);
           }
           break;
+        case 8:
+          if (fieldType === thrift.Thrift.Type.STRUCT) {
+            _args.crypto_metadata = ColumnCryptoMetaData.ColumnCryptoMetaData.read(input);
+          } else {
+            input.skip(fieldType);
+          }
+          break;
+        case 9:
+          if (fieldType === thrift.Thrift.Type.STRING) {
+            _args.encrypted_column_metadata = input.readBinary();
+          } else {
+            input.skip(fieldType);
+          }
+          break;
         default: {
           input.skip(fieldType);
         }

package/src/parquetjs/parquet-thrift/ColumnCryptoMetaData.ts

@@ -0,0 +1,139 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import * as thrift from '../utils/thrift-runtime';
+
+/** Marker for a column encrypted with the file footer key. */
+export class EncryptionWithFooterKey {
+  /** Writes the empty footer-key marker. */
+  public write(output: thrift.TProtocol): void {
+    output.writeStructBegin('EncryptionWithFooterKey');
+    output.writeFieldStop();
+    output.writeStructEnd();
+  }
+  /** Reads the empty footer-key marker. */
+  public static read(input: thrift.TProtocol): EncryptionWithFooterKey {
+    input.readStructBegin();
+    while (true) {
+      const field = input.readFieldBegin();
+      if (field.ftype === thrift.Thrift.Type.STOP) break;
+      input.skip(field.ftype);
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    return new EncryptionWithFooterKey();
+  }
+}
+
+/** Metadata needed to retrieve a column-specific encryption key. */
+export class EncryptionWithColumnKey {
+  public path_in_schema: string[];
+  public key_metadata?: Uint8Array;
+  constructor(args: {path_in_schema: string[]; key_metadata?: Uint8Array}) {
+    this.path_in_schema = args.path_in_schema;
+    this.key_metadata = args.key_metadata;
+  }
+
+  /** Writes column-key retrieval metadata. */
+  public write(output: thrift.TProtocol): void {
+    output.writeStructBegin('EncryptionWithColumnKey');
+    output.writeFieldBegin('path_in_schema', thrift.Thrift.Type.LIST, 1);
+    output.writeListBegin(thrift.Thrift.Type.STRING, this.path_in_schema.length);
+    for (const pathPart of this.path_in_schema) output.writeString(pathPart);
+    output.writeListEnd();
+    output.writeFieldEnd();
+    if (this.key_metadata) {
+      output.writeFieldBegin('key_metadata', thrift.Thrift.Type.STRING, 2);
+      output.writeBinary(this.key_metadata);
+      output.writeFieldEnd();
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+  }
+
+  /** Reads column-key retrieval metadata. */
+  public static read(input: thrift.TProtocol): EncryptionWithColumnKey {
+    input.readStructBegin();
+    let pathInSchema: string[] | undefined;
+    let keyMetadata: Uint8Array | undefined;
+    while (true) {
+      const field = input.readFieldBegin();
+      if (field.ftype === thrift.Thrift.Type.STOP) break;
+      if (field.fid === 1 && field.ftype === thrift.Thrift.Type.LIST) {
+        const list = input.readListBegin();
+        pathInSchema = [];
+        for (let index = 0; index < list.size; index++) pathInSchema.push(input.readString());
+        input.readListEnd();
+      } else if (field.fid === 2 && field.ftype === thrift.Thrift.Type.STRING) {
+        keyMetadata = input.readBinary();
+      } else {
+        input.skip(field.ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    if (!pathInSchema) throw new Error('EncryptionWithColumnKey path_in_schema is required');
+    return new EncryptionWithColumnKey({path_in_schema: pathInSchema, key_metadata: keyMetadata});
+  }
+}
+
+/** Column encryption metadata union. */
+export class ColumnCryptoMetaData {
+  public ENCRYPTION_WITH_FOOTER_KEY?: EncryptionWithFooterKey;
+  public ENCRYPTION_WITH_COLUMN_KEY?: EncryptionWithColumnKey;
+  constructor(args: {
+    ENCRYPTION_WITH_FOOTER_KEY?: EncryptionWithFooterKey;
+    ENCRYPTION_WITH_COLUMN_KEY?: EncryptionWithColumnKey;
+  }) {
+    if (
+      (args.ENCRYPTION_WITH_FOOTER_KEY ? 1 : 0) + (args.ENCRYPTION_WITH_COLUMN_KEY ? 1 : 0) !==
+      1
+    ) {
+      throw new thrift.Thrift.TProtocolException(
+        thrift.Thrift.TProtocolExceptionType.INVALID_DATA,
+        'ColumnCryptoMetaData must contain exactly one key reference'
+      );
+    }
+    Object.assign(this, args);
+  }
+
+  /** Writes the selected column encryption key reference. */
+  public write(output: thrift.TProtocol): void {
+    output.writeStructBegin('ColumnCryptoMetaData');
+    if (this.ENCRYPTION_WITH_FOOTER_KEY) {
+      output.writeFieldBegin('ENCRYPTION_WITH_FOOTER_KEY', thrift.Thrift.Type.STRUCT, 1);
+      this.ENCRYPTION_WITH_FOOTER_KEY.write(output);
+      output.writeFieldEnd();
+    } else if (this.ENCRYPTION_WITH_COLUMN_KEY) {
+      output.writeFieldBegin('ENCRYPTION_WITH_COLUMN_KEY', thrift.Thrift.Type.STRUCT, 2);
+      this.ENCRYPTION_WITH_COLUMN_KEY.write(output);
+      output.writeFieldEnd();
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+  }
+
+  /** Reads column encryption metadata. */
+  public static read(input: thrift.TProtocol): ColumnCryptoMetaData {
+    input.readStructBegin();
+    let footerKey: EncryptionWithFooterKey | undefined;
+    let columnKey: EncryptionWithColumnKey | undefined;
+    while (true) {
+      const field = input.readFieldBegin();
+      if (field.ftype === thrift.Thrift.Type.STOP) break;
+      if (field.fid === 1 && field.ftype === thrift.Thrift.Type.STRUCT) {
+        footerKey = EncryptionWithFooterKey.read(input);
+      } else if (field.fid === 2 && field.ftype === thrift.Thrift.Type.STRUCT) {
+        columnKey = EncryptionWithColumnKey.read(input);
+      } else {
+        input.skip(field.ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    return footerKey
+      ? new ColumnCryptoMetaData({ENCRYPTION_WITH_FOOTER_KEY: footerKey})
+      : new ColumnCryptoMetaData({ENCRYPTION_WITH_COLUMN_KEY: columnKey!});
+  }
+}

package/src/parquetjs/parquet-thrift/ColumnIndex.ts

@@ -10,20 +10,20 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import Int64 from 'node-int64';
-import * as thrift from 'thrift';
+import {CompactInt64 as Int64} from '../utils/uint8-array-compact-protocol';
+import * as thrift from '../utils/thrift-runtime';
 import * as BoundaryOrder from './BoundaryOrder';
 export interface IColumnIndexArgs {
   null_pages: Array<boolean>;
-  min_values: Array<Buffer>;
-  max_values: Array<Buffer>;
+  min_values: Array<Uint8Array>;
+  max_values: Array<Uint8Array>;
   boundary_order: BoundaryOrder.BoundaryOrder;
   null_counts?: Array<number | Int64>;
 }
 export class ColumnIndex {
   public null_pages: Array<boolean>;
-  public min_values: Array<Buffer>;
-  public max_values: Array<Buffer>;
+  public min_values: Array<Uint8Array>;
+  public max_values: Array<Uint8Array>;
   public boundary_order: BoundaryOrder.BoundaryOrder;
   public null_counts?: Array<Int64>;
   constructor(args: IColumnIndexArgs) {
@@ -60,7 +60,7 @@ export class ColumnIndex {
       );
     }
     if (args != null && args.null_counts != null) {
-      this.null_counts = args.null_counts.map((c) => new Int64(+c));
+      this.null_counts = args.null_counts.map(c => new Int64(+c));
     }
   }
   public write(output: thrift.TProtocol): void {
@@ -77,7 +77,7 @@ export class ColumnIndex {
     if (this.min_values != null) {
       output.writeFieldBegin('min_values', thrift.Thrift.Type.LIST, 2);
       output.writeListBegin(thrift.Thrift.Type.STRING, this.min_values.length);
-      this.min_values.forEach((value_2: Buffer): void => {
+      this.min_values.forEach((value_2: Uint8Array): void => {
         output.writeBinary(value_2);
       });
       output.writeListEnd();
@@ -86,7 +86,7 @@ export class ColumnIndex {
     if (this.max_values != null) {
       output.writeFieldBegin('max_values', thrift.Thrift.Type.LIST, 3);
       output.writeListBegin(thrift.Thrift.Type.STRING, this.max_values.length);
-      this.max_values.forEach((value_3: Buffer): void => {
+      this.max_values.forEach((value_3: Uint8Array): void => {
         output.writeBinary(value_3);
       });
       output.writeListEnd();
@@ -138,11 +138,11 @@ export class ColumnIndex {
           break;
         case 2:
           if (fieldType === thrift.Thrift.Type.LIST) {
-            const value_7: Array<Buffer> = new Array<Buffer>();
+            const value_7: Array<Uint8Array> = new Array<Uint8Array>();
             const metadata_2: thrift.TList = input.readListBegin();
             const size_2: number = metadata_2.size;
             for (let i_2: number = 0; i_2 < size_2; i_2++) {
-              const value_8: Buffer = input.readBinary();
+              const value_8: Uint8Array = input.readBinary();
               value_7.push(value_8);
             }
             input.readListEnd();
@@ -153,11 +153,11 @@ export class ColumnIndex {
           break;
         case 3:
           if (fieldType === thrift.Thrift.Type.LIST) {
-            const value_9: Array<Buffer> = new Array<Buffer>();
+            const value_9: Array<Uint8Array> = new Array<Uint8Array>();
             const metadata_3: thrift.TList = input.readListBegin();
             const size_3: number = metadata_3.size;
             for (let i_3: number = 0; i_3 < size_3; i_3++) {
-              const value_10: Buffer = input.readBinary();
+              const value_10: Uint8Array = input.readBinary();
               value_9.push(value_10);
             }
             input.readListEnd();

package/src/parquetjs/parquet-thrift/ColumnMetaData.ts

@@ -10,14 +10,16 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import Int64 from 'node-int64';
-import * as thrift from 'thrift';
+import {CompactInt64 as Int64} from '../utils/uint8-array-compact-protocol';
+import * as thrift from '../utils/thrift-runtime';
 import * as CompressionCodec from './CompressionCodec';
 import * as Encoding from './Encoding';
+import * as GeospatialStatistics from './GeospatialStatistics';
 import * as KeyValue from './KeyValue';
 import * as PageEncodingStats from './PageEncodingStats';
 import * as Statistics from './Statistics';
 import * as Type from './Type';
+import * as SizeStatistics from './SizeStatistics';
 export interface IColumnMetaDataArgs {
   type: Type.Type;
   encodings: Array<Encoding.Encoding>;
@@ -32,6 +34,10 @@ export interface IColumnMetaDataArgs {
   dictionary_page_offset?: number | Int64;
   statistics?: Statistics.Statistics;
   encoding_stats?: Array<PageEncodingStats.PageEncodingStats>;
+  bloom_filter_offset?: number | Int64;
+  bloom_filter_length?: number;
+  geospatial_statistics?: GeospatialStatistics.GeospatialStatistics;
+  size_statistics?: SizeStatistics.SizeStatistics;
 }
 export class ColumnMetaData {
   public type: Type.Type;
@@ -47,6 +53,10 @@ export class ColumnMetaData {
   public dictionary_page_offset?: Int64;
   public statistics?: Statistics.Statistics;
   public encoding_stats?: Array<PageEncodingStats.PageEncodingStats>;
+  public bloom_filter_offset?: Int64;
+  public bloom_filter_length?: number;
+  public geospatial_statistics?: GeospatialStatistics.GeospatialStatistics;
+  public size_statistics?: SizeStatistics.SizeStatistics;
   constructor(args: IColumnMetaDataArgs) {
     if (args != null && args.type != null) {
       this.type = args.type;
@@ -151,6 +161,21 @@ export class ColumnMetaData {
     if (args != null && args.encoding_stats != null) {
       this.encoding_stats = args.encoding_stats;
     }
+    if (args != null && args.bloom_filter_offset != null) {
+      this.bloom_filter_offset =
+        typeof args.bloom_filter_offset === 'number'
+          ? new Int64(args.bloom_filter_offset)
+          : args.bloom_filter_offset;
+    }
+    if (args != null && args.bloom_filter_length != null) {
+      this.bloom_filter_length = args.bloom_filter_length;
+    }
+    if (args != null && args.geospatial_statistics != null) {
+      this.geospatial_statistics = args.geospatial_statistics;
+    }
+    if (args != null && args.size_statistics != null) {
+      this.size_statistics = args.size_statistics;
+    }
   }
   public write(output: thrift.TProtocol): void {
     output.writeStructBegin('ColumnMetaData');
@@ -235,6 +260,26 @@ export class ColumnMetaData {
       output.writeListEnd();
       output.writeFieldEnd();
     }
+    if (this.bloom_filter_offset != null) {
+      output.writeFieldBegin('bloom_filter_offset', thrift.Thrift.Type.I64, 14);
+      output.writeI64(this.bloom_filter_offset);
+      output.writeFieldEnd();
+    }
+    if (this.bloom_filter_length != null) {
+      output.writeFieldBegin('bloom_filter_length', thrift.Thrift.Type.I32, 15);
+      output.writeI32(this.bloom_filter_length);
+      output.writeFieldEnd();
+    }
+    if (this.geospatial_statistics != null) {
+      output.writeFieldBegin('geospatial_statistics', thrift.Thrift.Type.STRUCT, 17);
+      this.geospatial_statistics.write(output);
+      output.writeFieldEnd();
+    }
+    if (this.size_statistics != null) {
+      output.writeFieldBegin('size_statistics', thrift.Thrift.Type.STRUCT, 16);
+      this.size_statistics.write(output);
+      output.writeFieldEnd();
+    }
     output.writeFieldStop();
     output.writeStructEnd();
     return;
@@ -384,6 +429,34 @@ export class ColumnMetaData {
             input.skip(fieldType);
           }
           break;
+        case 14:
+          if (fieldType === thrift.Thrift.Type.I64) {
+            _args.bloom_filter_offset = input.readI64();
+          } else {
+            input.skip(fieldType);
+          }
+          break;
+        case 15:
+          if (fieldType === thrift.Thrift.Type.I32) {
+            _args.bloom_filter_length = input.readI32();
+          } else {
+            input.skip(fieldType);
+          }
+          break;
+        case 17:
+          if (fieldType === thrift.Thrift.Type.STRUCT) {
+            _args.geospatial_statistics = GeospatialStatistics.GeospatialStatistics.read(input);
+          } else {
+            input.skip(fieldType);
+          }
+          break;
+        case 16:
+          if (fieldType === thrift.Thrift.Type.STRUCT) {
+            _args.size_statistics = SizeStatistics.SizeStatistics.read(input);
+          } else {
+            input.skip(fieldType);
+          }
+          break;
         default: {
           input.skip(fieldType);
         }

package/src/parquetjs/parquet-thrift/ColumnOrder.ts

@@ -10,7 +10,7 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import * as thrift from 'thrift';
+import * as thrift from '../utils/thrift-runtime';
 import * as TypeDefinedOrder from './TypeDefinedOrder';
 export interface IColumnOrderArgs {
   TYPE_ORDER?: TypeDefinedOrder.TypeDefinedOrder;

package/src/parquetjs/parquet-thrift/DataPageHeader.ts

@@ -10,7 +10,7 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import * as thrift from 'thrift';
+import * as thrift from '../utils/thrift-runtime';
 import * as Encoding from './Encoding';
 import * as Statistics from './Statistics';
 export interface IDataPageHeaderArgs {

package/src/parquetjs/parquet-thrift/DataPageHeaderV2.ts

@@ -10,7 +10,7 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import * as thrift from 'thrift';
+import * as thrift from '../utils/thrift-runtime';
 import * as Encoding from './Encoding';
 import * as Statistics from './Statistics';
 export interface IDataPageHeaderV2Args {

package/src/parquetjs/parquet-thrift/DateType.ts

@@ -10,7 +10,7 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import * as thrift from 'thrift';
+import * as thrift from '../utils/thrift-runtime';
 export interface IDateTypeArgs {}
 export class DateType {
   constructor() {}

package/src/parquetjs/parquet-thrift/DecimalType.ts

@@ -10,7 +10,7 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import * as thrift from 'thrift';
+import * as thrift from '../utils/thrift-runtime';
 export interface IDecimalTypeArgs {
   scale: number;
   precision: number;

package/src/parquetjs/parquet-thrift/DictionaryPageHeader.ts

@@ -10,7 +10,7 @@
  * Autogenerated by @creditkarma/thrift-typescript v3.7.2
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  */
-import * as thrift from 'thrift';
+import * as thrift from '../utils/thrift-runtime';
 import * as Encoding from './Encoding';
 export interface IDictionaryPageHeaderArgs {
   num_values: number;

package/src/parquetjs/parquet-thrift/EdgeInterpolationAlgorithm.ts

@@ -0,0 +1,13 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/* tslint:disable */
+/* eslint-disable */
+export enum EdgeInterpolationAlgorithm {
+  SPHERICAL = 0,
+  VINCENTY = 1,
+  THOMAS = 2,
+  ANDOYER = 3,
+  KARNEY = 4
+}

package/src/parquetjs/parquet-thrift/Encoding.ts

@@ -18,5 +18,6 @@ export enum Encoding {
   DELTA_BINARY_PACKED = 5,
   DELTA_LENGTH_BYTE_ARRAY = 6,
   DELTA_BYTE_ARRAY = 7,
-  RLE_DICTIONARY = 8
+  RLE_DICTIONARY = 8,
+  BYTE_STREAM_SPLIT = 9
 }