@types/google-protobuf - npm Package Compare versions

Comparing version 3.15.6 to 3.15.7

google-protobuf/google/protobuf/any_pb.d.ts

@@ -7,29 +7,29 @@ // package: google.protobuf
 export class Any extends jspb.Message {
-  getTypeUrl(): string;
-  setTypeUrl(value: string): Any;
+    getTypeUrl(): string;
+    setTypeUrl(value: string): Any;
 
-  getValue(): Uint8Array | string;
-  getValue_asU8(): Uint8Array;
-  getValue_asB64(): string;
-  setValue(value: Uint8Array | string): Any;
+    getValue(): Uint8Array | string;
+    getValue_asU8(): Uint8Array;
+    getValue_asB64(): string;
+    setValue(value: Uint8Array | string): Any;
 
-  getTypeName(): string;
-  pack(serialized: Uint8Array, name: string, typeUrlPrefix?: string): void;
-  unpack<T extends jspb.Message>(deserialize: (packed: Uint8Array) => T, name: string): T | null;
+    getTypeName(): string;
+    pack(serialized: Uint8Array, name: string, typeUrlPrefix?: string): void;
+    unpack<T extends jspb.Message>(deserialize: (packed: Uint8Array) => T, name: string): T | null;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Any.AsObject;
-  static toObject(includeInstance: boolean, msg: Any): Any.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Any, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Any;
-  static deserializeBinaryFromReader(message: Any, reader: jspb.BinaryReader): Any;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Any.AsObject;
+    static toObject(includeInstance: boolean, msg: Any): Any.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Any, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Any;
+    static deserializeBinaryFromReader(message: Any, reader: jspb.BinaryReader): Any;
 }
 
 export namespace Any {
-  export type AsObject = {
-    typeUrl: string,
-    value: Uint8Array | string,
-  }
+    export type AsObject = {
+        typeUrl: string;
+        value: Uint8Array | string;
+    };
 }

google-protobuf/google/protobuf/api_pb.d.ts

@@ -9,121 +9,121 @@ // package: google.protobuf
 export class Api extends jspb.Message {
-  getName(): string;
-  setName(value: string): Api;
+    getName(): string;
+    setName(value: string): Api;
 
-  clearMethodsList(): Api;
-  getMethodsList(): Array<Method>;
-  setMethodsList(value: Array<Method>): Api;
-  addMethods(value?: Method, index?: number): Method;
+    clearMethodsList(): Api;
+    getMethodsList(): Array<Method>;
+    setMethodsList(value: Array<Method>): Api;
+    addMethods(value?: Method, index?: number): Method;
 
-  clearOptionsList(): Api;
-  getOptionsList(): Array<google_protobuf_type_pb.Option>;
-  setOptionsList(value: Array<google_protobuf_type_pb.Option>): Api;
-  addOptions(value?: google_protobuf_type_pb.Option, index?: number): google_protobuf_type_pb.Option;
+    clearOptionsList(): Api;
+    getOptionsList(): Array<google_protobuf_type_pb.Option>;
+    setOptionsList(value: Array<google_protobuf_type_pb.Option>): Api;
+    addOptions(value?: google_protobuf_type_pb.Option, index?: number): google_protobuf_type_pb.Option;
 
-  getVersion(): string;
-  setVersion(value: string): Api;
+    getVersion(): string;
+    setVersion(value: string): Api;
 
-  hasSourceContext(): boolean;
-  clearSourceContext(): Api;
-  getSourceContext(): google_protobuf_source_context_pb.SourceContext | undefined;
-  setSourceContext(value?: google_protobuf_source_context_pb.SourceContext): Api;
+    hasSourceContext(): boolean;
+    clearSourceContext(): Api;
+    getSourceContext(): google_protobuf_source_context_pb.SourceContext | undefined;
+    setSourceContext(value?: google_protobuf_source_context_pb.SourceContext): Api;
 
-  clearMixinsList(): Api;
-  getMixinsList(): Array<Mixin>;
-  setMixinsList(value: Array<Mixin>): Api;
-  addMixins(value?: Mixin, index?: number): Mixin;
+    clearMixinsList(): Api;
+    getMixinsList(): Array<Mixin>;
+    setMixinsList(value: Array<Mixin>): Api;
+    addMixins(value?: Mixin, index?: number): Mixin;
 
-  getSyntax(): google_protobuf_type_pb.Syntax;
-  setSyntax(value: google_protobuf_type_pb.Syntax): Api;
+    getSyntax(): google_protobuf_type_pb.Syntax;
+    setSyntax(value: google_protobuf_type_pb.Syntax): Api;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Api.AsObject;
-  static toObject(includeInstance: boolean, msg: Api): Api.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Api, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Api;
-  static deserializeBinaryFromReader(message: Api, reader: jspb.BinaryReader): Api;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Api.AsObject;
+    static toObject(includeInstance: boolean, msg: Api): Api.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Api, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Api;
+    static deserializeBinaryFromReader(message: Api, reader: jspb.BinaryReader): Api;
 }
 
 export namespace Api {
-  export type AsObject = {
-    name: string,
-    methodsList: Array<Method.AsObject>,
-    optionsList: Array<google_protobuf_type_pb.Option.AsObject>,
-    version: string,
-    sourceContext?: google_protobuf_source_context_pb.SourceContext.AsObject | undefined,
-    mixinsList: Array<Mixin.AsObject>,
-    syntax: google_protobuf_type_pb.Syntax,
-  }
+    export type AsObject = {
+        name: string;
+        methodsList: Array<Method.AsObject>;
+        optionsList: Array<google_protobuf_type_pb.Option.AsObject>;
+        version: string;
+        sourceContext?: google_protobuf_source_context_pb.SourceContext.AsObject | undefined;
+        mixinsList: Array<Mixin.AsObject>;
+        syntax: google_protobuf_type_pb.Syntax;
+    };
 }
 
 export class Method extends jspb.Message {
-  getName(): string;
-  setName(value: string): Method;
+    getName(): string;
+    setName(value: string): Method;
 
-  getRequestTypeUrl(): string;
-  setRequestTypeUrl(value: string): Method;
+    getRequestTypeUrl(): string;
+    setRequestTypeUrl(value: string): Method;
 
-  getRequestStreaming(): boolean;
-  setRequestStreaming(value: boolean): Method;
+    getRequestStreaming(): boolean;
+    setRequestStreaming(value: boolean): Method;
 
-  getResponseTypeUrl(): string;
-  setResponseTypeUrl(value: string): Method;
+    getResponseTypeUrl(): string;
+    setResponseTypeUrl(value: string): Method;
 
-  getResponseStreaming(): boolean;
-  setResponseStreaming(value: boolean): Method;
+    getResponseStreaming(): boolean;
+    setResponseStreaming(value: boolean): Method;
 
-  clearOptionsList(): Method;
-  getOptionsList(): Array<google_protobuf_type_pb.Option>;
-  setOptionsList(value: Array<google_protobuf_type_pb.Option>): Method;
-  addOptions(value?: google_protobuf_type_pb.Option, index?: number): google_protobuf_type_pb.Option;
+    clearOptionsList(): Method;
+    getOptionsList(): Array<google_protobuf_type_pb.Option>;
+    setOptionsList(value: Array<google_protobuf_type_pb.Option>): Method;
+    addOptions(value?: google_protobuf_type_pb.Option, index?: number): google_protobuf_type_pb.Option;
 
-  getSyntax(): google_protobuf_type_pb.Syntax;
-  setSyntax(value: google_protobuf_type_pb.Syntax): Method;
+    getSyntax(): google_protobuf_type_pb.Syntax;
+    setSyntax(value: google_protobuf_type_pb.Syntax): Method;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Method.AsObject;
-  static toObject(includeInstance: boolean, msg: Method): Method.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Method, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Method;
-  static deserializeBinaryFromReader(message: Method, reader: jspb.BinaryReader): Method;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Method.AsObject;
+    static toObject(includeInstance: boolean, msg: Method): Method.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Method, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Method;
+    static deserializeBinaryFromReader(message: Method, reader: jspb.BinaryReader): Method;
 }
 
 export namespace Method {
-  export type AsObject = {
-    name: string,
-    requestTypeUrl: string,
-    requestStreaming: boolean,
-    responseTypeUrl: string,
-    responseStreaming: boolean,
-    optionsList: Array<google_protobuf_type_pb.Option.AsObject>,
-    syntax: google_protobuf_type_pb.Syntax,
-  }
+    export type AsObject = {
+        name: string;
+        requestTypeUrl: string;
+        requestStreaming: boolean;
+        responseTypeUrl: string;
+        responseStreaming: boolean;
+        optionsList: Array<google_protobuf_type_pb.Option.AsObject>;
+        syntax: google_protobuf_type_pb.Syntax;
+    };
 }
 
 export class Mixin extends jspb.Message {
-  getName(): string;
-  setName(value: string): Mixin;
+    getName(): string;
+    setName(value: string): Mixin;
 
-  getRoot(): string;
-  setRoot(value: string): Mixin;
+    getRoot(): string;
+    setRoot(value: string): Mixin;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Mixin.AsObject;
-  static toObject(includeInstance: boolean, msg: Mixin): Mixin.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Mixin, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Mixin;
-  static deserializeBinaryFromReader(message: Mixin, reader: jspb.BinaryReader): Mixin;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Mixin.AsObject;
+    static toObject(includeInstance: boolean, msg: Mixin): Mixin.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Mixin, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Mixin;
+    static deserializeBinaryFromReader(message: Mixin, reader: jspb.BinaryReader): Mixin;
 }
 
 export namespace Mixin {
-  export type AsObject = {
-    name: string,
-    root: string,
-  }
+    export type AsObject = {
+        name: string;
+        root: string;
+    };
 }

google-protobuf/google/protobuf/compiler/plugin_pb.d.ts

@@ -8,152 +8,158 @@ // package: google.protobuf.compiler
 export class Version extends jspb.Message {
-  hasMajor(): boolean;
-  clearMajor(): Version;
-  getMajor(): number | undefined;
-  setMajor(value: number): Version;
+    hasMajor(): boolean;
+    clearMajor(): Version;
+    getMajor(): number | undefined;
+    setMajor(value: number): Version;
 
-  hasMinor(): boolean;
-  clearMinor(): Version;
-  getMinor(): number | undefined;
-  setMinor(value: number): Version;
+    hasMinor(): boolean;
+    clearMinor(): Version;
+    getMinor(): number | undefined;
+    setMinor(value: number): Version;
 
-  hasPatch(): boolean;
-  clearPatch(): Version;
-  getPatch(): number | undefined;
-  setPatch(value: number): Version;
+    hasPatch(): boolean;
+    clearPatch(): Version;
+    getPatch(): number | undefined;
+    setPatch(value: number): Version;
 
-  hasSuffix(): boolean;
-  clearSuffix(): Version;
-  getSuffix(): string | undefined;
-  setSuffix(value: string): Version;
+    hasSuffix(): boolean;
+    clearSuffix(): Version;
+    getSuffix(): string | undefined;
+    setSuffix(value: string): Version;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Version.AsObject;
-  static toObject(includeInstance: boolean, msg: Version): Version.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Version, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Version;
-  static deserializeBinaryFromReader(message: Version, reader: jspb.BinaryReader): Version;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Version.AsObject;
+    static toObject(includeInstance: boolean, msg: Version): Version.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Version, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Version;
+    static deserializeBinaryFromReader(message: Version, reader: jspb.BinaryReader): Version;
 }
 
 export namespace Version {
-  export type AsObject = {
-    major?: number | undefined,
-    minor?: number | undefined,
-    patch?: number | undefined,
-    suffix?: string | undefined,
-  }
+    export type AsObject = {
+        major?: number | undefined;
+        minor?: number | undefined;
+        patch?: number | undefined;
+        suffix?: string | undefined;
+    };
 }
 
 export class CodeGeneratorRequest extends jspb.Message {
-  clearFileToGenerateList(): CodeGeneratorRequest;
-  getFileToGenerateList(): Array<string>;
-  setFileToGenerateList(value: Array<string>): CodeGeneratorRequest;
-  addFileToGenerate(value: string, index?: number): string;
+    clearFileToGenerateList(): CodeGeneratorRequest;
+    getFileToGenerateList(): Array<string>;
+    setFileToGenerateList(value: Array<string>): CodeGeneratorRequest;
+    addFileToGenerate(value: string, index?: number): string;
 
-  hasParameter(): boolean;
-  clearParameter(): CodeGeneratorRequest;
-  getParameter(): string | undefined;
-  setParameter(value: string): CodeGeneratorRequest;
+    hasParameter(): boolean;
+    clearParameter(): CodeGeneratorRequest;
+    getParameter(): string | undefined;
+    setParameter(value: string): CodeGeneratorRequest;
 
-  clearProtoFileList(): CodeGeneratorRequest;
-  getProtoFileList(): Array<google_protobuf_descriptor_pb.FileDescriptorProto>;
-  setProtoFileList(value: Array<google_protobuf_descriptor_pb.FileDescriptorProto>): CodeGeneratorRequest;
-  addProtoFile(value?: google_protobuf_descriptor_pb.FileDescriptorProto, index?: number): google_protobuf_descriptor_pb.FileDescriptorProto;
+    clearProtoFileList(): CodeGeneratorRequest;
+    getProtoFileList(): Array<google_protobuf_descriptor_pb.FileDescriptorProto>;
+    setProtoFileList(value: Array<google_protobuf_descriptor_pb.FileDescriptorProto>): CodeGeneratorRequest;
+    addProtoFile(
+        value?: google_protobuf_descriptor_pb.FileDescriptorProto,
+        index?: number,
+    ): google_protobuf_descriptor_pb.FileDescriptorProto;
 
-  hasCompilerVersion(): boolean;
-  clearCompilerVersion(): CodeGeneratorRequest;
-  getCompilerVersion(): Version | undefined;
-  setCompilerVersion(value?: Version): CodeGeneratorRequest;
+    hasCompilerVersion(): boolean;
+    clearCompilerVersion(): CodeGeneratorRequest;
+    getCompilerVersion(): Version | undefined;
+    setCompilerVersion(value?: Version): CodeGeneratorRequest;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): CodeGeneratorRequest.AsObject;
-  static toObject(includeInstance: boolean, msg: CodeGeneratorRequest): CodeGeneratorRequest.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: CodeGeneratorRequest, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): CodeGeneratorRequest;
-  static deserializeBinaryFromReader(message: CodeGeneratorRequest, reader: jspb.BinaryReader): CodeGeneratorRequest;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CodeGeneratorRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: CodeGeneratorRequest): CodeGeneratorRequest.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: CodeGeneratorRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CodeGeneratorRequest;
+    static deserializeBinaryFromReader(message: CodeGeneratorRequest, reader: jspb.BinaryReader): CodeGeneratorRequest;
 }
 
 export namespace CodeGeneratorRequest {
-  export type AsObject = {
-    fileToGenerateList: Array<string>,
-    parameter?: string | undefined,
-    protoFileList: Array<google_protobuf_descriptor_pb.FileDescriptorProto.AsObject>,
-    compilerVersion?: Version.AsObject | undefined,
-  }
+    export type AsObject = {
+        fileToGenerateList: Array<string>;
+        parameter?: string | undefined;
+        protoFileList: Array<google_protobuf_descriptor_pb.FileDescriptorProto.AsObject>;
+        compilerVersion?: Version.AsObject | undefined;
+    };
 }
 
 export class CodeGeneratorResponse extends jspb.Message {
-  hasError(): boolean;
-  clearError(): CodeGeneratorResponse;
-  getError(): string | undefined;
-  setError(value: string): CodeGeneratorResponse;
+    hasError(): boolean;
+    clearError(): CodeGeneratorResponse;
+    getError(): string | undefined;
+    setError(value: string): CodeGeneratorResponse;
 
-  hasSupportedFeatures(): boolean;
-  clearSupportedFeatures(): CodeGeneratorResponse;
-  getSupportedFeatures(): number | undefined;
-  setSupportedFeatures(value: number): CodeGeneratorResponse;
+    hasSupportedFeatures(): boolean;
+    clearSupportedFeatures(): CodeGeneratorResponse;
+    getSupportedFeatures(): number | undefined;
+    setSupportedFeatures(value: number): CodeGeneratorResponse;
 
-  clearFileList(): CodeGeneratorResponse;
-  getFileList(): Array<CodeGeneratorResponse.File>;
-  setFileList(value: Array<CodeGeneratorResponse.File>): CodeGeneratorResponse;
-  addFile(value?: CodeGeneratorResponse.File, index?: number): CodeGeneratorResponse.File;
+    clearFileList(): CodeGeneratorResponse;
+    getFileList(): Array<CodeGeneratorResponse.File>;
+    setFileList(value: Array<CodeGeneratorResponse.File>): CodeGeneratorResponse;
+    addFile(value?: CodeGeneratorResponse.File, index?: number): CodeGeneratorResponse.File;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): CodeGeneratorResponse.AsObject;
-  static toObject(includeInstance: boolean, msg: CodeGeneratorResponse): CodeGeneratorResponse.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: CodeGeneratorResponse, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): CodeGeneratorResponse;
-  static deserializeBinaryFromReader(message: CodeGeneratorResponse, reader: jspb.BinaryReader): CodeGeneratorResponse;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CodeGeneratorResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: CodeGeneratorResponse): CodeGeneratorResponse.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: CodeGeneratorResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CodeGeneratorResponse;
+    static deserializeBinaryFromReader(
+        message: CodeGeneratorResponse,
+        reader: jspb.BinaryReader,
+    ): CodeGeneratorResponse;
 }
 
 export namespace CodeGeneratorResponse {
-  export type AsObject = {
-    error?: string | undefined,
-    supportedFeatures?: number | undefined,
-    fileList: Array<File.AsObject>,
-  }
+    export type AsObject = {
+        error?: string | undefined;
+        supportedFeatures?: number | undefined;
+        fileList: Array<File.AsObject>;
+    };
 
-  export enum Feature {
-    FEATURE_NONE = 0,
-    FEATURE_PROTO3_OPTIONAL = 1,
-  }
+    export enum Feature {
+        FEATURE_NONE = 0,
+        FEATURE_PROTO3_OPTIONAL = 1,
+    }
 
-  export class File extends jspb.Message {
-    hasName(): boolean;
-    clearName(): File;
-    getName(): string | undefined;
-    setName(value: string): File;
+    export class File extends jspb.Message {
+        hasName(): boolean;
+        clearName(): File;
+        getName(): string | undefined;
+        setName(value: string): File;
 
-    hasInsertionPoint(): boolean;
-    clearInsertionPoint(): File;
-    getInsertionPoint(): string | undefined;
-    setInsertionPoint(value: string): File;
+        hasInsertionPoint(): boolean;
+        clearInsertionPoint(): File;
+        getInsertionPoint(): string | undefined;
+        setInsertionPoint(value: string): File;
 
-    hasContent(): boolean;
-    clearContent(): File;
-    getContent(): string | undefined;
-    setContent(value: string): File;
+        hasContent(): boolean;
+        clearContent(): File;
+        getContent(): string | undefined;
+        setContent(value: string): File;
 
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): File.AsObject;
-    static toObject(includeInstance: boolean, msg: File): File.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: File, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): File;
-    static deserializeBinaryFromReader(message: File, reader: jspb.BinaryReader): File;
-  }
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): File.AsObject;
+        static toObject(includeInstance: boolean, msg: File): File.AsObject;
+        static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+        static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+        static serializeBinaryToWriter(message: File, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): File;
+        static deserializeBinaryFromReader(message: File, reader: jspb.BinaryReader): File;
+    }
 
-  export namespace File {
-    export type AsObject = {
-      name?: string | undefined,
-      insertionPoint?: string | undefined,
-      content?: string | undefined,
+    export namespace File {
+        export type AsObject = {
+            name?: string | undefined;
+            insertionPoint?: string | undefined;
+            content?: string | undefined;
+        };
     }
-  }
 }

google-protobuf/google/protobuf/descriptor_pb.d.ts

@@ -7,1234 +7,1249 @@ // package: google.protobuf
 export class FileDescriptorSet extends jspb.Message {
-  clearFileList(): FileDescriptorSet;
-  getFileList(): Array<FileDescriptorProto>;
-  setFileList(value: Array<FileDescriptorProto>): FileDescriptorSet;
-  addFile(value?: FileDescriptorProto, index?: number): FileDescriptorProto;
+    clearFileList(): FileDescriptorSet;
+    getFileList(): Array<FileDescriptorProto>;
+    setFileList(value: Array<FileDescriptorProto>): FileDescriptorSet;
+    addFile(value?: FileDescriptorProto, index?: number): FileDescriptorProto;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): FileDescriptorSet.AsObject;
-  static toObject(includeInstance: boolean, msg: FileDescriptorSet): FileDescriptorSet.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: FileDescriptorSet, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): FileDescriptorSet;
-  static deserializeBinaryFromReader(message: FileDescriptorSet, reader: jspb.BinaryReader): FileDescriptorSet;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): FileDescriptorSet.AsObject;
+    static toObject(includeInstance: boolean, msg: FileDescriptorSet): FileDescriptorSet.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: FileDescriptorSet, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): FileDescriptorSet;
+    static deserializeBinaryFromReader(message: FileDescriptorSet, reader: jspb.BinaryReader): FileDescriptorSet;
 }
 
 export namespace FileDescriptorSet {
-  export type AsObject = {
-    fileList: Array<FileDescriptorProto.AsObject>,
-  }
+    export type AsObject = {
+        fileList: Array<FileDescriptorProto.AsObject>;
+    };
 }
 
 export class FileDescriptorProto extends jspb.Message {
-  hasName(): boolean;
-  clearName(): FileDescriptorProto;
-  getName(): string | undefined;
-  setName(value: string): FileDescriptorProto;
+    hasName(): boolean;
+    clearName(): FileDescriptorProto;
+    getName(): string | undefined;
+    setName(value: string): FileDescriptorProto;
 
-  hasPackage(): boolean;
-  clearPackage(): FileDescriptorProto;
-  getPackage(): string | undefined;
-  setPackage(value: string): FileDescriptorProto;
+    hasPackage(): boolean;
+    clearPackage(): FileDescriptorProto;
+    getPackage(): string | undefined;
+    setPackage(value: string): FileDescriptorProto;
 
-  clearDependencyList(): FileDescriptorProto;
-  getDependencyList(): Array<string>;
-  setDependencyList(value: Array<string>): FileDescriptorProto;
-  addDependency(value: string, index?: number): string;
+    clearDependencyList(): FileDescriptorProto;
+    getDependencyList(): Array<string>;
+    setDependencyList(value: Array<string>): FileDescriptorProto;
+    addDependency(value: string, index?: number): string;
 
-  clearPublicDependencyList(): FileDescriptorProto;
-  getPublicDependencyList(): Array<number>;
-  setPublicDependencyList(value: Array<number>): FileDescriptorProto;
-  addPublicDependency(value: number, index?: number): number;
+    clearPublicDependencyList(): FileDescriptorProto;
+    getPublicDependencyList(): Array<number>;
+    setPublicDependencyList(value: Array<number>): FileDescriptorProto;
+    addPublicDependency(value: number, index?: number): number;
 
-  clearWeakDependencyList(): FileDescriptorProto;
-  getWeakDependencyList(): Array<number>;
-  setWeakDependencyList(value: Array<number>): FileDescriptorProto;
-  addWeakDependency(value: number, index?: number): number;
+    clearWeakDependencyList(): FileDescriptorProto;
+    getWeakDependencyList(): Array<number>;
+    setWeakDependencyList(value: Array<number>): FileDescriptorProto;
+    addWeakDependency(value: number, index?: number): number;
 
-  clearMessageTypeList(): FileDescriptorProto;
-  getMessageTypeList(): Array<DescriptorProto>;
-  setMessageTypeList(value: Array<DescriptorProto>): FileDescriptorProto;
-  addMessageType(value?: DescriptorProto, index?: number): DescriptorProto;
+    clearMessageTypeList(): FileDescriptorProto;
+    getMessageTypeList(): Array<DescriptorProto>;
+    setMessageTypeList(value: Array<DescriptorProto>): FileDescriptorProto;
+    addMessageType(value?: DescriptorProto, index?: number): DescriptorProto;
 
-  clearEnumTypeList(): FileDescriptorProto;
-  getEnumTypeList(): Array<EnumDescriptorProto>;
-  setEnumTypeList(value: Array<EnumDescriptorProto>): FileDescriptorProto;
-  addEnumType(value?: EnumDescriptorProto, index?: number): EnumDescriptorProto;
+    clearEnumTypeList(): FileDescriptorProto;
+    getEnumTypeList(): Array<EnumDescriptorProto>;
+    setEnumTypeList(value: Array<EnumDescriptorProto>): FileDescriptorProto;
+    addEnumType(value?: EnumDescriptorProto, index?: number): EnumDescriptorProto;
 
-  clearServiceList(): FileDescriptorProto;
-  getServiceList(): Array<ServiceDescriptorProto>;
-  setServiceList(value: Array<ServiceDescriptorProto>): FileDescriptorProto;
-  addService(value?: ServiceDescriptorProto, index?: number): ServiceDescriptorProto;
+    clearServiceList(): FileDescriptorProto;
+    getServiceList(): Array<ServiceDescriptorProto>;
+    setServiceList(value: Array<ServiceDescriptorProto>): FileDescriptorProto;
+    addService(value?: ServiceDescriptorProto, index?: number): ServiceDescriptorProto;
 
-  clearExtensionList(): FileDescriptorProto;
-  getExtensionList(): Array<FieldDescriptorProto>;
-  setExtensionList(value: Array<FieldDescriptorProto>): FileDescriptorProto;
-  addExtension(value?: FieldDescriptorProto, index?: number): FieldDescriptorProto;
+    clearExtensionList(): FileDescriptorProto;
+    getExtensionList(): Array<FieldDescriptorProto>;
+    setExtensionList(value: Array<FieldDescriptorProto>): FileDescriptorProto;
+    addExtension(value?: FieldDescriptorProto, index?: number): FieldDescriptorProto;
 
-  hasOptions(): boolean;
-  clearOptions(): FileDescriptorProto;
-  getOptions(): FileOptions | undefined;
-  setOptions(value?: FileOptions): FileDescriptorProto;
+    hasOptions(): boolean;
+    clearOptions(): FileDescriptorProto;
+    getOptions(): FileOptions | undefined;
+    setOptions(value?: FileOptions): FileDescriptorProto;
 
-  hasSourceCodeInfo(): boolean;
-  clearSourceCodeInfo(): FileDescriptorProto;
-  getSourceCodeInfo(): SourceCodeInfo | undefined;
-  setSourceCodeInfo(value?: SourceCodeInfo): FileDescriptorProto;
+    hasSourceCodeInfo(): boolean;
+    clearSourceCodeInfo(): FileDescriptorProto;
+    getSourceCodeInfo(): SourceCodeInfo | undefined;
+    setSourceCodeInfo(value?: SourceCodeInfo): FileDescriptorProto;
 
-  hasSyntax(): boolean;
-  clearSyntax(): FileDescriptorProto;
-  getSyntax(): string | undefined;
-  setSyntax(value: string): FileDescriptorProto;
+    hasSyntax(): boolean;
+    clearSyntax(): FileDescriptorProto;
+    getSyntax(): string | undefined;
+    setSyntax(value: string): FileDescriptorProto;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): FileDescriptorProto.AsObject;
-  static toObject(includeInstance: boolean, msg: FileDescriptorProto): FileDescriptorProto.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: FileDescriptorProto, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): FileDescriptorProto;
-  static deserializeBinaryFromReader(message: FileDescriptorProto, reader: jspb.BinaryReader): FileDescriptorProto;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): FileDescriptorProto.AsObject;
+    static toObject(includeInstance: boolean, msg: FileDescriptorProto): FileDescriptorProto.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: FileDescriptorProto, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): FileDescriptorProto;
+    static deserializeBinaryFromReader(message: FileDescriptorProto, reader: jspb.BinaryReader): FileDescriptorProto;
 }
 
 export namespace FileDescriptorProto {
-  export type AsObject = {
-    name?: string | undefined,
-    pb_package?: string | undefined,
-    dependencyList: Array<string>,
-    publicDependencyList: Array<number>,
-    weakDependencyList: Array<number>,
-    messageTypeList: Array<DescriptorProto.AsObject>,
-    enumTypeList: Array<EnumDescriptorProto.AsObject>,
-    serviceList: Array<ServiceDescriptorProto.AsObject>,
-    extensionList: Array<FieldDescriptorProto.AsObject>,
-    options?: FileOptions.AsObject | undefined,
-    sourceCodeInfo?: SourceCodeInfo.AsObject | undefined,
-    syntax?: string | undefined,
-  }
+    export type AsObject = {
+        name?: string | undefined;
+        pb_package?: string | undefined;
+        dependencyList: Array<string>;
+        publicDependencyList: Array<number>;
+        weakDependencyList: Array<number>;
+        messageTypeList: Array<DescriptorProto.AsObject>;
+        enumTypeList: Array<EnumDescriptorProto.AsObject>;
+        serviceList: Array<ServiceDescriptorProto.AsObject>;
+        extensionList: Array<FieldDescriptorProto.AsObject>;
+        options?: FileOptions.AsObject | undefined;
+        sourceCodeInfo?: SourceCodeInfo.AsObject | undefined;
+        syntax?: string | undefined;
+    };
 }
 
 export class DescriptorProto extends jspb.Message {
-  hasName(): boolean;
-  clearName(): DescriptorProto;
-  getName(): string | undefined;
-  setName(value: string): DescriptorProto;
+    hasName(): boolean;
+    clearName(): DescriptorProto;
+    getName(): string | undefined;
+    setName(value: string): DescriptorProto;
 
-  clearFieldList(): DescriptorProto;
-  getFieldList(): Array<FieldDescriptorProto>;
-  setFieldList(value: Array<FieldDescriptorProto>): DescriptorProto;
-  addField(value?: FieldDescriptorProto, index?: number): FieldDescriptorProto;
+    clearFieldList(): DescriptorProto;
+    getFieldList(): Array<FieldDescriptorProto>;
+    setFieldList(value: Array<FieldDescriptorProto>): DescriptorProto;
+    addField(value?: FieldDescriptorProto, index?: number): FieldDescriptorProto;
 
-  clearExtensionList(): DescriptorProto;
-  getExtensionList(): Array<FieldDescriptorProto>;
-  setExtensionList(value: Array<FieldDescriptorProto>): DescriptorProto;
-  addExtension(value?: FieldDescriptorProto, index?: number): FieldDescriptorProto;
+    clearExtensionList(): DescriptorProto;
+    getExtensionList(): Array<FieldDescriptorProto>;
+    setExtensionList(value: Array<FieldDescriptorProto>): DescriptorProto;
+    addExtension(value?: FieldDescriptorProto, index?: number): FieldDescriptorProto;
 
-  clearNestedTypeList(): DescriptorProto;
-  getNestedTypeList(): Array<DescriptorProto>;
-  setNestedTypeList(value: Array<DescriptorProto>): DescriptorProto;
-  addNestedType(value?: DescriptorProto, index?: number): DescriptorProto;
+    clearNestedTypeList(): DescriptorProto;
+    getNestedTypeList(): Array<DescriptorProto>;
+    setNestedTypeList(value: Array<DescriptorProto>): DescriptorProto;
+    addNestedType(value?: DescriptorProto, index?: number): DescriptorProto;
 
-  clearEnumTypeList(): DescriptorProto;
-  getEnumTypeList(): Array<EnumDescriptorProto>;
-  setEnumTypeList(value: Array<EnumDescriptorProto>): DescriptorProto;
-  addEnumType(value?: EnumDescriptorProto, index?: number): EnumDescriptorProto;
+    clearEnumTypeList(): DescriptorProto;
+    getEnumTypeList(): Array<EnumDescriptorProto>;
+    setEnumTypeList(value: Array<EnumDescriptorProto>): DescriptorProto;
+    addEnumType(value?: EnumDescriptorProto, index?: number): EnumDescriptorProto;
 
-  clearExtensionRangeList(): DescriptorProto;
-  getExtensionRangeList(): Array<DescriptorProto.ExtensionRange>;
-  setExtensionRangeList(value: Array<DescriptorProto.ExtensionRange>): DescriptorProto;
-  addExtensionRange(value?: DescriptorProto.ExtensionRange, index?: number): DescriptorProto.ExtensionRange;
+    clearExtensionRangeList(): DescriptorProto;
+    getExtensionRangeList(): Array<DescriptorProto.ExtensionRange>;
+    setExtensionRangeList(value: Array<DescriptorProto.ExtensionRange>): DescriptorProto;
+    addExtensionRange(value?: DescriptorProto.ExtensionRange, index?: number): DescriptorProto.ExtensionRange;
 
-  clearOneofDeclList(): DescriptorProto;
-  getOneofDeclList(): Array<OneofDescriptorProto>;
-  setOneofDeclList(value: Array<OneofDescriptorProto>): DescriptorProto;
-  addOneofDecl(value?: OneofDescriptorProto, index?: number): OneofDescriptorProto;
+    clearOneofDeclList(): DescriptorProto;
+    getOneofDeclList(): Array<OneofDescriptorProto>;
+    setOneofDeclList(value: Array<OneofDescriptorProto>): DescriptorProto;
+    addOneofDecl(value?: OneofDescriptorProto, index?: number): OneofDescriptorProto;
 
-  hasOptions(): boolean;
-  clearOptions(): DescriptorProto;
-  getOptions(): MessageOptions | undefined;
-  setOptions(value?: MessageOptions): DescriptorProto;
+    hasOptions(): boolean;
+    clearOptions(): DescriptorProto;
+    getOptions(): MessageOptions | undefined;
+    setOptions(value?: MessageOptions): DescriptorProto;
 
-  clearReservedRangeList(): DescriptorProto;
-  getReservedRangeList(): Array<DescriptorProto.ReservedRange>;
-  setReservedRangeList(value: Array<DescriptorProto.ReservedRange>): DescriptorProto;
-  addReservedRange(value?: DescriptorProto.ReservedRange, index?: number): DescriptorProto.ReservedRange;
+    clearReservedRangeList(): DescriptorProto;
+    getReservedRangeList(): Array<DescriptorProto.ReservedRange>;
+    setReservedRangeList(value: Array<DescriptorProto.ReservedRange>): DescriptorProto;
+    addReservedRange(value?: DescriptorProto.ReservedRange, index?: number): DescriptorProto.ReservedRange;
 
-  clearReservedNameList(): DescriptorProto;
-  getReservedNameList(): Array<string>;
-  setReservedNameList(value: Array<string>): DescriptorProto;
-  addReservedName(value: string, index?: number): string;
+    clearReservedNameList(): DescriptorProto;
+    getReservedNameList(): Array<string>;
+    setReservedNameList(value: Array<string>): DescriptorProto;
+    addReservedName(value: string, index?: number): string;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): DescriptorProto.AsObject;
-  static toObject(includeInstance: boolean, msg: DescriptorProto): DescriptorProto.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: DescriptorProto, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): DescriptorProto;
-  static deserializeBinaryFromReader(message: DescriptorProto, reader: jspb.BinaryReader): DescriptorProto;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DescriptorProto.AsObject;
+    static toObject(includeInstance: boolean, msg: DescriptorProto): DescriptorProto.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: DescriptorProto, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DescriptorProto;
+    static deserializeBinaryFromReader(message: DescriptorProto, reader: jspb.BinaryReader): DescriptorProto;
 }
 
 export namespace DescriptorProto {
-  export type AsObject = {
-    name?: string | undefined,
-    fieldList: Array<FieldDescriptorProto.AsObject>,
-    extensionList: Array<FieldDescriptorProto.AsObject>,
-    nestedTypeList: Array<AsObject>,
-    enumTypeList: Array<EnumDescriptorProto.AsObject>,
-    extensionRangeList: Array<ExtensionRange.AsObject>,
-    oneofDeclList: Array<OneofDescriptorProto.AsObject>,
-    options?: MessageOptions.AsObject | undefined,
-    reservedRangeList: Array<ReservedRange.AsObject>,
-    reservedNameList: Array<string>,
-  }
+    export type AsObject = {
+        name?: string | undefined;
+        fieldList: Array<FieldDescriptorProto.AsObject>;
+        extensionList: Array<FieldDescriptorProto.AsObject>;
+        nestedTypeList: Array<AsObject>;
+        enumTypeList: Array<EnumDescriptorProto.AsObject>;
+        extensionRangeList: Array<ExtensionRange.AsObject>;
+        oneofDeclList: Array<OneofDescriptorProto.AsObject>;
+        options?: MessageOptions.AsObject | undefined;
+        reservedRangeList: Array<ReservedRange.AsObject>;
+        reservedNameList: Array<string>;
+    };
 
-  export class ExtensionRange extends jspb.Message {
-    hasStart(): boolean;
-    clearStart(): ExtensionRange;
-    getStart(): number | undefined;
-    setStart(value: number): ExtensionRange;
+    export class ExtensionRange extends jspb.Message {
+        hasStart(): boolean;
+        clearStart(): ExtensionRange;
+        getStart(): number | undefined;
+        setStart(value: number): ExtensionRange;
 
-    hasEnd(): boolean;
-    clearEnd(): ExtensionRange;
-    getEnd(): number | undefined;
-    setEnd(value: number): ExtensionRange;
+        hasEnd(): boolean;
+        clearEnd(): ExtensionRange;
+        getEnd(): number | undefined;
+        setEnd(value: number): ExtensionRange;
 
-    hasOptions(): boolean;
-    clearOptions(): ExtensionRange;
-    getOptions(): ExtensionRangeOptions | undefined;
-    setOptions(value?: ExtensionRangeOptions): ExtensionRange;
+        hasOptions(): boolean;
+        clearOptions(): ExtensionRange;
+        getOptions(): ExtensionRangeOptions | undefined;
+        setOptions(value?: ExtensionRangeOptions): ExtensionRange;
 
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): ExtensionRange.AsObject;
-    static toObject(includeInstance: boolean, msg: ExtensionRange): ExtensionRange.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: ExtensionRange, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): ExtensionRange;
-    static deserializeBinaryFromReader(message: ExtensionRange, reader: jspb.BinaryReader): ExtensionRange;
-  }
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): ExtensionRange.AsObject;
+        static toObject(includeInstance: boolean, msg: ExtensionRange): ExtensionRange.AsObject;
+        static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+        static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+        static serializeBinaryToWriter(message: ExtensionRange, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): ExtensionRange;
+        static deserializeBinaryFromReader(message: ExtensionRange, reader: jspb.BinaryReader): ExtensionRange;
+    }
 
-  export namespace ExtensionRange {
-    export type AsObject = {
-      start?: number | undefined,
-      end?: number | undefined,
-      options?: ExtensionRangeOptions.AsObject | undefined,
+    export namespace ExtensionRange {
+        export type AsObject = {
+            start?: number | undefined;
+            end?: number | undefined;
+            options?: ExtensionRangeOptions.AsObject | undefined;
+        };
     }
-  }
 
-  export class ReservedRange extends jspb.Message {
-    hasStart(): boolean;
-    clearStart(): ReservedRange;
-    getStart(): number | undefined;
-    setStart(value: number): ReservedRange;
+    export class ReservedRange extends jspb.Message {
+        hasStart(): boolean;
+        clearStart(): ReservedRange;
+        getStart(): number | undefined;
+        setStart(value: number): ReservedRange;
 
-    hasEnd(): boolean;
-    clearEnd(): ReservedRange;
-    getEnd(): number | undefined;
-    setEnd(value: number): ReservedRange;
+        hasEnd(): boolean;
+        clearEnd(): ReservedRange;
+        getEnd(): number | undefined;
+        setEnd(value: number): ReservedRange;
 
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): ReservedRange.AsObject;
-    static toObject(includeInstance: boolean, msg: ReservedRange): ReservedRange.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: ReservedRange, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): ReservedRange;
-    static deserializeBinaryFromReader(message: ReservedRange, reader: jspb.BinaryReader): ReservedRange;
-  }
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): ReservedRange.AsObject;
+        static toObject(includeInstance: boolean, msg: ReservedRange): ReservedRange.AsObject;
+        static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+        static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+        static serializeBinaryToWriter(message: ReservedRange, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): ReservedRange;
+        static deserializeBinaryFromReader(message: ReservedRange, reader: jspb.BinaryReader): ReservedRange;
+    }
 
-  export namespace ReservedRange {
-    export type AsObject = {
-      start?: number | undefined,
-      end?: number | undefined,
+    export namespace ReservedRange {
+        export type AsObject = {
+            start?: number | undefined;
+            end?: number | undefined;
+        };
     }
-  }
 }
 
 export class ExtensionRangeOptions extends jspb.Message {
-  clearUninterpretedOptionList(): ExtensionRangeOptions;
-  getUninterpretedOptionList(): Array<UninterpretedOption>;
-  setUninterpretedOptionList(value: Array<UninterpretedOption>): ExtensionRangeOptions;
-  addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
+    clearUninterpretedOptionList(): ExtensionRangeOptions;
+    getUninterpretedOptionList(): Array<UninterpretedOption>;
+    setUninterpretedOptionList(value: Array<UninterpretedOption>): ExtensionRangeOptions;
+    addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): ExtensionRangeOptions.AsObject;
-  static toObject(includeInstance: boolean, msg: ExtensionRangeOptions): ExtensionRangeOptions.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: ExtensionRangeOptions, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): ExtensionRangeOptions;
-  static deserializeBinaryFromReader(message: ExtensionRangeOptions, reader: jspb.BinaryReader): ExtensionRangeOptions;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ExtensionRangeOptions.AsObject;
+    static toObject(includeInstance: boolean, msg: ExtensionRangeOptions): ExtensionRangeOptions.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: ExtensionRangeOptions, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ExtensionRangeOptions;
+    static deserializeBinaryFromReader(
+        message: ExtensionRangeOptions,
+        reader: jspb.BinaryReader,
+    ): ExtensionRangeOptions;
 }
 
 export namespace ExtensionRangeOptions {
-  export type AsObject = {
-    uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
-  }
+    export type AsObject = {
+        uninterpretedOptionList: Array<UninterpretedOption.AsObject>;
+    };
 }
 
 export class FieldDescriptorProto extends jspb.Message {
-  hasName(): boolean;
-  clearName(): FieldDescriptorProto;
-  getName(): string | undefined;
-  setName(value: string): FieldDescriptorProto;
+    hasName(): boolean;
+    clearName(): FieldDescriptorProto;
+    getName(): string | undefined;
+    setName(value: string): FieldDescriptorProto;
 
-  hasNumber(): boolean;
-  clearNumber(): FieldDescriptorProto;
-  getNumber(): number | undefined;
-  setNumber(value: number): FieldDescriptorProto;
+    hasNumber(): boolean;
+    clearNumber(): FieldDescriptorProto;
+    getNumber(): number | undefined;
+    setNumber(value: number): FieldDescriptorProto;
 
-  hasLabel(): boolean;
-  clearLabel(): FieldDescriptorProto;
-  getLabel(): FieldDescriptorProto.Label | undefined;
-  setLabel(value: FieldDescriptorProto.Label): FieldDescriptorProto;
+    hasLabel(): boolean;
+    clearLabel(): FieldDescriptorProto;
+    getLabel(): FieldDescriptorProto.Label | undefined;
+    setLabel(value: FieldDescriptorProto.Label): FieldDescriptorProto;
 
-  hasType(): boolean;
-  clearType(): FieldDescriptorProto;
-  getType(): FieldDescriptorProto.Type | undefined;
-  setType(value: FieldDescriptorProto.Type): FieldDescriptorProto;
+    hasType(): boolean;
+    clearType(): FieldDescriptorProto;
+    getType(): FieldDescriptorProto.Type | undefined;
+    setType(value: FieldDescriptorProto.Type): FieldDescriptorProto;
 
-  hasTypeName(): boolean;
-  clearTypeName(): FieldDescriptorProto;
-  getTypeName(): string | undefined;
-  setTypeName(value: string): FieldDescriptorProto;
+    hasTypeName(): boolean;
+    clearTypeName(): FieldDescriptorProto;
+    getTypeName(): string | undefined;
+    setTypeName(value: string): FieldDescriptorProto;
 
-  hasExtendee(): boolean;
-  clearExtendee(): FieldDescriptorProto;
-  getExtendee(): string | undefined;
-  setExtendee(value: string): FieldDescriptorProto;
+    hasExtendee(): boolean;
+    clearExtendee(): FieldDescriptorProto;
+    getExtendee(): string | undefined;
+    setExtendee(value: string): FieldDescriptorProto;
 
-  hasDefaultValue(): boolean;
-  clearDefaultValue(): FieldDescriptorProto;
-  getDefaultValue(): string | undefined;
-  setDefaultValue(value: string): FieldDescriptorProto;
+    hasDefaultValue(): boolean;
+    clearDefaultValue(): FieldDescriptorProto;
+    getDefaultValue(): string | undefined;
+    setDefaultValue(value: string): FieldDescriptorProto;
 
-  hasOneofIndex(): boolean;
-  clearOneofIndex(): FieldDescriptorProto;
-  getOneofIndex(): number | undefined;
-  setOneofIndex(value: number): FieldDescriptorProto;
+    hasOneofIndex(): boolean;
+    clearOneofIndex(): FieldDescriptorProto;
+    getOneofIndex(): number | undefined;
+    setOneofIndex(value: number): FieldDescriptorProto;
 
-  hasJsonName(): boolean;
-  clearJsonName(): FieldDescriptorProto;
-  getJsonName(): string | undefined;
-  setJsonName(value: string): FieldDescriptorProto;
+    hasJsonName(): boolean;
+    clearJsonName(): FieldDescriptorProto;
+    getJsonName(): string | undefined;
+    setJsonName(value: string): FieldDescriptorProto;
 
-  hasOptions(): boolean;
-  clearOptions(): FieldDescriptorProto;
-  getOptions(): FieldOptions | undefined;
-  setOptions(value?: FieldOptions): FieldDescriptorProto;
+    hasOptions(): boolean;
+    clearOptions(): FieldDescriptorProto;
+    getOptions(): FieldOptions | undefined;
+    setOptions(value?: FieldOptions): FieldDescriptorProto;
 
-  hasProto3Optional(): boolean;
-  clearProto3Optional(): FieldDescriptorProto;
-  getProto3Optional(): boolean | undefined;
-  setProto3Optional(value: boolean): FieldDescriptorProto;
+    hasProto3Optional(): boolean;
+    clearProto3Optional(): FieldDescriptorProto;
+    getProto3Optional(): boolean | undefined;
+    setProto3Optional(value: boolean): FieldDescriptorProto;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): FieldDescriptorProto.AsObject;
-  static toObject(includeInstance: boolean, msg: FieldDescriptorProto): FieldDescriptorProto.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: FieldDescriptorProto, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): FieldDescriptorProto;
-  static deserializeBinaryFromReader(message: FieldDescriptorProto, reader: jspb.BinaryReader): FieldDescriptorProto;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): FieldDescriptorProto.AsObject;
+    static toObject(includeInstance: boolean, msg: FieldDescriptorProto): FieldDescriptorProto.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: FieldDescriptorProto, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): FieldDescriptorProto;
+    static deserializeBinaryFromReader(message: FieldDescriptorProto, reader: jspb.BinaryReader): FieldDescriptorProto;
 }
 
 export namespace FieldDescriptorProto {
-  export type AsObject = {
-    name?: string | undefined,
-    number?: number | undefined,
-    label?: Label | undefined,
-    type?: Type | undefined,
-    typeName?: string | undefined,
-    extendee?: string | undefined,
-    defaultValue?: string | undefined,
-    oneofIndex?: number | undefined,
-    jsonName?: string | undefined,
-    options?: FieldOptions.AsObject | undefined,
-    proto3Optional?: boolean | undefined,
-  }
+    export type AsObject = {
+        name?: string | undefined;
+        number?: number | undefined;
+        label?: Label | undefined;
+        type?: Type | undefined;
+        typeName?: string | undefined;
+        extendee?: string | undefined;
+        defaultValue?: string | undefined;
+        oneofIndex?: number | undefined;
+        jsonName?: string | undefined;
+        options?: FieldOptions.AsObject | undefined;
+        proto3Optional?: boolean | undefined;
+    };
 
-  export enum Type {
-    TYPE_DOUBLE = 1,
-    TYPE_FLOAT = 2,
-    TYPE_INT64 = 3,
-    TYPE_UINT64 = 4,
-    TYPE_INT32 = 5,
-    TYPE_FIXED64 = 6,
-    TYPE_FIXED32 = 7,
-    TYPE_BOOL = 8,
-    TYPE_STRING = 9,
-    TYPE_GROUP = 10,
-    TYPE_MESSAGE = 11,
-    TYPE_BYTES = 12,
-    TYPE_UINT32 = 13,
-    TYPE_ENUM = 14,
-    TYPE_SFIXED32 = 15,
-    TYPE_SFIXED64 = 16,
-    TYPE_SINT32 = 17,
-    TYPE_SINT64 = 18,
-  }
+    export enum Type {
+        TYPE_DOUBLE = 1,
+        TYPE_FLOAT = 2,
+        TYPE_INT64 = 3,
+        TYPE_UINT64 = 4,
+        TYPE_INT32 = 5,
+        TYPE_FIXED64 = 6,
+        TYPE_FIXED32 = 7,
+        TYPE_BOOL = 8,
+        TYPE_STRING = 9,
+        TYPE_GROUP = 10,
+        TYPE_MESSAGE = 11,
+        TYPE_BYTES = 12,
+        TYPE_UINT32 = 13,
+        TYPE_ENUM = 14,
+        TYPE_SFIXED32 = 15,
+        TYPE_SFIXED64 = 16,
+        TYPE_SINT32 = 17,
+        TYPE_SINT64 = 18,
+    }
 
-  export enum Label {
-    LABEL_OPTIONAL = 1,
-    LABEL_REQUIRED = 2,
-    LABEL_REPEATED = 3,
-  }
+    export enum Label {
+        LABEL_OPTIONAL = 1,
+        LABEL_REQUIRED = 2,
+        LABEL_REPEATED = 3,
+    }
 }
 
 export class OneofDescriptorProto extends jspb.Message {
-  hasName(): boolean;
-  clearName(): OneofDescriptorProto;
-  getName(): string | undefined;
-  setName(value: string): OneofDescriptorProto;
+    hasName(): boolean;
+    clearName(): OneofDescriptorProto;
+    getName(): string | undefined;
+    setName(value: string): OneofDescriptorProto;
 
-  hasOptions(): boolean;
-  clearOptions(): OneofDescriptorProto;
-  getOptions(): OneofOptions | undefined;
-  setOptions(value?: OneofOptions): OneofDescriptorProto;
+    hasOptions(): boolean;
+    clearOptions(): OneofDescriptorProto;
+    getOptions(): OneofOptions | undefined;
+    setOptions(value?: OneofOptions): OneofDescriptorProto;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): OneofDescriptorProto.AsObject;
-  static toObject(includeInstance: boolean, msg: OneofDescriptorProto): OneofDescriptorProto.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: OneofDescriptorProto, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): OneofDescriptorProto;
-  static deserializeBinaryFromReader(message: OneofDescriptorProto, reader: jspb.BinaryReader): OneofDescriptorProto;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): OneofDescriptorProto.AsObject;
+    static toObject(includeInstance: boolean, msg: OneofDescriptorProto): OneofDescriptorProto.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: OneofDescriptorProto, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): OneofDescriptorProto;
+    static deserializeBinaryFromReader(message: OneofDescriptorProto, reader: jspb.BinaryReader): OneofDescriptorProto;
 }
 
 export namespace OneofDescriptorProto {
-  export type AsObject = {
-    name?: string | undefined,
-    options?: OneofOptions.AsObject | undefined,
-  }
+    export type AsObject = {
+        name?: string | undefined;
+        options?: OneofOptions.AsObject | undefined;
+    };
 }
 
 export class EnumDescriptorProto extends jspb.Message {
-  hasName(): boolean;
-  clearName(): EnumDescriptorProto;
-  getName(): string | undefined;
-  setName(value: string): EnumDescriptorProto;
+    hasName(): boolean;
+    clearName(): EnumDescriptorProto;
+    getName(): string | undefined;
+    setName(value: string): EnumDescriptorProto;
 
-  clearValueList(): EnumDescriptorProto;
-  getValueList(): Array<EnumValueDescriptorProto>;
-  setValueList(value: Array<EnumValueDescriptorProto>): EnumDescriptorProto;
-  addValue(value?: EnumValueDescriptorProto, index?: number): EnumValueDescriptorProto;
+    clearValueList(): EnumDescriptorProto;
+    getValueList(): Array<EnumValueDescriptorProto>;
+    setValueList(value: Array<EnumValueDescriptorProto>): EnumDescriptorProto;
+    addValue(value?: EnumValueDescriptorProto, index?: number): EnumValueDescriptorProto;
 
-  hasOptions(): boolean;
-  clearOptions(): EnumDescriptorProto;
-  getOptions(): EnumOptions | undefined;
-  setOptions(value?: EnumOptions): EnumDescriptorProto;
+    hasOptions(): boolean;
+    clearOptions(): EnumDescriptorProto;
+    getOptions(): EnumOptions | undefined;
+    setOptions(value?: EnumOptions): EnumDescriptorProto;
 
-  clearReservedRangeList(): EnumDescriptorProto;
-  getReservedRangeList(): Array<EnumDescriptorProto.EnumReservedRange>;
-  setReservedRangeList(value: Array<EnumDescriptorProto.EnumReservedRange>): EnumDescriptorProto;
-  addReservedRange(value?: EnumDescriptorProto.EnumReservedRange, index?: number): EnumDescriptorProto.EnumReservedRange;
+    clearReservedRangeList(): EnumDescriptorProto;
+    getReservedRangeList(): Array<EnumDescriptorProto.EnumReservedRange>;
+    setReservedRangeList(value: Array<EnumDescriptorProto.EnumReservedRange>): EnumDescriptorProto;
+    addReservedRange(
+        value?: EnumDescriptorProto.EnumReservedRange,
+        index?: number,
+    ): EnumDescriptorProto.EnumReservedRange;
 
-  clearReservedNameList(): EnumDescriptorProto;
-  getReservedNameList(): Array<string>;
-  setReservedNameList(value: Array<string>): EnumDescriptorProto;
-  addReservedName(value: string, index?: number): string;
+    clearReservedNameList(): EnumDescriptorProto;
+    getReservedNameList(): Array<string>;
+    setReservedNameList(value: Array<string>): EnumDescriptorProto;
+    addReservedName(value: string, index?: number): string;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): EnumDescriptorProto.AsObject;
-  static toObject(includeInstance: boolean, msg: EnumDescriptorProto): EnumDescriptorProto.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: EnumDescriptorProto, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): EnumDescriptorProto;
-  static deserializeBinaryFromReader(message: EnumDescriptorProto, reader: jspb.BinaryReader): EnumDescriptorProto;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): EnumDescriptorProto.AsObject;
+    static toObject(includeInstance: boolean, msg: EnumDescriptorProto): EnumDescriptorProto.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: EnumDescriptorProto, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): EnumDescriptorProto;
+    static deserializeBinaryFromReader(message: EnumDescriptorProto, reader: jspb.BinaryReader): EnumDescriptorProto;
 }
 
 export namespace EnumDescriptorProto {
-  export type AsObject = {
-    name?: string | undefined,
-    valueList: Array<EnumValueDescriptorProto.AsObject>,
-    options?: EnumOptions.AsObject | undefined,
-    reservedRangeList: Array<EnumReservedRange.AsObject>,
-    reservedNameList: Array<string>,
-  }
+    export type AsObject = {
+        name?: string | undefined;
+        valueList: Array<EnumValueDescriptorProto.AsObject>;
+        options?: EnumOptions.AsObject | undefined;
+        reservedRangeList: Array<EnumReservedRange.AsObject>;
+        reservedNameList: Array<string>;
+    };
 
-  export class EnumReservedRange extends jspb.Message {
-    hasStart(): boolean;
-    clearStart(): EnumReservedRange;
-    getStart(): number | undefined;
-    setStart(value: number): EnumReservedRange;
+    export class EnumReservedRange extends jspb.Message {
+        hasStart(): boolean;
+        clearStart(): EnumReservedRange;
+        getStart(): number | undefined;
+        setStart(value: number): EnumReservedRange;
 
-    hasEnd(): boolean;
-    clearEnd(): EnumReservedRange;
-    getEnd(): number | undefined;
-    setEnd(value: number): EnumReservedRange;
+        hasEnd(): boolean;
+        clearEnd(): EnumReservedRange;
+        getEnd(): number | undefined;
+        setEnd(value: number): EnumReservedRange;
 
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): EnumReservedRange.AsObject;
-    static toObject(includeInstance: boolean, msg: EnumReservedRange): EnumReservedRange.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: EnumReservedRange, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): EnumReservedRange;
-    static deserializeBinaryFromReader(message: EnumReservedRange, reader: jspb.BinaryReader): EnumReservedRange;
-  }
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): EnumReservedRange.AsObject;
+        static toObject(includeInstance: boolean, msg: EnumReservedRange): EnumReservedRange.AsObject;
+        static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+        static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+        static serializeBinaryToWriter(message: EnumReservedRange, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): EnumReservedRange;
+        static deserializeBinaryFromReader(message: EnumReservedRange, reader: jspb.BinaryReader): EnumReservedRange;
+    }
 
-  export namespace EnumReservedRange {
-    export type AsObject = {
-      start?: number | undefined,
-      end?: number | undefined,
+    export namespace EnumReservedRange {
+        export type AsObject = {
+            start?: number | undefined;
+            end?: number | undefined;
+        };
     }
-  }
 }
 
 export class EnumValueDescriptorProto extends jspb.Message {
-  hasName(): boolean;
-  clearName(): EnumValueDescriptorProto;
-  getName(): string | undefined;
-  setName(value: string): EnumValueDescriptorProto;
+    hasName(): boolean;
+    clearName(): EnumValueDescriptorProto;
+    getName(): string | undefined;
+    setName(value: string): EnumValueDescriptorProto;
 
-  hasNumber(): boolean;
-  clearNumber(): EnumValueDescriptorProto;
-  getNumber(): number | undefined;
-  setNumber(value: number): EnumValueDescriptorProto;
+    hasNumber(): boolean;
+    clearNumber(): EnumValueDescriptorProto;
+    getNumber(): number | undefined;
+    setNumber(value: number): EnumValueDescriptorProto;
 
-  hasOptions(): boolean;
-  clearOptions(): EnumValueDescriptorProto;
-  getOptions(): EnumValueOptions | undefined;
-  setOptions(value?: EnumValueOptions): EnumValueDescriptorProto;
+    hasOptions(): boolean;
+    clearOptions(): EnumValueDescriptorProto;
+    getOptions(): EnumValueOptions | undefined;
+    setOptions(value?: EnumValueOptions): EnumValueDescriptorProto;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): EnumValueDescriptorProto.AsObject;
-  static toObject(includeInstance: boolean, msg: EnumValueDescriptorProto): EnumValueDescriptorProto.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: EnumValueDescriptorProto, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): EnumValueDescriptorProto;
-  static deserializeBinaryFromReader(message: EnumValueDescriptorProto, reader: jspb.BinaryReader): EnumValueDescriptorProto;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): EnumValueDescriptorProto.AsObject;
+    static toObject(includeInstance: boolean, msg: EnumValueDescriptorProto): EnumValueDescriptorProto.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: EnumValueDescriptorProto, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): EnumValueDescriptorProto;
+    static deserializeBinaryFromReader(
+        message: EnumValueDescriptorProto,
+        reader: jspb.BinaryReader,
+    ): EnumValueDescriptorProto;
 }
 
 export namespace EnumValueDescriptorProto {
-  export type AsObject = {
-    name?: string | undefined,
-    number?: number | undefined,
-    options?: EnumValueOptions.AsObject | undefined,
-  }
+    export type AsObject = {
+        name?: string | undefined;
+        number?: number | undefined;
+        options?: EnumValueOptions.AsObject | undefined;
+    };
 }
 
 export class ServiceDescriptorProto extends jspb.Message {
-  hasName(): boolean;
-  clearName(): ServiceDescriptorProto;
-  getName(): string | undefined;
-  setName(value: string): ServiceDescriptorProto;
+    hasName(): boolean;
+    clearName(): ServiceDescriptorProto;
+    getName(): string | undefined;
+    setName(value: string): ServiceDescriptorProto;
 
-  clearMethodList(): ServiceDescriptorProto;
-  getMethodList(): Array<MethodDescriptorProto>;
-  setMethodList(value: Array<MethodDescriptorProto>): ServiceDescriptorProto;
-  addMethod(value?: MethodDescriptorProto, index?: number): MethodDescriptorProto;
+    clearMethodList(): ServiceDescriptorProto;
+    getMethodList(): Array<MethodDescriptorProto>;
+    setMethodList(value: Array<MethodDescriptorProto>): ServiceDescriptorProto;
+    addMethod(value?: MethodDescriptorProto, index?: number): MethodDescriptorProto;
 
-  hasOptions(): boolean;
-  clearOptions(): ServiceDescriptorProto;
-  getOptions(): ServiceOptions | undefined;
-  setOptions(value?: ServiceOptions): ServiceDescriptorProto;
+    hasOptions(): boolean;
+    clearOptions(): ServiceDescriptorProto;
+    getOptions(): ServiceOptions | undefined;
+    setOptions(value?: ServiceOptions): ServiceDescriptorProto;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): ServiceDescriptorProto.AsObject;
-  static toObject(includeInstance: boolean, msg: ServiceDescriptorProto): ServiceDescriptorProto.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: ServiceDescriptorProto, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): ServiceDescriptorProto;
-  static deserializeBinaryFromReader(message: ServiceDescriptorProto, reader: jspb.BinaryReader): ServiceDescriptorProto;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ServiceDescriptorProto.AsObject;
+    static toObject(includeInstance: boolean, msg: ServiceDescriptorProto): ServiceDescriptorProto.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: ServiceDescriptorProto, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ServiceDescriptorProto;
+    static deserializeBinaryFromReader(
+        message: ServiceDescriptorProto,
+        reader: jspb.BinaryReader,
+    ): ServiceDescriptorProto;
 }
 
 export namespace ServiceDescriptorProto {
-  export type AsObject = {
-    name?: string | undefined,
-    methodList: Array<MethodDescriptorProto.AsObject>,
-    options?: ServiceOptions.AsObject | undefined,
-  }
+    export type AsObject = {
+        name?: string | undefined;
+        methodList: Array<MethodDescriptorProto.AsObject>;
+        options?: ServiceOptions.AsObject | undefined;
+    };
 }
 
 export class MethodDescriptorProto extends jspb.Message {
-  hasName(): boolean;
-  clearName(): MethodDescriptorProto;
-  getName(): string | undefined;
-  setName(value: string): MethodDescriptorProto;
+    hasName(): boolean;
+    clearName(): MethodDescriptorProto;
+    getName(): string | undefined;
+    setName(value: string): MethodDescriptorProto;
 
-  hasInputType(): boolean;
-  clearInputType(): MethodDescriptorProto;
-  getInputType(): string | undefined;
-  setInputType(value: string): MethodDescriptorProto;
+    hasInputType(): boolean;
+    clearInputType(): MethodDescriptorProto;
+    getInputType(): string | undefined;
+    setInputType(value: string): MethodDescriptorProto;
 
-  hasOutputType(): boolean;
-  clearOutputType(): MethodDescriptorProto;
-  getOutputType(): string | undefined;
-  setOutputType(value: string): MethodDescriptorProto;
+    hasOutputType(): boolean;
+    clearOutputType(): MethodDescriptorProto;
+    getOutputType(): string | undefined;
+    setOutputType(value: string): MethodDescriptorProto;
 
-  hasOptions(): boolean;
-  clearOptions(): MethodDescriptorProto;
-  getOptions(): MethodOptions | undefined;
-  setOptions(value?: MethodOptions): MethodDescriptorProto;
+    hasOptions(): boolean;
+    clearOptions(): MethodDescriptorProto;
+    getOptions(): MethodOptions | undefined;
+    setOptions(value?: MethodOptions): MethodDescriptorProto;
 
-  hasClientStreaming(): boolean;
-  clearClientStreaming(): MethodDescriptorProto;
-  getClientStreaming(): boolean | undefined;
-  setClientStreaming(value: boolean): MethodDescriptorProto;
+    hasClientStreaming(): boolean;
+    clearClientStreaming(): MethodDescriptorProto;
+    getClientStreaming(): boolean | undefined;
+    setClientStreaming(value: boolean): MethodDescriptorProto;
 
-  hasServerStreaming(): boolean;
-  clearServerStreaming(): MethodDescriptorProto;
-  getServerStreaming(): boolean | undefined;
-  setServerStreaming(value: boolean): MethodDescriptorProto;
+    hasServerStreaming(): boolean;
+    clearServerStreaming(): MethodDescriptorProto;
+    getServerStreaming(): boolean | undefined;
+    setServerStreaming(value: boolean): MethodDescriptorProto;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): MethodDescriptorProto.AsObject;
-  static toObject(includeInstance: boolean, msg: MethodDescriptorProto): MethodDescriptorProto.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: MethodDescriptorProto, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): MethodDescriptorProto;
-  static deserializeBinaryFromReader(message: MethodDescriptorProto, reader: jspb.BinaryReader): MethodDescriptorProto;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): MethodDescriptorProto.AsObject;
+    static toObject(includeInstance: boolean, msg: MethodDescriptorProto): MethodDescriptorProto.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: MethodDescriptorProto, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): MethodDescriptorProto;
+    static deserializeBinaryFromReader(
+        message: MethodDescriptorProto,
+        reader: jspb.BinaryReader,
+    ): MethodDescriptorProto;
 }
 
 export namespace MethodDescriptorProto {
-  export type AsObject = {
-    name?: string | undefined,
-    inputType?: string | undefined,
-    outputType?: string | undefined,
-    options?: MethodOptions.AsObject | undefined,
-    clientStreaming?: boolean | undefined,
-    serverStreaming?: boolean | undefined,
-  }
+    export type AsObject = {
+        name?: string | undefined;
+        inputType?: string | undefined;
+        outputType?: string | undefined;
+        options?: MethodOptions.AsObject | undefined;
+        clientStreaming?: boolean | undefined;
+        serverStreaming?: boolean | undefined;
+    };
 }
 
 export class FileOptions extends jspb.Message {
-  hasJavaPackage(): boolean;
-  clearJavaPackage(): FileOptions;
-  getJavaPackage(): string | undefined;
-  setJavaPackage(value: string): FileOptions;
+    hasJavaPackage(): boolean;
+    clearJavaPackage(): FileOptions;
+    getJavaPackage(): string | undefined;
+    setJavaPackage(value: string): FileOptions;
 
-  hasJavaOuterClassname(): boolean;
-  clearJavaOuterClassname(): FileOptions;
-  getJavaOuterClassname(): string | undefined;
-  setJavaOuterClassname(value: string): FileOptions;
+    hasJavaOuterClassname(): boolean;
+    clearJavaOuterClassname(): FileOptions;
+    getJavaOuterClassname(): string | undefined;
+    setJavaOuterClassname(value: string): FileOptions;
 
-  hasJavaMultipleFiles(): boolean;
-  clearJavaMultipleFiles(): FileOptions;
-  getJavaMultipleFiles(): boolean | undefined;
-  setJavaMultipleFiles(value: boolean): FileOptions;
+    hasJavaMultipleFiles(): boolean;
+    clearJavaMultipleFiles(): FileOptions;
+    getJavaMultipleFiles(): boolean | undefined;
+    setJavaMultipleFiles(value: boolean): FileOptions;
 
-  hasJavaGenerateEqualsAndHash(): boolean;
-  clearJavaGenerateEqualsAndHash(): FileOptions;
-  getJavaGenerateEqualsAndHash(): boolean | undefined;
-  setJavaGenerateEqualsAndHash(value: boolean): FileOptions;
+    hasJavaGenerateEqualsAndHash(): boolean;
+    clearJavaGenerateEqualsAndHash(): FileOptions;
+    getJavaGenerateEqualsAndHash(): boolean | undefined;
+    setJavaGenerateEqualsAndHash(value: boolean): FileOptions;
 
-  hasJavaStringCheckUtf8(): boolean;
-  clearJavaStringCheckUtf8(): FileOptions;
-  getJavaStringCheckUtf8(): boolean | undefined;
-  setJavaStringCheckUtf8(value: boolean): FileOptions;
+    hasJavaStringCheckUtf8(): boolean;
+    clearJavaStringCheckUtf8(): FileOptions;
+    getJavaStringCheckUtf8(): boolean | undefined;
+    setJavaStringCheckUtf8(value: boolean): FileOptions;
 
-  hasOptimizeFor(): boolean;
-  clearOptimizeFor(): FileOptions;
-  getOptimizeFor(): FileOptions.OptimizeMode | undefined;
-  setOptimizeFor(value: FileOptions.OptimizeMode): FileOptions;
+    hasOptimizeFor(): boolean;
+    clearOptimizeFor(): FileOptions;
+    getOptimizeFor(): FileOptions.OptimizeMode | undefined;
+    setOptimizeFor(value: FileOptions.OptimizeMode): FileOptions;
 
-  hasGoPackage(): boolean;
-  clearGoPackage(): FileOptions;
-  getGoPackage(): string | undefined;
-  setGoPackage(value: string): FileOptions;
+    hasGoPackage(): boolean;
+    clearGoPackage(): FileOptions;
+    getGoPackage(): string | undefined;
+    setGoPackage(value: string): FileOptions;
 
-  hasCcGenericServices(): boolean;
-  clearCcGenericServices(): FileOptions;
-  getCcGenericServices(): boolean | undefined;
-  setCcGenericServices(value: boolean): FileOptions;
+    hasCcGenericServices(): boolean;
+    clearCcGenericServices(): FileOptions;
+    getCcGenericServices(): boolean | undefined;
+    setCcGenericServices(value: boolean): FileOptions;
 
-  hasJavaGenericServices(): boolean;
-  clearJavaGenericServices(): FileOptions;
-  getJavaGenericServices(): boolean | undefined;
-  setJavaGenericServices(value: boolean): FileOptions;
+    hasJavaGenericServices(): boolean;
+    clearJavaGenericServices(): FileOptions;
+    getJavaGenericServices(): boolean | undefined;
+    setJavaGenericServices(value: boolean): FileOptions;
 
-  hasPyGenericServices(): boolean;
-  clearPyGenericServices(): FileOptions;
-  getPyGenericServices(): boolean | undefined;
-  setPyGenericServices(value: boolean): FileOptions;
+    hasPyGenericServices(): boolean;
+    clearPyGenericServices(): FileOptions;
+    getPyGenericServices(): boolean | undefined;
+    setPyGenericServices(value: boolean): FileOptions;
 
-  hasPhpGenericServices(): boolean;
-  clearPhpGenericServices(): FileOptions;
-  getPhpGenericServices(): boolean | undefined;
-  setPhpGenericServices(value: boolean): FileOptions;
+    hasPhpGenericServices(): boolean;
+    clearPhpGenericServices(): FileOptions;
+    getPhpGenericServices(): boolean | undefined;
+    setPhpGenericServices(value: boolean): FileOptions;
 
-  hasDeprecated(): boolean;
-  clearDeprecated(): FileOptions;
-  getDeprecated(): boolean | undefined;
-  setDeprecated(value: boolean): FileOptions;
+    hasDeprecated(): boolean;
+    clearDeprecated(): FileOptions;
+    getDeprecated(): boolean | undefined;
+    setDeprecated(value: boolean): FileOptions;
 
-  hasCcEnableArenas(): boolean;
-  clearCcEnableArenas(): FileOptions;
-  getCcEnableArenas(): boolean | undefined;
-  setCcEnableArenas(value: boolean): FileOptions;
+    hasCcEnableArenas(): boolean;
+    clearCcEnableArenas(): FileOptions;
+    getCcEnableArenas(): boolean | undefined;
+    setCcEnableArenas(value: boolean): FileOptions;
 
-  hasObjcClassPrefix(): boolean;
-  clearObjcClassPrefix(): FileOptions;
-  getObjcClassPrefix(): string | undefined;
-  setObjcClassPrefix(value: string): FileOptions;
+    hasObjcClassPrefix(): boolean;
+    clearObjcClassPrefix(): FileOptions;
+    getObjcClassPrefix(): string | undefined;
+    setObjcClassPrefix(value: string): FileOptions;
 
-  hasCsharpNamespace(): boolean;
-  clearCsharpNamespace(): FileOptions;
-  getCsharpNamespace(): string | undefined;
-  setCsharpNamespace(value: string): FileOptions;
+    hasCsharpNamespace(): boolean;
+    clearCsharpNamespace(): FileOptions;
+    getCsharpNamespace(): string | undefined;
+    setCsharpNamespace(value: string): FileOptions;
 
-  hasSwiftPrefix(): boolean;
-  clearSwiftPrefix(): FileOptions;
-  getSwiftPrefix(): string | undefined;
-  setSwiftPrefix(value: string): FileOptions;
+    hasSwiftPrefix(): boolean;
+    clearSwiftPrefix(): FileOptions;
+    getSwiftPrefix(): string | undefined;
+    setSwiftPrefix(value: string): FileOptions;
 
-  hasPhpClassPrefix(): boolean;
-  clearPhpClassPrefix(): FileOptions;
-  getPhpClassPrefix(): string | undefined;
-  setPhpClassPrefix(value: string): FileOptions;
+    hasPhpClassPrefix(): boolean;
+    clearPhpClassPrefix(): FileOptions;
+    getPhpClassPrefix(): string | undefined;
+    setPhpClassPrefix(value: string): FileOptions;
 
-  hasPhpNamespace(): boolean;
-  clearPhpNamespace(): FileOptions;
-  getPhpNamespace(): string | undefined;
-  setPhpNamespace(value: string): FileOptions;
+    hasPhpNamespace(): boolean;
+    clearPhpNamespace(): FileOptions;
+    getPhpNamespace(): string | undefined;
+    setPhpNamespace(value: string): FileOptions;
 
-  hasPhpMetadataNamespace(): boolean;
-  clearPhpMetadataNamespace(): FileOptions;
-  getPhpMetadataNamespace(): string | undefined;
-  setPhpMetadataNamespace(value: string): FileOptions;
+    hasPhpMetadataNamespace(): boolean;
+    clearPhpMetadataNamespace(): FileOptions;
+    getPhpMetadataNamespace(): string | undefined;
+    setPhpMetadataNamespace(value: string): FileOptions;
 
-  hasRubyPackage(): boolean;
-  clearRubyPackage(): FileOptions;
-  getRubyPackage(): string | undefined;
-  setRubyPackage(value: string): FileOptions;
+    hasRubyPackage(): boolean;
+    clearRubyPackage(): FileOptions;
+    getRubyPackage(): string | undefined;
+    setRubyPackage(value: string): FileOptions;
 
-  clearUninterpretedOptionList(): FileOptions;
-  getUninterpretedOptionList(): Array<UninterpretedOption>;
-  setUninterpretedOptionList(value: Array<UninterpretedOption>): FileOptions;
-  addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
+    clearUninterpretedOptionList(): FileOptions;
+    getUninterpretedOptionList(): Array<UninterpretedOption>;
+    setUninterpretedOptionList(value: Array<UninterpretedOption>): FileOptions;
+    addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): FileOptions.AsObject;
-  static toObject(includeInstance: boolean, msg: FileOptions): FileOptions.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: FileOptions, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): FileOptions;
-  static deserializeBinaryFromReader(message: FileOptions, reader: jspb.BinaryReader): FileOptions;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): FileOptions.AsObject;
+    static toObject(includeInstance: boolean, msg: FileOptions): FileOptions.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: FileOptions, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): FileOptions;
+    static deserializeBinaryFromReader(message: FileOptions, reader: jspb.BinaryReader): FileOptions;
 }
 
 export namespace FileOptions {
-  export type AsObject = {
-    javaPackage?: string | undefined,
-    javaOuterClassname?: string | undefined,
-    javaMultipleFiles?: boolean | undefined,
-    javaGenerateEqualsAndHash?: boolean | undefined,
-    javaStringCheckUtf8?: boolean | undefined,
-    optimizeFor?: OptimizeMode | undefined,
-    goPackage?: string | undefined,
-    ccGenericServices?: boolean | undefined,
-    javaGenericServices?: boolean | undefined,
-    pyGenericServices?: boolean | undefined,
-    phpGenericServices?: boolean | undefined,
-    deprecated?: boolean | undefined,
-    ccEnableArenas?: boolean | undefined,
-    objcClassPrefix?: string | undefined,
-    csharpNamespace?: string | undefined,
-    swiftPrefix?: string | undefined,
-    phpClassPrefix?: string | undefined,
-    phpNamespace?: string | undefined,
-    phpMetadataNamespace?: string | undefined,
-    rubyPackage?: string | undefined,
-    uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
-  }
+    export type AsObject = {
+        javaPackage?: string | undefined;
+        javaOuterClassname?: string | undefined;
+        javaMultipleFiles?: boolean | undefined;
+        javaGenerateEqualsAndHash?: boolean | undefined;
+        javaStringCheckUtf8?: boolean | undefined;
+        optimizeFor?: OptimizeMode | undefined;
+        goPackage?: string | undefined;
+        ccGenericServices?: boolean | undefined;
+        javaGenericServices?: boolean | undefined;
+        pyGenericServices?: boolean | undefined;
+        phpGenericServices?: boolean | undefined;
+        deprecated?: boolean | undefined;
+        ccEnableArenas?: boolean | undefined;
+        objcClassPrefix?: string | undefined;
+        csharpNamespace?: string | undefined;
+        swiftPrefix?: string | undefined;
+        phpClassPrefix?: string | undefined;
+        phpNamespace?: string | undefined;
+        phpMetadataNamespace?: string | undefined;
+        rubyPackage?: string | undefined;
+        uninterpretedOptionList: Array<UninterpretedOption.AsObject>;
+    };
 
-  export enum OptimizeMode {
-    SPEED = 1,
-    CODE_SIZE = 2,
-    LITE_RUNTIME = 3,
-  }
+    export enum OptimizeMode {
+        SPEED = 1,
+        CODE_SIZE = 2,
+        LITE_RUNTIME = 3,
+    }
 }
 
 export class MessageOptions extends jspb.Message {
-  hasMessageSetWireFormat(): boolean;
-  clearMessageSetWireFormat(): MessageOptions;
-  getMessageSetWireFormat(): boolean | undefined;
-  setMessageSetWireFormat(value: boolean): MessageOptions;
+    hasMessageSetWireFormat(): boolean;
+    clearMessageSetWireFormat(): MessageOptions;
+    getMessageSetWireFormat(): boolean | undefined;
+    setMessageSetWireFormat(value: boolean): MessageOptions;
 
-  hasNoStandardDescriptorAccessor(): boolean;
-  clearNoStandardDescriptorAccessor(): MessageOptions;
-  getNoStandardDescriptorAccessor(): boolean | undefined;
-  setNoStandardDescriptorAccessor(value: boolean): MessageOptions;
+    hasNoStandardDescriptorAccessor(): boolean;
+    clearNoStandardDescriptorAccessor(): MessageOptions;
+    getNoStandardDescriptorAccessor(): boolean | undefined;
+    setNoStandardDescriptorAccessor(value: boolean): MessageOptions;
 
-  hasDeprecated(): boolean;
-  clearDeprecated(): MessageOptions;
-  getDeprecated(): boolean | undefined;
-  setDeprecated(value: boolean): MessageOptions;
+    hasDeprecated(): boolean;
+    clearDeprecated(): MessageOptions;
+    getDeprecated(): boolean | undefined;
+    setDeprecated(value: boolean): MessageOptions;
 
-  hasMapEntry(): boolean;
-  clearMapEntry(): MessageOptions;
-  getMapEntry(): boolean | undefined;
-  setMapEntry(value: boolean): MessageOptions;
+    hasMapEntry(): boolean;
+    clearMapEntry(): MessageOptions;
+    getMapEntry(): boolean | undefined;
+    setMapEntry(value: boolean): MessageOptions;
 
-  clearUninterpretedOptionList(): MessageOptions;
-  getUninterpretedOptionList(): Array<UninterpretedOption>;
-  setUninterpretedOptionList(value: Array<UninterpretedOption>): MessageOptions;
-  addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
+    clearUninterpretedOptionList(): MessageOptions;
+    getUninterpretedOptionList(): Array<UninterpretedOption>;
+    setUninterpretedOptionList(value: Array<UninterpretedOption>): MessageOptions;
+    addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): MessageOptions.AsObject;
-  static toObject(includeInstance: boolean, msg: MessageOptions): MessageOptions.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: MessageOptions, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): MessageOptions;
-  static deserializeBinaryFromReader(message: MessageOptions, reader: jspb.BinaryReader): MessageOptions;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): MessageOptions.AsObject;
+    static toObject(includeInstance: boolean, msg: MessageOptions): MessageOptions.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: MessageOptions, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): MessageOptions;
+    static deserializeBinaryFromReader(message: MessageOptions, reader: jspb.BinaryReader): MessageOptions;
 }
 
 export namespace MessageOptions {
-  export type AsObject = {
-    messageSetWireFormat?: boolean | undefined,
-    noStandardDescriptorAccessor?: boolean | undefined,
-    deprecated?: boolean | undefined,
-    mapEntry?: boolean | undefined,
-    uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
-  }
+    export type AsObject = {
+        messageSetWireFormat?: boolean | undefined;
+        noStandardDescriptorAccessor?: boolean | undefined;
+        deprecated?: boolean | undefined;
+        mapEntry?: boolean | undefined;
+        uninterpretedOptionList: Array<UninterpretedOption.AsObject>;
+    };
 }
 
 export class FieldOptions extends jspb.Message {
-  hasCtype(): boolean;
-  clearCtype(): FieldOptions;
-  getCtype(): FieldOptions.CType | undefined;
-  setCtype(value: FieldOptions.CType): FieldOptions;
+    hasCtype(): boolean;
+    clearCtype(): FieldOptions;
+    getCtype(): FieldOptions.CType | undefined;
+    setCtype(value: FieldOptions.CType): FieldOptions;
 
-  hasPacked(): boolean;
-  clearPacked(): FieldOptions;
-  getPacked(): boolean | undefined;
-  setPacked(value: boolean): FieldOptions;
+    hasPacked(): boolean;
+    clearPacked(): FieldOptions;
+    getPacked(): boolean | undefined;
+    setPacked(value: boolean): FieldOptions;
 
-  hasJstype(): boolean;
-  clearJstype(): FieldOptions;
-  getJstype(): FieldOptions.JSType | undefined;
-  setJstype(value: FieldOptions.JSType): FieldOptions;
+    hasJstype(): boolean;
+    clearJstype(): FieldOptions;
+    getJstype(): FieldOptions.JSType | undefined;
+    setJstype(value: FieldOptions.JSType): FieldOptions;
 
-  hasLazy(): boolean;
-  clearLazy(): FieldOptions;
-  getLazy(): boolean | undefined;
-  setLazy(value: boolean): FieldOptions;
+    hasLazy(): boolean;
+    clearLazy(): FieldOptions;
+    getLazy(): boolean | undefined;
+    setLazy(value: boolean): FieldOptions;
 
-  hasDeprecated(): boolean;
-  clearDeprecated(): FieldOptions;
-  getDeprecated(): boolean | undefined;
-  setDeprecated(value: boolean): FieldOptions;
+    hasDeprecated(): boolean;
+    clearDeprecated(): FieldOptions;
+    getDeprecated(): boolean | undefined;
+    setDeprecated(value: boolean): FieldOptions;
 
-  hasWeak(): boolean;
-  clearWeak(): FieldOptions;
-  getWeak(): boolean | undefined;
-  setWeak(value: boolean): FieldOptions;
+    hasWeak(): boolean;
+    clearWeak(): FieldOptions;
+    getWeak(): boolean | undefined;
+    setWeak(value: boolean): FieldOptions;
 
-  clearUninterpretedOptionList(): FieldOptions;
-  getUninterpretedOptionList(): Array<UninterpretedOption>;
-  setUninterpretedOptionList(value: Array<UninterpretedOption>): FieldOptions;
-  addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
+    clearUninterpretedOptionList(): FieldOptions;
+    getUninterpretedOptionList(): Array<UninterpretedOption>;
+    setUninterpretedOptionList(value: Array<UninterpretedOption>): FieldOptions;
+    addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): FieldOptions.AsObject;
-  static toObject(includeInstance: boolean, msg: FieldOptions): FieldOptions.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: FieldOptions, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): FieldOptions;
-  static deserializeBinaryFromReader(message: FieldOptions, reader: jspb.BinaryReader): FieldOptions;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): FieldOptions.AsObject;
+    static toObject(includeInstance: boolean, msg: FieldOptions): FieldOptions.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: FieldOptions, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): FieldOptions;
+    static deserializeBinaryFromReader(message: FieldOptions, reader: jspb.BinaryReader): FieldOptions;
 }
 
 export namespace FieldOptions {
-  export type AsObject = {
-    ctype?: CType | undefined,
-    packed?: boolean | undefined,
-    jstype?: JSType | undefined,
-    lazy?: boolean | undefined,
-    deprecated?: boolean | undefined,
-    weak?: boolean | undefined,
-    uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
-  }
+    export type AsObject = {
+        ctype?: CType | undefined;
+        packed?: boolean | undefined;
+        jstype?: JSType | undefined;
+        lazy?: boolean | undefined;
+        deprecated?: boolean | undefined;
+        weak?: boolean | undefined;
+        uninterpretedOptionList: Array<UninterpretedOption.AsObject>;
+    };
 
-  export enum CType {
-    STRING = 0,
-    CORD = 1,
-    STRING_PIECE = 2,
-  }
+    export enum CType {
+        STRING = 0,
+        CORD = 1,
+        STRING_PIECE = 2,
+    }
 
-  export enum JSType {
-    JS_NORMAL = 0,
-    JS_STRING = 1,
-    JS_NUMBER = 2,
-  }
+    export enum JSType {
+        JS_NORMAL = 0,
+        JS_STRING = 1,
+        JS_NUMBER = 2,
+    }
 }
 
 export class OneofOptions extends jspb.Message {
-  clearUninterpretedOptionList(): OneofOptions;
-  getUninterpretedOptionList(): Array<UninterpretedOption>;
-  setUninterpretedOptionList(value: Array<UninterpretedOption>): OneofOptions;
-  addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
+    clearUninterpretedOptionList(): OneofOptions;
+    getUninterpretedOptionList(): Array<UninterpretedOption>;
+    setUninterpretedOptionList(value: Array<UninterpretedOption>): OneofOptions;
+    addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): OneofOptions.AsObject;
-  static toObject(includeInstance: boolean, msg: OneofOptions): OneofOptions.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: OneofOptions, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): OneofOptions;
-  static deserializeBinaryFromReader(message: OneofOptions, reader: jspb.BinaryReader): OneofOptions;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): OneofOptions.AsObject;
+    static toObject(includeInstance: boolean, msg: OneofOptions): OneofOptions.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: OneofOptions, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): OneofOptions;
+    static deserializeBinaryFromReader(message: OneofOptions, reader: jspb.BinaryReader): OneofOptions;
 }
 
 export namespace OneofOptions {
-  export type AsObject = {
-    uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
-  }
+    export type AsObject = {
+        uninterpretedOptionList: Array<UninterpretedOption.AsObject>;
+    };
 }
 
 export class EnumOptions extends jspb.Message {
-  hasAllowAlias(): boolean;
-  clearAllowAlias(): EnumOptions;
-  getAllowAlias(): boolean | undefined;
-  setAllowAlias(value: boolean): EnumOptions;
+    hasAllowAlias(): boolean;
+    clearAllowAlias(): EnumOptions;
+    getAllowAlias(): boolean | undefined;
+    setAllowAlias(value: boolean): EnumOptions;
 
-  hasDeprecated(): boolean;
-  clearDeprecated(): EnumOptions;
-  getDeprecated(): boolean | undefined;
-  setDeprecated(value: boolean): EnumOptions;
+    hasDeprecated(): boolean;
+    clearDeprecated(): EnumOptions;
+    getDeprecated(): boolean | undefined;
+    setDeprecated(value: boolean): EnumOptions;
 
-  clearUninterpretedOptionList(): EnumOptions;
-  getUninterpretedOptionList(): Array<UninterpretedOption>;
-  setUninterpretedOptionList(value: Array<UninterpretedOption>): EnumOptions;
-  addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
+    clearUninterpretedOptionList(): EnumOptions;
+    getUninterpretedOptionList(): Array<UninterpretedOption>;
+    setUninterpretedOptionList(value: Array<UninterpretedOption>): EnumOptions;
+    addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): EnumOptions.AsObject;
-  static toObject(includeInstance: boolean, msg: EnumOptions): EnumOptions.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: EnumOptions, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): EnumOptions;
-  static deserializeBinaryFromReader(message: EnumOptions, reader: jspb.BinaryReader): EnumOptions;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): EnumOptions.AsObject;
+    static toObject(includeInstance: boolean, msg: EnumOptions): EnumOptions.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: EnumOptions, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): EnumOptions;
+    static deserializeBinaryFromReader(message: EnumOptions, reader: jspb.BinaryReader): EnumOptions;
 }
 
 export namespace EnumOptions {
-  export type AsObject = {
-    allowAlias?: boolean | undefined,
-    deprecated?: boolean | undefined,
-    uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
-  }
+    export type AsObject = {
+        allowAlias?: boolean | undefined;
+        deprecated?: boolean | undefined;
+        uninterpretedOptionList: Array<UninterpretedOption.AsObject>;
+    };
 }
 
 export class EnumValueOptions extends jspb.Message {
-  hasDeprecated(): boolean;
-  clearDeprecated(): EnumValueOptions;
-  getDeprecated(): boolean | undefined;
-  setDeprecated(value: boolean): EnumValueOptions;
+    hasDeprecated(): boolean;
+    clearDeprecated(): EnumValueOptions;
+    getDeprecated(): boolean | undefined;
+    setDeprecated(value: boolean): EnumValueOptions;
 
-  clearUninterpretedOptionList(): EnumValueOptions;
-  getUninterpretedOptionList(): Array<UninterpretedOption>;
-  setUninterpretedOptionList(value: Array<UninterpretedOption>): EnumValueOptions;
-  addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
+    clearUninterpretedOptionList(): EnumValueOptions;
+    getUninterpretedOptionList(): Array<UninterpretedOption>;
+    setUninterpretedOptionList(value: Array<UninterpretedOption>): EnumValueOptions;
+    addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): EnumValueOptions.AsObject;
-  static toObject(includeInstance: boolean, msg: EnumValueOptions): EnumValueOptions.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: EnumValueOptions, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): EnumValueOptions;
-  static deserializeBinaryFromReader(message: EnumValueOptions, reader: jspb.BinaryReader): EnumValueOptions;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): EnumValueOptions.AsObject;
+    static toObject(includeInstance: boolean, msg: EnumValueOptions): EnumValueOptions.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: EnumValueOptions, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): EnumValueOptions;
+    static deserializeBinaryFromReader(message: EnumValueOptions, reader: jspb.BinaryReader): EnumValueOptions;
 }
 
 export namespace EnumValueOptions {
-  export type AsObject = {
-    deprecated?: boolean | undefined,
-    uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
-  }
+    export type AsObject = {
+        deprecated?: boolean | undefined;
+        uninterpretedOptionList: Array<UninterpretedOption.AsObject>;
+    };
 }
 
 export class ServiceOptions extends jspb.Message {
-  hasDeprecated(): boolean;
-  clearDeprecated(): ServiceOptions;
-  getDeprecated(): boolean | undefined;
-  setDeprecated(value: boolean): ServiceOptions;
+    hasDeprecated(): boolean;
+    clearDeprecated(): ServiceOptions;
+    getDeprecated(): boolean | undefined;
+    setDeprecated(value: boolean): ServiceOptions;
 
-  clearUninterpretedOptionList(): ServiceOptions;
-  getUninterpretedOptionList(): Array<UninterpretedOption>;
-  setUninterpretedOptionList(value: Array<UninterpretedOption>): ServiceOptions;
-  addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
+    clearUninterpretedOptionList(): ServiceOptions;
+    getUninterpretedOptionList(): Array<UninterpretedOption>;
+    setUninterpretedOptionList(value: Array<UninterpretedOption>): ServiceOptions;
+    addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): ServiceOptions.AsObject;
-  static toObject(includeInstance: boolean, msg: ServiceOptions): ServiceOptions.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: ServiceOptions, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): ServiceOptions;
-  static deserializeBinaryFromReader(message: ServiceOptions, reader: jspb.BinaryReader): ServiceOptions;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ServiceOptions.AsObject;
+    static toObject(includeInstance: boolean, msg: ServiceOptions): ServiceOptions.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: ServiceOptions, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ServiceOptions;
+    static deserializeBinaryFromReader(message: ServiceOptions, reader: jspb.BinaryReader): ServiceOptions;
 }
 
 export namespace ServiceOptions {
-  export type AsObject = {
-    deprecated?: boolean | undefined,
-    uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
-  }
+    export type AsObject = {
+        deprecated?: boolean | undefined;
+        uninterpretedOptionList: Array<UninterpretedOption.AsObject>;
+    };
 }
 
 export class MethodOptions extends jspb.Message {
-  hasDeprecated(): boolean;
-  clearDeprecated(): MethodOptions;
-  getDeprecated(): boolean | undefined;
-  setDeprecated(value: boolean): MethodOptions;
+    hasDeprecated(): boolean;
+    clearDeprecated(): MethodOptions;
+    getDeprecated(): boolean | undefined;
+    setDeprecated(value: boolean): MethodOptions;
 
-  hasIdempotencyLevel(): boolean;
-  clearIdempotencyLevel(): MethodOptions;
-  getIdempotencyLevel(): MethodOptions.IdempotencyLevel | undefined;
-  setIdempotencyLevel(value: MethodOptions.IdempotencyLevel): MethodOptions;
+    hasIdempotencyLevel(): boolean;
+    clearIdempotencyLevel(): MethodOptions;
+    getIdempotencyLevel(): MethodOptions.IdempotencyLevel | undefined;
+    setIdempotencyLevel(value: MethodOptions.IdempotencyLevel): MethodOptions;
 
-  clearUninterpretedOptionList(): MethodOptions;
-  getUninterpretedOptionList(): Array<UninterpretedOption>;
-  setUninterpretedOptionList(value: Array<UninterpretedOption>): MethodOptions;
-  addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
+    clearUninterpretedOptionList(): MethodOptions;
+    getUninterpretedOptionList(): Array<UninterpretedOption>;
+    setUninterpretedOptionList(value: Array<UninterpretedOption>): MethodOptions;
+    addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): MethodOptions.AsObject;
-  static toObject(includeInstance: boolean, msg: MethodOptions): MethodOptions.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: MethodOptions, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): MethodOptions;
-  static deserializeBinaryFromReader(message: MethodOptions, reader: jspb.BinaryReader): MethodOptions;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): MethodOptions.AsObject;
+    static toObject(includeInstance: boolean, msg: MethodOptions): MethodOptions.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: MethodOptions, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): MethodOptions;
+    static deserializeBinaryFromReader(message: MethodOptions, reader: jspb.BinaryReader): MethodOptions;
 }
 
 export namespace MethodOptions {
-  export type AsObject = {
-    deprecated?: boolean | undefined,
-    idempotencyLevel?: IdempotencyLevel | undefined,
-    uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
-  }
+    export type AsObject = {
+        deprecated?: boolean | undefined;
+        idempotencyLevel?: IdempotencyLevel | undefined;
+        uninterpretedOptionList: Array<UninterpretedOption.AsObject>;
+    };
 
-  export enum IdempotencyLevel {
-    IDEMPOTENCY_UNKNOWN = 0,
-    NO_SIDE_EFFECTS = 1,
-    IDEMPOTENT = 2,
-  }
+    export enum IdempotencyLevel {
+        IDEMPOTENCY_UNKNOWN = 0,
+        NO_SIDE_EFFECTS = 1,
+        IDEMPOTENT = 2,
+    }
 }
 
 export class UninterpretedOption extends jspb.Message {
-  clearNameList(): UninterpretedOption;
-  getNameList(): Array<UninterpretedOption.NamePart>;
-  setNameList(value: Array<UninterpretedOption.NamePart>): UninterpretedOption;
-  addName(value?: UninterpretedOption.NamePart, index?: number): UninterpretedOption.NamePart;
+    clearNameList(): UninterpretedOption;
+    getNameList(): Array<UninterpretedOption.NamePart>;
+    setNameList(value: Array<UninterpretedOption.NamePart>): UninterpretedOption;
+    addName(value?: UninterpretedOption.NamePart, index?: number): UninterpretedOption.NamePart;
 
-  hasIdentifierValue(): boolean;
-  clearIdentifierValue(): UninterpretedOption;
-  getIdentifierValue(): string | undefined;
-  setIdentifierValue(value: string): UninterpretedOption;
+    hasIdentifierValue(): boolean;
+    clearIdentifierValue(): UninterpretedOption;
+    getIdentifierValue(): string | undefined;
+    setIdentifierValue(value: string): UninterpretedOption;
 
-  hasPositiveIntValue(): boolean;
-  clearPositiveIntValue(): UninterpretedOption;
-  getPositiveIntValue(): number | undefined;
-  setPositiveIntValue(value: number): UninterpretedOption;
+    hasPositiveIntValue(): boolean;
+    clearPositiveIntValue(): UninterpretedOption;
+    getPositiveIntValue(): number | undefined;
+    setPositiveIntValue(value: number): UninterpretedOption;
 
-  hasNegativeIntValue(): boolean;
-  clearNegativeIntValue(): UninterpretedOption;
-  getNegativeIntValue(): number | undefined;
-  setNegativeIntValue(value: number): UninterpretedOption;
+    hasNegativeIntValue(): boolean;
+    clearNegativeIntValue(): UninterpretedOption;
+    getNegativeIntValue(): number | undefined;
+    setNegativeIntValue(value: number): UninterpretedOption;
 
-  hasDoubleValue(): boolean;
-  clearDoubleValue(): UninterpretedOption;
-  getDoubleValue(): number | undefined;
-  setDoubleValue(value: number): UninterpretedOption;
+    hasDoubleValue(): boolean;
+    clearDoubleValue(): UninterpretedOption;
+    getDoubleValue(): number | undefined;
+    setDoubleValue(value: number): UninterpretedOption;
 
-  hasStringValue(): boolean;
-  clearStringValue(): UninterpretedOption;
-  getStringValue(): Uint8Array | string;
-  getStringValue_asU8(): Uint8Array;
-  getStringValue_asB64(): string;
-  setStringValue(value: Uint8Array | string): UninterpretedOption;
+    hasStringValue(): boolean;
+    clearStringValue(): UninterpretedOption;
+    getStringValue(): Uint8Array | string;
+    getStringValue_asU8(): Uint8Array;
+    getStringValue_asB64(): string;
+    setStringValue(value: Uint8Array | string): UninterpretedOption;
 
-  hasAggregateValue(): boolean;
-  clearAggregateValue(): UninterpretedOption;
-  getAggregateValue(): string | undefined;
-  setAggregateValue(value: string): UninterpretedOption;
+    hasAggregateValue(): boolean;
+    clearAggregateValue(): UninterpretedOption;
+    getAggregateValue(): string | undefined;
+    setAggregateValue(value: string): UninterpretedOption;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): UninterpretedOption.AsObject;
-  static toObject(includeInstance: boolean, msg: UninterpretedOption): UninterpretedOption.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: UninterpretedOption, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): UninterpretedOption;
-  static deserializeBinaryFromReader(message: UninterpretedOption, reader: jspb.BinaryReader): UninterpretedOption;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UninterpretedOption.AsObject;
+    static toObject(includeInstance: boolean, msg: UninterpretedOption): UninterpretedOption.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: UninterpretedOption, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UninterpretedOption;
+    static deserializeBinaryFromReader(message: UninterpretedOption, reader: jspb.BinaryReader): UninterpretedOption;
 }
 
 export namespace UninterpretedOption {
-  export type AsObject = {
-    nameList: Array<NamePart.AsObject>,
-    identifierValue?: string | undefined,
-    positiveIntValue?: number | undefined,
-    negativeIntValue?: number | undefined,
-    doubleValue?: number | undefined,
-    stringValue: Uint8Array | string,
-    aggregateValue?: string | undefined,
-  }
+    export type AsObject = {
+        nameList: Array<NamePart.AsObject>;
+        identifierValue?: string | undefined;
+        positiveIntValue?: number | undefined;
+        negativeIntValue?: number | undefined;
+        doubleValue?: number | undefined;
+        stringValue: Uint8Array | string;
+        aggregateValue?: string | undefined;
+    };
 
-  export class NamePart extends jspb.Message {
-    hasNamePart(): boolean;
-    clearNamePart(): NamePart;
-    getNamePart(): string | undefined;
-    setNamePart(value: string): NamePart;
+    export class NamePart extends jspb.Message {
+        hasNamePart(): boolean;
+        clearNamePart(): NamePart;
+        getNamePart(): string | undefined;
+        setNamePart(value: string): NamePart;
 
-    hasIsExtension(): boolean;
-    clearIsExtension(): NamePart;
-    getIsExtension(): boolean | undefined;
-    setIsExtension(value: boolean): NamePart;
+        hasIsExtension(): boolean;
+        clearIsExtension(): NamePart;
+        getIsExtension(): boolean | undefined;
+        setIsExtension(value: boolean): NamePart;
 
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): NamePart.AsObject;
-    static toObject(includeInstance: boolean, msg: NamePart): NamePart.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: NamePart, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): NamePart;
-    static deserializeBinaryFromReader(message: NamePart, reader: jspb.BinaryReader): NamePart;
-  }
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): NamePart.AsObject;
+        static toObject(includeInstance: boolean, msg: NamePart): NamePart.AsObject;
+        static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+        static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+        static serializeBinaryToWriter(message: NamePart, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): NamePart;
+        static deserializeBinaryFromReader(message: NamePart, reader: jspb.BinaryReader): NamePart;
+    }
 
-  export namespace NamePart {
-    export type AsObject = {
-      namePart?: string | undefined,
-      isExtension?: boolean | undefined,
+    export namespace NamePart {
+        export type AsObject = {
+            namePart?: string | undefined;
+            isExtension?: boolean | undefined;
+        };
     }
-  }
 }
 
 export class SourceCodeInfo extends jspb.Message {
-  clearLocationList(): SourceCodeInfo;
-  getLocationList(): Array<SourceCodeInfo.Location>;
-  setLocationList(value: Array<SourceCodeInfo.Location>): SourceCodeInfo;
-  addLocation(value?: SourceCodeInfo.Location, index?: number): SourceCodeInfo.Location;
+    clearLocationList(): SourceCodeInfo;
+    getLocationList(): Array<SourceCodeInfo.Location>;
+    setLocationList(value: Array<SourceCodeInfo.Location>): SourceCodeInfo;
+    addLocation(value?: SourceCodeInfo.Location, index?: number): SourceCodeInfo.Location;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): SourceCodeInfo.AsObject;
-  static toObject(includeInstance: boolean, msg: SourceCodeInfo): SourceCodeInfo.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: SourceCodeInfo, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): SourceCodeInfo;
-  static deserializeBinaryFromReader(message: SourceCodeInfo, reader: jspb.BinaryReader): SourceCodeInfo;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SourceCodeInfo.AsObject;
+    static toObject(includeInstance: boolean, msg: SourceCodeInfo): SourceCodeInfo.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: SourceCodeInfo, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SourceCodeInfo;
+    static deserializeBinaryFromReader(message: SourceCodeInfo, reader: jspb.BinaryReader): SourceCodeInfo;
 }
 
 export namespace SourceCodeInfo {
-  export type AsObject = {
-    locationList: Array<Location.AsObject>,
-  }
+    export type AsObject = {
+        locationList: Array<Location.AsObject>;
+    };
 
-  export class Location extends jspb.Message {
-    clearPathList(): Location;
-    getPathList(): Array<number>;
-    setPathList(value: Array<number>): Location;
-    addPath(value: number, index?: number): number;
+    export class Location extends jspb.Message {
+        clearPathList(): Location;
+        getPathList(): Array<number>;
+        setPathList(value: Array<number>): Location;
+        addPath(value: number, index?: number): number;
 
-    clearSpanList(): Location;
-    getSpanList(): Array<number>;
-    setSpanList(value: Array<number>): Location;
-    addSpan(value: number, index?: number): number;
+        clearSpanList(): Location;
+        getSpanList(): Array<number>;
+        setSpanList(value: Array<number>): Location;
+        addSpan(value: number, index?: number): number;
 
-    hasLeadingComments(): boolean;
-    clearLeadingComments(): Location;
-    getLeadingComments(): string | undefined;
-    setLeadingComments(value: string): Location;
+        hasLeadingComments(): boolean;
+        clearLeadingComments(): Location;
+        getLeadingComments(): string | undefined;
+        setLeadingComments(value: string): Location;
 
-    hasTrailingComments(): boolean;
-    clearTrailingComments(): Location;
-    getTrailingComments(): string | undefined;
-    setTrailingComments(value: string): Location;
+        hasTrailingComments(): boolean;
+        clearTrailingComments(): Location;
+        getTrailingComments(): string | undefined;
+        setTrailingComments(value: string): Location;
 
-    clearLeadingDetachedCommentsList(): Location;
-    getLeadingDetachedCommentsList(): Array<string>;
-    setLeadingDetachedCommentsList(value: Array<string>): Location;
-    addLeadingDetachedComments(value: string, index?: number): string;
+        clearLeadingDetachedCommentsList(): Location;
+        getLeadingDetachedCommentsList(): Array<string>;
+        setLeadingDetachedCommentsList(value: Array<string>): Location;
+        addLeadingDetachedComments(value: string, index?: number): string;
 
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): Location.AsObject;
-    static toObject(includeInstance: boolean, msg: Location): Location.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: Location, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): Location;
-    static deserializeBinaryFromReader(message: Location, reader: jspb.BinaryReader): Location;
-  }
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): Location.AsObject;
+        static toObject(includeInstance: boolean, msg: Location): Location.AsObject;
+        static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+        static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+        static serializeBinaryToWriter(message: Location, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): Location;
+        static deserializeBinaryFromReader(message: Location, reader: jspb.BinaryReader): Location;
+    }
 
-  export namespace Location {
-    export type AsObject = {
-      pathList: Array<number>,
-      spanList: Array<number>,
-      leadingComments?: string | undefined,
-      trailingComments?: string | undefined,
-      leadingDetachedCommentsList: Array<string>,
+    export namespace Location {
+        export type AsObject = {
+            pathList: Array<number>;
+            spanList: Array<number>;
+            leadingComments?: string | undefined;
+            trailingComments?: string | undefined;
+            leadingDetachedCommentsList: Array<string>;
+        };
     }
-  }
 }
 
 export class GeneratedCodeInfo extends jspb.Message {
-  clearAnnotationList(): GeneratedCodeInfo;
-  getAnnotationList(): Array<GeneratedCodeInfo.Annotation>;
-  setAnnotationList(value: Array<GeneratedCodeInfo.Annotation>): GeneratedCodeInfo;
-  addAnnotation(value?: GeneratedCodeInfo.Annotation, index?: number): GeneratedCodeInfo.Annotation;
+    clearAnnotationList(): GeneratedCodeInfo;
+    getAnnotationList(): Array<GeneratedCodeInfo.Annotation>;
+    setAnnotationList(value: Array<GeneratedCodeInfo.Annotation>): GeneratedCodeInfo;
+    addAnnotation(value?: GeneratedCodeInfo.Annotation, index?: number): GeneratedCodeInfo.Annotation;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): GeneratedCodeInfo.AsObject;
-  static toObject(includeInstance: boolean, msg: GeneratedCodeInfo): GeneratedCodeInfo.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: GeneratedCodeInfo, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): GeneratedCodeInfo;
-  static deserializeBinaryFromReader(message: GeneratedCodeInfo, reader: jspb.BinaryReader): GeneratedCodeInfo;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GeneratedCodeInfo.AsObject;
+    static toObject(includeInstance: boolean, msg: GeneratedCodeInfo): GeneratedCodeInfo.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: GeneratedCodeInfo, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GeneratedCodeInfo;
+    static deserializeBinaryFromReader(message: GeneratedCodeInfo, reader: jspb.BinaryReader): GeneratedCodeInfo;
 }
 
 export namespace GeneratedCodeInfo {
-  export type AsObject = {
-    annotationList: Array<Annotation.AsObject>,
-  }
+    export type AsObject = {
+        annotationList: Array<Annotation.AsObject>;
+    };
 
-  export class Annotation extends jspb.Message {
-    clearPathList(): Annotation;
-    getPathList(): Array<number>;
-    setPathList(value: Array<number>): Annotation;
-    addPath(value: number, index?: number): number;
+    export class Annotation extends jspb.Message {
+        clearPathList(): Annotation;
+        getPathList(): Array<number>;
+        setPathList(value: Array<number>): Annotation;
+        addPath(value: number, index?: number): number;
 
-    hasSourceFile(): boolean;
-    clearSourceFile(): Annotation;
-    getSourceFile(): string | undefined;
-    setSourceFile(value: string): Annotation;
+        hasSourceFile(): boolean;
+        clearSourceFile(): Annotation;
+        getSourceFile(): string | undefined;
+        setSourceFile(value: string): Annotation;
 
-    hasBegin(): boolean;
-    clearBegin(): Annotation;
-    getBegin(): number | undefined;
-    setBegin(value: number): Annotation;
+        hasBegin(): boolean;
+        clearBegin(): Annotation;
+        getBegin(): number | undefined;
+        setBegin(value: number): Annotation;
 
-    hasEnd(): boolean;
-    clearEnd(): Annotation;
-    getEnd(): number | undefined;
-    setEnd(value: number): Annotation;
+        hasEnd(): boolean;
+        clearEnd(): Annotation;
+        getEnd(): number | undefined;
+        setEnd(value: number): Annotation;
 
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): Annotation.AsObject;
-    static toObject(includeInstance: boolean, msg: Annotation): Annotation.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: Annotation, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): Annotation;
-    static deserializeBinaryFromReader(message: Annotation, reader: jspb.BinaryReader): Annotation;
-  }
+        serializeBinary(): Uint8Array;
+        toObject(includeInstance?: boolean): Annotation.AsObject;
+        static toObject(includeInstance: boolean, msg: Annotation): Annotation.AsObject;
+        static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+        static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+        static serializeBinaryToWriter(message: Annotation, writer: jspb.BinaryWriter): void;
+        static deserializeBinary(bytes: Uint8Array): Annotation;
+        static deserializeBinaryFromReader(message: Annotation, reader: jspb.BinaryReader): Annotation;
+    }
 
-  export namespace Annotation {
-    export type AsObject = {
-      pathList: Array<number>,
-      sourceFile?: string | undefined,
-      begin?: number | undefined,
-      end?: number | undefined,
+    export namespace Annotation {
+        export type AsObject = {
+            pathList: Array<number>;
+            sourceFile?: string | undefined;
+            begin?: number | undefined;
+            end?: number | undefined;
+        };
     }
-  }
 }

google-protobuf/google/protobuf/duration_pb.d.ts

@@ -7,23 +7,23 @@ // package: google.protobuf
 export class Duration extends jspb.Message {
-  getSeconds(): number;
-  setSeconds(value: number): Duration;
+    getSeconds(): number;
+    setSeconds(value: number): Duration;
 
-  getNanos(): number;
-  setNanos(value: number): Duration;
+    getNanos(): number;
+    setNanos(value: number): Duration;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Duration.AsObject;
-  static toObject(includeInstance: boolean, msg: Duration): Duration.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Duration, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Duration;
-  static deserializeBinaryFromReader(message: Duration, reader: jspb.BinaryReader): Duration;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Duration.AsObject;
+    static toObject(includeInstance: boolean, msg: Duration): Duration.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Duration, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Duration;
+    static deserializeBinaryFromReader(message: Duration, reader: jspb.BinaryReader): Duration;
 }
 
 export namespace Duration {
-  export type AsObject = {
-    seconds: number,
-    nanos: number,
-  }
+    export type AsObject = {
+        seconds: number;
+        nanos: number;
+    };
 }

google-protobuf/google/protobuf/empty_pb.d.ts

@@ -7,15 +7,14 @@ // package: google.protobuf
 export class Empty extends jspb.Message {
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Empty.AsObject;
-  static toObject(includeInstance: boolean, msg: Empty): Empty.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Empty, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Empty;
-  static deserializeBinaryFromReader(message: Empty, reader: jspb.BinaryReader): Empty;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Empty.AsObject;
+    static toObject(includeInstance: boolean, msg: Empty): Empty.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Empty, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Empty;
+    static deserializeBinaryFromReader(message: Empty, reader: jspb.BinaryReader): Empty;
 }
 
 export namespace Empty {
-  export type AsObject = {
-  }
+    export type AsObject = {};
 }

google-protobuf/google/protobuf/field_mask_pb.d.ts

@@ -7,21 +7,21 @@ // package: google.protobuf
 export class FieldMask extends jspb.Message {
-  clearPathsList(): FieldMask;
-  getPathsList(): Array<string>;
-  setPathsList(value: Array<string>): FieldMask;
-  addPaths(value: string, index?: number): string;
+    clearPathsList(): FieldMask;
+    getPathsList(): Array<string>;
+    setPathsList(value: Array<string>): FieldMask;
+    addPaths(value: string, index?: number): string;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): FieldMask.AsObject;
-  static toObject(includeInstance: boolean, msg: FieldMask): FieldMask.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: FieldMask, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): FieldMask;
-  static deserializeBinaryFromReader(message: FieldMask, reader: jspb.BinaryReader): FieldMask;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): FieldMask.AsObject;
+    static toObject(includeInstance: boolean, msg: FieldMask): FieldMask.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: FieldMask, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): FieldMask;
+    static deserializeBinaryFromReader(message: FieldMask, reader: jspb.BinaryReader): FieldMask;
 }
 
 export namespace FieldMask {
-  export type AsObject = {
-    pathsList: Array<string>,
-  }
+    export type AsObject = {
+        pathsList: Array<string>;
+    };
 }

google-protobuf/google/protobuf/source_context_pb.d.ts

@@ -7,19 +7,19 @@ // package: google.protobuf
 export class SourceContext extends jspb.Message {
-  getFileName(): string;
-  setFileName(value: string): SourceContext;
+    getFileName(): string;
+    setFileName(value: string): SourceContext;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): SourceContext.AsObject;
-  static toObject(includeInstance: boolean, msg: SourceContext): SourceContext.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: SourceContext, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): SourceContext;
-  static deserializeBinaryFromReader(message: SourceContext, reader: jspb.BinaryReader): SourceContext;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): SourceContext.AsObject;
+    static toObject(includeInstance: boolean, msg: SourceContext): SourceContext.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: SourceContext, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): SourceContext;
+    static deserializeBinaryFromReader(message: SourceContext, reader: jspb.BinaryReader): SourceContext;
 }
 
 export namespace SourceContext {
-  export type AsObject = {
-    fileName: string,
-  }
+    export type AsObject = {
+        fileName: string;
+    };
 }

google-protobuf/google/protobuf/struct_pb.d.ts

@@ -7,120 +7,120 @@ // package: google.protobuf
 export class Struct extends jspb.Message {
-  getFieldsMap(): jspb.Map<string, Value>;
-  clearFieldsMap(): Struct;
+    getFieldsMap(): jspb.Map<string, Value>;
+    clearFieldsMap(): Struct;
 
-  toJavaScript(): {[key: string]: JavaScriptValue};
-  static fromJavaScript(value: {[key: string]: JavaScriptValue}): Struct;
+    toJavaScript(): { [key: string]: JavaScriptValue };
+    static fromJavaScript(value: { [key: string]: JavaScriptValue }): Struct;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Struct.AsObject;
-  static toObject(includeInstance: boolean, msg: Struct): Struct.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Struct, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Struct;
-  static deserializeBinaryFromReader(message: Struct, reader: jspb.BinaryReader): Struct;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Struct.AsObject;
+    static toObject(includeInstance: boolean, msg: Struct): Struct.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Struct, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Struct;
+    static deserializeBinaryFromReader(message: Struct, reader: jspb.BinaryReader): Struct;
 }
 
 export namespace Struct {
-  export type AsObject = {
-    fieldsMap: Array<[string, Value.AsObject]>,
-  }
+    export type AsObject = {
+        fieldsMap: Array<[string, Value.AsObject]>;
+    };
 }
 
 export class Value extends jspb.Message {
-  hasNullValue(): boolean;
-  clearNullValue(): Value;
-  getNullValue(): NullValue;
-  setNullValue(value: NullValue): Value;
+    hasNullValue(): boolean;
+    clearNullValue(): Value;
+    getNullValue(): NullValue;
+    setNullValue(value: NullValue): Value;
 
-  hasNumberValue(): boolean;
-  clearNumberValue(): Value;
-  getNumberValue(): number;
-  setNumberValue(value: number): Value;
+    hasNumberValue(): boolean;
+    clearNumberValue(): Value;
+    getNumberValue(): number;
+    setNumberValue(value: number): Value;
 
-  hasStringValue(): boolean;
-  clearStringValue(): Value;
-  getStringValue(): string;
-  setStringValue(value: string): Value;
+    hasStringValue(): boolean;
+    clearStringValue(): Value;
+    getStringValue(): string;
+    setStringValue(value: string): Value;
 
-  hasBoolValue(): boolean;
-  clearBoolValue(): Value;
-  getBoolValue(): boolean;
-  setBoolValue(value: boolean): Value;
+    hasBoolValue(): boolean;
+    clearBoolValue(): Value;
+    getBoolValue(): boolean;
+    setBoolValue(value: boolean): Value;
 
-  hasStructValue(): boolean;
-  clearStructValue(): Value;
-  getStructValue(): Struct | undefined;
-  setStructValue(value?: Struct): Value;
+    hasStructValue(): boolean;
+    clearStructValue(): Value;
+    getStructValue(): Struct | undefined;
+    setStructValue(value?: Struct): Value;
 
-  hasListValue(): boolean;
-  clearListValue(): Value;
-  getListValue(): ListValue | undefined;
-  setListValue(value?: ListValue): Value;
+    hasListValue(): boolean;
+    clearListValue(): Value;
+    getListValue(): ListValue | undefined;
+    setListValue(value?: ListValue): Value;
 
-  getKindCase(): Value.KindCase;
+    getKindCase(): Value.KindCase;
 
-  toJavaScript(): JavaScriptValue;
-  static fromJavaScript(value: JavaScriptValue): Value;
+    toJavaScript(): JavaScriptValue;
+    static fromJavaScript(value: JavaScriptValue): Value;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Value.AsObject;
-  static toObject(includeInstance: boolean, msg: Value): Value.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Value, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Value;
-  static deserializeBinaryFromReader(message: Value, reader: jspb.BinaryReader): Value;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Value.AsObject;
+    static toObject(includeInstance: boolean, msg: Value): Value.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Value, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Value;
+    static deserializeBinaryFromReader(message: Value, reader: jspb.BinaryReader): Value;
 }
 
 export namespace Value {
-  export type AsObject = {
-    nullValue: NullValue,
-    numberValue: number,
-    stringValue: string,
-    boolValue: boolean,
-    structValue?: Struct.AsObject | undefined,
-    listValue?: ListValue.AsObject | undefined,
-  }
+    export type AsObject = {
+        nullValue: NullValue;
+        numberValue: number;
+        stringValue: string;
+        boolValue: boolean;
+        structValue?: Struct.AsObject | undefined;
+        listValue?: ListValue.AsObject | undefined;
+    };
 
-  export enum KindCase {
-    KIND_NOT_SET = 0,
-    NULL_VALUE = 1,
-    NUMBER_VALUE = 2,
-    STRING_VALUE = 3,
-    BOOL_VALUE = 4,
-    STRUCT_VALUE = 5,
-    LIST_VALUE = 6,
-  }
+    export enum KindCase {
+        KIND_NOT_SET = 0,
+        NULL_VALUE = 1,
+        NUMBER_VALUE = 2,
+        STRING_VALUE = 3,
+        BOOL_VALUE = 4,
+        STRUCT_VALUE = 5,
+        LIST_VALUE = 6,
+    }
 }
 
 export class ListValue extends jspb.Message {
-  clearValuesList(): ListValue;
-  getValuesList(): Array<Value>;
-  setValuesList(value: Array<Value>): ListValue;
-  addValues(value?: Value, index?: number): Value;
+    clearValuesList(): ListValue;
+    getValuesList(): Array<Value>;
+    setValuesList(value: Array<Value>): ListValue;
+    addValues(value?: Value, index?: number): Value;
 
-  toJavaScript(): Array<JavaScriptValue>;
-  static fromJavaScript(value: Array<JavaScriptValue>): ListValue;
+    toJavaScript(): Array<JavaScriptValue>;
+    static fromJavaScript(value: Array<JavaScriptValue>): ListValue;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): ListValue.AsObject;
-  static toObject(includeInstance: boolean, msg: ListValue): ListValue.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: ListValue, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): ListValue;
-  static deserializeBinaryFromReader(message: ListValue, reader: jspb.BinaryReader): ListValue;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ListValue.AsObject;
+    static toObject(includeInstance: boolean, msg: ListValue): ListValue.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: ListValue, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ListValue;
+    static deserializeBinaryFromReader(message: ListValue, reader: jspb.BinaryReader): ListValue;
 }
 
 export namespace ListValue {
-  export type AsObject = {
-    valuesList: Array<Value.AsObject>,
-  }
+    export type AsObject = {
+        valuesList: Array<Value.AsObject>;
+    };
 }
 
 export enum NullValue {
-  NULL_VALUE = 0,
+    NULL_VALUE = 0,
 }
 
 export type JavaScriptValue = null | number | string | boolean | Array<any> | {};

google-protobuf/google/protobuf/timestamp_pb.d.ts

@@ -7,27 +7,27 @@ // package: google.protobuf
 export class Timestamp extends jspb.Message {
-  getSeconds(): number;
-  setSeconds(value: number): Timestamp;
+    getSeconds(): number;
+    setSeconds(value: number): Timestamp;
 
-  getNanos(): number;
-  setNanos(value: number): Timestamp;
+    getNanos(): number;
+    setNanos(value: number): Timestamp;
 
-  toDate(): Date;
-  fromDate(date: Date): void;
+    toDate(): Date;
+    fromDate(date: Date): void;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Timestamp.AsObject;
-  static toObject(includeInstance: boolean, msg: Timestamp): Timestamp.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Timestamp, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Timestamp;
-  static deserializeBinaryFromReader(message: Timestamp, reader: jspb.BinaryReader): Timestamp;
-  static fromDate(date: Date): Timestamp;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Timestamp.AsObject;
+    static toObject(includeInstance: boolean, msg: Timestamp): Timestamp.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Timestamp, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Timestamp;
+    static deserializeBinaryFromReader(message: Timestamp, reader: jspb.BinaryReader): Timestamp;
+    static fromDate(date: Date): Timestamp;
 }
 
 export namespace Timestamp {
-  export type AsObject = {
-    seconds: number,
-    nanos: number,
-  }
+    export type AsObject = {
+        seconds: number;
+        nanos: number;
+    };
 }

google-protobuf/google/protobuf/type_pb.d.ts

@@ -9,237 +9,237 @@ // package: google.protobuf
 export class Type extends jspb.Message {
-  getName(): string;
-  setName(value: string): Type;
+    getName(): string;
+    setName(value: string): Type;
 
-  clearFieldsList(): Type;
-  getFieldsList(): Array<Field>;
-  setFieldsList(value: Array<Field>): Type;
-  addFields(value?: Field, index?: number): Field;
+    clearFieldsList(): Type;
+    getFieldsList(): Array<Field>;
+    setFieldsList(value: Array<Field>): Type;
+    addFields(value?: Field, index?: number): Field;
 
-  clearOneofsList(): Type;
-  getOneofsList(): Array<string>;
-  setOneofsList(value: Array<string>): Type;
-  addOneofs(value: string, index?: number): string;
+    clearOneofsList(): Type;
+    getOneofsList(): Array<string>;
+    setOneofsList(value: Array<string>): Type;
+    addOneofs(value: string, index?: number): string;
 
-  clearOptionsList(): Type;
-  getOptionsList(): Array<Option>;
-  setOptionsList(value: Array<Option>): Type;
-  addOptions(value?: Option, index?: number): Option;
+    clearOptionsList(): Type;
+    getOptionsList(): Array<Option>;
+    setOptionsList(value: Array<Option>): Type;
+    addOptions(value?: Option, index?: number): Option;
 
-  hasSourceContext(): boolean;
-  clearSourceContext(): Type;
-  getSourceContext(): google_protobuf_source_context_pb.SourceContext | undefined;
-  setSourceContext(value?: google_protobuf_source_context_pb.SourceContext): Type;
+    hasSourceContext(): boolean;
+    clearSourceContext(): Type;
+    getSourceContext(): google_protobuf_source_context_pb.SourceContext | undefined;
+    setSourceContext(value?: google_protobuf_source_context_pb.SourceContext): Type;
 
-  getSyntax(): Syntax;
-  setSyntax(value: Syntax): Type;
+    getSyntax(): Syntax;
+    setSyntax(value: Syntax): Type;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Type.AsObject;
-  static toObject(includeInstance: boolean, msg: Type): Type.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Type, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Type;
-  static deserializeBinaryFromReader(message: Type, reader: jspb.BinaryReader): Type;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Type.AsObject;
+    static toObject(includeInstance: boolean, msg: Type): Type.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Type, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Type;
+    static deserializeBinaryFromReader(message: Type, reader: jspb.BinaryReader): Type;
 }
 
 export namespace Type {
-  export type AsObject = {
-    name: string,
-    fieldsList: Array<Field.AsObject>,
-    oneofsList: Array<string>,
-    optionsList: Array<Option.AsObject>,
-    sourceContext?: google_protobuf_source_context_pb.SourceContext.AsObject | undefined,
-    syntax: Syntax,
-  }
+    export type AsObject = {
+        name: string;
+        fieldsList: Array<Field.AsObject>;
+        oneofsList: Array<string>;
+        optionsList: Array<Option.AsObject>;
+        sourceContext?: google_protobuf_source_context_pb.SourceContext.AsObject | undefined;
+        syntax: Syntax;
+    };
 }
 
 export class Field extends jspb.Message {
-  getKind(): Field.Kind;
-  setKind(value: Field.Kind): Field;
+    getKind(): Field.Kind;
+    setKind(value: Field.Kind): Field;
 
-  getCardinality(): Field.Cardinality;
-  setCardinality(value: Field.Cardinality): Field;
+    getCardinality(): Field.Cardinality;
+    setCardinality(value: Field.Cardinality): Field;
 
-  getNumber(): number;
-  setNumber(value: number): Field;
+    getNumber(): number;
+    setNumber(value: number): Field;
 
-  getName(): string;
-  setName(value: string): Field;
+    getName(): string;
+    setName(value: string): Field;
 
-  getTypeUrl(): string;
-  setTypeUrl(value: string): Field;
+    getTypeUrl(): string;
+    setTypeUrl(value: string): Field;
 
-  getOneofIndex(): number;
-  setOneofIndex(value: number): Field;
+    getOneofIndex(): number;
+    setOneofIndex(value: number): Field;
 
-  getPacked(): boolean;
-  setPacked(value: boolean): Field;
+    getPacked(): boolean;
+    setPacked(value: boolean): Field;
 
-  clearOptionsList(): Field;
-  getOptionsList(): Array<Option>;
-  setOptionsList(value: Array<Option>): Field;
-  addOptions(value?: Option, index?: number): Option;
+    clearOptionsList(): Field;
+    getOptionsList(): Array<Option>;
+    setOptionsList(value: Array<Option>): Field;
+    addOptions(value?: Option, index?: number): Option;
 
-  getJsonName(): string;
-  setJsonName(value: string): Field;
+    getJsonName(): string;
+    setJsonName(value: string): Field;
 
-  getDefaultValue(): string;
-  setDefaultValue(value: string): Field;
+    getDefaultValue(): string;
+    setDefaultValue(value: string): Field;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Field.AsObject;
-  static toObject(includeInstance: boolean, msg: Field): Field.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Field, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Field;
-  static deserializeBinaryFromReader(message: Field, reader: jspb.BinaryReader): Field;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Field.AsObject;
+    static toObject(includeInstance: boolean, msg: Field): Field.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Field, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Field;
+    static deserializeBinaryFromReader(message: Field, reader: jspb.BinaryReader): Field;
 }
 
 export namespace Field {
-  export type AsObject = {
-    kind: Kind,
-    cardinality: Cardinality,
-    number: number,
-    name: string,
-    typeUrl: string,
-    oneofIndex: number,
-    packed: boolean,
-    optionsList: Array<Option.AsObject>,
-    jsonName: string,
-    defaultValue: string,
-  }
+    export type AsObject = {
+        kind: Kind;
+        cardinality: Cardinality;
+        number: number;
+        name: string;
+        typeUrl: string;
+        oneofIndex: number;
+        packed: boolean;
+        optionsList: Array<Option.AsObject>;
+        jsonName: string;
+        defaultValue: string;
+    };
 
-  export enum Kind {
-    TYPE_UNKNOWN = 0,
-    TYPE_DOUBLE = 1,
-    TYPE_FLOAT = 2,
-    TYPE_INT64 = 3,
-    TYPE_UINT64 = 4,
-    TYPE_INT32 = 5,
-    TYPE_FIXED64 = 6,
-    TYPE_FIXED32 = 7,
-    TYPE_BOOL = 8,
-    TYPE_STRING = 9,
-    TYPE_GROUP = 10,
-    TYPE_MESSAGE = 11,
-    TYPE_BYTES = 12,
-    TYPE_UINT32 = 13,
-    TYPE_ENUM = 14,
-    TYPE_SFIXED32 = 15,
-    TYPE_SFIXED64 = 16,
-    TYPE_SINT32 = 17,
-    TYPE_SINT64 = 18,
-  }
+    export enum Kind {
+        TYPE_UNKNOWN = 0,
+        TYPE_DOUBLE = 1,
+        TYPE_FLOAT = 2,
+        TYPE_INT64 = 3,
+        TYPE_UINT64 = 4,
+        TYPE_INT32 = 5,
+        TYPE_FIXED64 = 6,
+        TYPE_FIXED32 = 7,
+        TYPE_BOOL = 8,
+        TYPE_STRING = 9,
+        TYPE_GROUP = 10,
+        TYPE_MESSAGE = 11,
+        TYPE_BYTES = 12,
+        TYPE_UINT32 = 13,
+        TYPE_ENUM = 14,
+        TYPE_SFIXED32 = 15,
+        TYPE_SFIXED64 = 16,
+        TYPE_SINT32 = 17,
+        TYPE_SINT64 = 18,
+    }
 
-  export enum Cardinality {
-    CARDINALITY_UNKNOWN = 0,
-    CARDINALITY_OPTIONAL = 1,
-    CARDINALITY_REQUIRED = 2,
-    CARDINALITY_REPEATED = 3,
-  }
+    export enum Cardinality {
+        CARDINALITY_UNKNOWN = 0,
+        CARDINALITY_OPTIONAL = 1,
+        CARDINALITY_REQUIRED = 2,
+        CARDINALITY_REPEATED = 3,
+    }
 }
 
 export class Enum extends jspb.Message {
-  getName(): string;
-  setName(value: string): Enum;
+    getName(): string;
+    setName(value: string): Enum;
 
-  clearEnumvalueList(): Enum;
-  getEnumvalueList(): Array<EnumValue>;
-  setEnumvalueList(value: Array<EnumValue>): Enum;
-  addEnumvalue(value?: EnumValue, index?: number): EnumValue;
+    clearEnumvalueList(): Enum;
+    getEnumvalueList(): Array<EnumValue>;
+    setEnumvalueList(value: Array<EnumValue>): Enum;
+    addEnumvalue(value?: EnumValue, index?: number): EnumValue;
 
-  clearOptionsList(): Enum;
-  getOptionsList(): Array<Option>;
-  setOptionsList(value: Array<Option>): Enum;
-  addOptions(value?: Option, index?: number): Option;
+    clearOptionsList(): Enum;
+    getOptionsList(): Array<Option>;
+    setOptionsList(value: Array<Option>): Enum;
+    addOptions(value?: Option, index?: number): Option;
 
-  hasSourceContext(): boolean;
-  clearSourceContext(): Enum;
-  getSourceContext(): google_protobuf_source_context_pb.SourceContext | undefined;
-  setSourceContext(value?: google_protobuf_source_context_pb.SourceContext): Enum;
+    hasSourceContext(): boolean;
+    clearSourceContext(): Enum;
+    getSourceContext(): google_protobuf_source_context_pb.SourceContext | undefined;
+    setSourceContext(value?: google_protobuf_source_context_pb.SourceContext): Enum;
 
-  getSyntax(): Syntax;
-  setSyntax(value: Syntax): Enum;
+    getSyntax(): Syntax;
+    setSyntax(value: Syntax): Enum;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Enum.AsObject;
-  static toObject(includeInstance: boolean, msg: Enum): Enum.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Enum, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Enum;
-  static deserializeBinaryFromReader(message: Enum, reader: jspb.BinaryReader): Enum;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Enum.AsObject;
+    static toObject(includeInstance: boolean, msg: Enum): Enum.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Enum, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Enum;
+    static deserializeBinaryFromReader(message: Enum, reader: jspb.BinaryReader): Enum;
 }
 
 export namespace Enum {
-  export type AsObject = {
-    name: string,
-    enumvalueList: Array<EnumValue.AsObject>,
-    optionsList: Array<Option.AsObject>,
-    sourceContext?: google_protobuf_source_context_pb.SourceContext.AsObject | undefined,
-    syntax: Syntax,
-  }
+    export type AsObject = {
+        name: string;
+        enumvalueList: Array<EnumValue.AsObject>;
+        optionsList: Array<Option.AsObject>;
+        sourceContext?: google_protobuf_source_context_pb.SourceContext.AsObject | undefined;
+        syntax: Syntax;
+    };
 }
 
 export class EnumValue extends jspb.Message {
-  getName(): string;
-  setName(value: string): EnumValue;
+    getName(): string;
+    setName(value: string): EnumValue;
 
-  getNumber(): number;
-  setNumber(value: number): EnumValue;
+    getNumber(): number;
+    setNumber(value: number): EnumValue;
 
-  clearOptionsList(): EnumValue;
-  getOptionsList(): Array<Option>;
-  setOptionsList(value: Array<Option>): EnumValue;
-  addOptions(value?: Option, index?: number): Option;
+    clearOptionsList(): EnumValue;
+    getOptionsList(): Array<Option>;
+    setOptionsList(value: Array<Option>): EnumValue;
+    addOptions(value?: Option, index?: number): Option;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): EnumValue.AsObject;
-  static toObject(includeInstance: boolean, msg: EnumValue): EnumValue.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: EnumValue, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): EnumValue;
-  static deserializeBinaryFromReader(message: EnumValue, reader: jspb.BinaryReader): EnumValue;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): EnumValue.AsObject;
+    static toObject(includeInstance: boolean, msg: EnumValue): EnumValue.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: EnumValue, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): EnumValue;
+    static deserializeBinaryFromReader(message: EnumValue, reader: jspb.BinaryReader): EnumValue;
 }
 
 export namespace EnumValue {
-  export type AsObject = {
-    name: string,
-    number: number,
-    optionsList: Array<Option.AsObject>,
-  }
+    export type AsObject = {
+        name: string;
+        number: number;
+        optionsList: Array<Option.AsObject>;
+    };
 }
 
 export class Option extends jspb.Message {
-  getName(): string;
-  setName(value: string): Option;
+    getName(): string;
+    setName(value: string): Option;
 
-  hasValue(): boolean;
-  clearValue(): Option;
-  getValue(): google_protobuf_any_pb.Any | undefined;
-  setValue(value?: google_protobuf_any_pb.Any): Option;
+    hasValue(): boolean;
+    clearValue(): Option;
+    getValue(): google_protobuf_any_pb.Any | undefined;
+    setValue(value?: google_protobuf_any_pb.Any): Option;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Option.AsObject;
-  static toObject(includeInstance: boolean, msg: Option): Option.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Option, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Option;
-  static deserializeBinaryFromReader(message: Option, reader: jspb.BinaryReader): Option;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Option.AsObject;
+    static toObject(includeInstance: boolean, msg: Option): Option.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Option, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Option;
+    static deserializeBinaryFromReader(message: Option, reader: jspb.BinaryReader): Option;
 }
 
 export namespace Option {
-  export type AsObject = {
-    name: string,
-    value?: google_protobuf_any_pb.Any.AsObject | undefined,
-  }
+    export type AsObject = {
+        name: string;
+        value?: google_protobuf_any_pb.Any.AsObject | undefined;
+    };
 }
 
 export enum Syntax {
-  SYNTAX_PROTO2 = 0,
-  SYNTAX_PROTO3 = 1,
+    SYNTAX_PROTO2 = 0,
+    SYNTAX_PROTO3 = 1,
 }

google-protobuf/google/protobuf/wrappers_pb.d.ts

@@ -7,181 +7,181 @@ // package: google.protobuf
 export class DoubleValue extends jspb.Message {
-  getValue(): number;
-  setValue(value: number): DoubleValue;
+    getValue(): number;
+    setValue(value: number): DoubleValue;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): DoubleValue.AsObject;
-  static toObject(includeInstance: boolean, msg: DoubleValue): DoubleValue.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: DoubleValue, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): DoubleValue;
-  static deserializeBinaryFromReader(message: DoubleValue, reader: jspb.BinaryReader): DoubleValue;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DoubleValue.AsObject;
+    static toObject(includeInstance: boolean, msg: DoubleValue): DoubleValue.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: DoubleValue, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DoubleValue;
+    static deserializeBinaryFromReader(message: DoubleValue, reader: jspb.BinaryReader): DoubleValue;
 }
 
 export namespace DoubleValue {
-  export type AsObject = {
-    value: number,
-  }
+    export type AsObject = {
+        value: number;
+    };
 }
 
 export class FloatValue extends jspb.Message {
-  getValue(): number;
-  setValue(value: number): FloatValue;
+    getValue(): number;
+    setValue(value: number): FloatValue;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): FloatValue.AsObject;
-  static toObject(includeInstance: boolean, msg: FloatValue): FloatValue.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: FloatValue, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): FloatValue;
-  static deserializeBinaryFromReader(message: FloatValue, reader: jspb.BinaryReader): FloatValue;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): FloatValue.AsObject;
+    static toObject(includeInstance: boolean, msg: FloatValue): FloatValue.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: FloatValue, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): FloatValue;
+    static deserializeBinaryFromReader(message: FloatValue, reader: jspb.BinaryReader): FloatValue;
 }
 
 export namespace FloatValue {
-  export type AsObject = {
-    value: number,
-  }
+    export type AsObject = {
+        value: number;
+    };
 }
 
 export class Int64Value extends jspb.Message {
-  getValue(): number;
-  setValue(value: number): Int64Value;
+    getValue(): number;
+    setValue(value: number): Int64Value;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Int64Value.AsObject;
-  static toObject(includeInstance: boolean, msg: Int64Value): Int64Value.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Int64Value, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Int64Value;
-  static deserializeBinaryFromReader(message: Int64Value, reader: jspb.BinaryReader): Int64Value;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Int64Value.AsObject;
+    static toObject(includeInstance: boolean, msg: Int64Value): Int64Value.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Int64Value, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Int64Value;
+    static deserializeBinaryFromReader(message: Int64Value, reader: jspb.BinaryReader): Int64Value;
 }
 
 export namespace Int64Value {
-  export type AsObject = {
-    value: number,
-  }
+    export type AsObject = {
+        value: number;
+    };
 }
 
 export class UInt64Value extends jspb.Message {
-  getValue(): number;
-  setValue(value: number): UInt64Value;
+    getValue(): number;
+    setValue(value: number): UInt64Value;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): UInt64Value.AsObject;
-  static toObject(includeInstance: boolean, msg: UInt64Value): UInt64Value.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: UInt64Value, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): UInt64Value;
-  static deserializeBinaryFromReader(message: UInt64Value, reader: jspb.BinaryReader): UInt64Value;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UInt64Value.AsObject;
+    static toObject(includeInstance: boolean, msg: UInt64Value): UInt64Value.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: UInt64Value, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UInt64Value;
+    static deserializeBinaryFromReader(message: UInt64Value, reader: jspb.BinaryReader): UInt64Value;
 }
 
 export namespace UInt64Value {
-  export type AsObject = {
-    value: number,
-  }
+    export type AsObject = {
+        value: number;
+    };
 }
 
 export class Int32Value extends jspb.Message {
-  getValue(): number;
-  setValue(value: number): Int32Value;
+    getValue(): number;
+    setValue(value: number): Int32Value;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): Int32Value.AsObject;
-  static toObject(includeInstance: boolean, msg: Int32Value): Int32Value.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: Int32Value, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): Int32Value;
-  static deserializeBinaryFromReader(message: Int32Value, reader: jspb.BinaryReader): Int32Value;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): Int32Value.AsObject;
+    static toObject(includeInstance: boolean, msg: Int32Value): Int32Value.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: Int32Value, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): Int32Value;
+    static deserializeBinaryFromReader(message: Int32Value, reader: jspb.BinaryReader): Int32Value;
 }
 
 export namespace Int32Value {
-  export type AsObject = {
-    value: number,
-  }
+    export type AsObject = {
+        value: number;
+    };
 }
 
 export class UInt32Value extends jspb.Message {
-  getValue(): number;
-  setValue(value: number): UInt32Value;
+    getValue(): number;
+    setValue(value: number): UInt32Value;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): UInt32Value.AsObject;
-  static toObject(includeInstance: boolean, msg: UInt32Value): UInt32Value.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: UInt32Value, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): UInt32Value;
-  static deserializeBinaryFromReader(message: UInt32Value, reader: jspb.BinaryReader): UInt32Value;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): UInt32Value.AsObject;
+    static toObject(includeInstance: boolean, msg: UInt32Value): UInt32Value.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: UInt32Value, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): UInt32Value;
+    static deserializeBinaryFromReader(message: UInt32Value, reader: jspb.BinaryReader): UInt32Value;
 }
 
 export namespace UInt32Value {
-  export type AsObject = {
-    value: number,
-  }
+    export type AsObject = {
+        value: number;
+    };
 }
 
 export class BoolValue extends jspb.Message {
-  getValue(): boolean;
-  setValue(value: boolean): BoolValue;
+    getValue(): boolean;
+    setValue(value: boolean): BoolValue;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): BoolValue.AsObject;
-  static toObject(includeInstance: boolean, msg: BoolValue): BoolValue.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: BoolValue, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): BoolValue;
-  static deserializeBinaryFromReader(message: BoolValue, reader: jspb.BinaryReader): BoolValue;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): BoolValue.AsObject;
+    static toObject(includeInstance: boolean, msg: BoolValue): BoolValue.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: BoolValue, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BoolValue;
+    static deserializeBinaryFromReader(message: BoolValue, reader: jspb.BinaryReader): BoolValue;
 }
 
 export namespace BoolValue {
-  export type AsObject = {
-    value: boolean,
-  }
+    export type AsObject = {
+        value: boolean;
+    };
 }
 
 export class StringValue extends jspb.Message {
-  getValue(): string;
-  setValue(value: string): StringValue;
+    getValue(): string;
+    setValue(value: string): StringValue;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): StringValue.AsObject;
-  static toObject(includeInstance: boolean, msg: StringValue): StringValue.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: StringValue, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): StringValue;
-  static deserializeBinaryFromReader(message: StringValue, reader: jspb.BinaryReader): StringValue;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): StringValue.AsObject;
+    static toObject(includeInstance: boolean, msg: StringValue): StringValue.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: StringValue, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): StringValue;
+    static deserializeBinaryFromReader(message: StringValue, reader: jspb.BinaryReader): StringValue;
 }
 
 export namespace StringValue {
-  export type AsObject = {
-    value: string,
-  }
+    export type AsObject = {
+        value: string;
+    };
 }
 
 export class BytesValue extends jspb.Message {
-  getValue(): Uint8Array | string;
-  getValue_asU8(): Uint8Array;
-  getValue_asB64(): string;
-  setValue(value: Uint8Array | string): BytesValue;
+    getValue(): Uint8Array | string;
+    getValue_asU8(): Uint8Array;
+    getValue_asB64(): string;
+    setValue(value: Uint8Array | string): BytesValue;
 
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): BytesValue.AsObject;
-  static toObject(includeInstance: boolean, msg: BytesValue): BytesValue.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: BytesValue, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): BytesValue;
-  static deserializeBinaryFromReader(message: BytesValue, reader: jspb.BinaryReader): BytesValue;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): BytesValue.AsObject;
+    static toObject(includeInstance: boolean, msg: BytesValue): BytesValue.AsObject;
+    static extensions: { [key: number]: jspb.ExtensionFieldInfo<jspb.Message> };
+    static extensionsBinary: { [key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message> };
+    static serializeBinaryToWriter(message: BytesValue, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): BytesValue;
+    static deserializeBinaryFromReader(message: BytesValue, reader: jspb.BinaryReader): BytesValue;
 }
 
 export namespace BytesValue {
-  export type AsObject = {
-    value: Uint8Array | string,
-  }
+    export type AsObject = {
+        value: Uint8Array | string;
+    };
 }

google-protobuf/index.d.ts

@@ -15,210 +15,231 @@ // Type definitions for google-protobuf 3.15
 export abstract class Message {
-  getJsPbMessageId(): (string | undefined);
-  static initialize(
-    msg: Message,
-    data: Message.MessageArray,
-    messageId: (string | number),
-    suggestedPivot: number,
-    repeatedFields?: number[] | null,
-    oneofFields?: number[][] | null): void;
-  static toObjectList<T extends Message>(
-    field: T[],
-    toObjectFn: (includeInstance: boolean, data: T) => {},
-    includeInstance?: boolean): Array<{}>;
-  static toObjectExtension(
-    msg: Message,
-    obj: {},
-    extensions: {[key: number]: ExtensionFieldInfo<Message>},
-    getExtensionFn: (fieldInfo: ExtensionFieldInfo<Message>) => Message,
-    includeInstance?: boolean): void;
-  serializeBinaryExtensions(
-    proto: Message,
-    writer: BinaryWriter,
-    extensions: { [key: number]: ExtensionFieldBinaryInfo<Message> },
-    getExtensionFn: <T>(fieldInfo: ExtensionFieldInfo<T>) => T): void
-  readBinaryExtension(
-    proto: Message,
-    reader: BinaryReader,
-    extensions: {[key: number]: ExtensionFieldBinaryInfo<Message>},
-    setExtensionFn: <T>(fieldInfo: ExtensionFieldInfo<T>,
-    val: T) => void): void
-  static getField(msg: Message, fieldNumber: number): FieldValue|null;
-  static getOptionalFloatingPointField(msg: Message, fieldNumber: number): number | undefined;
-  static getRepeatedFloatingPointField(msg: Message, fieldNumber: number): number[];
-  static bytesAsB64(bytes: Uint8Array): string;
-  static bytesAsU8(str: string): Uint8Array;
-  static bytesListAsB64(bytesList: Uint8Array[]): string[];
-  static bytesListAsU8(strList: string[]): Uint8Array[];
-  static getFieldWithDefault<T>(msg: Message, fieldNumber: number, defaultValue: T): T;
-  static getMapField(
-    msg: Message,
-    fieldNumber: number,
-    noLazyCreate: boolean,
-    valueCtor?: typeof Message): Map<any, any>;
-  static setField(
-    msg: Message,
-    fieldNumber: number,
-    value: FieldValue): void;
-  static addToRepeatedField(
-    msg: Message,
-    fieldNumber: number,
-    value: any,
-    index?: number): void;
-  static setOneofField(
-    msg: Message,
-    fieldNumber: number,
-    oneof: number[],
-    value: FieldValue): void;
-  static computeOneofCase(msg: Message, oneof: number[]): number;
-  static getWrapperField<T extends Message>(
-    msg: Message,
-    ctor: { new(): T },
-    fieldNumber: number,
-    required?: number): T;
-  static getRepeatedWrapperField<T extends Message>(
-    msg: Message,
-    ctor: { new(): T },
-    fieldNumber: number): T[];
-  static setWrapperField<T extends Message>(
-    msg: Message,
-    fieldNumber: number,
-    value?: (T|Map<any, any>)): void;
-  static setOneofWrapperField(
-    msg: Message,
-    fieldNumber: number,
-    oneof: number[],
-    value: any): void;
-  static setRepeatedWrapperField<T extends Message>(
-    msg: Message,
-    fieldNumber: number,
-    value?: T[]): void;
-  static addToRepeatedWrapperField<T extends Message>(
-    msg: Message,
-    fieldNumber: number,
-    value: T | undefined,
-    ctor: { new(): T },
-    index?: number): T;
-  static toMap(
-    field: any[],
-    mapKeyGetterFn: (field: any) => string,
-    toObjectFn?: Message.StaticToObject,
-    includeInstance?: boolean): void;
-  toArray(): Message.MessageArray;
-  toString(): string;
-  getExtension<T>(fieldInfo: ExtensionFieldInfo<T>): T;
-  setExtension<T>(fieldInfo: ExtensionFieldInfo<T>, value: T): void;
-  static difference<T extends Message>(m1: T, m2: T): T;
-  static equals(m1: Message, m2: Message): boolean;
-  static compareExtensions(extension1: {}, extension2: {}): boolean;
-  static compareFields(field1: any, field2: any): boolean;
-  cloneMessage(): this;
-  clone(): this;
-  static clone<T extends Message>(msg: T): T;
-  static cloneMessage<T extends Message>(msg: T): T;
-  static copyInto(fromMessage: Message, toMessage: Message): void;
-  static registerMessageType(id: number, constructor: typeof Message): void;
+    getJsPbMessageId(): string | undefined;
+    static initialize(
+        msg: Message,
+        data: Message.MessageArray,
+        messageId: string | number,
+        suggestedPivot: number,
+        repeatedFields?: number[] | null,
+        oneofFields?: number[][] | null,
+    ): void;
+    static toObjectList<T extends Message>(
+        field: T[],
+        toObjectFn: (includeInstance: boolean, data: T) => {},
+        includeInstance?: boolean,
+    ): Array<{}>;
+    static toObjectExtension(
+        msg: Message,
+        obj: {},
+        extensions: { [key: number]: ExtensionFieldInfo<Message> },
+        getExtensionFn: (fieldInfo: ExtensionFieldInfo<Message>) => Message,
+        includeInstance?: boolean,
+    ): void;
+    serializeBinaryExtensions(
+        proto: Message,
+        writer: BinaryWriter,
+        extensions: { [key: number]: ExtensionFieldBinaryInfo<Message> },
+        getExtensionFn: <T>(fieldInfo: ExtensionFieldInfo<T>) => T,
+    ): void;
+    readBinaryExtension(
+        proto: Message,
+        reader: BinaryReader,
+        extensions: { [key: number]: ExtensionFieldBinaryInfo<Message> },
+        setExtensionFn: <T>(fieldInfo: ExtensionFieldInfo<T>, val: T) => void,
+    ): void;
+    static getField(msg: Message, fieldNumber: number): FieldValue | null;
+    static getOptionalFloatingPointField(msg: Message, fieldNumber: number): number | undefined;
+    static getRepeatedFloatingPointField(msg: Message, fieldNumber: number): number[];
+    static bytesAsB64(bytes: Uint8Array): string;
+    static bytesAsU8(str: string): Uint8Array;
+    static bytesListAsB64(bytesList: Uint8Array[]): string[];
+    static bytesListAsU8(strList: string[]): Uint8Array[];
+    static getFieldWithDefault<T>(msg: Message, fieldNumber: number, defaultValue: T): T;
+    static getMapField(
+        msg: Message,
+        fieldNumber: number,
+        noLazyCreate: boolean,
+        valueCtor?: typeof Message,
+    ): Map<any, any>;
+    static setField(
+        msg: Message,
+        fieldNumber: number,
+        value: FieldValue,
+    ): void;
+    static addToRepeatedField(
+        msg: Message,
+        fieldNumber: number,
+        value: any,
+        index?: number,
+    ): void;
+    static setOneofField(
+        msg: Message,
+        fieldNumber: number,
+        oneof: number[],
+        value: FieldValue,
+    ): void;
+    static computeOneofCase(msg: Message, oneof: number[]): number;
+    static getWrapperField<T extends Message>(
+        msg: Message,
+        ctor: { new(): T },
+        fieldNumber: number,
+        required?: number,
+    ): T;
+    static getRepeatedWrapperField<T extends Message>(
+        msg: Message,
+        ctor: { new(): T },
+        fieldNumber: number,
+    ): T[];
+    static setWrapperField<T extends Message>(
+        msg: Message,
+        fieldNumber: number,
+        value?: T | Map<any, any>,
+    ): void;
+    static setOneofWrapperField(
+        msg: Message,
+        fieldNumber: number,
+        oneof: number[],
+        value: any,
+    ): void;
+    static setRepeatedWrapperField<T extends Message>(
+        msg: Message,
+        fieldNumber: number,
+        value?: T[],
+    ): void;
+    static addToRepeatedWrapperField<T extends Message>(
+        msg: Message,
+        fieldNumber: number,
+        value: T | undefined,
+        ctor: { new(): T },
+        index?: number,
+    ): T;
+    static toMap(
+        field: any[],
+        mapKeyGetterFn: (field: any) => string,
+        toObjectFn?: Message.StaticToObject,
+        includeInstance?: boolean,
+    ): void;
+    toArray(): Message.MessageArray;
+    toString(): string;
+    getExtension<T>(fieldInfo: ExtensionFieldInfo<T>): T;
+    setExtension<T>(fieldInfo: ExtensionFieldInfo<T>, value: T): void;
+    static difference<T extends Message>(m1: T, m2: T): T;
+    static equals(m1: Message, m2: Message): boolean;
+    static compareExtensions(extension1: {}, extension2: {}): boolean;
+    static compareFields(field1: any, field2: any): boolean;
+    cloneMessage(): this;
+    clone(): this;
+    static clone<T extends Message>(msg: T): T;
+    static cloneMessage<T extends Message>(msg: T): T;
+    static copyInto(fromMessage: Message, toMessage: Message): void;
+    static registerMessageType(id: number, constructor: typeof Message): void;
 
-  abstract serializeBinary(): Uint8Array;
-  abstract toObject(includeInstance?: boolean): {};
+    abstract serializeBinary(): Uint8Array;
+    abstract toObject(includeInstance?: boolean): {};
 
-  // These are `abstract static`, but that isn't allowed. Subclasses of Message will have these methods and properties
-  // and not having them on Message makes using this class for its intended purpose quite difficult.
-  static deserializeBinary(bytes: Uint8Array): Message;
-  static deserializeBinaryFromReader(message: Message, reader: BinaryReader): Message;
-  static serializeBinaryToWriter(message: Message, writer: BinaryWriter): void;
-  static toObject(includeInstance: boolean, msg: Message): {};
-  static extensions: { [key: number]: ExtensionFieldInfo<Message> };
-  static extensionsBinary: { [key: number]: ExtensionFieldBinaryInfo<Message> };
+    // These are `abstract static`, but that isn't allowed. Subclasses of Message will have these methods and properties
+    // and not having them on Message makes using this class for its intended purpose quite difficult.
+    static deserializeBinary(bytes: Uint8Array): Message;
+    static deserializeBinaryFromReader(message: Message, reader: BinaryReader): Message;
+    static serializeBinaryToWriter(message: Message, writer: BinaryWriter): void;
+    static toObject(includeInstance: boolean, msg: Message): {};
+    static extensions: { [key: number]: ExtensionFieldInfo<Message> };
+    static extensionsBinary: { [key: number]: ExtensionFieldBinaryInfo<Message> };
 }
 
 export namespace Message {
-  type MessageArray = any[]; // This type needs to reference itself
-  type StaticToObject = (includeInstance: boolean, msg: Message) => {};
+    type MessageArray = any[]; // This type needs to reference itself
+    type StaticToObject = (includeInstance: boolean, msg: Message) => {};
 }
 
 export class ExtensionFieldInfo<T> {
-  fieldIndex: number;
-  fieldName: number;
-  ctor: typeof Message;
-  toObjectFn: Message.StaticToObject;
-  isRepeated: number;
-  constructor(
-    fieldIndex: number,
-    fieldName: {[key: string]: number},
-    ctor: typeof Message,
-    toObjectFn: Message.StaticToObject,
-    isRepeated: number);
-  isMessageType(): boolean;
+    fieldIndex: number;
+    fieldName: number;
+    ctor: typeof Message;
+    toObjectFn: Message.StaticToObject;
+    isRepeated: number;
+    constructor(
+        fieldIndex: number,
+        fieldName: { [key: string]: number },
+        ctor: typeof Message,
+        toObjectFn: Message.StaticToObject,
+        isRepeated: number,
+    );
+    isMessageType(): boolean;
 }
 
 export class ExtensionFieldBinaryInfo<T> {
-  fieldInfo: ExtensionFieldInfo<T>;
-  binaryReaderFn: BinaryRead;
-  binaryWriterFn: BinaryWrite;
-  opt_binaryMessageSerializeFn: (msg: Message, writer: BinaryWriter) => void;
-  opt_binaryMessageDeserializeFn: (msg: Message, reader: BinaryReader) => Message;
-  opt_isPacked: boolean;
-  constructor(
-    fieldInfo: ExtensionFieldInfo<T>,
-    binaryReaderFn: BinaryRead,
-    binaryWriterFn: BinaryWrite,
-    opt_binaryMessageSerializeFn: (msg: Message, writer: BinaryWriter) => void,
-    opt_binaryMessageDeserializeFn: (msg: Message, reader: BinaryReader) => Message,
-    opt_isPacked: boolean);
+    fieldInfo: ExtensionFieldInfo<T>;
+    binaryReaderFn: BinaryRead;
+    binaryWriterFn: BinaryWrite;
+    opt_binaryMessageSerializeFn: (msg: Message, writer: BinaryWriter) => void;
+    opt_binaryMessageDeserializeFn: (msg: Message, reader: BinaryReader) => Message;
+    opt_isPacked: boolean;
+    constructor(
+        fieldInfo: ExtensionFieldInfo<T>,
+        binaryReaderFn: BinaryRead,
+        binaryWriterFn: BinaryWrite,
+        opt_binaryMessageSerializeFn: (msg: Message, writer: BinaryWriter) => void,
+        opt_binaryMessageDeserializeFn: (msg: Message, reader: BinaryReader) => Message,
+        opt_isPacked: boolean,
+    );
 }
 
 export class Map<K, V> {
-  constructor(
-    arr: Array<[K, V]>,
-    valueCtor?: {new(init: any): V});
-  toArray(): Array<[K, V]>;
-  toObject(includeInstance?: boolean): Array<[K, V]>;
-  toObject<VO>(
-    includeInstance: boolean,
-    valueToObject: (includeInstance: boolean, valueWrapper: V) => VO): Array<[K, VO]>;
-  static fromObject<TK, TV>(
-    entries: Array<[TK, TV]>,
-    valueCtor: any,
-    valueFromObject: any): Map<TK, TV>;
-  getLength(): number;
-  clear(): void;
-  del(key: K): boolean;
-  getEntryList(): Array<[K, V]>;
-  entries(): Map.Iterator<[K, V]>;
-  keys(): Map.Iterator<K>;
-  values(): Map.Iterator<V>;
-  forEach(
-    callback: (entry: V, key: K) => void,
-    thisArg?: {}): void;
-  set(key: K, value: V): this;
-  get(key: K): (V | undefined);
-  has(key: K): boolean;
-  serializeBinary(
-    fieldNumber: number,
-    writer: BinaryWriter,
-    keyWriterFn: (field: number, key: K) => void,
-    valueWriterFn: (field: number, value: V, writerCallback: BinaryWriteCallback) => void,
-    writeCallback?: BinaryWriteCallback
-  ): void;
-  static deserializeBinary<K, V>(
-    map: Map<K, V>,
-    reader: BinaryReader,
-    keyReaderFn: (reader: BinaryReader) => K,
-    valueReaderFn: (reader: BinaryReader, value: any, readerCallback: BinaryReadCallback) => V,
-    readCallback?: BinaryReadCallback,
-    defaultKey?: K,
-    defaultValue?: V
-  ): void;
+    constructor(
+        arr: Array<[K, V]>,
+        valueCtor?: { new(init: any): V },
+    );
+    toArray(): Array<[K, V]>;
+    toObject(includeInstance?: boolean): Array<[K, V]>;
+    toObject<VO>(
+        includeInstance: boolean,
+        valueToObject: (includeInstance: boolean, valueWrapper: V) => VO,
+    ): Array<[K, VO]>;
+    static fromObject<TK, TV>(
+        entries: Array<[TK, TV]>,
+        valueCtor: any,
+        valueFromObject: any,
+    ): Map<TK, TV>;
+    getLength(): number;
+    clear(): void;
+    del(key: K): boolean;
+    getEntryList(): Array<[K, V]>;
+    entries(): Map.Iterator<[K, V]>;
+    keys(): Map.Iterator<K>;
+    values(): Map.Iterator<V>;
+    forEach(
+        callback: (entry: V, key: K) => void,
+        thisArg?: {},
+    ): void;
+    set(key: K, value: V): this;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    serializeBinary(
+        fieldNumber: number,
+        writer: BinaryWriter,
+        keyWriterFn: (field: number, key: K) => void,
+        valueWriterFn: (field: number, value: V, writerCallback: BinaryWriteCallback) => void,
+        writeCallback?: BinaryWriteCallback,
+    ): void;
+    static deserializeBinary<K, V>(
+        map: Map<K, V>,
+        reader: BinaryReader,
+        keyReaderFn: (reader: BinaryReader) => K,
+        valueReaderFn: (reader: BinaryReader, value: any, readerCallback: BinaryReadCallback) => V,
+        readCallback?: BinaryReadCallback,
+        defaultKey?: K,
+        defaultValue?: V,
+    ): void;
 }
 
 export namespace Map {
-  // This is implemented by jspb.Map.ArrayIteratorIterable_, but that class shouldn't be exported
-  interface Iterator<T> {
-    [Symbol.iterator](): Iterator<T>;
-    next(): IteratorResult<T>;
-  }
-  interface IteratorResult<T> {
-    done: boolean;
-    value: T;
-  }
+    // This is implemented by jspb.Map.ArrayIteratorIterable_, but that class shouldn't be exported
+    interface Iterator<T> {
+        [Symbol.iterator](): Iterator<T>;
+        next(): IteratorResult<T>;
+    }
+    interface IteratorResult<T> {
+        done: boolean;
+        value: T;
+    }
 }
@@ -237,357 +258,360 @@
 export class BinaryReader {
-  constructor(bytes?: ByteSource, start?: number, length?: number);
-  static alloc(bytes?: ByteSource, start?: number, length?: number): BinaryReader;
-  alloc(bytes?: ByteSource, start?: number, length?: number): BinaryReader;
-  free(): void;
-  getFieldCursor(): number;
-  getCursor(): number;
-  getBuffer(): Uint8Array;
-  getFieldNumber(): number;
-  getWireType(): BinaryConstants.WireType;
-  isDelimited(): boolean;
-  isEndGroup(): boolean;
-  getError(): boolean;
-  setBlock(bytes?: ByteSource, start?: number, length?: number): void;
-  reset(): void;
-  advance(count: number): void;
-  nextField(): boolean;
-  unskipHeader(): void;
-  skipMatchingFields(): void;
-  skipVarintField(): void;
-  skipDelimitedField(): void;
-  skipFixed32Field(): void;
-  skipFixed64Field(): void;
-  skipGroup(): void;
-  skipField(): void;
-  registerReadCallback(callbackName: string, callback: (binaryReader: BinaryReader) => any): void;
-  runReadCallback(callbackName: string): any;
-  readAny(fieldType: BinaryConstants.FieldType): AnyFieldType;
-  readMessage: BinaryRead;
-  readGroup(field: number, message: Message, reader: BinaryReadReader): void;
-  getFieldDecoder(): BinaryDecoder;
-  readInt32(): number;
-  readInt32String(): string;
-  readInt64(): number;
-  readInt64String(): string;
-  readUint32(): number;
-  readUint32String(): string;
-  readUint64(): number;
-  readUint64String(): string;
-  readSint32(): number;
-  readSint64(): number;
-  readSint64String(): string;
-  readFixed32(): number;
-  readFixed64(): number;
-  readFixed64String(): string;
-  readSfixed32(): number;
-  readSfixed32String(): string;
-  readSfixed64(): number;
-  readSfixed64String(): string;
-  readFloat(): number;
-  readDouble(): number;
-  readBool(): boolean;
-  readEnum(): number;
-  readString(): string;
-  readBytes(): Uint8Array;
-  readVarintHash64(): string;
-  readFixedHash64(): string;
-  readPackedInt32(): number[];
-  readPackedInt32String(): string[];
-  readPackedInt64(): number[];
-  readPackedInt64String(): string[];
-  readPackedUint32(): number[];
-  readPackedUint32String(): string[];
-  readPackedUint64(): number[];
-  readPackedUint64String(): string[];
-  readPackedSint32(): number[];
-  readPackedSint64(): number[];
-  readPackedSint64String(): string[];
-  readPackedFixed32(): number[];
-  readPackedFixed64(): number[];
-  readPackedFixed64String(): string[];
-  readPackedSfixed32(): number[];
-  readPackedSfixed64(): number[];
-  readPackedSfixed64String(): string[];
-  readPackedFloat(): number[];
-  readPackedDouble(): number[];
-  readPackedBool(): boolean[];
-  readPackedEnum(): number[];
-  readPackedVarintHash64(): string[];
-  readPackedFixedHash64(): string[];
+    constructor(bytes?: ByteSource, start?: number, length?: number);
+    static alloc(bytes?: ByteSource, start?: number, length?: number): BinaryReader;
+    alloc(bytes?: ByteSource, start?: number, length?: number): BinaryReader;
+    free(): void;
+    getFieldCursor(): number;
+    getCursor(): number;
+    getBuffer(): Uint8Array;
+    getFieldNumber(): number;
+    getWireType(): BinaryConstants.WireType;
+    isDelimited(): boolean;
+    isEndGroup(): boolean;
+    getError(): boolean;
+    setBlock(bytes?: ByteSource, start?: number, length?: number): void;
+    reset(): void;
+    advance(count: number): void;
+    nextField(): boolean;
+    unskipHeader(): void;
+    skipMatchingFields(): void;
+    skipVarintField(): void;
+    skipDelimitedField(): void;
+    skipFixed32Field(): void;
+    skipFixed64Field(): void;
+    skipGroup(): void;
+    skipField(): void;
+    registerReadCallback(callbackName: string, callback: (binaryReader: BinaryReader) => any): void;
+    runReadCallback(callbackName: string): any;
+    readAny(fieldType: BinaryConstants.FieldType): AnyFieldType;
+    readMessage: BinaryRead;
+    readGroup(field: number, message: Message, reader: BinaryReadReader): void;
+    getFieldDecoder(): BinaryDecoder;
+    readInt32(): number;
+    readInt32String(): string;
+    readInt64(): number;
+    readInt64String(): string;
+    readUint32(): number;
+    readUint32String(): string;
+    readUint64(): number;
+    readUint64String(): string;
+    readSint32(): number;
+    readSint64(): number;
+    readSint64String(): string;
+    readFixed32(): number;
+    readFixed64(): number;
+    readFixed64String(): string;
+    readSfixed32(): number;
+    readSfixed32String(): string;
+    readSfixed64(): number;
+    readSfixed64String(): string;
+    readFloat(): number;
+    readDouble(): number;
+    readBool(): boolean;
+    readEnum(): number;
+    readString(): string;
+    readBytes(): Uint8Array;
+    readVarintHash64(): string;
+    readFixedHash64(): string;
+    readPackedInt32(): number[];
+    readPackedInt32String(): string[];
+    readPackedInt64(): number[];
+    readPackedInt64String(): string[];
+    readPackedUint32(): number[];
+    readPackedUint32String(): string[];
+    readPackedUint64(): number[];
+    readPackedUint64String(): string[];
+    readPackedSint32(): number[];
+    readPackedSint64(): number[];
+    readPackedSint64String(): string[];
+    readPackedFixed32(): number[];
+    readPackedFixed64(): number[];
+    readPackedFixed64String(): string[];
+    readPackedSfixed32(): number[];
+    readPackedSfixed64(): number[];
+    readPackedSfixed64String(): string[];
+    readPackedFloat(): number[];
+    readPackedDouble(): number[];
+    readPackedBool(): boolean[];
+    readPackedEnum(): number[];
+    readPackedVarintHash64(): string[];
+    readPackedFixedHash64(): string[];
 }
 
 export class BinaryWriter {
-  constructor();
-  writeSerializedMessage(bytes: Uint8Array, start: number, end: number): void;
-  maybeWriteSerializedMessage(bytes?: Uint8Array, start?: number, end?: number): void;
-  reset(): void;
-  getResultBuffer(): Uint8Array;
-  getResultBase64String(): string;
-  beginSubMessage(field: number): void;
-  endSubMessage(field: number): void;
-  writeAny(fieldType: BinaryConstants.FieldType, field: number, value: AnyFieldType): void;
-  writeInt32(field: number, value?: number): void;
-  writeInt32String(field: number, value?: string): void;
-  writeInt64(field: number, value?: number): void;
-  writeInt64String(field: number, value?: string): void;
-  writeUint32(field: number, value?: number): void;
-  writeUint32String(field: number, value?: string): void;
-  writeUint64(field: number, value?: number): void;
-  writeUint64String(field: number, value?: string): void;
-  writeSint32(field: number, value?: number): void;
-  writeSint64(field: number, value?: number): void;
-  writeSint64String(field: number, value?: string): void;
-  writeFixed32(field: number, value?: number): void;
-  writeFixed64(field: number, value?: number): void;
-  writeFixed64String(field: number, value?: string): void;
-  writeSfixed32(field: number, value?: number): void;
-  writeSfixed64(field: number, value?: number): void;
-  writeSfixed64String(field: number, value?: string): void;
-  writeFloat(field: number, value?: number): void;
-  writeDouble(field: number, value?: number): void;
-  writeBool(field: number, value?: boolean): void;
-  writeEnum(field: number, value?: number): void;
-  writeString(field: number, value?: string): void;
-  writeBytes(field: number, value?: ByteSource): void;
-  writeMessage: BinaryWrite;
-  writeGroup(field: number, value: any, writeCallback: BinaryWriteCallback): void;
-  writeFixedHash64(field: number, value?: string): void;
-  writeVarintHash64(field: number, value?: string): void;
-  writeRepeatedInt32(field: number, value?: number[]): void;
-  writeRepeatedInt32String(field: number, value?: string[]): void;
-  writeRepeatedInt64(field: number, value?: number[]): void;
-  writeRepeatedInt64String(field: number, value?: string[]): void;
-  writeRepeatedUint32(field: number, value?: number[]): void;
-  writeRepeatedUint32String(field: number, value?: string[]): void;
-  writeRepeatedUint64(field: number, value?: number[]): void;
-  writeRepeatedUint64String(field: number, value?: string[]): void;
-  writeRepeatedSint32(field: number, value?: number[]): void;
-  writeRepeatedSint64(field: number, value?: number[]): void;
-  writeRepeatedSint64String(field: number, value?: string[]): void;
-  writeRepeatedFixed32(field: number, value?: number[]): void;
-  writeRepeatedFixed64(field: number, value?: number[]): void;
-  writeRepeatedFixed64String(field: number, value?: string[]): void;
-  writeRepeatedSfixed32(field: number, value?: number[]): void;
-  writeRepeatedSfixed64(field: number, value?: number[]): void;
-  writeRepeatedSfixed64String(field: number, value?: string[]): void;
-  writeRepeatedFloat(field: number, value?: number[]): void;
-  writeRepeatedDouble(field: number, value?: number[]): void;
-  writeRepeatedBool(field: number, value?: boolean[]): void;
-  writeRepeatedEnum(field: number, value?: number[]): void;
-  writeRepeatedString(field: number, value?: string[]): void;
-  writeRepeatedBytes(field: number, value?: ByteSource[]): void;
-  writeRepeatedMessage(field: number, value: Message[],  writerCallback: BinaryWriteCallback): void;
-  writeRepeatedGroup(field: number, value: Message[], writerCallback: BinaryWriteCallback): void;
-  writeRepeatedFixedHash64(field: number, value?: string[]): void;
-  writeRepeatedVarintHash64(field: number, value?: string[]): void;
-  writePackedInt32(field: number, value?: number[]): void;
-  writePackedInt32String(field: number, value?: string[]): void;
-  writePackedInt64(field: number, value?: number[]): void;
-  writePackedInt64String(field: number, value?: string[]): void;
-  writePackedUint32(field: number, value?: number[]): void;
-  writePackedUint32String(field: number, value?: string[]): void;
-  writePackedUint64(field: number, value?: number[]): void;
-  writePackedUint64String(field: number, value?: string[]): void;
-  writePackedSint32(field: number, value?: number[]): void;
-  writePackedSint64(field: number, value?: number[]): void;
-  writePackedSint64String(field: number, value?: string[]): void;
-  writePackedFixed32(field: number, value?: number[]): void;
-  writePackedFixed64(field: number, value?: number[]): void;
-  writePackedFixed64String(field: number, value?: string[]): void;
-  writePackedSfixed32(field: number, value?: number[]): void;
-  writePackedSfixed64(field: number, value?: number[]): void;
-  writePackedSfixed64String(field: number, value?: string[]): void;
-  writePackedFloat(field: number, value?: number[]): void;
-  writePackedDouble(field: number, value?: number[]): void;
-  writePackedBool(field: number, value?: boolean[]): void;
-  writePackedEnum(field: number, value?: number[]): void;
-  writePackedFixedHash64(field: number, value?: string[]): void;
-  writePackedVarintHash64(field: number, value?: string[]): void;
+    constructor();
+    writeSerializedMessage(bytes: Uint8Array, start: number, end: number): void;
+    maybeWriteSerializedMessage(bytes?: Uint8Array, start?: number, end?: number): void;
+    reset(): void;
+    getResultBuffer(): Uint8Array;
+    getResultBase64String(): string;
+    beginSubMessage(field: number): void;
+    endSubMessage(field: number): void;
+    writeAny(fieldType: BinaryConstants.FieldType, field: number, value: AnyFieldType): void;
+    writeInt32(field: number, value?: number): void;
+    writeInt32String(field: number, value?: string): void;
+    writeInt64(field: number, value?: number): void;
+    writeInt64String(field: number, value?: string): void;
+    writeUint32(field: number, value?: number): void;
+    writeUint32String(field: number, value?: string): void;
+    writeUint64(field: number, value?: number): void;
+    writeUint64String(field: number, value?: string): void;
+    writeSint32(field: number, value?: number): void;
+    writeSint64(field: number, value?: number): void;
+    writeSint64String(field: number, value?: string): void;
+    writeFixed32(field: number, value?: number): void;
+    writeFixed64(field: number, value?: number): void;
+    writeFixed64String(field: number, value?: string): void;
+    writeSfixed32(field: number, value?: number): void;
+    writeSfixed64(field: number, value?: number): void;
+    writeSfixed64String(field: number, value?: string): void;
+    writeFloat(field: number, value?: number): void;
+    writeDouble(field: number, value?: number): void;
+    writeBool(field: number, value?: boolean): void;
+    writeEnum(field: number, value?: number): void;
+    writeString(field: number, value?: string): void;
+    writeBytes(field: number, value?: ByteSource): void;
+    writeMessage: BinaryWrite;
+    writeGroup(field: number, value: any, writeCallback: BinaryWriteCallback): void;
+    writeFixedHash64(field: number, value?: string): void;
+    writeVarintHash64(field: number, value?: string): void;
+    writeRepeatedInt32(field: number, value?: number[]): void;
+    writeRepeatedInt32String(field: number, value?: string[]): void;
+    writeRepeatedInt64(field: number, value?: number[]): void;
+    writeRepeatedInt64String(field: number, value?: string[]): void;
+    writeRepeatedUint32(field: number, value?: number[]): void;
+    writeRepeatedUint32String(field: number, value?: string[]): void;
+    writeRepeatedUint64(field: number, value?: number[]): void;
+    writeRepeatedUint64String(field: number, value?: string[]): void;
+    writeRepeatedSint32(field: number, value?: number[]): void;
+    writeRepeatedSint64(field: number, value?: number[]): void;
+    writeRepeatedSint64String(field: number, value?: string[]): void;
+    writeRepeatedFixed32(field: number, value?: number[]): void;
+    writeRepeatedFixed64(field: number, value?: number[]): void;
+    writeRepeatedFixed64String(field: number, value?: string[]): void;
+    writeRepeatedSfixed32(field: number, value?: number[]): void;
+    writeRepeatedSfixed64(field: number, value?: number[]): void;
+    writeRepeatedSfixed64String(field: number, value?: string[]): void;
+    writeRepeatedFloat(field: number, value?: number[]): void;
+    writeRepeatedDouble(field: number, value?: number[]): void;
+    writeRepeatedBool(field: number, value?: boolean[]): void;
+    writeRepeatedEnum(field: number, value?: number[]): void;
+    writeRepeatedString(field: number, value?: string[]): void;
+    writeRepeatedBytes(field: number, value?: ByteSource[]): void;
+    writeRepeatedMessage(field: number, value: Message[], writerCallback: BinaryWriteCallback): void;
+    writeRepeatedGroup(field: number, value: Message[], writerCallback: BinaryWriteCallback): void;
+    writeRepeatedFixedHash64(field: number, value?: string[]): void;
+    writeRepeatedVarintHash64(field: number, value?: string[]): void;
+    writePackedInt32(field: number, value?: number[]): void;
+    writePackedInt32String(field: number, value?: string[]): void;
+    writePackedInt64(field: number, value?: number[]): void;
+    writePackedInt64String(field: number, value?: string[]): void;
+    writePackedUint32(field: number, value?: number[]): void;
+    writePackedUint32String(field: number, value?: string[]): void;
+    writePackedUint64(field: number, value?: number[]): void;
+    writePackedUint64String(field: number, value?: string[]): void;
+    writePackedSint32(field: number, value?: number[]): void;
+    writePackedSint64(field: number, value?: number[]): void;
+    writePackedSint64String(field: number, value?: string[]): void;
+    writePackedFixed32(field: number, value?: number[]): void;
+    writePackedFixed64(field: number, value?: number[]): void;
+    writePackedFixed64String(field: number, value?: string[]): void;
+    writePackedSfixed32(field: number, value?: number[]): void;
+    writePackedSfixed64(field: number, value?: number[]): void;
+    writePackedSfixed64String(field: number, value?: string[]): void;
+    writePackedFloat(field: number, value?: number[]): void;
+    writePackedDouble(field: number, value?: number[]): void;
+    writePackedBool(field: number, value?: boolean[]): void;
+    writePackedEnum(field: number, value?: number[]): void;
+    writePackedFixedHash64(field: number, value?: string[]): void;
+    writePackedVarintHash64(field: number, value?: string[]): void;
 }
 
 export class BinaryEncoder {
-  constructor();
-  length(): number;
-  end(): number[];
-  writeSplitVarint64(lowBits: number, highBits: number): void;
-  writeSplitFixed64(lowBits: number, highBits: number): void;
-  writeUnsignedVarint32(value: number): void;
-  writeSignedVarint32(value: number): void;
-  writeUnsignedVarint64(value: number): void;
-  writeSignedVarint64(value: number): void;
-  writeZigzagVarint32(value: number): void;
-  writeZigzagVarint64(value: number): void;
-  writeZigzagVarint64String(value: string): void;
-  writeUint8(value: number): void;
-  writeUint16(value: number): void;
-  writeUint32(value: number): void;
-  writeUint64(value: number): void;
-  writeInt8(value: number): void;
-  writeInt16(value: number): void;
-  writeInt32(value: number): void;
-  writeInt64(value: number): void;
-  writeInt64String(value: string): void;
-  writeFloat(value: number): void;
-  writeDouble(value: number): void;
-  writeBool(value: boolean): void;
-  writeEnum(value: number): void;
-  writeBytes(bytes: Uint8Array): void;
-  writeVarintHash64(hash: string): void;
-  writeFixedHash64(hash: string): void;
-  writeString(value: string): number;
+    constructor();
+    length(): number;
+    end(): number[];
+    writeSplitVarint64(lowBits: number, highBits: number): void;
+    writeSplitFixed64(lowBits: number, highBits: number): void;
+    writeUnsignedVarint32(value: number): void;
+    writeSignedVarint32(value: number): void;
+    writeUnsignedVarint64(value: number): void;
+    writeSignedVarint64(value: number): void;
+    writeZigzagVarint32(value: number): void;
+    writeZigzagVarint64(value: number): void;
+    writeZigzagVarint64String(value: string): void;
+    writeUint8(value: number): void;
+    writeUint16(value: number): void;
+    writeUint32(value: number): void;
+    writeUint64(value: number): void;
+    writeInt8(value: number): void;
+    writeInt16(value: number): void;
+    writeInt32(value: number): void;
+    writeInt64(value: number): void;
+    writeInt64String(value: string): void;
+    writeFloat(value: number): void;
+    writeDouble(value: number): void;
+    writeBool(value: boolean): void;
+    writeEnum(value: number): void;
+    writeBytes(bytes: Uint8Array): void;
+    writeVarintHash64(hash: string): void;
+    writeFixedHash64(hash: string): void;
+    writeString(value: string): number;
 }
 
 export class BinaryDecoder {
-  constructor(bytes?: ByteSource, start?: number, length?: number)
-  static alloc(bytes?: ByteSource, start?: number, length?: number): BinaryDecoder;
-  free(): void;
-  clone(): BinaryDecoder;
-  clear(): void;
-  getBuffer(): Uint8Array;
-  setBlock(data: ByteSource, start?: number, length?: number): void;
-  getEnd(): number;
-  setEnd(end: number): void;
-  reset(): void;
-  getCursor(): number;
-  setCursor(cursor: number): void;
-  advance(count: number): void;
-  atEnd(): boolean;
-  pastEnd(): boolean;
-  getError(): boolean;
-  skipVarint(): void;
-  unskipVarint(value: number): void;
-  readUnsignedVarint32(): number;
-  readSignedVarint32(): number;
-  readUnsignedVarint32String(): number;
-  readSignedVarint32String(): number;
-  readZigzagVarint32(): number;
-  readUnsignedVarint64(): number;
-  readUnsignedVarint64String(): number;
-  readSignedVarint64(): number;
-  readSignedVarint64String(): number;
-  readZigzagVarint64(): number;
-  readZigzagVarint64String(): number;
-  readUint8(): number;
-  readUint16(): number;
-  readUint32(): number;
-  readUint64(): number;
-  readUint64String(): string;
-  readInt8(): number;
-  readInt16(): number;
-  readInt32(): number;
-  readInt64(): number;
-  readInt64String(): string;
-  readFloat(): number;
-  readDouble(): number;
-  readBool(): boolean;
-  readEnum(): number;
-  readString(length: number): string;
-  readStringWithLength(): string;
-  readBytes(length: number): Uint8Array;
-  readVarintHash64(): string;
-  readFixedHash64(): string;
+    constructor(bytes?: ByteSource, start?: number, length?: number);
+    static alloc(bytes?: ByteSource, start?: number, length?: number): BinaryDecoder;
+    free(): void;
+    clone(): BinaryDecoder;
+    clear(): void;
+    getBuffer(): Uint8Array;
+    setBlock(data: ByteSource, start?: number, length?: number): void;
+    getEnd(): number;
+    setEnd(end: number): void;
+    reset(): void;
+    getCursor(): number;
+    setCursor(cursor: number): void;
+    advance(count: number): void;
+    atEnd(): boolean;
+    pastEnd(): boolean;
+    getError(): boolean;
+    skipVarint(): void;
+    unskipVarint(value: number): void;
+    readUnsignedVarint32(): number;
+    readSignedVarint32(): number;
+    readUnsignedVarint32String(): number;
+    readSignedVarint32String(): number;
+    readZigzagVarint32(): number;
+    readUnsignedVarint64(): number;
+    readUnsignedVarint64String(): number;
+    readSignedVarint64(): number;
+    readSignedVarint64String(): number;
+    readZigzagVarint64(): number;
+    readZigzagVarint64String(): number;
+    readUint8(): number;
+    readUint16(): number;
+    readUint32(): number;
+    readUint64(): number;
+    readUint64String(): string;
+    readInt8(): number;
+    readInt16(): number;
+    readInt32(): number;
+    readInt64(): number;
+    readInt64String(): string;
+    readFloat(): number;
+    readDouble(): number;
+    readBool(): boolean;
+    readEnum(): number;
+    readString(length: number): string;
+    readStringWithLength(): string;
+    readBytes(length: number): Uint8Array;
+    readVarintHash64(): string;
+    readFixedHash64(): string;
 }
 
 export class BinaryIterator {
-  constructor(
-    decoder?: BinaryDecoder, next?: () => number | boolean | string | null,
-    elements?: Array<number | boolean | string>)
-  static alloc(
-    decoder?: BinaryDecoder,
-    next?: () => number | boolean | string | null,
-    elements?: Array<number | boolean | string>): BinaryIterator;
-  free(): void;
-  clear(): void;
-  get(): ScalarFieldType | null;
-  atEnd(): boolean;
-  next(): ScalarFieldType | null;
+    constructor(
+        decoder?: BinaryDecoder,
+        next?: () => number | boolean | string | null,
+        elements?: Array<number | boolean | string>,
+    );
+    static alloc(
+        decoder?: BinaryDecoder,
+        next?: () => number | boolean | string | null,
+        elements?: Array<number | boolean | string>,
+    ): BinaryIterator;
+    free(): void;
+    clear(): void;
+    get(): ScalarFieldType | null;
+    atEnd(): boolean;
+    next(): ScalarFieldType | null;
 }
 
 export namespace BinaryConstants {
-  enum FieldType {
-    INVALID = -1,
-    DOUBLE = 1,
-    FLOAT = 2,
-    INT64 = 3,
-    UINT64 = 4,
-    INT32 = 5,
-    FIXED64 = 6,
-    FIXED32 = 7,
-    BOOL = 8,
-    STRING = 9,
-    GROUP = 10,
-    MESSAGE = 11,
-    BYTES = 12,
-    UINT32 = 13,
-    ENUM = 14,
-    SFIXED32 = 15,
-    SFIXED64 = 16,
-    SINT32 = 17,
-    SINT64 = 18,
-    FHASH64 = 30,
-    VHASH64 = 31,
-  }
+    enum FieldType {
+        INVALID = -1,
+        DOUBLE = 1,
+        FLOAT = 2,
+        INT64 = 3,
+        UINT64 = 4,
+        INT32 = 5,
+        FIXED64 = 6,
+        FIXED32 = 7,
+        BOOL = 8,
+        STRING = 9,
+        GROUP = 10,
+        MESSAGE = 11,
+        BYTES = 12,
+        UINT32 = 13,
+        ENUM = 14,
+        SFIXED32 = 15,
+        SFIXED64 = 16,
+        SINT32 = 17,
+        SINT64 = 18,
+        FHASH64 = 30,
+        VHASH64 = 31,
+    }
 
-  enum WireType {
-    INVALID = -1,
-    VARINT = 0,
-    FIXED64 = 1,
-    DELIMITED = 2,
-    START_GROUP = 3,
-    END_GROUP = 4,
-    FIXED32 = 5,
-  }
+    enum WireType {
+        INVALID = -1,
+        VARINT = 0,
+        FIXED64 = 1,
+        DELIMITED = 2,
+        START_GROUP = 3,
+        END_GROUP = 4,
+        FIXED32 = 5,
+    }
 
-  const FieldTypeToWireType: (fieldType: FieldType) => WireType;
+    const FieldTypeToWireType: (fieldType: FieldType) => WireType;
 
-  const INVALID_FIELD_NUMBER: number;
-  const FLOAT32_EPS: number;
-  const FLOAT32_MIN: number;
-  const FLOAT32_MAX: number;
-  const FLOAT64_EPS: number;
-  const FLOAT64_MIN: number;
-  const FLOAT64_MAX: number;
-  const TWO_TO_20: number;
-  const TWO_TO_23: number;
-  const TWO_TO_31: number;
-  const TWO_TO_32: number;
-  const TWO_TO_52: number;
-  const TWO_TO_63: number;
-  const TWO_TO_64: number;
-  const ZERO_HASH: string;
+    const INVALID_FIELD_NUMBER: number;
+    const FLOAT32_EPS: number;
+    const FLOAT32_MIN: number;
+    const FLOAT32_MAX: number;
+    const FLOAT64_EPS: number;
+    const FLOAT64_MIN: number;
+    const FLOAT64_MAX: number;
+    const TWO_TO_20: number;
+    const TWO_TO_23: number;
+    const TWO_TO_31: number;
+    const TWO_TO_32: number;
+    const TWO_TO_52: number;
+    const TWO_TO_63: number;
+    const TWO_TO_64: number;
+    const ZERO_HASH: string;
 }
 
 export namespace arith {
-  class UInt64 {
-    lo: number;
-    hi: number;
-    constructor(lo: number, hi: number);
-    cmp(other: UInt64): number;
-    rightShift(): UInt64;
-    leftShift(): UInt64;
-    msb(): boolean;
-    lsb(): boolean;
-    zero(): boolean;
-    add(other: UInt64): UInt64;
-    sub(other: UInt64): UInt64;
-    static mul32x32(a: number, b: number): UInt64;
-    mul(a: number): UInt64;
-    div(divisor: number): [UInt64, UInt64];
-    toString(): string;
-    static fromString(str: string): UInt64;
-    clone(): UInt64;
-  }
+    class UInt64 {
+        lo: number;
+        hi: number;
+        constructor(lo: number, hi: number);
+        cmp(other: UInt64): number;
+        rightShift(): UInt64;
+        leftShift(): UInt64;
+        msb(): boolean;
+        lsb(): boolean;
+        zero(): boolean;
+        add(other: UInt64): UInt64;
+        sub(other: UInt64): UInt64;
+        static mul32x32(a: number, b: number): UInt64;
+        mul(a: number): UInt64;
+        div(divisor: number): [UInt64, UInt64];
+        toString(): string;
+        static fromString(str: string): UInt64;
+        clone(): UInt64;
+    }
 
-  class Int64 {
-    lo: number;
-    hi: number;
-    constructor(lo: number, hi: number);
-    add(other: Int64): Int64;
-    sub(other: Int64): Int64;
-    clone(): Int64;
-    toString(): string;
-    static fromString(str: string): Int64;
-  }
+    class Int64 {
+        lo: number;
+        hi: number;
+        constructor(lo: number, hi: number);
+        add(other: Int64): Int64;
+        sub(other: Int64): Int64;
+        clone(): Int64;
+        toString(): string;
+        static fromString(str: string): Int64;
+    }
 }
 
 // jspb.utils package excluded as it likely shouldn't be called by user code

google-protobuf/package.json

 {
     "name": "@types/google-protobuf",
-    "version": "3.15.6",
+    "version": "3.15.7",
     "description": "TypeScript definitions for google-protobuf",
@@ -28,4 +28,4 @@ "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/google-protobuf",
     "dependencies": {},
-    "typesPublisherContentHash": "52bcbdc0bcf70a9d296a1564997129b047f30feeb42083c4ea21b45150611304",
-    "typeScriptVersion": "3.9"
+    "typesPublisherContentHash": "a412938d061da5ef98c06893ffe67820261cf3c8c999000805849ede3cbbba56",
+    "typeScriptVersion": "4.5"
 }

google-protobuf/README.md

@@ -11,3 +11,3 @@ # Installation
 ### Additional Details
- * Last updated: Thu, 28 Apr 2022 23:31:44 GMT
+ * Last updated: Wed, 20 Sep 2023 17:08:03 GMT
  * Dependencies: none
@@ -14,0 +14,0 @@ * Global values: none

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

116510

increased by5.57%

Lines of code

2502

increased by1.79%

No dependency changes