1240 lines
48 KiB
TypeScript
Executable File
1240 lines
48 KiB
TypeScript
Executable File
// package: google.protobuf
|
|
// file: descriptor.proto
|
|
|
|
import * as jspb from "../../index";
|
|
|
|
export class FileDescriptorSet extends jspb.Message {
|
|
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;
|
|
}
|
|
|
|
export namespace FileDescriptorSet {
|
|
export type AsObject = {
|
|
fileList: Array<FileDescriptorProto.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class FileDescriptorProto extends jspb.Message {
|
|
hasName(): boolean;
|
|
clearName(): FileDescriptorProto;
|
|
getName(): string | undefined;
|
|
setName(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;
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
hasOptions(): boolean;
|
|
clearOptions(): FileDescriptorProto;
|
|
getOptions(): FileOptions | undefined;
|
|
setOptions(value?: FileOptions): FileDescriptorProto;
|
|
|
|
hasSourceCodeInfo(): boolean;
|
|
clearSourceCodeInfo(): FileDescriptorProto;
|
|
getSourceCodeInfo(): SourceCodeInfo | undefined;
|
|
setSourceCodeInfo(value?: SourceCodeInfo): 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;
|
|
}
|
|
|
|
export namespace FileDescriptorProto {
|
|
export type AsObject = {
|
|
name?: string,
|
|
pb_package?: string,
|
|
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,
|
|
sourceCodeInfo?: SourceCodeInfo.AsObject,
|
|
syntax?: string,
|
|
}
|
|
}
|
|
|
|
export class DescriptorProto extends jspb.Message {
|
|
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;
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
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;
|
|
|
|
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,
|
|
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,
|
|
reservedRangeList: Array<ReservedRange.AsObject>,
|
|
reservedNameList: Array<string>,
|
|
}
|
|
|
|
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;
|
|
|
|
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;
|
|
}
|
|
|
|
export namespace ExtensionRange {
|
|
export type AsObject = {
|
|
start?: number,
|
|
end?: number,
|
|
options?: ExtensionRangeOptions.AsObject,
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
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,
|
|
end?: number,
|
|
}
|
|
}
|
|
}
|
|
|
|
export class ExtensionRangeOptions extends jspb.Message {
|
|
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;
|
|
}
|
|
|
|
export namespace ExtensionRangeOptions {
|
|
export type AsObject = {
|
|
uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class FieldDescriptorProto extends jspb.Message {
|
|
hasName(): boolean;
|
|
clearName(): FieldDescriptorProto;
|
|
getName(): string | undefined;
|
|
setName(value: string): 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;
|
|
|
|
hasType(): boolean;
|
|
clearType(): FieldDescriptorProto;
|
|
getType(): FieldDescriptorProto.Type | undefined;
|
|
setType(value: FieldDescriptorProto.Type): FieldDescriptorProto;
|
|
|
|
hasTypeName(): boolean;
|
|
clearTypeName(): FieldDescriptorProto;
|
|
getTypeName(): string | undefined;
|
|
setTypeName(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;
|
|
|
|
hasOneofIndex(): boolean;
|
|
clearOneofIndex(): FieldDescriptorProto;
|
|
getOneofIndex(): number | undefined;
|
|
setOneofIndex(value: number): FieldDescriptorProto;
|
|
|
|
hasJsonName(): boolean;
|
|
clearJsonName(): FieldDescriptorProto;
|
|
getJsonName(): string | undefined;
|
|
setJsonName(value: string): FieldDescriptorProto;
|
|
|
|
hasOptions(): boolean;
|
|
clearOptions(): FieldDescriptorProto;
|
|
getOptions(): FieldOptions | undefined;
|
|
setOptions(value?: FieldOptions): 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;
|
|
}
|
|
|
|
export namespace FieldDescriptorProto {
|
|
export type AsObject = {
|
|
name?: string,
|
|
number?: number,
|
|
label?: Label,
|
|
type?: Type,
|
|
typeName?: string,
|
|
extendee?: string,
|
|
defaultValue?: string,
|
|
oneofIndex?: number,
|
|
jsonName?: string,
|
|
options?: FieldOptions.AsObject,
|
|
proto3Optional?: boolean,
|
|
}
|
|
|
|
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 class OneofDescriptorProto extends jspb.Message {
|
|
hasName(): boolean;
|
|
clearName(): OneofDescriptorProto;
|
|
getName(): string | undefined;
|
|
setName(value: string): 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;
|
|
}
|
|
|
|
export namespace OneofDescriptorProto {
|
|
export type AsObject = {
|
|
name?: string,
|
|
options?: OneofOptions.AsObject,
|
|
}
|
|
}
|
|
|
|
export class EnumDescriptorProto extends jspb.Message {
|
|
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;
|
|
|
|
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;
|
|
|
|
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;
|
|
}
|
|
|
|
export namespace EnumDescriptorProto {
|
|
export type AsObject = {
|
|
name?: string,
|
|
valueList: Array<EnumValueDescriptorProto.AsObject>,
|
|
options?: EnumOptions.AsObject,
|
|
reservedRangeList: Array<EnumReservedRange.AsObject>,
|
|
reservedNameList: Array<string>,
|
|
}
|
|
|
|
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;
|
|
|
|
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,
|
|
end?: number,
|
|
}
|
|
}
|
|
}
|
|
|
|
export class EnumValueDescriptorProto extends jspb.Message {
|
|
hasName(): boolean;
|
|
clearName(): EnumValueDescriptorProto;
|
|
getName(): string | undefined;
|
|
setName(value: string): EnumValueDescriptorProto;
|
|
|
|
hasNumber(): boolean;
|
|
clearNumber(): EnumValueDescriptorProto;
|
|
getNumber(): number | undefined;
|
|
setNumber(value: number): 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;
|
|
}
|
|
|
|
export namespace EnumValueDescriptorProto {
|
|
export type AsObject = {
|
|
name?: string,
|
|
number?: number,
|
|
options?: EnumValueOptions.AsObject,
|
|
}
|
|
}
|
|
|
|
export class ServiceDescriptorProto extends jspb.Message {
|
|
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;
|
|
|
|
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;
|
|
}
|
|
|
|
export namespace ServiceDescriptorProto {
|
|
export type AsObject = {
|
|
name?: string,
|
|
methodList: Array<MethodDescriptorProto.AsObject>,
|
|
options?: ServiceOptions.AsObject,
|
|
}
|
|
}
|
|
|
|
export class MethodDescriptorProto extends jspb.Message {
|
|
hasName(): boolean;
|
|
clearName(): MethodDescriptorProto;
|
|
getName(): string | undefined;
|
|
setName(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;
|
|
|
|
hasOptions(): boolean;
|
|
clearOptions(): MethodDescriptorProto;
|
|
getOptions(): MethodOptions | undefined;
|
|
setOptions(value?: MethodOptions): MethodDescriptorProto;
|
|
|
|
hasClientStreaming(): boolean;
|
|
clearClientStreaming(): MethodDescriptorProto;
|
|
getClientStreaming(): boolean | undefined;
|
|
setClientStreaming(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;
|
|
}
|
|
|
|
export namespace MethodDescriptorProto {
|
|
export type AsObject = {
|
|
name?: string,
|
|
inputType?: string,
|
|
outputType?: string,
|
|
options?: MethodOptions.AsObject,
|
|
clientStreaming?: boolean,
|
|
serverStreaming?: boolean,
|
|
}
|
|
}
|
|
|
|
export class FileOptions extends jspb.Message {
|
|
hasJavaPackage(): boolean;
|
|
clearJavaPackage(): FileOptions;
|
|
getJavaPackage(): string | undefined;
|
|
setJavaPackage(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;
|
|
|
|
hasJavaGenerateEqualsAndHash(): boolean;
|
|
clearJavaGenerateEqualsAndHash(): FileOptions;
|
|
getJavaGenerateEqualsAndHash(): boolean | undefined;
|
|
setJavaGenerateEqualsAndHash(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;
|
|
|
|
hasGoPackage(): boolean;
|
|
clearGoPackage(): FileOptions;
|
|
getGoPackage(): string | undefined;
|
|
setGoPackage(value: string): FileOptions;
|
|
|
|
hasCcGenericServices(): boolean;
|
|
clearCcGenericServices(): FileOptions;
|
|
getCcGenericServices(): boolean | undefined;
|
|
setCcGenericServices(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;
|
|
|
|
hasPhpGenericServices(): boolean;
|
|
clearPhpGenericServices(): FileOptions;
|
|
getPhpGenericServices(): boolean | undefined;
|
|
setPhpGenericServices(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;
|
|
|
|
hasObjcClassPrefix(): boolean;
|
|
clearObjcClassPrefix(): FileOptions;
|
|
getObjcClassPrefix(): string | undefined;
|
|
setObjcClassPrefix(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;
|
|
|
|
hasPhpClassPrefix(): boolean;
|
|
clearPhpClassPrefix(): FileOptions;
|
|
getPhpClassPrefix(): string | undefined;
|
|
setPhpClassPrefix(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;
|
|
|
|
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;
|
|
|
|
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,
|
|
javaOuterClassname?: string,
|
|
javaMultipleFiles?: boolean,
|
|
javaGenerateEqualsAndHash?: boolean,
|
|
javaStringCheckUtf8?: boolean,
|
|
optimizeFor?: OptimizeMode,
|
|
goPackage?: string,
|
|
ccGenericServices?: boolean,
|
|
javaGenericServices?: boolean,
|
|
pyGenericServices?: boolean,
|
|
phpGenericServices?: boolean,
|
|
deprecated?: boolean,
|
|
ccEnableArenas?: boolean,
|
|
objcClassPrefix?: string,
|
|
csharpNamespace?: string,
|
|
swiftPrefix?: string,
|
|
phpClassPrefix?: string,
|
|
phpNamespace?: string,
|
|
phpMetadataNamespace?: string,
|
|
rubyPackage?: string,
|
|
uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
|
|
}
|
|
|
|
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;
|
|
|
|
hasNoStandardDescriptorAccessor(): boolean;
|
|
clearNoStandardDescriptorAccessor(): MessageOptions;
|
|
getNoStandardDescriptorAccessor(): boolean | undefined;
|
|
setNoStandardDescriptorAccessor(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;
|
|
|
|
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;
|
|
}
|
|
|
|
export namespace MessageOptions {
|
|
export type AsObject = {
|
|
messageSetWireFormat?: boolean,
|
|
noStandardDescriptorAccessor?: boolean,
|
|
deprecated?: boolean,
|
|
mapEntry?: boolean,
|
|
uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class FieldOptions extends jspb.Message {
|
|
hasCtype(): boolean;
|
|
clearCtype(): FieldOptions;
|
|
getCtype(): FieldOptions.CType | undefined;
|
|
setCtype(value: FieldOptions.CType): 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;
|
|
|
|
hasLazy(): boolean;
|
|
clearLazy(): FieldOptions;
|
|
getLazy(): boolean | undefined;
|
|
setLazy(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;
|
|
|
|
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;
|
|
}
|
|
|
|
export namespace FieldOptions {
|
|
export type AsObject = {
|
|
ctype?: CType,
|
|
packed?: boolean,
|
|
jstype?: JSType,
|
|
lazy?: boolean,
|
|
deprecated?: boolean,
|
|
weak?: boolean,
|
|
uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
|
|
}
|
|
|
|
export enum CType {
|
|
STRING = 0,
|
|
CORD = 1,
|
|
STRING_PIECE = 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;
|
|
|
|
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 class EnumOptions extends jspb.Message {
|
|
hasAllowAlias(): boolean;
|
|
clearAllowAlias(): EnumOptions;
|
|
getAllowAlias(): boolean | undefined;
|
|
setAllowAlias(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;
|
|
|
|
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,
|
|
deprecated?: boolean,
|
|
uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class EnumValueOptions extends jspb.Message {
|
|
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;
|
|
|
|
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,
|
|
uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class ServiceOptions extends jspb.Message {
|
|
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;
|
|
|
|
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,
|
|
uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
|
|
}
|
|
}
|
|
|
|
export class MethodOptions extends jspb.Message {
|
|
hasDeprecated(): boolean;
|
|
clearDeprecated(): MethodOptions;
|
|
getDeprecated(): boolean | undefined;
|
|
setDeprecated(value: boolean): 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;
|
|
|
|
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,
|
|
idempotencyLevel?: IdempotencyLevel,
|
|
uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
|
|
}
|
|
|
|
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;
|
|
|
|
hasIdentifierValue(): boolean;
|
|
clearIdentifierValue(): UninterpretedOption;
|
|
getIdentifierValue(): string | undefined;
|
|
setIdentifierValue(value: string): UninterpretedOption;
|
|
|
|
hasPositiveIntValue(): boolean;
|
|
clearPositiveIntValue(): UninterpretedOption;
|
|
getPositiveIntValue(): number | undefined;
|
|
setPositiveIntValue(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;
|
|
|
|
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;
|
|
|
|
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,
|
|
positiveIntValue?: number,
|
|
negativeIntValue?: number,
|
|
doubleValue?: number,
|
|
stringValue: Uint8Array | string,
|
|
aggregateValue?: string,
|
|
}
|
|
|
|
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;
|
|
|
|
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,
|
|
isExtension?: boolean,
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
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 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;
|
|
|
|
hasLeadingComments(): boolean;
|
|
clearLeadingComments(): Location;
|
|
getLeadingComments(): string | undefined;
|
|
setLeadingComments(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;
|
|
|
|
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,
|
|
trailingComments?: string,
|
|
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;
|
|
|
|
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 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;
|
|
|
|
hasBegin(): boolean;
|
|
clearBegin(): Annotation;
|
|
getBegin(): number | undefined;
|
|
setBegin(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;
|
|
}
|
|
|
|
export namespace Annotation {
|
|
export type AsObject = {
|
|
pathList: Array<number>,
|
|
sourceFile?: string,
|
|
begin?: number,
|
|
end?: number,
|
|
}
|
|
}
|
|
}
|