@paradeum/burrow/proto/rpcquery_pb.d.ts

TypeScript library that calls a Hyperledger Burrow server over GRPC.

// package: rpcquery
// file: rpcquery.proto

import * as jspb from "google-protobuf";
import * as google_protobuf_timestamp_pb from "google-protobuf/google/protobuf/timestamp_pb";
import * as github_com_gogo_protobuf_gogoproto_gogo_pb from "./github.com/gogo/protobuf/gogoproto/gogo_pb";
import * as github_com_tendermint_tendermint_abci_types_types_pb from "./github.com/tendermint/tendermint/abci/types/types_pb";
import * as names_pb from "./names_pb";
import * as acm_pb from "./acm_pb";
import * as validator_pb from "./validator_pb";
import * as registry_pb from "./registry_pb";
import * as rpc_pb from "./rpc_pb";
import * as payload_pb from "./payload_pb";
import * as txs_pb from "./txs_pb";
import * as tendermint_pb from "./tendermint_pb";
import * as permission_pb from "./permission_pb";

export class StatusParam extends jspb.Message {
  getBlocktimewithin(): string;
  setBlocktimewithin(value: string): void;

  getBlockseentimewithin(): string;
  setBlockseentimewithin(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): StatusParam.AsObject;
  static toObject(includeInstance: boolean, msg: StatusParam): StatusParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: StatusParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): StatusParam;
  static deserializeBinaryFromReader(message: StatusParam, reader: jspb.BinaryReader): StatusParam;
}

export namespace StatusParam {
  export type AsObject = {
    blocktimewithin: string,
    blockseentimewithin: string,
  }
}

export class GetAccountParam extends jspb.Message {
  getAddress(): Uint8Array | string;
  getAddress_asU8(): Uint8Array;
  getAddress_asB64(): string;
  setAddress(value: Uint8Array | string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetAccountParam.AsObject;
  static toObject(includeInstance: boolean, msg: GetAccountParam): GetAccountParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetAccountParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetAccountParam;
  static deserializeBinaryFromReader(message: GetAccountParam, reader: jspb.BinaryReader): GetAccountParam;
}

export namespace GetAccountParam {
  export type AsObject = {
    address: Uint8Array | string,
  }
}

export class GetMetadataParam extends jspb.Message {
  getAddress(): Uint8Array | string;
  getAddress_asU8(): Uint8Array;
  getAddress_asB64(): string;
  setAddress(value: Uint8Array | string): void;

  getMetadatahash(): Uint8Array | string;
  getMetadatahash_asU8(): Uint8Array;
  getMetadatahash_asB64(): string;
  setMetadatahash(value: Uint8Array | string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetMetadataParam.AsObject;
  static toObject(includeInstance: boolean, msg: GetMetadataParam): GetMetadataParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetMetadataParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetMetadataParam;
  static deserializeBinaryFromReader(message: GetMetadataParam, reader: jspb.BinaryReader): GetMetadataParam;
}

export namespace GetMetadataParam {
  export type AsObject = {
    address: Uint8Array | string,
    metadatahash: Uint8Array | string,
  }
}

export class MetadataResult extends jspb.Message {
  getMetadata(): string;
  setMetadata(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): MetadataResult.AsObject;
  static toObject(includeInstance: boolean, msg: MetadataResult): MetadataResult.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: MetadataResult, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): MetadataResult;
  static deserializeBinaryFromReader(message: MetadataResult, reader: jspb.BinaryReader): MetadataResult;
}

export namespace MetadataResult {
  export type AsObject = {
    metadata: string,
  }
}

export class GetStorageParam extends jspb.Message {
  getAddress(): Uint8Array | string;
  getAddress_asU8(): Uint8Array;
  getAddress_asB64(): string;
  setAddress(value: Uint8Array | string): void;

  getKey(): Uint8Array | string;
  getKey_asU8(): Uint8Array;
  getKey_asB64(): string;
  setKey(value: Uint8Array | string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetStorageParam.AsObject;
  static toObject(includeInstance: boolean, msg: GetStorageParam): GetStorageParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetStorageParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetStorageParam;
  static deserializeBinaryFromReader(message: GetStorageParam, reader: jspb.BinaryReader): GetStorageParam;
}

export namespace GetStorageParam {
  export type AsObject = {
    address: Uint8Array | string,
    key: Uint8Array | string,
  }
}

export class StorageValue extends jspb.Message {
  getValue(): Uint8Array | string;
  getValue_asU8(): Uint8Array;
  getValue_asB64(): string;
  setValue(value: Uint8Array | string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): StorageValue.AsObject;
  static toObject(includeInstance: boolean, msg: StorageValue): StorageValue.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: StorageValue, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): StorageValue;
  static deserializeBinaryFromReader(message: StorageValue, reader: jspb.BinaryReader): StorageValue;
}

export namespace StorageValue {
  export type AsObject = {
    value: Uint8Array | string,
  }
}

export class ListAccountsParam extends jspb.Message {
  getQuery(): string;
  setQuery(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ListAccountsParam.AsObject;
  static toObject(includeInstance: boolean, msg: ListAccountsParam): ListAccountsParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ListAccountsParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ListAccountsParam;
  static deserializeBinaryFromReader(message: ListAccountsParam, reader: jspb.BinaryReader): ListAccountsParam;
}

export namespace ListAccountsParam {
  export type AsObject = {
    query: string,
  }
}

export class GetNameParam extends jspb.Message {
  getName(): string;
  setName(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetNameParam.AsObject;
  static toObject(includeInstance: boolean, msg: GetNameParam): GetNameParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetNameParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetNameParam;
  static deserializeBinaryFromReader(message: GetNameParam, reader: jspb.BinaryReader): GetNameParam;
}

export namespace GetNameParam {
  export type AsObject = {
    name: string,
  }
}

export class ListNamesParam extends jspb.Message {
  getQuery(): string;
  setQuery(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ListNamesParam.AsObject;
  static toObject(includeInstance: boolean, msg: ListNamesParam): ListNamesParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ListNamesParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ListNamesParam;
  static deserializeBinaryFromReader(message: ListNamesParam, reader: jspb.BinaryReader): ListNamesParam;
}

export namespace ListNamesParam {
  export type AsObject = {
    query: string,
  }
}

export class GetNetworkRegistryParam extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetNetworkRegistryParam.AsObject;
  static toObject(includeInstance: boolean, msg: GetNetworkRegistryParam): GetNetworkRegistryParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetNetworkRegistryParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetNetworkRegistryParam;
  static deserializeBinaryFromReader(message: GetNetworkRegistryParam, reader: jspb.BinaryReader): GetNetworkRegistryParam;
}

export namespace GetNetworkRegistryParam {
  export type AsObject = {
  }
}

export class GetValidatorSetParam extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetValidatorSetParam.AsObject;
  static toObject(includeInstance: boolean, msg: GetValidatorSetParam): GetValidatorSetParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetValidatorSetParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetValidatorSetParam;
  static deserializeBinaryFromReader(message: GetValidatorSetParam, reader: jspb.BinaryReader): GetValidatorSetParam;
}

export namespace GetValidatorSetParam {
  export type AsObject = {
  }
}

export class GetValidatorSetHistoryParam extends jspb.Message {
  getIncludeprevious(): number;
  setIncludeprevious(value: number): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetValidatorSetHistoryParam.AsObject;
  static toObject(includeInstance: boolean, msg: GetValidatorSetHistoryParam): GetValidatorSetHistoryParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetValidatorSetHistoryParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetValidatorSetHistoryParam;
  static deserializeBinaryFromReader(message: GetValidatorSetHistoryParam, reader: jspb.BinaryReader): GetValidatorSetHistoryParam;
}

export namespace GetValidatorSetHistoryParam {
  export type AsObject = {
    includeprevious: number,
  }
}

export class NetworkRegistry extends jspb.Message {
  clearSetList(): void;
  getSetList(): Array<RegisteredValidator>;
  setSetList(value: Array<RegisteredValidator>): void;
  addSet(value?: RegisteredValidator, index?: number): RegisteredValidator;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): NetworkRegistry.AsObject;
  static toObject(includeInstance: boolean, msg: NetworkRegistry): NetworkRegistry.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: NetworkRegistry, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): NetworkRegistry;
  static deserializeBinaryFromReader(message: NetworkRegistry, reader: jspb.BinaryReader): NetworkRegistry;
}

export namespace NetworkRegistry {
  export type AsObject = {
    setList: Array<RegisteredValidator.AsObject>,
  }
}

export class RegisteredValidator extends jspb.Message {
  getAddress(): Uint8Array | string;
  getAddress_asU8(): Uint8Array;
  getAddress_asB64(): string;
  setAddress(value: Uint8Array | string): void;

  hasNode(): boolean;
  clearNode(): void;
  getNode(): registry_pb.NodeIdentity | undefined;
  setNode(value?: registry_pb.NodeIdentity): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RegisteredValidator.AsObject;
  static toObject(includeInstance: boolean, msg: RegisteredValidator): RegisteredValidator.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: RegisteredValidator, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RegisteredValidator;
  static deserializeBinaryFromReader(message: RegisteredValidator, reader: jspb.BinaryReader): RegisteredValidator;
}

export namespace RegisteredValidator {
  export type AsObject = {
    address: Uint8Array | string,
    node?: registry_pb.NodeIdentity.AsObject,
  }
}

export class ValidatorSetHistory extends jspb.Message {
  clearHistoryList(): void;
  getHistoryList(): Array<ValidatorSet>;
  setHistoryList(value: Array<ValidatorSet>): void;
  addHistory(value?: ValidatorSet, index?: number): ValidatorSet;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ValidatorSetHistory.AsObject;
  static toObject(includeInstance: boolean, msg: ValidatorSetHistory): ValidatorSetHistory.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ValidatorSetHistory, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ValidatorSetHistory;
  static deserializeBinaryFromReader(message: ValidatorSetHistory, reader: jspb.BinaryReader): ValidatorSetHistory;
}

export namespace ValidatorSetHistory {
  export type AsObject = {
    historyList: Array<ValidatorSet.AsObject>,
  }
}

export class ValidatorSet extends jspb.Message {
  getHeight(): number;
  setHeight(value: number): void;

  clearSetList(): void;
  getSetList(): Array<validator_pb.Validator>;
  setSetList(value: Array<validator_pb.Validator>): void;
  addSet(value?: validator_pb.Validator, index?: number): validator_pb.Validator;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ValidatorSet.AsObject;
  static toObject(includeInstance: boolean, msg: ValidatorSet): ValidatorSet.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ValidatorSet, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ValidatorSet;
  static deserializeBinaryFromReader(message: ValidatorSet, reader: jspb.BinaryReader): ValidatorSet;
}

export namespace ValidatorSet {
  export type AsObject = {
    height: number,
    setList: Array<validator_pb.Validator.AsObject>,
  }
}

export class GetProposalParam extends jspb.Message {
  getHash(): Uint8Array | string;
  getHash_asU8(): Uint8Array;
  getHash_asB64(): string;
  setHash(value: Uint8Array | string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetProposalParam.AsObject;
  static toObject(includeInstance: boolean, msg: GetProposalParam): GetProposalParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetProposalParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetProposalParam;
  static deserializeBinaryFromReader(message: GetProposalParam, reader: jspb.BinaryReader): GetProposalParam;
}

export namespace GetProposalParam {
  export type AsObject = {
    hash: Uint8Array | string,
  }
}

export class ListProposalsParam extends jspb.Message {
  getProposed(): boolean;
  setProposed(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ListProposalsParam.AsObject;
  static toObject(includeInstance: boolean, msg: ListProposalsParam): ListProposalsParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ListProposalsParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ListProposalsParam;
  static deserializeBinaryFromReader(message: ListProposalsParam, reader: jspb.BinaryReader): ListProposalsParam;
}

export namespace ListProposalsParam {
  export type AsObject = {
    proposed: boolean,
  }
}

export class ProposalResult extends jspb.Message {
  getHash(): Uint8Array | string;
  getHash_asU8(): Uint8Array;
  getHash_asB64(): string;
  setHash(value: Uint8Array | string): void;

  hasBallot(): boolean;
  clearBallot(): void;
  getBallot(): payload_pb.Ballot | undefined;
  setBallot(value?: payload_pb.Ballot): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ProposalResult.AsObject;
  static toObject(includeInstance: boolean, msg: ProposalResult): ProposalResult.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ProposalResult, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ProposalResult;
  static deserializeBinaryFromReader(message: ProposalResult, reader: jspb.BinaryReader): ProposalResult;
}

export namespace ProposalResult {
  export type AsObject = {
    hash: Uint8Array | string,
    ballot?: payload_pb.Ballot.AsObject,
  }
}

export class GetStatsParam extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetStatsParam.AsObject;
  static toObject(includeInstance: boolean, msg: GetStatsParam): GetStatsParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetStatsParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetStatsParam;
  static deserializeBinaryFromReader(message: GetStatsParam, reader: jspb.BinaryReader): GetStatsParam;
}

export namespace GetStatsParam {
  export type AsObject = {
  }
}

export class Stats extends jspb.Message {
  getAccountswithcode(): number;
  setAccountswithcode(value: number): void;

  getAccountswithoutcode(): number;
  setAccountswithoutcode(value: number): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Stats.AsObject;
  static toObject(includeInstance: boolean, msg: Stats): Stats.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Stats, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Stats;
  static deserializeBinaryFromReader(message: Stats, reader: jspb.BinaryReader): Stats;
}

export namespace Stats {
  export type AsObject = {
    accountswithcode: number,
    accountswithoutcode: number,
  }
}

export class GetBlockParam extends jspb.Message {
  getHeight(): number;
  setHeight(value: number): void;

  getHash(): string;
  setHash(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetBlockParam.AsObject;
  static toObject(includeInstance: boolean, msg: GetBlockParam): GetBlockParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetBlockParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetBlockParam;
  static deserializeBinaryFromReader(message: GetBlockParam, reader: jspb.BinaryReader): GetBlockParam;
}

export namespace GetBlockParam {
  export type AsObject = {
    height: number,
    hash: string,
  }
}

export class GetNetworkParam extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetNetworkParam.AsObject;
  static toObject(includeInstance: boolean, msg: GetNetworkParam): GetNetworkParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetNetworkParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetNetworkParam;
  static deserializeBinaryFromReader(message: GetNetworkParam, reader: jspb.BinaryReader): GetNetworkParam;
}

export namespace GetNetworkParam {
  export type AsObject = {
  }
}

export class Network extends jspb.Message {
  clearPeersList(): void;
  getPeersList(): Array<tendermint_pb.NodeInfo>;
  setPeersList(value: Array<tendermint_pb.NodeInfo>): void;
  addPeers(value?: tendermint_pb.NodeInfo, index?: number): tendermint_pb.NodeInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Network.AsObject;
  static toObject(includeInstance: boolean, msg: Network): Network.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Network, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Network;
  static deserializeBinaryFromReader(message: Network, reader: jspb.BinaryReader): Network;
}

export namespace Network {
  export type AsObject = {
    peersList: Array<tendermint_pb.NodeInfo.AsObject>,
  }
}

export class GetGenesisParam extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetGenesisParam.AsObject;
  static toObject(includeInstance: boolean, msg: GetGenesisParam): GetGenesisParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetGenesisParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetGenesisParam;
  static deserializeBinaryFromReader(message: GetGenesisParam, reader: jspb.BinaryReader): GetGenesisParam;
}

export namespace GetGenesisParam {
  export type AsObject = {
  }
}

export class Params extends jspb.Message {
  getProposalthreshold(): number;
  setProposalthreshold(value: number): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Params.AsObject;
  static toObject(includeInstance: boolean, msg: Params): Params.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Params, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Params;
  static deserializeBinaryFromReader(message: Params, reader: jspb.BinaryReader): Params;
}

export namespace Params {
  export type AsObject = {
    proposalthreshold: number,
  }
}

export class Genesis extends jspb.Message {
  hasGenesistime(): boolean;
  clearGenesistime(): void;
  getGenesistime(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setGenesistime(value?: google_protobuf_timestamp_pb.Timestamp): void;

  getChainname(): string;
  setChainname(value: string): void;

  getApphash(): string;
  setApphash(value: string): void;

  hasParams(): boolean;
  clearParams(): void;
  getParams(): Params | undefined;
  setParams(value?: Params): void;

  getSalt(): Uint8Array | string;
  getSalt_asU8(): Uint8Array;
  getSalt_asB64(): string;
  setSalt(value: Uint8Array | string): void;

  hasGlobalpermissions(): boolean;
  clearGlobalpermissions(): void;
  getGlobalpermissions(): permission_pb.AccountPermissions | undefined;
  setGlobalpermissions(value?: permission_pb.AccountPermissions): void;

  clearAccountsList(): void;
  getAccountsList(): Array<acm_pb.Account>;
  setAccountsList(value: Array<acm_pb.Account>): void;
  addAccounts(value?: acm_pb.Account, index?: number): acm_pb.Account;

  clearValidatorsList(): void;
  getValidatorsList(): Array<validator_pb.Validator>;
  setValidatorsList(value: Array<validator_pb.Validator>): void;
  addValidators(value?: validator_pb.Validator, index?: number): validator_pb.Validator;

  getHash(): Uint8Array | string;
  getHash_asU8(): Uint8Array;
  getHash_asB64(): string;
  setHash(value: Uint8Array | string): void;

  getChainid(): string;
  setChainid(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Genesis.AsObject;
  static toObject(includeInstance: boolean, msg: Genesis): Genesis.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Genesis, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Genesis;
  static deserializeBinaryFromReader(message: Genesis, reader: jspb.BinaryReader): Genesis;
}

export namespace Genesis {
  export type AsObject = {
    genesistime?: google_protobuf_timestamp_pb.Timestamp.AsObject,
    chainname: string,
    apphash: string,
    params?: Params.AsObject,
    salt: Uint8Array | string,
    globalpermissions?: permission_pb.AccountPermissions.AsObject,
    accountsList: Array<acm_pb.Account.AsObject>,
    validatorsList: Array<validator_pb.Validator.AsObject>,
    hash: Uint8Array | string,
    chainid: string,
  }
}

export class GetChainIDParam extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetChainIDParam.AsObject;
  static toObject(includeInstance: boolean, msg: GetChainIDParam): GetChainIDParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetChainIDParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetChainIDParam;
  static deserializeBinaryFromReader(message: GetChainIDParam, reader: jspb.BinaryReader): GetChainIDParam;
}

export namespace GetChainIDParam {
  export type AsObject = {
  }
}

export class ChainID extends jspb.Message {
  getChainid(): string;
  setChainid(value: string): void;

  getChainname(): string;
  setChainname(value: string): void;

  getGenesishash(): Uint8Array | string;
  getGenesishash_asU8(): Uint8Array;
  getGenesishash_asB64(): string;
  setGenesishash(value: Uint8Array | string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ChainID.AsObject;
  static toObject(includeInstance: boolean, msg: ChainID): ChainID.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ChainID, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ChainID;
  static deserializeBinaryFromReader(message: ChainID, reader: jspb.BinaryReader): ChainID;
}

export namespace ChainID {
  export type AsObject = {
    chainid: string,
    chainname: string,
    genesishash: Uint8Array | string,
  }
}

export class GetUnconfirmedTxsParam extends jspb.Message {
  getMaxtxs(): number;
  setMaxtxs(value: number): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetUnconfirmedTxsParam.AsObject;
  static toObject(includeInstance: boolean, msg: GetUnconfirmedTxsParam): GetUnconfirmedTxsParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetUnconfirmedTxsParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetUnconfirmedTxsParam;
  static deserializeBinaryFromReader(message: GetUnconfirmedTxsParam, reader: jspb.BinaryReader): GetUnconfirmedTxsParam;
}

export namespace GetUnconfirmedTxsParam {
  export type AsObject = {
    maxtxs: number,
  }
}

export class UnconfirmedTxs extends jspb.Message {
  clearTxsList(): void;
  getTxsList(): Array<txs_pb.Envelope>;
  setTxsList(value: Array<txs_pb.Envelope>): void;
  addTxs(value?: txs_pb.Envelope, index?: number): txs_pb.Envelope;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): UnconfirmedTxs.AsObject;
  static toObject(includeInstance: boolean, msg: UnconfirmedTxs): UnconfirmedTxs.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: UnconfirmedTxs, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): UnconfirmedTxs;
  static deserializeBinaryFromReader(message: UnconfirmedTxs, reader: jspb.BinaryReader): UnconfirmedTxs;
}

export namespace UnconfirmedTxs {
  export type AsObject = {
    txsList: Array<txs_pb.Envelope.AsObject>,
  }
}

export class ConsensusState extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ConsensusState.AsObject;
  static toObject(includeInstance: boolean, msg: ConsensusState): ConsensusState.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ConsensusState, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ConsensusState;
  static deserializeBinaryFromReader(message: ConsensusState, reader: jspb.BinaryReader): ConsensusState;
}

export namespace ConsensusState {
  export type AsObject = {
  }
}

export class ListBlocksParam extends jspb.Message {
  getStartheight(): number;
  setStartheight(value: number): void;

  getEndheight(): number;
  setEndheight(value: number): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ListBlocksParam.AsObject;
  static toObject(includeInstance: boolean, msg: ListBlocksParam): ListBlocksParam.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: ListBlocksParam, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ListBlocksParam;
  static deserializeBinaryFromReader(message: ListBlocksParam, reader: jspb.BinaryReader): ListBlocksParam;
}

export namespace ListBlocksParam {
  export type AsObject = {
    startheight: number,
    endheight: number,
  }
}

export class Block extends jspb.Message {
  hasHeader(): boolean;
  clearHeader(): void;
  getHeader(): github_com_tendermint_tendermint_abci_types_types_pb.Header | undefined;
  setHeader(value?: github_com_tendermint_tendermint_abci_types_types_pb.Header): void;

  getHash(): string;
  setHash(value: string): void;

  getNumtxs(): number;
  setNumtxs(value: number): void;

  clearTxhashsList(): void;
  getTxhashsList(): Array<string>;
  setTxhashsList(value: Array<string>): void;
  addTxhashs(value: string, index?: number): string;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Block.AsObject;
  static toObject(includeInstance: boolean, msg: Block): Block.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Block, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Block;
  static deserializeBinaryFromReader(message: Block, reader: jspb.BinaryReader): Block;
}

export namespace Block {
  export type AsObject = {
    header?: github_com_tendermint_tendermint_abci_types_types_pb.Header.AsObject,
    hash: string,
    numtxs: number,
    txhashsList: Array<string>,
  }
}

export class BlocksResult extends jspb.Message {
  getLastheight(): number;
  setLastheight(value: number): void;

  clearBlocksList(): void;
  getBlocksList(): Array<Block>;
  setBlocksList(value: Array<Block>): void;
  addBlocks(value?: Block, index?: number): Block;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): BlocksResult.AsObject;
  static toObject(includeInstance: boolean, msg: BlocksResult): BlocksResult.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: BlocksResult, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): BlocksResult;
  static deserializeBinaryFromReader(message: BlocksResult, reader: jspb.BinaryReader): BlocksResult;
}

export namespace BlocksResult {
  export type AsObject = {
    lastheight: number,
    blocksList: Array<Block.AsObject>,
  }
}