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

TypeScript library that calls a Hyperledger Burrow server over GRPC.

// package: rpcevents
// file: rpcevents.proto

import * as jspb from "google-protobuf";
import * as github_com_gogo_protobuf_gogoproto_gogo_pb from "./github.com/gogo/protobuf/gogoproto/gogo_pb";
import * as google_protobuf_duration_pb from "google-protobuf/google/protobuf/duration_pb";
import * as google_protobuf_timestamp_pb from "google-protobuf/google/protobuf/timestamp_pb";
import * as exec_pb from "./exec_pb";

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

  getWait(): boolean;
  setWait(value: boolean): void;

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

export namespace GetBlockRequest {
  export type AsObject = {
    height: number,
    wait: boolean,
  }
}

export class TxRequest extends jspb.Message {
  getTxhash(): Uint8Array | string;
  getTxhash_asU8(): Uint8Array;
  getTxhash_asB64(): string;
  setTxhash(value: Uint8Array | string): void;

  getWait(): boolean;
  setWait(value: boolean): void;

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

export namespace TxRequest {
  export type AsObject = {
    txhash: Uint8Array | string,
    wait: boolean,
  }
}

export class BlocksRequest extends jspb.Message {
  hasBlockrange(): boolean;
  clearBlockrange(): void;
  getBlockrange(): BlockRange | undefined;
  setBlockrange(value?: BlockRange): void;

  getQuery(): string;
  setQuery(value: string): void;

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

export namespace BlocksRequest {
  export type AsObject = {
    blockrange?: BlockRange.AsObject,
    query: string,
  }
}

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

  clearEventsList(): void;
  getEventsList(): Array<exec_pb.Event>;
  setEventsList(value: Array<exec_pb.Event>): void;
  addEvents(value?: exec_pb.Event, index?: number): exec_pb.Event;

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

export namespace EventsResponse {
  export type AsObject = {
    height: number,
    eventsList: Array<exec_pb.Event.AsObject>,
  }
}

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

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

  getQuery(): string;
  setQuery(value: string): void;

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

export namespace GetTxsRequest {
  export type AsObject = {
    startheight: number,
    endheight: number,
    query: string,
  }
}

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

  clearTxexecutionsList(): void;
  getTxexecutionsList(): Array<exec_pb.TxExecution>;
  setTxexecutionsList(value: Array<exec_pb.TxExecution>): void;
  addTxexecutions(value?: exec_pb.TxExecution, index?: number): exec_pb.TxExecution;

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

export namespace GetTxsResponse {
  export type AsObject = {
    height: number,
    txexecutionsList: Array<exec_pb.TxExecution.AsObject>,
  }
}

export class Bound extends jspb.Message {
  getType(): Bound.BoundTypeMap[keyof Bound.BoundTypeMap];
  setType(value: Bound.BoundTypeMap[keyof Bound.BoundTypeMap]): void;

  getIndex(): number;
  setIndex(value: number): void;

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

export namespace Bound {
  export type AsObject = {
    type: Bound.BoundTypeMap[keyof Bound.BoundTypeMap],
    index: number,
  }

  export interface BoundTypeMap {
    ABSOLUTE: 0;
    RELATIVE: 1;
    FIRST: 2;
    LATEST: 3;
    STREAM: 4;
  }

  export const BoundType: BoundTypeMap;
}

export class BlockRange extends jspb.Message {
  hasStart(): boolean;
  clearStart(): void;
  getStart(): Bound | undefined;
  setStart(value?: Bound): void;

  hasEnd(): boolean;
  clearEnd(): void;
  getEnd(): Bound | undefined;
  setEnd(value?: Bound): void;

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

export namespace BlockRange {
  export type AsObject = {
    start?: Bound.AsObject,
    end?: Bound.AsObject,
  }
}

export class StatRequest extends jspb.Message {
  hasStatperiod(): boolean;
  clearStatperiod(): void;
  getStatperiod(): google_protobuf_duration_pb.Duration | undefined;
  setStatperiod(value?: google_protobuf_duration_pb.Duration): void;

  hasRateperiod(): boolean;
  clearRateperiod(): void;
  getRateperiod(): google_protobuf_duration_pb.Duration | undefined;
  setRateperiod(value?: google_protobuf_duration_pb.Duration): void;

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

export namespace StatRequest {
  export type AsObject = {
    statperiod?: google_protobuf_duration_pb.Duration.AsObject,
    rateperiod?: google_protobuf_duration_pb.Duration.AsObject,
  }
}

export class NodeStat extends jspb.Message {
  getValidators(): number;
  setValidators(value: number): void;

  getPeers(): number;
  setPeers(value: number): void;

  getLastblockheight(): number;
  setLastblockheight(value: number): void;

  getPendingtxs(): number;
  setPendingtxs(value: number): void;

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

export namespace NodeStat {
  export type AsObject = {
    validators: number,
    peers: number,
    lastblockheight: number,
    pendingtxs: number,
  }
}

export class RateStat extends jspb.Message {
  getBlock(): number;
  setBlock(value: number): void;

  getTx(): number;
  setTx(value: number): void;

  hasTime(): boolean;
  clearTime(): void;
  getTime(): google_protobuf_timestamp_pb.Timestamp | undefined;
  setTime(value?: google_protobuf_timestamp_pb.Timestamp): void;

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

export namespace RateStat {
  export type AsObject = {
    block: number,
    tx: number,
    time?: google_protobuf_timestamp_pb.Timestamp.AsObject,
  }
}

export class StatResponse extends jspb.Message {
  hasNode(): boolean;
  clearNode(): void;
  getNode(): NodeStat | undefined;
  setNode(value?: NodeStat): void;

  hasRate(): boolean;
  clearRate(): void;
  getRate(): RateStat | undefined;
  setRate(value?: RateStat): void;

  hasBlock(): boolean;
  clearBlock(): void;
  getBlock(): exec_pb.BlockExecution | undefined;
  setBlock(value?: exec_pb.BlockExecution): void;

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

export namespace StatResponse {
  export type AsObject = {
    node?: NodeStat.AsObject,
    rate?: RateStat.AsObject,
    block?: exec_pb.BlockExecution.AsObject,
  }
}