import * as jspb from 'google-protobuf'

import * as common_block_pb from '../common/block_pb'; // proto import: "common/block.proto"
import * as txpool_transaction_pool_pb from '../txpool/transaction_pool_pb'; // proto import: "txpool/transaction_pool.proto"


export class SyncMsg extends jspb.Message {
  getType(): SyncMsg.MsgType;
  setType(value: SyncMsg.MsgType): SyncMsg;

  getPayload(): Uint8Array | string;
  getPayload_asU8(): Uint8Array;
  getPayload_asB64(): string;
  setPayload(value: Uint8Array | string): SyncMsg;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SyncMsg.AsObject;
  static toObject(includeInstance: boolean, msg: SyncMsg): SyncMsg.AsObject;
  static serializeBinaryToWriter(message: SyncMsg, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SyncMsg;
  static deserializeBinaryFromReader(message: SyncMsg, reader: jspb.BinaryReader): SyncMsg;
}

export namespace SyncMsg {
  export type AsObject = {
    type: SyncMsg.MsgType,
    payload: Uint8Array | string,
  }

  export enum MsgType { 
    NODE_STATUS_REQ = 0,
    NODE_STATUS_RESP = 1,
    BLOCK_SYNC_REQ = 2,
    BLOCK_SYNC_RESP = 3,
    TX_POOL_STATUS_REQ = 4,
    TX_POOL_STATUS_RESP = 5,
  }
}

export class TxPoolSyncMsg extends jspb.Message {
  getTxPoolSyncReqId(): number;
  setTxPoolSyncReqId(value: number): TxPoolSyncMsg;

  getTxPoolStatus(): txpool_transaction_pool_pb.TxPoolStatus | undefined;
  setTxPoolStatus(value?: txpool_transaction_pool_pb.TxPoolStatus): TxPoolSyncMsg;
  hasTxPoolStatus(): boolean;
  clearTxPoolStatus(): TxPoolSyncMsg;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): TxPoolSyncMsg.AsObject;
  static toObject(includeInstance: boolean, msg: TxPoolSyncMsg): TxPoolSyncMsg.AsObject;
  static serializeBinaryToWriter(message: TxPoolSyncMsg, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): TxPoolSyncMsg;
  static deserializeBinaryFromReader(message: TxPoolSyncMsg, reader: jspb.BinaryReader): TxPoolSyncMsg;
}

export namespace TxPoolSyncMsg {
  export type AsObject = {
    txPoolSyncReqId: number,
    txPoolStatus?: txpool_transaction_pool_pb.TxPoolStatus.AsObject,
  }
}

export class BlockHeightBCM extends jspb.Message {
  getBlockHeight(): number;
  setBlockHeight(value: number): BlockHeightBCM;

  getArchivedHeight(): number;
  setArchivedHeight(value: number): BlockHeightBCM;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): BlockHeightBCM.AsObject;
  static toObject(includeInstance: boolean, msg: BlockHeightBCM): BlockHeightBCM.AsObject;
  static serializeBinaryToWriter(message: BlockHeightBCM, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): BlockHeightBCM;
  static deserializeBinaryFromReader(message: BlockHeightBCM, reader: jspb.BinaryReader): BlockHeightBCM;
}

export namespace BlockHeightBCM {
  export type AsObject = {
    blockHeight: number,
    archivedHeight: number,
  }
}

export class BlockSyncReq extends jspb.Message {
  getBlockHeight(): number;
  setBlockHeight(value: number): BlockSyncReq;

  getBatchSize(): number;
  setBatchSize(value: number): BlockSyncReq;

  getWithRwset(): boolean;
  setWithRwset(value: boolean): BlockSyncReq;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): BlockSyncReq.AsObject;
  static toObject(includeInstance: boolean, msg: BlockSyncReq): BlockSyncReq.AsObject;
  static serializeBinaryToWriter(message: BlockSyncReq, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): BlockSyncReq;
  static deserializeBinaryFromReader(message: BlockSyncReq, reader: jspb.BinaryReader): BlockSyncReq;
}

export namespace BlockSyncReq {
  export type AsObject = {
    blockHeight: number,
    batchSize: number,
    withRwset: boolean,
  }
}

export class BlockBatch extends jspb.Message {
  getBatchesList(): Array<common_block_pb.Block>;
  setBatchesList(value: Array<common_block_pb.Block>): BlockBatch;
  clearBatchesList(): BlockBatch;
  addBatches(value?: common_block_pb.Block, index?: number): common_block_pb.Block;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): BlockBatch.AsObject;
  static toObject(includeInstance: boolean, msg: BlockBatch): BlockBatch.AsObject;
  static serializeBinaryToWriter(message: BlockBatch, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): BlockBatch;
  static deserializeBinaryFromReader(message: BlockBatch, reader: jspb.BinaryReader): BlockBatch;
}

export namespace BlockBatch {
  export type AsObject = {
    batchesList: Array<common_block_pb.Block.AsObject>,
  }
}

export class BlockInfoBatch extends jspb.Message {
  getBatchList(): Array<common_block_pb.BlockInfo>;
  setBatchList(value: Array<common_block_pb.BlockInfo>): BlockInfoBatch;
  clearBatchList(): BlockInfoBatch;
  addBatch(value?: common_block_pb.BlockInfo, index?: number): common_block_pb.BlockInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): BlockInfoBatch.AsObject;
  static toObject(includeInstance: boolean, msg: BlockInfoBatch): BlockInfoBatch.AsObject;
  static serializeBinaryToWriter(message: BlockInfoBatch, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): BlockInfoBatch;
  static deserializeBinaryFromReader(message: BlockInfoBatch, reader: jspb.BinaryReader): BlockInfoBatch;
}

export namespace BlockInfoBatch {
  export type AsObject = {
    batchList: Array<common_block_pb.BlockInfo.AsObject>,
  }
}

export class SyncBlockBatch extends jspb.Message {
  getBlockBatch(): BlockBatch | undefined;
  setBlockBatch(value?: BlockBatch): SyncBlockBatch;
  hasBlockBatch(): boolean;
  clearBlockBatch(): SyncBlockBatch;

  getBlockinfoBatch(): BlockInfoBatch | undefined;
  setBlockinfoBatch(value?: BlockInfoBatch): SyncBlockBatch;
  hasBlockinfoBatch(): boolean;
  clearBlockinfoBatch(): SyncBlockBatch;

  getWithRwset(): boolean;
  setWithRwset(value: boolean): SyncBlockBatch;

  getDataCase(): SyncBlockBatch.DataCase;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SyncBlockBatch.AsObject;
  static toObject(includeInstance: boolean, msg: SyncBlockBatch): SyncBlockBatch.AsObject;
  static serializeBinaryToWriter(message: SyncBlockBatch, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SyncBlockBatch;
  static deserializeBinaryFromReader(message: SyncBlockBatch, reader: jspb.BinaryReader): SyncBlockBatch;
}

export namespace SyncBlockBatch {
  export type AsObject = {
    blockBatch?: BlockBatch.AsObject,
    blockinfoBatch?: BlockInfoBatch.AsObject,
    withRwset: boolean,
  }

  export enum DataCase { 
    DATA_NOT_SET = 0,
    BLOCK_BATCH = 1,
    BLOCKINFO_BATCH = 2,
  }
}

export class NodeInform extends jspb.Message {
  getId(): string;
  setId(value: string): NodeInform;

  getHeight(): number;
  setHeight(value: number): NodeInform;

  getArchiveheight(): number;
  setArchiveheight(value: number): NodeInform;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): NodeInform.AsObject;
  static toObject(includeInstance: boolean, msg: NodeInform): NodeInform.AsObject;
  static serializeBinaryToWriter(message: NodeInform, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): NodeInform;
  static deserializeBinaryFromReader(message: NodeInform, reader: jspb.BinaryReader): NodeInform;
}

export namespace NodeInform {
  export type AsObject = {
    id: string,
    height: number,
    archiveheight: number,
  }
}

export class Rule extends jspb.Message {
  getId(): number;
  setId(value: number): Rule;

  getBeginHeight(): number;
  setBeginHeight(value: number): Rule;

  getEndHeight(): number;
  setEndHeight(value: number): Rule;

  getContent(): string;
  setContent(value: string): Rule;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Rule.AsObject;
  static toObject(includeInstance: boolean, msg: Rule): Rule.AsObject;
  static serializeBinaryToWriter(message: Rule, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Rule;
  static deserializeBinaryFromReader(message: Rule, reader: jspb.BinaryReader): Rule;
}

export namespace Rule {
  export type AsObject = {
    id: number,
    beginHeight: number,
    endHeight: number,
    content: string,
  }
}

export class NodeRule extends jspb.Message {
  getNodeId(): string;
  setNodeId(value: string): NodeRule;

  getLatestRuleId(): number;
  setLatestRuleId(value: number): NodeRule;

  getRulesList(): Array<Rule>;
  setRulesList(value: Array<Rule>): NodeRule;
  clearRulesList(): NodeRule;
  addRules(value?: Rule, index?: number): Rule;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): NodeRule.AsObject;
  static toObject(includeInstance: boolean, msg: NodeRule): NodeRule.AsObject;
  static serializeBinaryToWriter(message: NodeRule, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): NodeRule;
  static deserializeBinaryFromReader(message: NodeRule, reader: jspb.BinaryReader): NodeRule;
}

export namespace NodeRule {
  export type AsObject = {
    nodeId: string,
    latestRuleId: number,
    rulesList: Array<Rule.AsObject>,
  }
}

export class SliceData extends jspb.Message {
  getVersion(): number;
  setVersion(value: number): SliceData;

  getRuleId(): number;
  setRuleId(value: number): SliceData;

  getData(): Uint8Array | string;
  getData_asU8(): Uint8Array;
  getData_asB64(): string;
  setData(value: Uint8Array | string): SliceData;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SliceData.AsObject;
  static toObject(includeInstance: boolean, msg: SliceData): SliceData.AsObject;
  static serializeBinaryToWriter(message: SliceData, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SliceData;
  static deserializeBinaryFromReader(message: SliceData, reader: jspb.BinaryReader): SliceData;
}

export namespace SliceData {
  export type AsObject = {
    version: number,
    ruleId: number,
    data: Uint8Array | string,
  }
}

export class TxHashSet extends jspb.Message {
  getTxHashSetMap(): jspb.Map<string, Uint8Array | string>;
  clearTxHashSetMap(): TxHashSet;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): TxHashSet.AsObject;
  static toObject(includeInstance: boolean, msg: TxHashSet): TxHashSet.AsObject;
  static serializeBinaryToWriter(message: TxHashSet, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): TxHashSet;
  static deserializeBinaryFromReader(message: TxHashSet, reader: jspb.BinaryReader): TxHashSet;
}

export namespace TxHashSet {
  export type AsObject = {
    txHashSetMap: Array<[string, Uint8Array | string]>,
  }
}

export class GetSyncStateRequest extends jspb.Message {
  getChainId(): string;
  setChainId(value: string): GetSyncStateRequest;

  getWithPeers(): boolean;
  setWithPeers(value: boolean): GetSyncStateRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetSyncStateRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GetSyncStateRequest): GetSyncStateRequest.AsObject;
  static serializeBinaryToWriter(message: GetSyncStateRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetSyncStateRequest;
  static deserializeBinaryFromReader(message: GetSyncStateRequest, reader: jspb.BinaryReader): GetSyncStateRequest;
}

export namespace GetSyncStateRequest {
  export type AsObject = {
    chainId: string,
    withPeers: boolean,
  }
}

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

  getArchivedHeight(): number;
  setArchivedHeight(value: number): SyncState;

  getBlocksHasSynced(): number;
  setBlocksHasSynced(value: number): SyncState;

  getBlocksInCache(): number;
  setBlocksInCache(value: number): SyncState;

  getOthersList(): Array<NodeState>;
  setOthersList(value: Array<NodeState>): SyncState;
  clearOthersList(): SyncState;
  addOthers(value?: NodeState, index?: number): NodeState;

  getConfigShow(): string;
  setConfigShow(value: string): SyncState;

  getTimestamp(): number;
  setTimestamp(value: number): SyncState;

  getNodeId(): string;
  setNodeId(value: string): SyncState;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SyncState.AsObject;
  static toObject(includeInstance: boolean, msg: SyncState): SyncState.AsObject;
  static serializeBinaryToWriter(message: SyncState, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SyncState;
  static deserializeBinaryFromReader(message: SyncState, reader: jspb.BinaryReader): SyncState;
}

export namespace SyncState {
  export type AsObject = {
    height: number,
    archivedHeight: number,
    blocksHasSynced: number,
    blocksInCache: number,
    othersList: Array<NodeState.AsObject>,
    configShow: string,
    timestamp: number,
    nodeId: string,
  }
}

export class NodeState extends jspb.Message {
  getNodeId(): string;
  setNodeId(value: string): NodeState;

  getHeight(): number;
  setHeight(value: number): NodeState;

  getArchivedHeight(): number;
  setArchivedHeight(value: number): NodeState;

  getReceiveTime(): number;
  setReceiveTime(value: number): NodeState;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): NodeState.AsObject;
  static toObject(includeInstance: boolean, msg: NodeState): NodeState.AsObject;
  static serializeBinaryToWriter(message: NodeState, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): NodeState;
  static deserializeBinaryFromReader(message: NodeState, reader: jspb.BinaryReader): NodeState;
}

export namespace NodeState {
  export type AsObject = {
    nodeId: string,
    height: number,
    archivedHeight: number,
    receiveTime: number,
  }
}