@types/google-protobuf - npm Package Compare versions

@types/google-protobuf

Package Overview

Dependencies

Maintainers

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

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;
		};
		}

176

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;
		};
		}

240

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;
		};
		}
		}
		}

1935

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;
		};
		}

170

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;
		};
		}

354

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,
		}

238

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;
		};
		}

1068

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

Improved metrics