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

     1  // package: rpcquery
     2  // file: rpcquery.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 tendermint_types_types_pb from "./tendermint/types/types_pb";
    10  import * as names_pb from "./names_pb";
    11  import * as acm_pb from "./acm_pb";
    12  import * as validator_pb from "./validator_pb";
    13  import * as registry_pb from "./registry_pb";
    14  import * as rpc_pb from "./rpc_pb";
    15  import * as payload_pb from "./payload_pb";
    16  
    17  export class StatusParam extends jspb.Message { 
    18      getBlocktimewithin(): string;
    19      setBlocktimewithin(value: string): StatusParam;
    20      getBlockseentimewithin(): string;
    21      setBlockseentimewithin(value: string): StatusParam;
    22  
    23      serializeBinary(): Uint8Array;
    24      toObject(includeInstance?: boolean): StatusParam.AsObject;
    25      static toObject(includeInstance: boolean, msg: StatusParam): StatusParam.AsObject;
    26      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    27      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    28      static serializeBinaryToWriter(message: StatusParam, writer: jspb.BinaryWriter): void;
    29      static deserializeBinary(bytes: Uint8Array): StatusParam;
    30      static deserializeBinaryFromReader(message: StatusParam, reader: jspb.BinaryReader): StatusParam;
    31  }
    32  
    33  export namespace StatusParam {
    34      export type AsObject = {
    35          blocktimewithin: string,
    36          blockseentimewithin: string,
    37      }
    38  }
    39  
    40  export class GetAccountParam extends jspb.Message { 
    41      getAddress(): Uint8Array | string;
    42      getAddress_asU8(): Uint8Array;
    43      getAddress_asB64(): string;
    44      setAddress(value: Uint8Array | string): GetAccountParam;
    45  
    46      serializeBinary(): Uint8Array;
    47      toObject(includeInstance?: boolean): GetAccountParam.AsObject;
    48      static toObject(includeInstance: boolean, msg: GetAccountParam): GetAccountParam.AsObject;
    49      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    50      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    51      static serializeBinaryToWriter(message: GetAccountParam, writer: jspb.BinaryWriter): void;
    52      static deserializeBinary(bytes: Uint8Array): GetAccountParam;
    53      static deserializeBinaryFromReader(message: GetAccountParam, reader: jspb.BinaryReader): GetAccountParam;
    54  }
    55  
    56  export namespace GetAccountParam {
    57      export type AsObject = {
    58          address: Uint8Array | string,
    59      }
    60  }
    61  
    62  export class GetMetadataParam extends jspb.Message { 
    63      getAddress(): Uint8Array | string;
    64      getAddress_asU8(): Uint8Array;
    65      getAddress_asB64(): string;
    66      setAddress(value: Uint8Array | string): GetMetadataParam;
    67      getMetadatahash(): Uint8Array | string;
    68      getMetadatahash_asU8(): Uint8Array;
    69      getMetadatahash_asB64(): string;
    70      setMetadatahash(value: Uint8Array | string): GetMetadataParam;
    71  
    72      serializeBinary(): Uint8Array;
    73      toObject(includeInstance?: boolean): GetMetadataParam.AsObject;
    74      static toObject(includeInstance: boolean, msg: GetMetadataParam): GetMetadataParam.AsObject;
    75      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    76      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    77      static serializeBinaryToWriter(message: GetMetadataParam, writer: jspb.BinaryWriter): void;
    78      static deserializeBinary(bytes: Uint8Array): GetMetadataParam;
    79      static deserializeBinaryFromReader(message: GetMetadataParam, reader: jspb.BinaryReader): GetMetadataParam;
    80  }
    81  
    82  export namespace GetMetadataParam {
    83      export type AsObject = {
    84          address: Uint8Array | string,
    85          metadatahash: Uint8Array | string,
    86      }
    87  }
    88  
    89  export class MetadataResult extends jspb.Message { 
    90      getMetadata(): string;
    91      setMetadata(value: string): MetadataResult;
    92  
    93      serializeBinary(): Uint8Array;
    94      toObject(includeInstance?: boolean): MetadataResult.AsObject;
    95      static toObject(includeInstance: boolean, msg: MetadataResult): MetadataResult.AsObject;
    96      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
    97      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
    98      static serializeBinaryToWriter(message: MetadataResult, writer: jspb.BinaryWriter): void;
    99      static deserializeBinary(bytes: Uint8Array): MetadataResult;
   100      static deserializeBinaryFromReader(message: MetadataResult, reader: jspb.BinaryReader): MetadataResult;
   101  }
   102  
   103  export namespace MetadataResult {
   104      export type AsObject = {
   105          metadata: string,
   106      }
   107  }
   108  
   109  export class GetStorageParam extends jspb.Message { 
   110      getAddress(): Uint8Array | string;
   111      getAddress_asU8(): Uint8Array;
   112      getAddress_asB64(): string;
   113      setAddress(value: Uint8Array | string): GetStorageParam;
   114      getKey(): Uint8Array | string;
   115      getKey_asU8(): Uint8Array;
   116      getKey_asB64(): string;
   117      setKey(value: Uint8Array | string): GetStorageParam;
   118  
   119      serializeBinary(): Uint8Array;
   120      toObject(includeInstance?: boolean): GetStorageParam.AsObject;
   121      static toObject(includeInstance: boolean, msg: GetStorageParam): GetStorageParam.AsObject;
   122      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   123      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   124      static serializeBinaryToWriter(message: GetStorageParam, writer: jspb.BinaryWriter): void;
   125      static deserializeBinary(bytes: Uint8Array): GetStorageParam;
   126      static deserializeBinaryFromReader(message: GetStorageParam, reader: jspb.BinaryReader): GetStorageParam;
   127  }
   128  
   129  export namespace GetStorageParam {
   130      export type AsObject = {
   131          address: Uint8Array | string,
   132          key: Uint8Array | string,
   133      }
   134  }
   135  
   136  export class StorageValue extends jspb.Message { 
   137      getValue(): Uint8Array | string;
   138      getValue_asU8(): Uint8Array;
   139      getValue_asB64(): string;
   140      setValue(value: Uint8Array | string): StorageValue;
   141  
   142      serializeBinary(): Uint8Array;
   143      toObject(includeInstance?: boolean): StorageValue.AsObject;
   144      static toObject(includeInstance: boolean, msg: StorageValue): StorageValue.AsObject;
   145      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   146      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   147      static serializeBinaryToWriter(message: StorageValue, writer: jspb.BinaryWriter): void;
   148      static deserializeBinary(bytes: Uint8Array): StorageValue;
   149      static deserializeBinaryFromReader(message: StorageValue, reader: jspb.BinaryReader): StorageValue;
   150  }
   151  
   152  export namespace StorageValue {
   153      export type AsObject = {
   154          value: Uint8Array | string,
   155      }
   156  }
   157  
   158  export class ListAccountsParam extends jspb.Message { 
   159      getQuery(): string;
   160      setQuery(value: string): ListAccountsParam;
   161  
   162      serializeBinary(): Uint8Array;
   163      toObject(includeInstance?: boolean): ListAccountsParam.AsObject;
   164      static toObject(includeInstance: boolean, msg: ListAccountsParam): ListAccountsParam.AsObject;
   165      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   166      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   167      static serializeBinaryToWriter(message: ListAccountsParam, writer: jspb.BinaryWriter): void;
   168      static deserializeBinary(bytes: Uint8Array): ListAccountsParam;
   169      static deserializeBinaryFromReader(message: ListAccountsParam, reader: jspb.BinaryReader): ListAccountsParam;
   170  }
   171  
   172  export namespace ListAccountsParam {
   173      export type AsObject = {
   174          query: string,
   175      }
   176  }
   177  
   178  export class GetNameParam extends jspb.Message { 
   179      getName(): string;
   180      setName(value: string): GetNameParam;
   181  
   182      serializeBinary(): Uint8Array;
   183      toObject(includeInstance?: boolean): GetNameParam.AsObject;
   184      static toObject(includeInstance: boolean, msg: GetNameParam): GetNameParam.AsObject;
   185      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   186      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   187      static serializeBinaryToWriter(message: GetNameParam, writer: jspb.BinaryWriter): void;
   188      static deserializeBinary(bytes: Uint8Array): GetNameParam;
   189      static deserializeBinaryFromReader(message: GetNameParam, reader: jspb.BinaryReader): GetNameParam;
   190  }
   191  
   192  export namespace GetNameParam {
   193      export type AsObject = {
   194          name: string,
   195      }
   196  }
   197  
   198  export class ListNamesParam extends jspb.Message { 
   199      getQuery(): string;
   200      setQuery(value: string): ListNamesParam;
   201  
   202      serializeBinary(): Uint8Array;
   203      toObject(includeInstance?: boolean): ListNamesParam.AsObject;
   204      static toObject(includeInstance: boolean, msg: ListNamesParam): ListNamesParam.AsObject;
   205      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   206      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   207      static serializeBinaryToWriter(message: ListNamesParam, writer: jspb.BinaryWriter): void;
   208      static deserializeBinary(bytes: Uint8Array): ListNamesParam;
   209      static deserializeBinaryFromReader(message: ListNamesParam, reader: jspb.BinaryReader): ListNamesParam;
   210  }
   211  
   212  export namespace ListNamesParam {
   213      export type AsObject = {
   214          query: string,
   215      }
   216  }
   217  
   218  export class GetNetworkRegistryParam extends jspb.Message { 
   219  
   220      serializeBinary(): Uint8Array;
   221      toObject(includeInstance?: boolean): GetNetworkRegistryParam.AsObject;
   222      static toObject(includeInstance: boolean, msg: GetNetworkRegistryParam): GetNetworkRegistryParam.AsObject;
   223      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   224      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   225      static serializeBinaryToWriter(message: GetNetworkRegistryParam, writer: jspb.BinaryWriter): void;
   226      static deserializeBinary(bytes: Uint8Array): GetNetworkRegistryParam;
   227      static deserializeBinaryFromReader(message: GetNetworkRegistryParam, reader: jspb.BinaryReader): GetNetworkRegistryParam;
   228  }
   229  
   230  export namespace GetNetworkRegistryParam {
   231      export type AsObject = {
   232      }
   233  }
   234  
   235  export class GetValidatorSetParam extends jspb.Message { 
   236  
   237      serializeBinary(): Uint8Array;
   238      toObject(includeInstance?: boolean): GetValidatorSetParam.AsObject;
   239      static toObject(includeInstance: boolean, msg: GetValidatorSetParam): GetValidatorSetParam.AsObject;
   240      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   241      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   242      static serializeBinaryToWriter(message: GetValidatorSetParam, writer: jspb.BinaryWriter): void;
   243      static deserializeBinary(bytes: Uint8Array): GetValidatorSetParam;
   244      static deserializeBinaryFromReader(message: GetValidatorSetParam, reader: jspb.BinaryReader): GetValidatorSetParam;
   245  }
   246  
   247  export namespace GetValidatorSetParam {
   248      export type AsObject = {
   249      }
   250  }
   251  
   252  export class GetValidatorSetHistoryParam extends jspb.Message { 
   253      getIncludeprevious(): number;
   254      setIncludeprevious(value: number): GetValidatorSetHistoryParam;
   255  
   256      serializeBinary(): Uint8Array;
   257      toObject(includeInstance?: boolean): GetValidatorSetHistoryParam.AsObject;
   258      static toObject(includeInstance: boolean, msg: GetValidatorSetHistoryParam): GetValidatorSetHistoryParam.AsObject;
   259      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   260      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   261      static serializeBinaryToWriter(message: GetValidatorSetHistoryParam, writer: jspb.BinaryWriter): void;
   262      static deserializeBinary(bytes: Uint8Array): GetValidatorSetHistoryParam;
   263      static deserializeBinaryFromReader(message: GetValidatorSetHistoryParam, reader: jspb.BinaryReader): GetValidatorSetHistoryParam;
   264  }
   265  
   266  export namespace GetValidatorSetHistoryParam {
   267      export type AsObject = {
   268          includeprevious: number,
   269      }
   270  }
   271  
   272  export class NetworkRegistry extends jspb.Message { 
   273      clearSetList(): void;
   274      getSetList(): Array<RegisteredValidator>;
   275      setSetList(value: Array<RegisteredValidator>): NetworkRegistry;
   276      addSet(value?: RegisteredValidator, index?: number): RegisteredValidator;
   277  
   278      serializeBinary(): Uint8Array;
   279      toObject(includeInstance?: boolean): NetworkRegistry.AsObject;
   280      static toObject(includeInstance: boolean, msg: NetworkRegistry): NetworkRegistry.AsObject;
   281      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   282      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   283      static serializeBinaryToWriter(message: NetworkRegistry, writer: jspb.BinaryWriter): void;
   284      static deserializeBinary(bytes: Uint8Array): NetworkRegistry;
   285      static deserializeBinaryFromReader(message: NetworkRegistry, reader: jspb.BinaryReader): NetworkRegistry;
   286  }
   287  
   288  export namespace NetworkRegistry {
   289      export type AsObject = {
   290          setList: Array<RegisteredValidator.AsObject>,
   291      }
   292  }
   293  
   294  export class RegisteredValidator extends jspb.Message { 
   295      getAddress(): Uint8Array | string;
   296      getAddress_asU8(): Uint8Array;
   297      getAddress_asB64(): string;
   298      setAddress(value: Uint8Array | string): RegisteredValidator;
   299  
   300      hasNode(): boolean;
   301      clearNode(): void;
   302      getNode(): registry_pb.NodeIdentity | undefined;
   303      setNode(value?: registry_pb.NodeIdentity): RegisteredValidator;
   304  
   305      serializeBinary(): Uint8Array;
   306      toObject(includeInstance?: boolean): RegisteredValidator.AsObject;
   307      static toObject(includeInstance: boolean, msg: RegisteredValidator): RegisteredValidator.AsObject;
   308      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   309      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   310      static serializeBinaryToWriter(message: RegisteredValidator, writer: jspb.BinaryWriter): void;
   311      static deserializeBinary(bytes: Uint8Array): RegisteredValidator;
   312      static deserializeBinaryFromReader(message: RegisteredValidator, reader: jspb.BinaryReader): RegisteredValidator;
   313  }
   314  
   315  export namespace RegisteredValidator {
   316      export type AsObject = {
   317          address: Uint8Array | string,
   318          node?: registry_pb.NodeIdentity.AsObject,
   319      }
   320  }
   321  
   322  export class ValidatorSetHistory extends jspb.Message { 
   323      clearHistoryList(): void;
   324      getHistoryList(): Array<ValidatorSet>;
   325      setHistoryList(value: Array<ValidatorSet>): ValidatorSetHistory;
   326      addHistory(value?: ValidatorSet, index?: number): ValidatorSet;
   327  
   328      serializeBinary(): Uint8Array;
   329      toObject(includeInstance?: boolean): ValidatorSetHistory.AsObject;
   330      static toObject(includeInstance: boolean, msg: ValidatorSetHistory): ValidatorSetHistory.AsObject;
   331      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   332      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   333      static serializeBinaryToWriter(message: ValidatorSetHistory, writer: jspb.BinaryWriter): void;
   334      static deserializeBinary(bytes: Uint8Array): ValidatorSetHistory;
   335      static deserializeBinaryFromReader(message: ValidatorSetHistory, reader: jspb.BinaryReader): ValidatorSetHistory;
   336  }
   337  
   338  export namespace ValidatorSetHistory {
   339      export type AsObject = {
   340          historyList: Array<ValidatorSet.AsObject>,
   341      }
   342  }
   343  
   344  export class ValidatorSet extends jspb.Message { 
   345      getHeight(): number;
   346      setHeight(value: number): ValidatorSet;
   347      clearSetList(): void;
   348      getSetList(): Array<validator_pb.Validator>;
   349      setSetList(value: Array<validator_pb.Validator>): ValidatorSet;
   350      addSet(value?: validator_pb.Validator, index?: number): validator_pb.Validator;
   351  
   352      serializeBinary(): Uint8Array;
   353      toObject(includeInstance?: boolean): ValidatorSet.AsObject;
   354      static toObject(includeInstance: boolean, msg: ValidatorSet): ValidatorSet.AsObject;
   355      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   356      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   357      static serializeBinaryToWriter(message: ValidatorSet, writer: jspb.BinaryWriter): void;
   358      static deserializeBinary(bytes: Uint8Array): ValidatorSet;
   359      static deserializeBinaryFromReader(message: ValidatorSet, reader: jspb.BinaryReader): ValidatorSet;
   360  }
   361  
   362  export namespace ValidatorSet {
   363      export type AsObject = {
   364          height: number,
   365          setList: Array<validator_pb.Validator.AsObject>,
   366      }
   367  }
   368  
   369  export class GetProposalParam extends jspb.Message { 
   370      getHash(): Uint8Array | string;
   371      getHash_asU8(): Uint8Array;
   372      getHash_asB64(): string;
   373      setHash(value: Uint8Array | string): GetProposalParam;
   374  
   375      serializeBinary(): Uint8Array;
   376      toObject(includeInstance?: boolean): GetProposalParam.AsObject;
   377      static toObject(includeInstance: boolean, msg: GetProposalParam): GetProposalParam.AsObject;
   378      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   379      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   380      static serializeBinaryToWriter(message: GetProposalParam, writer: jspb.BinaryWriter): void;
   381      static deserializeBinary(bytes: Uint8Array): GetProposalParam;
   382      static deserializeBinaryFromReader(message: GetProposalParam, reader: jspb.BinaryReader): GetProposalParam;
   383  }
   384  
   385  export namespace GetProposalParam {
   386      export type AsObject = {
   387          hash: Uint8Array | string,
   388      }
   389  }
   390  
   391  export class ListProposalsParam extends jspb.Message { 
   392      getProposed(): boolean;
   393      setProposed(value: boolean): ListProposalsParam;
   394  
   395      serializeBinary(): Uint8Array;
   396      toObject(includeInstance?: boolean): ListProposalsParam.AsObject;
   397      static toObject(includeInstance: boolean, msg: ListProposalsParam): ListProposalsParam.AsObject;
   398      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   399      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   400      static serializeBinaryToWriter(message: ListProposalsParam, writer: jspb.BinaryWriter): void;
   401      static deserializeBinary(bytes: Uint8Array): ListProposalsParam;
   402      static deserializeBinaryFromReader(message: ListProposalsParam, reader: jspb.BinaryReader): ListProposalsParam;
   403  }
   404  
   405  export namespace ListProposalsParam {
   406      export type AsObject = {
   407          proposed: boolean,
   408      }
   409  }
   410  
   411  export class ProposalResult extends jspb.Message { 
   412      getHash(): Uint8Array | string;
   413      getHash_asU8(): Uint8Array;
   414      getHash_asB64(): string;
   415      setHash(value: Uint8Array | string): ProposalResult;
   416  
   417      hasBallot(): boolean;
   418      clearBallot(): void;
   419      getBallot(): payload_pb.Ballot | undefined;
   420      setBallot(value?: payload_pb.Ballot): ProposalResult;
   421  
   422      serializeBinary(): Uint8Array;
   423      toObject(includeInstance?: boolean): ProposalResult.AsObject;
   424      static toObject(includeInstance: boolean, msg: ProposalResult): ProposalResult.AsObject;
   425      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   426      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   427      static serializeBinaryToWriter(message: ProposalResult, writer: jspb.BinaryWriter): void;
   428      static deserializeBinary(bytes: Uint8Array): ProposalResult;
   429      static deserializeBinaryFromReader(message: ProposalResult, reader: jspb.BinaryReader): ProposalResult;
   430  }
   431  
   432  export namespace ProposalResult {
   433      export type AsObject = {
   434          hash: Uint8Array | string,
   435          ballot?: payload_pb.Ballot.AsObject,
   436      }
   437  }
   438  
   439  export class GetStatsParam extends jspb.Message { 
   440  
   441      serializeBinary(): Uint8Array;
   442      toObject(includeInstance?: boolean): GetStatsParam.AsObject;
   443      static toObject(includeInstance: boolean, msg: GetStatsParam): GetStatsParam.AsObject;
   444      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   445      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   446      static serializeBinaryToWriter(message: GetStatsParam, writer: jspb.BinaryWriter): void;
   447      static deserializeBinary(bytes: Uint8Array): GetStatsParam;
   448      static deserializeBinaryFromReader(message: GetStatsParam, reader: jspb.BinaryReader): GetStatsParam;
   449  }
   450  
   451  export namespace GetStatsParam {
   452      export type AsObject = {
   453      }
   454  }
   455  
   456  export class Stats extends jspb.Message { 
   457      getAccountswithcode(): number;
   458      setAccountswithcode(value: number): Stats;
   459      getAccountswithoutcode(): number;
   460      setAccountswithoutcode(value: number): Stats;
   461  
   462      serializeBinary(): Uint8Array;
   463      toObject(includeInstance?: boolean): Stats.AsObject;
   464      static toObject(includeInstance: boolean, msg: Stats): Stats.AsObject;
   465      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   466      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   467      static serializeBinaryToWriter(message: Stats, writer: jspb.BinaryWriter): void;
   468      static deserializeBinary(bytes: Uint8Array): Stats;
   469      static deserializeBinaryFromReader(message: Stats, reader: jspb.BinaryReader): Stats;
   470  }
   471  
   472  export namespace Stats {
   473      export type AsObject = {
   474          accountswithcode: number,
   475          accountswithoutcode: number,
   476      }
   477  }
   478  
   479  export class GetBlockParam extends jspb.Message { 
   480      getHeight(): number;
   481      setHeight(value: number): GetBlockParam;
   482  
   483      serializeBinary(): Uint8Array;
   484      toObject(includeInstance?: boolean): GetBlockParam.AsObject;
   485      static toObject(includeInstance: boolean, msg: GetBlockParam): GetBlockParam.AsObject;
   486      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   487      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
   488      static serializeBinaryToWriter(message: GetBlockParam, writer: jspb.BinaryWriter): void;
   489      static deserializeBinary(bytes: Uint8Array): GetBlockParam;
   490      static deserializeBinaryFromReader(message: GetBlockParam, reader: jspb.BinaryReader): GetBlockParam;
   491  }
   492  
   493  export namespace GetBlockParam {
   494      export type AsObject = {
   495          height: number,
   496      }
   497  }