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

     1  // package: keys
     2  // file: keys.proto
     3  
     4  /* tslint:disable */
     5  /* eslint-disable */
     6  
     7  import * as jspb from "google-protobuf";
     8  import * as gogoproto_gogo_pb from "./gogoproto/gogo_pb";
     9  import * as crypto_pb from "./crypto_pb";
    10  
    11  export class ListRequest extends jspb.Message { 
    12      getKeyname(): string;
    13      setKeyname(value: string): ListRequest;
    14  
    15      serializeBinary(): Uint8Array;
    16      toObject(includeInstance?: boolean): ListRequest.AsObject;
    17      static toObject(includeInstance: boolean, msg: ListRequest): ListRequest.AsObject;
    18      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    19      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    20      static serializeBinaryToWriter(message: ListRequest, writer: jspb.BinaryWriter): void;
    21      static deserializeBinary(bytes: Uint8Array): ListRequest;
    22      static deserializeBinaryFromReader(message: ListRequest, reader: jspb.BinaryReader): ListRequest;
    23  }
    24  
    25  export namespace ListRequest {
    26      export type AsObject = {
    27          keyname: string,
    28      }
    29  }
    30  
    31  export class VerifyResponse extends jspb.Message { 
    32  
    33      serializeBinary(): Uint8Array;
    34      toObject(includeInstance?: boolean): VerifyResponse.AsObject;
    35      static toObject(includeInstance: boolean, msg: VerifyResponse): VerifyResponse.AsObject;
    36      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    37      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    38      static serializeBinaryToWriter(message: VerifyResponse, writer: jspb.BinaryWriter): void;
    39      static deserializeBinary(bytes: Uint8Array): VerifyResponse;
    40      static deserializeBinaryFromReader(message: VerifyResponse, reader: jspb.BinaryReader): VerifyResponse;
    41  }
    42  
    43  export namespace VerifyResponse {
    44      export type AsObject = {
    45      }
    46  }
    47  
    48  export class RemoveNameResponse extends jspb.Message { 
    49  
    50      serializeBinary(): Uint8Array;
    51      toObject(includeInstance?: boolean): RemoveNameResponse.AsObject;
    52      static toObject(includeInstance: boolean, msg: RemoveNameResponse): RemoveNameResponse.AsObject;
    53      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    54      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    55      static serializeBinaryToWriter(message: RemoveNameResponse, writer: jspb.BinaryWriter): void;
    56      static deserializeBinary(bytes: Uint8Array): RemoveNameResponse;
    57      static deserializeBinaryFromReader(message: RemoveNameResponse, reader: jspb.BinaryReader): RemoveNameResponse;
    58  }
    59  
    60  export namespace RemoveNameResponse {
    61      export type AsObject = {
    62      }
    63  }
    64  
    65  export class AddNameResponse extends jspb.Message { 
    66  
    67      serializeBinary(): Uint8Array;
    68      toObject(includeInstance?: boolean): AddNameResponse.AsObject;
    69      static toObject(includeInstance: boolean, msg: AddNameResponse): AddNameResponse.AsObject;
    70      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    71      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    72      static serializeBinaryToWriter(message: AddNameResponse, writer: jspb.BinaryWriter): void;
    73      static deserializeBinary(bytes: Uint8Array): AddNameResponse;
    74      static deserializeBinaryFromReader(message: AddNameResponse, reader: jspb.BinaryReader): AddNameResponse;
    75  }
    76  
    77  export namespace AddNameResponse {
    78      export type AsObject = {
    79      }
    80  }
    81  
    82  export class RemoveNameRequest extends jspb.Message { 
    83      getKeyname(): string;
    84      setKeyname(value: string): RemoveNameRequest;
    85  
    86      serializeBinary(): Uint8Array;
    87      toObject(includeInstance?: boolean): RemoveNameRequest.AsObject;
    88      static toObject(includeInstance: boolean, msg: RemoveNameRequest): RemoveNameRequest.AsObject;
    89      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    90      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    91      static serializeBinaryToWriter(message: RemoveNameRequest, writer: jspb.BinaryWriter): void;
    92      static deserializeBinary(bytes: Uint8Array): RemoveNameRequest;
    93      static deserializeBinaryFromReader(message: RemoveNameRequest, reader: jspb.BinaryReader): RemoveNameRequest;
    94  }
    95  
    96  export namespace RemoveNameRequest {
    97      export type AsObject = {
    98          keyname: string,
    99      }
   100  }
   101  
   102  export class GenRequest extends jspb.Message { 
   103      getPassphrase(): string;
   104      setPassphrase(value: string): GenRequest;
   105      getCurvetype(): string;
   106      setCurvetype(value: string): GenRequest;
   107      getKeyname(): string;
   108      setKeyname(value: string): GenRequest;
   109  
   110      serializeBinary(): Uint8Array;
   111      toObject(includeInstance?: boolean): GenRequest.AsObject;
   112      static toObject(includeInstance: boolean, msg: GenRequest): GenRequest.AsObject;
   113      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   114      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   115      static serializeBinaryToWriter(message: GenRequest, writer: jspb.BinaryWriter): void;
   116      static deserializeBinary(bytes: Uint8Array): GenRequest;
   117      static deserializeBinaryFromReader(message: GenRequest, reader: jspb.BinaryReader): GenRequest;
   118  }
   119  
   120  export namespace GenRequest {
   121      export type AsObject = {
   122          passphrase: string,
   123          curvetype: string,
   124          keyname: string,
   125      }
   126  }
   127  
   128  export class GenResponse extends jspb.Message { 
   129      getAddress(): string;
   130      setAddress(value: string): GenResponse;
   131  
   132      serializeBinary(): Uint8Array;
   133      toObject(includeInstance?: boolean): GenResponse.AsObject;
   134      static toObject(includeInstance: boolean, msg: GenResponse): GenResponse.AsObject;
   135      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   136      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   137      static serializeBinaryToWriter(message: GenResponse, writer: jspb.BinaryWriter): void;
   138      static deserializeBinary(bytes: Uint8Array): GenResponse;
   139      static deserializeBinaryFromReader(message: GenResponse, reader: jspb.BinaryReader): GenResponse;
   140  }
   141  
   142  export namespace GenResponse {
   143      export type AsObject = {
   144          address: string,
   145      }
   146  }
   147  
   148  export class PubRequest extends jspb.Message { 
   149      getAddress(): string;
   150      setAddress(value: string): PubRequest;
   151      getName(): string;
   152      setName(value: string): PubRequest;
   153  
   154      serializeBinary(): Uint8Array;
   155      toObject(includeInstance?: boolean): PubRequest.AsObject;
   156      static toObject(includeInstance: boolean, msg: PubRequest): PubRequest.AsObject;
   157      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   158      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   159      static serializeBinaryToWriter(message: PubRequest, writer: jspb.BinaryWriter): void;
   160      static deserializeBinary(bytes: Uint8Array): PubRequest;
   161      static deserializeBinaryFromReader(message: PubRequest, reader: jspb.BinaryReader): PubRequest;
   162  }
   163  
   164  export namespace PubRequest {
   165      export type AsObject = {
   166          address: string,
   167          name: string,
   168      }
   169  }
   170  
   171  export class PubResponse extends jspb.Message { 
   172      getPublickey(): Uint8Array | string;
   173      getPublickey_asU8(): Uint8Array;
   174      getPublickey_asB64(): string;
   175      setPublickey(value: Uint8Array | string): PubResponse;
   176      getCurvetype(): string;
   177      setCurvetype(value: string): PubResponse;
   178  
   179      serializeBinary(): Uint8Array;
   180      toObject(includeInstance?: boolean): PubResponse.AsObject;
   181      static toObject(includeInstance: boolean, msg: PubResponse): PubResponse.AsObject;
   182      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   183      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   184      static serializeBinaryToWriter(message: PubResponse, writer: jspb.BinaryWriter): void;
   185      static deserializeBinary(bytes: Uint8Array): PubResponse;
   186      static deserializeBinaryFromReader(message: PubResponse, reader: jspb.BinaryReader): PubResponse;
   187  }
   188  
   189  export namespace PubResponse {
   190      export type AsObject = {
   191          publickey: Uint8Array | string,
   192          curvetype: string,
   193      }
   194  }
   195  
   196  export class ImportJSONRequest extends jspb.Message { 
   197      getPassphrase(): string;
   198      setPassphrase(value: string): ImportJSONRequest;
   199      getJson(): string;
   200      setJson(value: string): ImportJSONRequest;
   201  
   202      serializeBinary(): Uint8Array;
   203      toObject(includeInstance?: boolean): ImportJSONRequest.AsObject;
   204      static toObject(includeInstance: boolean, msg: ImportJSONRequest): ImportJSONRequest.AsObject;
   205      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   206      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   207      static serializeBinaryToWriter(message: ImportJSONRequest, writer: jspb.BinaryWriter): void;
   208      static deserializeBinary(bytes: Uint8Array): ImportJSONRequest;
   209      static deserializeBinaryFromReader(message: ImportJSONRequest, reader: jspb.BinaryReader): ImportJSONRequest;
   210  }
   211  
   212  export namespace ImportJSONRequest {
   213      export type AsObject = {
   214          passphrase: string,
   215          json: string,
   216      }
   217  }
   218  
   219  export class ImportResponse extends jspb.Message { 
   220      getAddress(): string;
   221      setAddress(value: string): ImportResponse;
   222  
   223      serializeBinary(): Uint8Array;
   224      toObject(includeInstance?: boolean): ImportResponse.AsObject;
   225      static toObject(includeInstance: boolean, msg: ImportResponse): ImportResponse.AsObject;
   226      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   227      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   228      static serializeBinaryToWriter(message: ImportResponse, writer: jspb.BinaryWriter): void;
   229      static deserializeBinary(bytes: Uint8Array): ImportResponse;
   230      static deserializeBinaryFromReader(message: ImportResponse, reader: jspb.BinaryReader): ImportResponse;
   231  }
   232  
   233  export namespace ImportResponse {
   234      export type AsObject = {
   235          address: string,
   236      }
   237  }
   238  
   239  export class ImportRequest extends jspb.Message { 
   240      getPassphrase(): string;
   241      setPassphrase(value: string): ImportRequest;
   242      getName(): string;
   243      setName(value: string): ImportRequest;
   244      getCurvetype(): string;
   245      setCurvetype(value: string): ImportRequest;
   246      getKeybytes(): Uint8Array | string;
   247      getKeybytes_asU8(): Uint8Array;
   248      getKeybytes_asB64(): string;
   249      setKeybytes(value: Uint8Array | string): ImportRequest;
   250  
   251      serializeBinary(): Uint8Array;
   252      toObject(includeInstance?: boolean): ImportRequest.AsObject;
   253      static toObject(includeInstance: boolean, msg: ImportRequest): ImportRequest.AsObject;
   254      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   255      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   256      static serializeBinaryToWriter(message: ImportRequest, writer: jspb.BinaryWriter): void;
   257      static deserializeBinary(bytes: Uint8Array): ImportRequest;
   258      static deserializeBinaryFromReader(message: ImportRequest, reader: jspb.BinaryReader): ImportRequest;
   259  }
   260  
   261  export namespace ImportRequest {
   262      export type AsObject = {
   263          passphrase: string,
   264          name: string,
   265          curvetype: string,
   266          keybytes: Uint8Array | string,
   267      }
   268  }
   269  
   270  export class ExportRequest extends jspb.Message { 
   271      getPassphrase(): string;
   272      setPassphrase(value: string): ExportRequest;
   273      getName(): string;
   274      setName(value: string): ExportRequest;
   275      getAddress(): string;
   276      setAddress(value: string): ExportRequest;
   277  
   278      serializeBinary(): Uint8Array;
   279      toObject(includeInstance?: boolean): ExportRequest.AsObject;
   280      static toObject(includeInstance: boolean, msg: ExportRequest): ExportRequest.AsObject;
   281      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   282      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   283      static serializeBinaryToWriter(message: ExportRequest, writer: jspb.BinaryWriter): void;
   284      static deserializeBinary(bytes: Uint8Array): ExportRequest;
   285      static deserializeBinaryFromReader(message: ExportRequest, reader: jspb.BinaryReader): ExportRequest;
   286  }
   287  
   288  export namespace ExportRequest {
   289      export type AsObject = {
   290          passphrase: string,
   291          name: string,
   292          address: string,
   293      }
   294  }
   295  
   296  export class ExportResponse extends jspb.Message { 
   297      getPublickey(): Uint8Array | string;
   298      getPublickey_asU8(): Uint8Array;
   299      getPublickey_asB64(): string;
   300      setPublickey(value: Uint8Array | string): ExportResponse;
   301      getPrivatekey(): Uint8Array | string;
   302      getPrivatekey_asU8(): Uint8Array;
   303      getPrivatekey_asB64(): string;
   304      setPrivatekey(value: Uint8Array | string): ExportResponse;
   305      getAddress(): Uint8Array | string;
   306      getAddress_asU8(): Uint8Array;
   307      getAddress_asB64(): string;
   308      setAddress(value: Uint8Array | string): ExportResponse;
   309      getCurvetype(): string;
   310      setCurvetype(value: string): ExportResponse;
   311  
   312      serializeBinary(): Uint8Array;
   313      toObject(includeInstance?: boolean): ExportResponse.AsObject;
   314      static toObject(includeInstance: boolean, msg: ExportResponse): ExportResponse.AsObject;
   315      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   316      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   317      static serializeBinaryToWriter(message: ExportResponse, writer: jspb.BinaryWriter): void;
   318      static deserializeBinary(bytes: Uint8Array): ExportResponse;
   319      static deserializeBinaryFromReader(message: ExportResponse, reader: jspb.BinaryReader): ExportResponse;
   320  }
   321  
   322  export namespace ExportResponse {
   323      export type AsObject = {
   324          publickey: Uint8Array | string,
   325          privatekey: Uint8Array | string,
   326          address: Uint8Array | string,
   327          curvetype: string,
   328      }
   329  }
   330  
   331  export class SignRequest extends jspb.Message { 
   332      getPassphrase(): string;
   333      setPassphrase(value: string): SignRequest;
   334      getAddress(): string;
   335      setAddress(value: string): SignRequest;
   336      getName(): string;
   337      setName(value: string): SignRequest;
   338      getMessage(): Uint8Array | string;
   339      getMessage_asU8(): Uint8Array;
   340      getMessage_asB64(): string;
   341      setMessage(value: Uint8Array | string): SignRequest;
   342  
   343      serializeBinary(): Uint8Array;
   344      toObject(includeInstance?: boolean): SignRequest.AsObject;
   345      static toObject(includeInstance: boolean, msg: SignRequest): SignRequest.AsObject;
   346      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   347      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   348      static serializeBinaryToWriter(message: SignRequest, writer: jspb.BinaryWriter): void;
   349      static deserializeBinary(bytes: Uint8Array): SignRequest;
   350      static deserializeBinaryFromReader(message: SignRequest, reader: jspb.BinaryReader): SignRequest;
   351  }
   352  
   353  export namespace SignRequest {
   354      export type AsObject = {
   355          passphrase: string,
   356          address: string,
   357          name: string,
   358          message: Uint8Array | string,
   359      }
   360  }
   361  
   362  export class SignResponse extends jspb.Message { 
   363  
   364      hasSignature(): boolean;
   365      clearSignature(): void;
   366      getSignature(): crypto_pb.Signature | undefined;
   367      setSignature(value?: crypto_pb.Signature): SignResponse;
   368  
   369      serializeBinary(): Uint8Array;
   370      toObject(includeInstance?: boolean): SignResponse.AsObject;
   371      static toObject(includeInstance: boolean, msg: SignResponse): SignResponse.AsObject;
   372      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   373      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   374      static serializeBinaryToWriter(message: SignResponse, writer: jspb.BinaryWriter): void;
   375      static deserializeBinary(bytes: Uint8Array): SignResponse;
   376      static deserializeBinaryFromReader(message: SignResponse, reader: jspb.BinaryReader): SignResponse;
   377  }
   378  
   379  export namespace SignResponse {
   380      export type AsObject = {
   381          signature?: crypto_pb.Signature.AsObject,
   382      }
   383  }
   384  
   385  export class VerifyRequest extends jspb.Message { 
   386      getPublickey(): Uint8Array | string;
   387      getPublickey_asU8(): Uint8Array;
   388      getPublickey_asB64(): string;
   389      setPublickey(value: Uint8Array | string): VerifyRequest;
   390      getMessage(): Uint8Array | string;
   391      getMessage_asU8(): Uint8Array;
   392      getMessage_asB64(): string;
   393      setMessage(value: Uint8Array | string): VerifyRequest;
   394  
   395      hasSignature(): boolean;
   396      clearSignature(): void;
   397      getSignature(): crypto_pb.Signature | undefined;
   398      setSignature(value?: crypto_pb.Signature): VerifyRequest;
   399  
   400      serializeBinary(): Uint8Array;
   401      toObject(includeInstance?: boolean): VerifyRequest.AsObject;
   402      static toObject(includeInstance: boolean, msg: VerifyRequest): VerifyRequest.AsObject;
   403      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   404      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   405      static serializeBinaryToWriter(message: VerifyRequest, writer: jspb.BinaryWriter): void;
   406      static deserializeBinary(bytes: Uint8Array): VerifyRequest;
   407      static deserializeBinaryFromReader(message: VerifyRequest, reader: jspb.BinaryReader): VerifyRequest;
   408  }
   409  
   410  export namespace VerifyRequest {
   411      export type AsObject = {
   412          publickey: Uint8Array | string,
   413          message: Uint8Array | string,
   414          signature?: crypto_pb.Signature.AsObject,
   415      }
   416  }
   417  
   418  export class HashRequest extends jspb.Message { 
   419      getHashtype(): string;
   420      setHashtype(value: string): HashRequest;
   421      getMessage(): Uint8Array | string;
   422      getMessage_asU8(): Uint8Array;
   423      getMessage_asB64(): string;
   424      setMessage(value: Uint8Array | string): HashRequest;
   425  
   426      serializeBinary(): Uint8Array;
   427      toObject(includeInstance?: boolean): HashRequest.AsObject;
   428      static toObject(includeInstance: boolean, msg: HashRequest): HashRequest.AsObject;
   429      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   430      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   431      static serializeBinaryToWriter(message: HashRequest, writer: jspb.BinaryWriter): void;
   432      static deserializeBinary(bytes: Uint8Array): HashRequest;
   433      static deserializeBinaryFromReader(message: HashRequest, reader: jspb.BinaryReader): HashRequest;
   434  }
   435  
   436  export namespace HashRequest {
   437      export type AsObject = {
   438          hashtype: string,
   439          message: Uint8Array | string,
   440      }
   441  }
   442  
   443  export class HashResponse extends jspb.Message { 
   444      getHash(): string;
   445      setHash(value: string): HashResponse;
   446  
   447      serializeBinary(): Uint8Array;
   448      toObject(includeInstance?: boolean): HashResponse.AsObject;
   449      static toObject(includeInstance: boolean, msg: HashResponse): HashResponse.AsObject;
   450      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   451      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   452      static serializeBinaryToWriter(message: HashResponse, writer: jspb.BinaryWriter): void;
   453      static deserializeBinary(bytes: Uint8Array): HashResponse;
   454      static deserializeBinaryFromReader(message: HashResponse, reader: jspb.BinaryReader): HashResponse;
   455  }
   456  
   457  export namespace HashResponse {
   458      export type AsObject = {
   459          hash: string,
   460      }
   461  }
   462  
   463  export class KeyID extends jspb.Message { 
   464      getAddress(): string;
   465      setAddress(value: string): KeyID;
   466      clearKeynameList(): void;
   467      getKeynameList(): Array<string>;
   468      setKeynameList(value: Array<string>): KeyID;
   469      addKeyname(value: string, index?: number): string;
   470  
   471      serializeBinary(): Uint8Array;
   472      toObject(includeInstance?: boolean): KeyID.AsObject;
   473      static toObject(includeInstance: boolean, msg: KeyID): KeyID.AsObject;
   474      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   475      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   476      static serializeBinaryToWriter(message: KeyID, writer: jspb.BinaryWriter): void;
   477      static deserializeBinary(bytes: Uint8Array): KeyID;
   478      static deserializeBinaryFromReader(message: KeyID, reader: jspb.BinaryReader): KeyID;
   479  }
   480  
   481  export namespace KeyID {
   482      export type AsObject = {
   483          address: string,
   484          keynameList: Array<string>,
   485      }
   486  }
   487  
   488  export class ListResponse extends jspb.Message { 
   489      clearKeyList(): void;
   490      getKeyList(): Array<KeyID>;
   491      setKeyList(value: Array<KeyID>): ListResponse;
   492      addKey(value?: KeyID, index?: number): KeyID;
   493  
   494      serializeBinary(): Uint8Array;
   495      toObject(includeInstance?: boolean): ListResponse.AsObject;
   496      static toObject(includeInstance: boolean, msg: ListResponse): ListResponse.AsObject;
   497      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   498      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   499      static serializeBinaryToWriter(message: ListResponse, writer: jspb.BinaryWriter): void;
   500      static deserializeBinary(bytes: Uint8Array): ListResponse;
   501      static deserializeBinaryFromReader(message: ListResponse, reader: jspb.BinaryReader): ListResponse;
   502  }
   503  
   504  export namespace ListResponse {
   505      export type AsObject = {
   506          keyList: Array<KeyID.AsObject>,
   507      }
   508  }
   509  
   510  export class AddNameRequest extends jspb.Message { 
   511      getKeyname(): string;
   512      setKeyname(value: string): AddNameRequest;
   513      getAddress(): string;
   514      setAddress(value: string): AddNameRequest;
   515  
   516      serializeBinary(): Uint8Array;
   517      toObject(includeInstance?: boolean): AddNameRequest.AsObject;
   518      static toObject(includeInstance: boolean, msg: AddNameRequest): AddNameRequest.AsObject;
   519      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   520      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   521      static serializeBinaryToWriter(message: AddNameRequest, writer: jspb.BinaryWriter): void;
   522      static deserializeBinary(bytes: Uint8Array): AddNameRequest;
   523      static deserializeBinaryFromReader(message: AddNameRequest, reader: jspb.BinaryReader): AddNameRequest;
   524  }
   525  
   526  export namespace AddNameRequest {
   527      export type AsObject = {
   528          keyname: string,
   529          address: string,
   530      }
   531  }