@loaders.gl/parquet 5.0.0-alpha.2 → 5.0.0-alpha.4

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/ColumnChunk.ts

@@ -13,6 +13,7 @@
 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/ColumnMetaData.ts

@@ -14,10 +14,12 @@ 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/EncryptionAlgorithm.ts

@@ -0,0 +1,127 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import * as thrift from '../utils/thrift-runtime';
+
+/** AES-GCM algorithm parameters from the Parquet modular-encryption spec. */
+export class AesGcmV1 {
+  public aad_prefix?: Uint8Array;
+  public aad_file_unique?: Uint8Array;
+  public supply_aad_prefix?: boolean;
+
+  constructor(args: Partial<AesGcmV1> = {}) {
+    Object.assign(this, args);
+  }
+}
+
+/** AES-GCM metadata algorithm with AES-CTR page encryption. */
+export class AesGcmCtrV1 extends AesGcmV1 {}
+
+/** Parquet modular-encryption algorithm union. */
+export class EncryptionAlgorithm {
+  public AES_GCM_V1?: AesGcmV1;
+  public AES_GCM_CTR_V1?: AesGcmCtrV1;
+
+  constructor(args: Partial<EncryptionAlgorithm> = {}) {
+    const fields = [args.AES_GCM_V1, args.AES_GCM_CTR_V1].filter(Boolean);
+    if (fields.length !== 1) {
+      throw new thrift.Thrift.TProtocolException(
+        thrift.Thrift.TProtocolExceptionType.INVALID_DATA,
+        'EncryptionAlgorithm must contain exactly one algorithm'
+      );
+    }
+    Object.assign(this, args);
+  }
+
+  /** Writes the selected encryption algorithm union. */
+  public write(output: thrift.TProtocol): void {
+    output.writeStructBegin('EncryptionAlgorithm');
+    if (this.AES_GCM_V1) {
+      writeAlgorithm(output, 'AES_GCM_V1', 1, this.AES_GCM_V1);
+    } else if (this.AES_GCM_CTR_V1) {
+      writeAlgorithm(output, 'AES_GCM_CTR_V1', 2, this.AES_GCM_CTR_V1);
+    }
+    output.writeFieldStop();
+    output.writeStructEnd();
+  }
+
+  /** Reads an encryption algorithm union. */
+  public static read(input: thrift.TProtocol): EncryptionAlgorithm {
+    input.readStructBegin();
+    let algorithm: EncryptionAlgorithm | 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) {
+        algorithm = new EncryptionAlgorithm({AES_GCM_V1: readAlgorithm(input)});
+      } else if (field.fid === 2 && field.ftype === thrift.Thrift.Type.STRUCT) {
+        algorithm = new EncryptionAlgorithm({AES_GCM_CTR_V1: readAlgorithm(input)});
+      } else {
+        input.skip(field.ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    if (!algorithm) {
+      throw new thrift.Thrift.TProtocolException(
+        thrift.Thrift.TProtocolExceptionType.INVALID_DATA,
+        'EncryptionAlgorithm union has no selected algorithm'
+      );
+    }
+    return algorithm;
+  }
+}
+
+function writeAlgorithm(
+  output: thrift.TProtocol,
+  name: string,
+  fieldId: number,
+  algorithm: AesGcmV1
+): void {
+  output.writeFieldBegin(name, thrift.Thrift.Type.STRUCT, fieldId);
+  output.writeStructBegin(name);
+  if (algorithm.aad_prefix) writeBinary(output, 'aad_prefix', 1, algorithm.aad_prefix);
+  if (algorithm.aad_file_unique)
+    writeBinary(output, 'aad_file_unique', 2, algorithm.aad_file_unique);
+  if (algorithm.supply_aad_prefix !== undefined) {
+    output.writeFieldBegin('supply_aad_prefix', thrift.Thrift.Type.BOOL, 3);
+    output.writeBool(algorithm.supply_aad_prefix);
+    output.writeFieldEnd();
+  }
+  output.writeFieldStop();
+  output.writeStructEnd();
+  output.writeFieldEnd();
+}
+
+function readAlgorithm(input: thrift.TProtocol): AesGcmV1 {
+  input.readStructBegin();
+  const result = new AesGcmV1();
+  while (true) {
+    const field = input.readFieldBegin();
+    if (field.ftype === thrift.Thrift.Type.STOP) break;
+    if (field.fid === 1 && field.ftype === thrift.Thrift.Type.STRING) {
+      result.aad_prefix = input.readBinary();
+    } else if (field.fid === 2 && field.ftype === thrift.Thrift.Type.STRING) {
+      result.aad_file_unique = input.readBinary();
+    } else if (field.fid === 3 && field.ftype === thrift.Thrift.Type.BOOL) {
+      result.supply_aad_prefix = input.readBool();
+    } else {
+      input.skip(field.ftype);
+    }
+    input.readFieldEnd();
+  }
+  input.readStructEnd();
+  return result;
+}
+
+function writeBinary(
+  output: thrift.TProtocol,
+  name: string,
+  fieldId: number,
+  value: Uint8Array
+): void {
+  output.writeFieldBegin(name, thrift.Thrift.Type.STRING, fieldId);
+  output.writeBinary(value);
+  output.writeFieldEnd();
+}

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

@@ -0,0 +1,60 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import * as thrift from '../utils/thrift-runtime';
+import * as EncryptionAlgorithm from './EncryptionAlgorithm';
+
+/** File-level crypto metadata stored before an encrypted Parquet footer. */
+export class FileCryptoMetaData {
+  public encryption_algorithm: EncryptionAlgorithm.EncryptionAlgorithm;
+  public key_metadata?: Uint8Array;
+  constructor(args: {
+    encryption_algorithm: EncryptionAlgorithm.EncryptionAlgorithm;
+    key_metadata?: Uint8Array;
+  }) {
+    this.encryption_algorithm = args.encryption_algorithm;
+    this.key_metadata = args.key_metadata;
+  }
+
+  /** Writes file-level encryption metadata. */
+  public write(output: thrift.TProtocol): void {
+    output.writeStructBegin('FileCryptoMetaData');
+    output.writeFieldBegin('encryption_algorithm', thrift.Thrift.Type.STRUCT, 1);
+    this.encryption_algorithm.write(output);
+    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 file-level encryption metadata. */
+  public static read(input: thrift.TProtocol): FileCryptoMetaData {
+    input.readStructBegin();
+    let encryptionAlgorithm: EncryptionAlgorithm.EncryptionAlgorithm | 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.STRUCT) {
+        encryptionAlgorithm = EncryptionAlgorithm.EncryptionAlgorithm.read(input);
+      } else if (field.fid === 2 && field.ftype === thrift.Thrift.Type.STRING) {
+        keyMetadata = input.readBinary();
+      } else {
+        input.skip(field.ftype);
+      }
+      input.readFieldEnd();
+    }
+    input.readStructEnd();
+    if (!encryptionAlgorithm)
+      throw new Error('FileCryptoMetaData encryption_algorithm is required');
+    return new FileCryptoMetaData({
+      encryption_algorithm: encryptionAlgorithm,
+      key_metadata: keyMetadata
+    });
+  }
+}