github.com/hyperledger/burrow@v0.34.5-0.20220512172541-77f09336001d/js/proto/google/protobuf/descriptor_pb.d.ts (about)

     1  // package: google.protobuf
     2  // file: google/protobuf/descriptor.proto
     3  
     4  /* tslint:disable */
     5  /* eslint-disable */
     6  
     7  import * as jspb from "google-protobuf";
     8  
     9  export class FileDescriptorSet extends jspb.Message { 
    10      clearFileList(): void;
    11      getFileList(): Array<FileDescriptorProto>;
    12      setFileList(value: Array<FileDescriptorProto>): FileDescriptorSet;
    13      addFile(value?: FileDescriptorProto, index?: number): FileDescriptorProto;
    14  
    15      serializeBinary(): Uint8Array;
    16      toObject(includeInstance?: boolean): FileDescriptorSet.AsObject;
    17      static toObject(includeInstance: boolean, msg: FileDescriptorSet): FileDescriptorSet.AsObject;
    18      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    19      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    20      static serializeBinaryToWriter(message: FileDescriptorSet, writer: jspb.BinaryWriter): void;
    21      static deserializeBinary(bytes: Uint8Array): FileDescriptorSet;
    22      static deserializeBinaryFromReader(message: FileDescriptorSet, reader: jspb.BinaryReader): FileDescriptorSet;
    23  }
    24  
    25  export namespace FileDescriptorSet {
    26      export type AsObject = {
    27          fileList: Array<FileDescriptorProto.AsObject>,
    28      }
    29  }
    30  
    31  export class FileDescriptorProto extends jspb.Message { 
    32  
    33      hasName(): boolean;
    34      clearName(): void;
    35      getName(): string | undefined;
    36      setName(value: string): FileDescriptorProto;
    37  
    38      hasPackage(): boolean;
    39      clearPackage(): void;
    40      getPackage(): string | undefined;
    41      setPackage(value: string): FileDescriptorProto;
    42      clearDependencyList(): void;
    43      getDependencyList(): Array<string>;
    44      setDependencyList(value: Array<string>): FileDescriptorProto;
    45      addDependency(value: string, index?: number): string;
    46      clearPublicDependencyList(): void;
    47      getPublicDependencyList(): Array<number>;
    48      setPublicDependencyList(value: Array<number>): FileDescriptorProto;
    49      addPublicDependency(value: number, index?: number): number;
    50      clearWeakDependencyList(): void;
    51      getWeakDependencyList(): Array<number>;
    52      setWeakDependencyList(value: Array<number>): FileDescriptorProto;
    53      addWeakDependency(value: number, index?: number): number;
    54      clearMessageTypeList(): void;
    55      getMessageTypeList(): Array<DescriptorProto>;
    56      setMessageTypeList(value: Array<DescriptorProto>): FileDescriptorProto;
    57      addMessageType(value?: DescriptorProto, index?: number): DescriptorProto;
    58      clearEnumTypeList(): void;
    59      getEnumTypeList(): Array<EnumDescriptorProto>;
    60      setEnumTypeList(value: Array<EnumDescriptorProto>): FileDescriptorProto;
    61      addEnumType(value?: EnumDescriptorProto, index?: number): EnumDescriptorProto;
    62      clearServiceList(): void;
    63      getServiceList(): Array<ServiceDescriptorProto>;
    64      setServiceList(value: Array<ServiceDescriptorProto>): FileDescriptorProto;
    65      addService(value?: ServiceDescriptorProto, index?: number): ServiceDescriptorProto;
    66      clearExtensionList(): void;
    67      getExtensionList(): Array<FieldDescriptorProto>;
    68      setExtensionList(value: Array<FieldDescriptorProto>): FileDescriptorProto;
    69      addExtension$(value?: FieldDescriptorProto, index?: number): FieldDescriptorProto;
    70  
    71      hasOptions(): boolean;
    72      clearOptions(): void;
    73      getOptions(): FileOptions | undefined;
    74      setOptions(value?: FileOptions): FileDescriptorProto;
    75  
    76      hasSourceCodeInfo(): boolean;
    77      clearSourceCodeInfo(): void;
    78      getSourceCodeInfo(): SourceCodeInfo | undefined;
    79      setSourceCodeInfo(value?: SourceCodeInfo): FileDescriptorProto;
    80  
    81      hasSyntax(): boolean;
    82      clearSyntax(): void;
    83      getSyntax(): string | undefined;
    84      setSyntax(value: string): FileDescriptorProto;
    85  
    86      serializeBinary(): Uint8Array;
    87      toObject(includeInstance?: boolean): FileDescriptorProto.AsObject;
    88      static toObject(includeInstance: boolean, msg: FileDescriptorProto): FileDescriptorProto.AsObject;
    89      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    90      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    91      static serializeBinaryToWriter(message: FileDescriptorProto, writer: jspb.BinaryWriter): void;
    92      static deserializeBinary(bytes: Uint8Array): FileDescriptorProto;
    93      static deserializeBinaryFromReader(message: FileDescriptorProto, reader: jspb.BinaryReader): FileDescriptorProto;
    94  }
    95  
    96  export namespace FileDescriptorProto {
    97      export type AsObject = {
    98          name?: string,
    99          pb_package?: string,
   100          dependencyList: Array<string>,
   101          publicDependencyList: Array<number>,
   102          weakDependencyList: Array<number>,
   103          messageTypeList: Array<DescriptorProto.AsObject>,
   104          enumTypeList: Array<EnumDescriptorProto.AsObject>,
   105          serviceList: Array<ServiceDescriptorProto.AsObject>,
   106          extensionList: Array<FieldDescriptorProto.AsObject>,
   107          options?: FileOptions.AsObject,
   108          sourceCodeInfo?: SourceCodeInfo.AsObject,
   109          syntax?: string,
   110      }
   111  }
   112  
   113  export class DescriptorProto extends jspb.Message { 
   114  
   115      hasName(): boolean;
   116      clearName(): void;
   117      getName(): string | undefined;
   118      setName(value: string): DescriptorProto;
   119      clearFieldList(): void;
   120      getFieldList(): Array<FieldDescriptorProto>;
   121      setFieldList(value: Array<FieldDescriptorProto>): DescriptorProto;
   122      addField(value?: FieldDescriptorProto, index?: number): FieldDescriptorProto;
   123      clearExtensionList(): void;
   124      getExtensionList(): Array<FieldDescriptorProto>;
   125      setExtensionList(value: Array<FieldDescriptorProto>): DescriptorProto;
   126      addExtension$(value?: FieldDescriptorProto, index?: number): FieldDescriptorProto;
   127      clearNestedTypeList(): void;
   128      getNestedTypeList(): Array<DescriptorProto>;
   129      setNestedTypeList(value: Array<DescriptorProto>): DescriptorProto;
   130      addNestedType(value?: DescriptorProto, index?: number): DescriptorProto;
   131      clearEnumTypeList(): void;
   132      getEnumTypeList(): Array<EnumDescriptorProto>;
   133      setEnumTypeList(value: Array<EnumDescriptorProto>): DescriptorProto;
   134      addEnumType(value?: EnumDescriptorProto, index?: number): EnumDescriptorProto;
   135      clearExtensionRangeList(): void;
   136      getExtensionRangeList(): Array<DescriptorProto.ExtensionRange>;
   137      setExtensionRangeList(value: Array<DescriptorProto.ExtensionRange>): DescriptorProto;
   138      addExtensionRange(value?: DescriptorProto.ExtensionRange, index?: number): DescriptorProto.ExtensionRange;
   139      clearOneofDeclList(): void;
   140      getOneofDeclList(): Array<OneofDescriptorProto>;
   141      setOneofDeclList(value: Array<OneofDescriptorProto>): DescriptorProto;
   142      addOneofDecl(value?: OneofDescriptorProto, index?: number): OneofDescriptorProto;
   143  
   144      hasOptions(): boolean;
   145      clearOptions(): void;
   146      getOptions(): MessageOptions | undefined;
   147      setOptions(value?: MessageOptions): DescriptorProto;
   148      clearReservedRangeList(): void;
   149      getReservedRangeList(): Array<DescriptorProto.ReservedRange>;
   150      setReservedRangeList(value: Array<DescriptorProto.ReservedRange>): DescriptorProto;
   151      addReservedRange(value?: DescriptorProto.ReservedRange, index?: number): DescriptorProto.ReservedRange;
   152      clearReservedNameList(): void;
   153      getReservedNameList(): Array<string>;
   154      setReservedNameList(value: Array<string>): DescriptorProto;
   155      addReservedName(value: string, index?: number): string;
   156  
   157      serializeBinary(): Uint8Array;
   158      toObject(includeInstance?: boolean): DescriptorProto.AsObject;
   159      static toObject(includeInstance: boolean, msg: DescriptorProto): DescriptorProto.AsObject;
   160      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   161      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   162      static serializeBinaryToWriter(message: DescriptorProto, writer: jspb.BinaryWriter): void;
   163      static deserializeBinary(bytes: Uint8Array): DescriptorProto;
   164      static deserializeBinaryFromReader(message: DescriptorProto, reader: jspb.BinaryReader): DescriptorProto;
   165  }
   166  
   167  export namespace DescriptorProto {
   168      export type AsObject = {
   169          name?: string,
   170          fieldList: Array<FieldDescriptorProto.AsObject>,
   171          extensionList: Array<FieldDescriptorProto.AsObject>,
   172          nestedTypeList: Array<DescriptorProto.AsObject>,
   173          enumTypeList: Array<EnumDescriptorProto.AsObject>,
   174          extensionRangeList: Array<DescriptorProto.ExtensionRange.AsObject>,
   175          oneofDeclList: Array<OneofDescriptorProto.AsObject>,
   176          options?: MessageOptions.AsObject,
   177          reservedRangeList: Array<DescriptorProto.ReservedRange.AsObject>,
   178          reservedNameList: Array<string>,
   179      }
   180  
   181  
   182      export class ExtensionRange extends jspb.Message { 
   183  
   184          hasStart(): boolean;
   185          clearStart(): void;
   186          getStart(): number | undefined;
   187          setStart(value: number): ExtensionRange;
   188  
   189          hasEnd(): boolean;
   190          clearEnd(): void;
   191          getEnd(): number | undefined;
   192          setEnd(value: number): ExtensionRange;
   193  
   194          hasOptions(): boolean;
   195          clearOptions(): void;
   196          getOptions(): ExtensionRangeOptions | undefined;
   197          setOptions(value?: ExtensionRangeOptions): ExtensionRange;
   198  
   199          serializeBinary(): Uint8Array;
   200          toObject(includeInstance?: boolean): ExtensionRange.AsObject;
   201          static toObject(includeInstance: boolean, msg: ExtensionRange): ExtensionRange.AsObject;
   202          static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   203          static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   204          static serializeBinaryToWriter(message: ExtensionRange, writer: jspb.BinaryWriter): void;
   205          static deserializeBinary(bytes: Uint8Array): ExtensionRange;
   206          static deserializeBinaryFromReader(message: ExtensionRange, reader: jspb.BinaryReader): ExtensionRange;
   207      }
   208  
   209      export namespace ExtensionRange {
   210          export type AsObject = {
   211              start?: number,
   212              end?: number,
   213              options?: ExtensionRangeOptions.AsObject,
   214          }
   215      }
   216  
   217      export class ReservedRange extends jspb.Message { 
   218  
   219          hasStart(): boolean;
   220          clearStart(): void;
   221          getStart(): number | undefined;
   222          setStart(value: number): ReservedRange;
   223  
   224          hasEnd(): boolean;
   225          clearEnd(): void;
   226          getEnd(): number | undefined;
   227          setEnd(value: number): ReservedRange;
   228  
   229          serializeBinary(): Uint8Array;
   230          toObject(includeInstance?: boolean): ReservedRange.AsObject;
   231          static toObject(includeInstance: boolean, msg: ReservedRange): ReservedRange.AsObject;
   232          static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   233          static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   234          static serializeBinaryToWriter(message: ReservedRange, writer: jspb.BinaryWriter): void;
   235          static deserializeBinary(bytes: Uint8Array): ReservedRange;
   236          static deserializeBinaryFromReader(message: ReservedRange, reader: jspb.BinaryReader): ReservedRange;
   237      }
   238  
   239      export namespace ReservedRange {
   240          export type AsObject = {
   241              start?: number,
   242              end?: number,
   243          }
   244      }
   245  
   246  }
   247  
   248  export class ExtensionRangeOptions extends jspb.Message { 
   249      clearUninterpretedOptionList(): void;
   250      getUninterpretedOptionList(): Array<UninterpretedOption>;
   251      setUninterpretedOptionList(value: Array<UninterpretedOption>): ExtensionRangeOptions;
   252      addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
   253  
   254      serializeBinary(): Uint8Array;
   255      toObject(includeInstance?: boolean): ExtensionRangeOptions.AsObject;
   256      static toObject(includeInstance: boolean, msg: ExtensionRangeOptions): ExtensionRangeOptions.AsObject;
   257      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   258      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   259      static serializeBinaryToWriter(message: ExtensionRangeOptions, writer: jspb.BinaryWriter): void;
   260      static deserializeBinary(bytes: Uint8Array): ExtensionRangeOptions;
   261      static deserializeBinaryFromReader(message: ExtensionRangeOptions, reader: jspb.BinaryReader): ExtensionRangeOptions;
   262  }
   263  
   264  export namespace ExtensionRangeOptions {
   265      export type AsObject = {
   266          uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
   267      }
   268  }
   269  
   270  export class FieldDescriptorProto extends jspb.Message { 
   271  
   272      hasName(): boolean;
   273      clearName(): void;
   274      getName(): string | undefined;
   275      setName(value: string): FieldDescriptorProto;
   276  
   277      hasNumber(): boolean;
   278      clearNumber(): void;
   279      getNumber(): number | undefined;
   280      setNumber(value: number): FieldDescriptorProto;
   281  
   282      hasLabel(): boolean;
   283      clearLabel(): void;
   284      getLabel(): FieldDescriptorProto.Label | undefined;
   285      setLabel(value: FieldDescriptorProto.Label): FieldDescriptorProto;
   286  
   287      hasType(): boolean;
   288      clearType(): void;
   289      getType(): FieldDescriptorProto.Type | undefined;
   290      setType(value: FieldDescriptorProto.Type): FieldDescriptorProto;
   291  
   292      hasTypeName(): boolean;
   293      clearTypeName(): void;
   294      getTypeName(): string | undefined;
   295      setTypeName(value: string): FieldDescriptorProto;
   296  
   297      hasExtendee(): boolean;
   298      clearExtendee(): void;
   299      getExtendee(): string | undefined;
   300      setExtendee(value: string): FieldDescriptorProto;
   301  
   302      hasDefaultValue(): boolean;
   303      clearDefaultValue(): void;
   304      getDefaultValue(): string | undefined;
   305      setDefaultValue(value: string): FieldDescriptorProto;
   306  
   307      hasOneofIndex(): boolean;
   308      clearOneofIndex(): void;
   309      getOneofIndex(): number | undefined;
   310      setOneofIndex(value: number): FieldDescriptorProto;
   311  
   312      hasJsonName(): boolean;
   313      clearJsonName(): void;
   314      getJsonName(): string | undefined;
   315      setJsonName(value: string): FieldDescriptorProto;
   316  
   317      hasOptions(): boolean;
   318      clearOptions(): void;
   319      getOptions(): FieldOptions | undefined;
   320      setOptions(value?: FieldOptions): FieldDescriptorProto;
   321  
   322      serializeBinary(): Uint8Array;
   323      toObject(includeInstance?: boolean): FieldDescriptorProto.AsObject;
   324      static toObject(includeInstance: boolean, msg: FieldDescriptorProto): FieldDescriptorProto.AsObject;
   325      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   326      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   327      static serializeBinaryToWriter(message: FieldDescriptorProto, writer: jspb.BinaryWriter): void;
   328      static deserializeBinary(bytes: Uint8Array): FieldDescriptorProto;
   329      static deserializeBinaryFromReader(message: FieldDescriptorProto, reader: jspb.BinaryReader): FieldDescriptorProto;
   330  }
   331  
   332  export namespace FieldDescriptorProto {
   333      export type AsObject = {
   334          name?: string,
   335          number?: number,
   336          label?: FieldDescriptorProto.Label,
   337          type?: FieldDescriptorProto.Type,
   338          typeName?: string,
   339          extendee?: string,
   340          defaultValue?: string,
   341          oneofIndex?: number,
   342          jsonName?: string,
   343          options?: FieldOptions.AsObject,
   344      }
   345  
   346      export enum Type {
   347      TYPE_DOUBLE = 1,
   348      TYPE_FLOAT = 2,
   349      TYPE_INT64 = 3,
   350      TYPE_UINT64 = 4,
   351      TYPE_INT32 = 5,
   352      TYPE_FIXED64 = 6,
   353      TYPE_FIXED32 = 7,
   354      TYPE_BOOL = 8,
   355      TYPE_STRING = 9,
   356      TYPE_GROUP = 10,
   357      TYPE_MESSAGE = 11,
   358      TYPE_BYTES = 12,
   359      TYPE_UINT32 = 13,
   360      TYPE_ENUM = 14,
   361      TYPE_SFIXED32 = 15,
   362      TYPE_SFIXED64 = 16,
   363      TYPE_SINT32 = 17,
   364      TYPE_SINT64 = 18,
   365      }
   366  
   367      export enum Label {
   368      LABEL_OPTIONAL = 1,
   369      LABEL_REQUIRED = 2,
   370      LABEL_REPEATED = 3,
   371      }
   372  
   373  }
   374  
   375  export class OneofDescriptorProto extends jspb.Message { 
   376  
   377      hasName(): boolean;
   378      clearName(): void;
   379      getName(): string | undefined;
   380      setName(value: string): OneofDescriptorProto;
   381  
   382      hasOptions(): boolean;
   383      clearOptions(): void;
   384      getOptions(): OneofOptions | undefined;
   385      setOptions(value?: OneofOptions): OneofDescriptorProto;
   386  
   387      serializeBinary(): Uint8Array;
   388      toObject(includeInstance?: boolean): OneofDescriptorProto.AsObject;
   389      static toObject(includeInstance: boolean, msg: OneofDescriptorProto): OneofDescriptorProto.AsObject;
   390      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   391      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   392      static serializeBinaryToWriter(message: OneofDescriptorProto, writer: jspb.BinaryWriter): void;
   393      static deserializeBinary(bytes: Uint8Array): OneofDescriptorProto;
   394      static deserializeBinaryFromReader(message: OneofDescriptorProto, reader: jspb.BinaryReader): OneofDescriptorProto;
   395  }
   396  
   397  export namespace OneofDescriptorProto {
   398      export type AsObject = {
   399          name?: string,
   400          options?: OneofOptions.AsObject,
   401      }
   402  }
   403  
   404  export class EnumDescriptorProto extends jspb.Message { 
   405  
   406      hasName(): boolean;
   407      clearName(): void;
   408      getName(): string | undefined;
   409      setName(value: string): EnumDescriptorProto;
   410      clearValueList(): void;
   411      getValueList(): Array<EnumValueDescriptorProto>;
   412      setValueList(value: Array<EnumValueDescriptorProto>): EnumDescriptorProto;
   413      addValue(value?: EnumValueDescriptorProto, index?: number): EnumValueDescriptorProto;
   414  
   415      hasOptions(): boolean;
   416      clearOptions(): void;
   417      getOptions(): EnumOptions | undefined;
   418      setOptions(value?: EnumOptions): EnumDescriptorProto;
   419      clearReservedRangeList(): void;
   420      getReservedRangeList(): Array<EnumDescriptorProto.EnumReservedRange>;
   421      setReservedRangeList(value: Array<EnumDescriptorProto.EnumReservedRange>): EnumDescriptorProto;
   422      addReservedRange(value?: EnumDescriptorProto.EnumReservedRange, index?: number): EnumDescriptorProto.EnumReservedRange;
   423      clearReservedNameList(): void;
   424      getReservedNameList(): Array<string>;
   425      setReservedNameList(value: Array<string>): EnumDescriptorProto;
   426      addReservedName(value: string, index?: number): string;
   427  
   428      serializeBinary(): Uint8Array;
   429      toObject(includeInstance?: boolean): EnumDescriptorProto.AsObject;
   430      static toObject(includeInstance: boolean, msg: EnumDescriptorProto): EnumDescriptorProto.AsObject;
   431      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   432      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   433      static serializeBinaryToWriter(message: EnumDescriptorProto, writer: jspb.BinaryWriter): void;
   434      static deserializeBinary(bytes: Uint8Array): EnumDescriptorProto;
   435      static deserializeBinaryFromReader(message: EnumDescriptorProto, reader: jspb.BinaryReader): EnumDescriptorProto;
   436  }
   437  
   438  export namespace EnumDescriptorProto {
   439      export type AsObject = {
   440          name?: string,
   441          valueList: Array<EnumValueDescriptorProto.AsObject>,
   442          options?: EnumOptions.AsObject,
   443          reservedRangeList: Array<EnumDescriptorProto.EnumReservedRange.AsObject>,
   444          reservedNameList: Array<string>,
   445      }
   446  
   447  
   448      export class EnumReservedRange extends jspb.Message { 
   449  
   450          hasStart(): boolean;
   451          clearStart(): void;
   452          getStart(): number | undefined;
   453          setStart(value: number): EnumReservedRange;
   454  
   455          hasEnd(): boolean;
   456          clearEnd(): void;
   457          getEnd(): number | undefined;
   458          setEnd(value: number): EnumReservedRange;
   459  
   460          serializeBinary(): Uint8Array;
   461          toObject(includeInstance?: boolean): EnumReservedRange.AsObject;
   462          static toObject(includeInstance: boolean, msg: EnumReservedRange): EnumReservedRange.AsObject;
   463          static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   464          static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   465          static serializeBinaryToWriter(message: EnumReservedRange, writer: jspb.BinaryWriter): void;
   466          static deserializeBinary(bytes: Uint8Array): EnumReservedRange;
   467          static deserializeBinaryFromReader(message: EnumReservedRange, reader: jspb.BinaryReader): EnumReservedRange;
   468      }
   469  
   470      export namespace EnumReservedRange {
   471          export type AsObject = {
   472              start?: number,
   473              end?: number,
   474          }
   475      }
   476  
   477  }
   478  
   479  export class EnumValueDescriptorProto extends jspb.Message { 
   480  
   481      hasName(): boolean;
   482      clearName(): void;
   483      getName(): string | undefined;
   484      setName(value: string): EnumValueDescriptorProto;
   485  
   486      hasNumber(): boolean;
   487      clearNumber(): void;
   488      getNumber(): number | undefined;
   489      setNumber(value: number): EnumValueDescriptorProto;
   490  
   491      hasOptions(): boolean;
   492      clearOptions(): void;
   493      getOptions(): EnumValueOptions | undefined;
   494      setOptions(value?: EnumValueOptions): EnumValueDescriptorProto;
   495  
   496      serializeBinary(): Uint8Array;
   497      toObject(includeInstance?: boolean): EnumValueDescriptorProto.AsObject;
   498      static toObject(includeInstance: boolean, msg: EnumValueDescriptorProto): EnumValueDescriptorProto.AsObject;
   499      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   500      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   501      static serializeBinaryToWriter(message: EnumValueDescriptorProto, writer: jspb.BinaryWriter): void;
   502      static deserializeBinary(bytes: Uint8Array): EnumValueDescriptorProto;
   503      static deserializeBinaryFromReader(message: EnumValueDescriptorProto, reader: jspb.BinaryReader): EnumValueDescriptorProto;
   504  }
   505  
   506  export namespace EnumValueDescriptorProto {
   507      export type AsObject = {
   508          name?: string,
   509          number?: number,
   510          options?: EnumValueOptions.AsObject,
   511      }
   512  }
   513  
   514  export class ServiceDescriptorProto extends jspb.Message { 
   515  
   516      hasName(): boolean;
   517      clearName(): void;
   518      getName(): string | undefined;
   519      setName(value: string): ServiceDescriptorProto;
   520      clearMethodList(): void;
   521      getMethodList(): Array<MethodDescriptorProto>;
   522      setMethodList(value: Array<MethodDescriptorProto>): ServiceDescriptorProto;
   523      addMethod(value?: MethodDescriptorProto, index?: number): MethodDescriptorProto;
   524  
   525      hasOptions(): boolean;
   526      clearOptions(): void;
   527      getOptions(): ServiceOptions | undefined;
   528      setOptions(value?: ServiceOptions): ServiceDescriptorProto;
   529  
   530      serializeBinary(): Uint8Array;
   531      toObject(includeInstance?: boolean): ServiceDescriptorProto.AsObject;
   532      static toObject(includeInstance: boolean, msg: ServiceDescriptorProto): ServiceDescriptorProto.AsObject;
   533      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   534      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   535      static serializeBinaryToWriter(message: ServiceDescriptorProto, writer: jspb.BinaryWriter): void;
   536      static deserializeBinary(bytes: Uint8Array): ServiceDescriptorProto;
   537      static deserializeBinaryFromReader(message: ServiceDescriptorProto, reader: jspb.BinaryReader): ServiceDescriptorProto;
   538  }
   539  
   540  export namespace ServiceDescriptorProto {
   541      export type AsObject = {
   542          name?: string,
   543          methodList: Array<MethodDescriptorProto.AsObject>,
   544          options?: ServiceOptions.AsObject,
   545      }
   546  }
   547  
   548  export class MethodDescriptorProto extends jspb.Message { 
   549  
   550      hasName(): boolean;
   551      clearName(): void;
   552      getName(): string | undefined;
   553      setName(value: string): MethodDescriptorProto;
   554  
   555      hasInputType(): boolean;
   556      clearInputType(): void;
   557      getInputType(): string | undefined;
   558      setInputType(value: string): MethodDescriptorProto;
   559  
   560      hasOutputType(): boolean;
   561      clearOutputType(): void;
   562      getOutputType(): string | undefined;
   563      setOutputType(value: string): MethodDescriptorProto;
   564  
   565      hasOptions(): boolean;
   566      clearOptions(): void;
   567      getOptions(): MethodOptions | undefined;
   568      setOptions(value?: MethodOptions): MethodDescriptorProto;
   569  
   570      hasClientStreaming(): boolean;
   571      clearClientStreaming(): void;
   572      getClientStreaming(): boolean | undefined;
   573      setClientStreaming(value: boolean): MethodDescriptorProto;
   574  
   575      hasServerStreaming(): boolean;
   576      clearServerStreaming(): void;
   577      getServerStreaming(): boolean | undefined;
   578      setServerStreaming(value: boolean): MethodDescriptorProto;
   579  
   580      serializeBinary(): Uint8Array;
   581      toObject(includeInstance?: boolean): MethodDescriptorProto.AsObject;
   582      static toObject(includeInstance: boolean, msg: MethodDescriptorProto): MethodDescriptorProto.AsObject;
   583      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   584      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   585      static serializeBinaryToWriter(message: MethodDescriptorProto, writer: jspb.BinaryWriter): void;
   586      static deserializeBinary(bytes: Uint8Array): MethodDescriptorProto;
   587      static deserializeBinaryFromReader(message: MethodDescriptorProto, reader: jspb.BinaryReader): MethodDescriptorProto;
   588  }
   589  
   590  export namespace MethodDescriptorProto {
   591      export type AsObject = {
   592          name?: string,
   593          inputType?: string,
   594          outputType?: string,
   595          options?: MethodOptions.AsObject,
   596          clientStreaming?: boolean,
   597          serverStreaming?: boolean,
   598      }
   599  }
   600  
   601  export class FileOptions extends jspb.Message { 
   602  
   603      hasJavaPackage(): boolean;
   604      clearJavaPackage(): void;
   605      getJavaPackage(): string | undefined;
   606      setJavaPackage(value: string): FileOptions;
   607  
   608      hasJavaOuterClassname(): boolean;
   609      clearJavaOuterClassname(): void;
   610      getJavaOuterClassname(): string | undefined;
   611      setJavaOuterClassname(value: string): FileOptions;
   612  
   613      hasJavaMultipleFiles(): boolean;
   614      clearJavaMultipleFiles(): void;
   615      getJavaMultipleFiles(): boolean | undefined;
   616      setJavaMultipleFiles(value: boolean): FileOptions;
   617  
   618      hasJavaGenerateEqualsAndHash(): boolean;
   619      clearJavaGenerateEqualsAndHash(): void;
   620      getJavaGenerateEqualsAndHash(): boolean | undefined;
   621      setJavaGenerateEqualsAndHash(value: boolean): FileOptions;
   622  
   623      hasJavaStringCheckUtf8(): boolean;
   624      clearJavaStringCheckUtf8(): void;
   625      getJavaStringCheckUtf8(): boolean | undefined;
   626      setJavaStringCheckUtf8(value: boolean): FileOptions;
   627  
   628      hasOptimizeFor(): boolean;
   629      clearOptimizeFor(): void;
   630      getOptimizeFor(): FileOptions.OptimizeMode | undefined;
   631      setOptimizeFor(value: FileOptions.OptimizeMode): FileOptions;
   632  
   633      hasGoPackage(): boolean;
   634      clearGoPackage(): void;
   635      getGoPackage(): string | undefined;
   636      setGoPackage(value: string): FileOptions;
   637  
   638      hasCcGenericServices(): boolean;
   639      clearCcGenericServices(): void;
   640      getCcGenericServices(): boolean | undefined;
   641      setCcGenericServices(value: boolean): FileOptions;
   642  
   643      hasJavaGenericServices(): boolean;
   644      clearJavaGenericServices(): void;
   645      getJavaGenericServices(): boolean | undefined;
   646      setJavaGenericServices(value: boolean): FileOptions;
   647  
   648      hasPyGenericServices(): boolean;
   649      clearPyGenericServices(): void;
   650      getPyGenericServices(): boolean | undefined;
   651      setPyGenericServices(value: boolean): FileOptions;
   652  
   653      hasPhpGenericServices(): boolean;
   654      clearPhpGenericServices(): void;
   655      getPhpGenericServices(): boolean | undefined;
   656      setPhpGenericServices(value: boolean): FileOptions;
   657  
   658      hasDeprecated(): boolean;
   659      clearDeprecated(): void;
   660      getDeprecated(): boolean | undefined;
   661      setDeprecated(value: boolean): FileOptions;
   662  
   663      hasCcEnableArenas(): boolean;
   664      clearCcEnableArenas(): void;
   665      getCcEnableArenas(): boolean | undefined;
   666      setCcEnableArenas(value: boolean): FileOptions;
   667  
   668      hasObjcClassPrefix(): boolean;
   669      clearObjcClassPrefix(): void;
   670      getObjcClassPrefix(): string | undefined;
   671      setObjcClassPrefix(value: string): FileOptions;
   672  
   673      hasCsharpNamespace(): boolean;
   674      clearCsharpNamespace(): void;
   675      getCsharpNamespace(): string | undefined;
   676      setCsharpNamespace(value: string): FileOptions;
   677  
   678      hasSwiftPrefix(): boolean;
   679      clearSwiftPrefix(): void;
   680      getSwiftPrefix(): string | undefined;
   681      setSwiftPrefix(value: string): FileOptions;
   682  
   683      hasPhpClassPrefix(): boolean;
   684      clearPhpClassPrefix(): void;
   685      getPhpClassPrefix(): string | undefined;
   686      setPhpClassPrefix(value: string): FileOptions;
   687  
   688      hasPhpNamespace(): boolean;
   689      clearPhpNamespace(): void;
   690      getPhpNamespace(): string | undefined;
   691      setPhpNamespace(value: string): FileOptions;
   692  
   693      hasPhpMetadataNamespace(): boolean;
   694      clearPhpMetadataNamespace(): void;
   695      getPhpMetadataNamespace(): string | undefined;
   696      setPhpMetadataNamespace(value: string): FileOptions;
   697  
   698      hasRubyPackage(): boolean;
   699      clearRubyPackage(): void;
   700      getRubyPackage(): string | undefined;
   701      setRubyPackage(value: string): FileOptions;
   702      clearUninterpretedOptionList(): void;
   703      getUninterpretedOptionList(): Array<UninterpretedOption>;
   704      setUninterpretedOptionList(value: Array<UninterpretedOption>): FileOptions;
   705      addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
   706  
   707      serializeBinary(): Uint8Array;
   708      toObject(includeInstance?: boolean): FileOptions.AsObject;
   709      static toObject(includeInstance: boolean, msg: FileOptions): FileOptions.AsObject;
   710      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   711      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   712      static serializeBinaryToWriter(message: FileOptions, writer: jspb.BinaryWriter): void;
   713      static deserializeBinary(bytes: Uint8Array): FileOptions;
   714      static deserializeBinaryFromReader(message: FileOptions, reader: jspb.BinaryReader): FileOptions;
   715  }
   716  
   717  export namespace FileOptions {
   718      export type AsObject = {
   719          javaPackage?: string,
   720          javaOuterClassname?: string,
   721          javaMultipleFiles?: boolean,
   722          javaGenerateEqualsAndHash?: boolean,
   723          javaStringCheckUtf8?: boolean,
   724          optimizeFor?: FileOptions.OptimizeMode,
   725          goPackage?: string,
   726          ccGenericServices?: boolean,
   727          javaGenericServices?: boolean,
   728          pyGenericServices?: boolean,
   729          phpGenericServices?: boolean,
   730          deprecated?: boolean,
   731          ccEnableArenas?: boolean,
   732          objcClassPrefix?: string,
   733          csharpNamespace?: string,
   734          swiftPrefix?: string,
   735          phpClassPrefix?: string,
   736          phpNamespace?: string,
   737          phpMetadataNamespace?: string,
   738          rubyPackage?: string,
   739          uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
   740      }
   741  
   742      export enum OptimizeMode {
   743      SPEED = 1,
   744      CODE_SIZE = 2,
   745      LITE_RUNTIME = 3,
   746      }
   747  
   748  }
   749  
   750  export class MessageOptions extends jspb.Message { 
   751  
   752      hasMessageSetWireFormat(): boolean;
   753      clearMessageSetWireFormat(): void;
   754      getMessageSetWireFormat(): boolean | undefined;
   755      setMessageSetWireFormat(value: boolean): MessageOptions;
   756  
   757      hasNoStandardDescriptorAccessor(): boolean;
   758      clearNoStandardDescriptorAccessor(): void;
   759      getNoStandardDescriptorAccessor(): boolean | undefined;
   760      setNoStandardDescriptorAccessor(value: boolean): MessageOptions;
   761  
   762      hasDeprecated(): boolean;
   763      clearDeprecated(): void;
   764      getDeprecated(): boolean | undefined;
   765      setDeprecated(value: boolean): MessageOptions;
   766  
   767      hasMapEntry(): boolean;
   768      clearMapEntry(): void;
   769      getMapEntry(): boolean | undefined;
   770      setMapEntry(value: boolean): MessageOptions;
   771      clearUninterpretedOptionList(): void;
   772      getUninterpretedOptionList(): Array<UninterpretedOption>;
   773      setUninterpretedOptionList(value: Array<UninterpretedOption>): MessageOptions;
   774      addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
   775  
   776      serializeBinary(): Uint8Array;
   777      toObject(includeInstance?: boolean): MessageOptions.AsObject;
   778      static toObject(includeInstance: boolean, msg: MessageOptions): MessageOptions.AsObject;
   779      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   780      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   781      static serializeBinaryToWriter(message: MessageOptions, writer: jspb.BinaryWriter): void;
   782      static deserializeBinary(bytes: Uint8Array): MessageOptions;
   783      static deserializeBinaryFromReader(message: MessageOptions, reader: jspb.BinaryReader): MessageOptions;
   784  }
   785  
   786  export namespace MessageOptions {
   787      export type AsObject = {
   788          messageSetWireFormat?: boolean,
   789          noStandardDescriptorAccessor?: boolean,
   790          deprecated?: boolean,
   791          mapEntry?: boolean,
   792          uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
   793      }
   794  }
   795  
   796  export class FieldOptions extends jspb.Message { 
   797  
   798      hasCtype(): boolean;
   799      clearCtype(): void;
   800      getCtype(): FieldOptions.CType | undefined;
   801      setCtype(value: FieldOptions.CType): FieldOptions;
   802  
   803      hasPacked(): boolean;
   804      clearPacked(): void;
   805      getPacked(): boolean | undefined;
   806      setPacked(value: boolean): FieldOptions;
   807  
   808      hasJstype(): boolean;
   809      clearJstype(): void;
   810      getJstype(): FieldOptions.JSType | undefined;
   811      setJstype(value: FieldOptions.JSType): FieldOptions;
   812  
   813      hasLazy(): boolean;
   814      clearLazy(): void;
   815      getLazy(): boolean | undefined;
   816      setLazy(value: boolean): FieldOptions;
   817  
   818      hasDeprecated(): boolean;
   819      clearDeprecated(): void;
   820      getDeprecated(): boolean | undefined;
   821      setDeprecated(value: boolean): FieldOptions;
   822  
   823      hasWeak(): boolean;
   824      clearWeak(): void;
   825      getWeak(): boolean | undefined;
   826      setWeak(value: boolean): FieldOptions;
   827      clearUninterpretedOptionList(): void;
   828      getUninterpretedOptionList(): Array<UninterpretedOption>;
   829      setUninterpretedOptionList(value: Array<UninterpretedOption>): FieldOptions;
   830      addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
   831  
   832      serializeBinary(): Uint8Array;
   833      toObject(includeInstance?: boolean): FieldOptions.AsObject;
   834      static toObject(includeInstance: boolean, msg: FieldOptions): FieldOptions.AsObject;
   835      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   836      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   837      static serializeBinaryToWriter(message: FieldOptions, writer: jspb.BinaryWriter): void;
   838      static deserializeBinary(bytes: Uint8Array): FieldOptions;
   839      static deserializeBinaryFromReader(message: FieldOptions, reader: jspb.BinaryReader): FieldOptions;
   840  }
   841  
   842  export namespace FieldOptions {
   843      export type AsObject = {
   844          ctype?: FieldOptions.CType,
   845          packed?: boolean,
   846          jstype?: FieldOptions.JSType,
   847          lazy?: boolean,
   848          deprecated?: boolean,
   849          weak?: boolean,
   850          uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
   851      }
   852  
   853      export enum CType {
   854      STRING = 0,
   855      CORD = 1,
   856      STRING_PIECE = 2,
   857      }
   858  
   859      export enum JSType {
   860      JS_NORMAL = 0,
   861      JS_STRING = 1,
   862      JS_NUMBER = 2,
   863      }
   864  
   865  }
   866  
   867  export class OneofOptions extends jspb.Message { 
   868      clearUninterpretedOptionList(): void;
   869      getUninterpretedOptionList(): Array<UninterpretedOption>;
   870      setUninterpretedOptionList(value: Array<UninterpretedOption>): OneofOptions;
   871      addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
   872  
   873      serializeBinary(): Uint8Array;
   874      toObject(includeInstance?: boolean): OneofOptions.AsObject;
   875      static toObject(includeInstance: boolean, msg: OneofOptions): OneofOptions.AsObject;
   876      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   877      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   878      static serializeBinaryToWriter(message: OneofOptions, writer: jspb.BinaryWriter): void;
   879      static deserializeBinary(bytes: Uint8Array): OneofOptions;
   880      static deserializeBinaryFromReader(message: OneofOptions, reader: jspb.BinaryReader): OneofOptions;
   881  }
   882  
   883  export namespace OneofOptions {
   884      export type AsObject = {
   885          uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
   886      }
   887  }
   888  
   889  export class EnumOptions extends jspb.Message { 
   890  
   891      hasAllowAlias(): boolean;
   892      clearAllowAlias(): void;
   893      getAllowAlias(): boolean | undefined;
   894      setAllowAlias(value: boolean): EnumOptions;
   895  
   896      hasDeprecated(): boolean;
   897      clearDeprecated(): void;
   898      getDeprecated(): boolean | undefined;
   899      setDeprecated(value: boolean): EnumOptions;
   900      clearUninterpretedOptionList(): void;
   901      getUninterpretedOptionList(): Array<UninterpretedOption>;
   902      setUninterpretedOptionList(value: Array<UninterpretedOption>): EnumOptions;
   903      addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
   904  
   905      serializeBinary(): Uint8Array;
   906      toObject(includeInstance?: boolean): EnumOptions.AsObject;
   907      static toObject(includeInstance: boolean, msg: EnumOptions): EnumOptions.AsObject;
   908      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   909      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   910      static serializeBinaryToWriter(message: EnumOptions, writer: jspb.BinaryWriter): void;
   911      static deserializeBinary(bytes: Uint8Array): EnumOptions;
   912      static deserializeBinaryFromReader(message: EnumOptions, reader: jspb.BinaryReader): EnumOptions;
   913  }
   914  
   915  export namespace EnumOptions {
   916      export type AsObject = {
   917          allowAlias?: boolean,
   918          deprecated?: boolean,
   919          uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
   920      }
   921  }
   922  
   923  export class EnumValueOptions extends jspb.Message { 
   924  
   925      hasDeprecated(): boolean;
   926      clearDeprecated(): void;
   927      getDeprecated(): boolean | undefined;
   928      setDeprecated(value: boolean): EnumValueOptions;
   929      clearUninterpretedOptionList(): void;
   930      getUninterpretedOptionList(): Array<UninterpretedOption>;
   931      setUninterpretedOptionList(value: Array<UninterpretedOption>): EnumValueOptions;
   932      addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
   933  
   934      serializeBinary(): Uint8Array;
   935      toObject(includeInstance?: boolean): EnumValueOptions.AsObject;
   936      static toObject(includeInstance: boolean, msg: EnumValueOptions): EnumValueOptions.AsObject;
   937      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   938      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   939      static serializeBinaryToWriter(message: EnumValueOptions, writer: jspb.BinaryWriter): void;
   940      static deserializeBinary(bytes: Uint8Array): EnumValueOptions;
   941      static deserializeBinaryFromReader(message: EnumValueOptions, reader: jspb.BinaryReader): EnumValueOptions;
   942  }
   943  
   944  export namespace EnumValueOptions {
   945      export type AsObject = {
   946          deprecated?: boolean,
   947          uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
   948      }
   949  }
   950  
   951  export class ServiceOptions extends jspb.Message { 
   952  
   953      hasDeprecated(): boolean;
   954      clearDeprecated(): void;
   955      getDeprecated(): boolean | undefined;
   956      setDeprecated(value: boolean): ServiceOptions;
   957      clearUninterpretedOptionList(): void;
   958      getUninterpretedOptionList(): Array<UninterpretedOption>;
   959      setUninterpretedOptionList(value: Array<UninterpretedOption>): ServiceOptions;
   960      addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
   961  
   962      serializeBinary(): Uint8Array;
   963      toObject(includeInstance?: boolean): ServiceOptions.AsObject;
   964      static toObject(includeInstance: boolean, msg: ServiceOptions): ServiceOptions.AsObject;
   965      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   966      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   967      static serializeBinaryToWriter(message: ServiceOptions, writer: jspb.BinaryWriter): void;
   968      static deserializeBinary(bytes: Uint8Array): ServiceOptions;
   969      static deserializeBinaryFromReader(message: ServiceOptions, reader: jspb.BinaryReader): ServiceOptions;
   970  }
   971  
   972  export namespace ServiceOptions {
   973      export type AsObject = {
   974          deprecated?: boolean,
   975          uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
   976      }
   977  }
   978  
   979  export class MethodOptions extends jspb.Message { 
   980  
   981      hasDeprecated(): boolean;
   982      clearDeprecated(): void;
   983      getDeprecated(): boolean | undefined;
   984      setDeprecated(value: boolean): MethodOptions;
   985  
   986      hasIdempotencyLevel(): boolean;
   987      clearIdempotencyLevel(): void;
   988      getIdempotencyLevel(): MethodOptions.IdempotencyLevel | undefined;
   989      setIdempotencyLevel(value: MethodOptions.IdempotencyLevel): MethodOptions;
   990      clearUninterpretedOptionList(): void;
   991      getUninterpretedOptionList(): Array<UninterpretedOption>;
   992      setUninterpretedOptionList(value: Array<UninterpretedOption>): MethodOptions;
   993      addUninterpretedOption(value?: UninterpretedOption, index?: number): UninterpretedOption;
   994  
   995      serializeBinary(): Uint8Array;
   996      toObject(includeInstance?: boolean): MethodOptions.AsObject;
   997      static toObject(includeInstance: boolean, msg: MethodOptions): MethodOptions.AsObject;
   998      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   999      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  1000      static serializeBinaryToWriter(message: MethodOptions, writer: jspb.BinaryWriter): void;
  1001      static deserializeBinary(bytes: Uint8Array): MethodOptions;
  1002      static deserializeBinaryFromReader(message: MethodOptions, reader: jspb.BinaryReader): MethodOptions;
  1003  }
  1004  
  1005  export namespace MethodOptions {
  1006      export type AsObject = {
  1007          deprecated?: boolean,
  1008          idempotencyLevel?: MethodOptions.IdempotencyLevel,
  1009          uninterpretedOptionList: Array<UninterpretedOption.AsObject>,
  1010      }
  1011  
  1012      export enum IdempotencyLevel {
  1013      IDEMPOTENCY_UNKNOWN = 0,
  1014      NO_SIDE_EFFECTS = 1,
  1015      IDEMPOTENT = 2,
  1016      }
  1017  
  1018  }
  1019  
  1020  export class UninterpretedOption extends jspb.Message { 
  1021      clearNameList(): void;
  1022      getNameList(): Array<UninterpretedOption.NamePart>;
  1023      setNameList(value: Array<UninterpretedOption.NamePart>): UninterpretedOption;
  1024      addName(value?: UninterpretedOption.NamePart, index?: number): UninterpretedOption.NamePart;
  1025  
  1026      hasIdentifierValue(): boolean;
  1027      clearIdentifierValue(): void;
  1028      getIdentifierValue(): string | undefined;
  1029      setIdentifierValue(value: string): UninterpretedOption;
  1030  
  1031      hasPositiveIntValue(): boolean;
  1032      clearPositiveIntValue(): void;
  1033      getPositiveIntValue(): number | undefined;
  1034      setPositiveIntValue(value: number): UninterpretedOption;
  1035  
  1036      hasNegativeIntValue(): boolean;
  1037      clearNegativeIntValue(): void;
  1038      getNegativeIntValue(): number | undefined;
  1039      setNegativeIntValue(value: number): UninterpretedOption;
  1040  
  1041      hasDoubleValue(): boolean;
  1042      clearDoubleValue(): void;
  1043      getDoubleValue(): number | undefined;
  1044      setDoubleValue(value: number): UninterpretedOption;
  1045  
  1046      hasStringValue(): boolean;
  1047      clearStringValue(): void;
  1048      getStringValue(): Uint8Array | string;
  1049      getStringValue_asU8(): Uint8Array;
  1050      getStringValue_asB64(): string;
  1051      setStringValue(value: Uint8Array | string): UninterpretedOption;
  1052  
  1053      hasAggregateValue(): boolean;
  1054      clearAggregateValue(): void;
  1055      getAggregateValue(): string | undefined;
  1056      setAggregateValue(value: string): UninterpretedOption;
  1057  
  1058      serializeBinary(): Uint8Array;
  1059      toObject(includeInstance?: boolean): UninterpretedOption.AsObject;
  1060      static toObject(includeInstance: boolean, msg: UninterpretedOption): UninterpretedOption.AsObject;
  1061      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  1062      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  1063      static serializeBinaryToWriter(message: UninterpretedOption, writer: jspb.BinaryWriter): void;
  1064      static deserializeBinary(bytes: Uint8Array): UninterpretedOption;
  1065      static deserializeBinaryFromReader(message: UninterpretedOption, reader: jspb.BinaryReader): UninterpretedOption;
  1066  }
  1067  
  1068  export namespace UninterpretedOption {
  1069      export type AsObject = {
  1070          nameList: Array<UninterpretedOption.NamePart.AsObject>,
  1071          identifierValue?: string,
  1072          positiveIntValue?: number,
  1073          negativeIntValue?: number,
  1074          doubleValue?: number,
  1075          stringValue: Uint8Array | string,
  1076          aggregateValue?: string,
  1077      }
  1078  
  1079  
  1080      export class NamePart extends jspb.Message { 
  1081  
  1082          hasNamePart(): boolean;
  1083          clearNamePart(): void;
  1084          getNamePart(): string | undefined;
  1085          setNamePart(value: string): NamePart;
  1086  
  1087          hasIsExtension(): boolean;
  1088          clearIsExtension(): void;
  1089          getIsExtension(): boolean | undefined;
  1090          setIsExtension(value: boolean): NamePart;
  1091  
  1092          serializeBinary(): Uint8Array;
  1093          toObject(includeInstance?: boolean): NamePart.AsObject;
  1094          static toObject(includeInstance: boolean, msg: NamePart): NamePart.AsObject;
  1095          static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  1096          static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  1097          static serializeBinaryToWriter(message: NamePart, writer: jspb.BinaryWriter): void;
  1098          static deserializeBinary(bytes: Uint8Array): NamePart;
  1099          static deserializeBinaryFromReader(message: NamePart, reader: jspb.BinaryReader): NamePart;
  1100      }
  1101  
  1102      export namespace NamePart {
  1103          export type AsObject = {
  1104              namePart?: string,
  1105              isExtension?: boolean,
  1106          }
  1107      }
  1108  
  1109  }
  1110  
  1111  export class SourceCodeInfo extends jspb.Message { 
  1112      clearLocationList(): void;
  1113      getLocationList(): Array<SourceCodeInfo.Location>;
  1114      setLocationList(value: Array<SourceCodeInfo.Location>): SourceCodeInfo;
  1115      addLocation(value?: SourceCodeInfo.Location, index?: number): SourceCodeInfo.Location;
  1116  
  1117      serializeBinary(): Uint8Array;
  1118      toObject(includeInstance?: boolean): SourceCodeInfo.AsObject;
  1119      static toObject(includeInstance: boolean, msg: SourceCodeInfo): SourceCodeInfo.AsObject;
  1120      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  1121      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  1122      static serializeBinaryToWriter(message: SourceCodeInfo, writer: jspb.BinaryWriter): void;
  1123      static deserializeBinary(bytes: Uint8Array): SourceCodeInfo;
  1124      static deserializeBinaryFromReader(message: SourceCodeInfo, reader: jspb.BinaryReader): SourceCodeInfo;
  1125  }
  1126  
  1127  export namespace SourceCodeInfo {
  1128      export type AsObject = {
  1129          locationList: Array<SourceCodeInfo.Location.AsObject>,
  1130      }
  1131  
  1132  
  1133      export class Location extends jspb.Message { 
  1134          clearPathList(): void;
  1135          getPathList(): Array<number>;
  1136          setPathList(value: Array<number>): Location;
  1137          addPath(value: number, index?: number): number;
  1138          clearSpanList(): void;
  1139          getSpanList(): Array<number>;
  1140          setSpanList(value: Array<number>): Location;
  1141          addSpan(value: number, index?: number): number;
  1142  
  1143          hasLeadingComments(): boolean;
  1144          clearLeadingComments(): void;
  1145          getLeadingComments(): string | undefined;
  1146          setLeadingComments(value: string): Location;
  1147  
  1148          hasTrailingComments(): boolean;
  1149          clearTrailingComments(): void;
  1150          getTrailingComments(): string | undefined;
  1151          setTrailingComments(value: string): Location;
  1152          clearLeadingDetachedCommentsList(): void;
  1153          getLeadingDetachedCommentsList(): Array<string>;
  1154          setLeadingDetachedCommentsList(value: Array<string>): Location;
  1155          addLeadingDetachedComments(value: string, index?: number): string;
  1156  
  1157          serializeBinary(): Uint8Array;
  1158          toObject(includeInstance?: boolean): Location.AsObject;
  1159          static toObject(includeInstance: boolean, msg: Location): Location.AsObject;
  1160          static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  1161          static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  1162          static serializeBinaryToWriter(message: Location, writer: jspb.BinaryWriter): void;
  1163          static deserializeBinary(bytes: Uint8Array): Location;
  1164          static deserializeBinaryFromReader(message: Location, reader: jspb.BinaryReader): Location;
  1165      }
  1166  
  1167      export namespace Location {
  1168          export type AsObject = {
  1169              pathList: Array<number>,
  1170              spanList: Array<number>,
  1171              leadingComments?: string,
  1172              trailingComments?: string,
  1173              leadingDetachedCommentsList: Array<string>,
  1174          }
  1175      }
  1176  
  1177  }
  1178  
  1179  export class GeneratedCodeInfo extends jspb.Message { 
  1180      clearAnnotationList(): void;
  1181      getAnnotationList(): Array<GeneratedCodeInfo.Annotation>;
  1182      setAnnotationList(value: Array<GeneratedCodeInfo.Annotation>): GeneratedCodeInfo;
  1183      addAnnotation(value?: GeneratedCodeInfo.Annotation, index?: number): GeneratedCodeInfo.Annotation;
  1184  
  1185      serializeBinary(): Uint8Array;
  1186      toObject(includeInstance?: boolean): GeneratedCodeInfo.AsObject;
  1187      static toObject(includeInstance: boolean, msg: GeneratedCodeInfo): GeneratedCodeInfo.AsObject;
  1188      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  1189      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  1190      static serializeBinaryToWriter(message: GeneratedCodeInfo, writer: jspb.BinaryWriter): void;
  1191      static deserializeBinary(bytes: Uint8Array): GeneratedCodeInfo;
  1192      static deserializeBinaryFromReader(message: GeneratedCodeInfo, reader: jspb.BinaryReader): GeneratedCodeInfo;
  1193  }
  1194  
  1195  export namespace GeneratedCodeInfo {
  1196      export type AsObject = {
  1197          annotationList: Array<GeneratedCodeInfo.Annotation.AsObject>,
  1198      }
  1199  
  1200  
  1201      export class Annotation extends jspb.Message { 
  1202          clearPathList(): void;
  1203          getPathList(): Array<number>;
  1204          setPathList(value: Array<number>): Annotation;
  1205          addPath(value: number, index?: number): number;
  1206  
  1207          hasSourceFile(): boolean;
  1208          clearSourceFile(): void;
  1209          getSourceFile(): string | undefined;
  1210          setSourceFile(value: string): Annotation;
  1211  
  1212          hasBegin(): boolean;
  1213          clearBegin(): void;
  1214          getBegin(): number | undefined;
  1215          setBegin(value: number): Annotation;
  1216  
  1217          hasEnd(): boolean;
  1218          clearEnd(): void;
  1219          getEnd(): number | undefined;
  1220          setEnd(value: number): Annotation;
  1221  
  1222          serializeBinary(): Uint8Array;
  1223          toObject(includeInstance?: boolean): Annotation.AsObject;
  1224          static toObject(includeInstance: boolean, msg: Annotation): Annotation.AsObject;
  1225          static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  1226          static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  1227          static serializeBinaryToWriter(message: Annotation, writer: jspb.BinaryWriter): void;
  1228          static deserializeBinary(bytes: Uint8Array): Annotation;
  1229          static deserializeBinaryFromReader(message: Annotation, reader: jspb.BinaryReader): Annotation;
  1230      }
  1231  
  1232      export namespace Annotation {
  1233          export type AsObject = {
  1234              pathList: Array<number>,
  1235              sourceFile?: string,
  1236              begin?: number,
  1237              end?: number,
  1238          }
  1239      }
  1240  
  1241  }