@agoric/client-utils 0.1.1-other-dev-3eb1a1d.0 → 0.1.1-other-dev-fbe72e7.0.fbe72e7

package/dist/codegen/tendermint/abci/types.d.ts

@@ -0,0 +1,843 @@
+import { Header, type HeaderSDKType } from '../types/types.js';
+import { ProofOps, type ProofOpsSDKType } from '../crypto/proof.js';
+import { ConsensusParams, type ConsensusParamsSDKType } from '../types/params.js';
+import { PublicKey, type PublicKeySDKType } from '../crypto/keys.js';
+import { Timestamp, type TimestampSDKType } from '../../google/protobuf/timestamp.js';
+import { BinaryReader, BinaryWriter } from '../../binary.js';
+import { type JsonSafe } from '../../json-safe.js';
+export declare enum CheckTxType {
+    NEW = 0,
+    RECHECK = 1,
+    UNRECOGNIZED = -1
+}
+export declare const CheckTxTypeSDKType: typeof CheckTxType;
+export declare function checkTxTypeFromJSON(object: any): CheckTxType;
+export declare function checkTxTypeToJSON(object: CheckTxType): string;
+export declare enum EvidenceType {
+    UNKNOWN = 0,
+    DUPLICATE_VOTE = 1,
+    LIGHT_CLIENT_ATTACK = 2,
+    UNRECOGNIZED = -1
+}
+export declare const EvidenceTypeSDKType: typeof EvidenceType;
+export declare function evidenceTypeFromJSON(object: any): EvidenceType;
+export declare function evidenceTypeToJSON(object: EvidenceType): string;
+/**
+ * message Request {
+ * oneof value {
+ * RequestEcho               echo                 = 1;
+ * RequestFlush              flush                = 2;
+ * RequestInfo               info                 = 3;
+ * RequestSetOption          set_option           = 4;
+ * RequestInitChain          init_chain           = 5;
+ * RequestQuery              query                = 6;
+ * RequestBeginBlock         begin_block          = 7;
+ * RequestCheckTx            check_tx             = 8;
+ * RequestDeliverTx          deliver_tx           = 9;
+ * RequestEndBlock           end_block            = 10;
+ * RequestCommit             commit               = 11;
+ * RequestListSnapshots      list_snapshots       = 12;
+ * RequestOfferSnapshot      offer_snapshot       = 13;
+ * RequestLoadSnapshotChunk  load_snapshot_chunk  = 14;
+ * RequestApplySnapshotChunk apply_snapshot_chunk = 15;
+ * }
+ * }
+ *
+ * message RequestEcho {
+ * string message = 1;
+ * }
+ *
+ * message RequestFlush {}
+ *
+ * message RequestInfo {
+ * string version       = 1;
+ * uint64 block_version = 2;
+ * uint64 p2p_version   = 3;
+ * }
+ *
+ * nondeterministic
+ * message RequestSetOption {
+ * string key   = 1;
+ * string value = 2;
+ * }
+ *
+ * message RequestInitChain {
+ * google.protobuf.Timestamp time             = 1 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
+ * string                    chain_id         = 2;
+ * ConsensusParams           consensus_params = 3;
+ * repeated ValidatorUpdate  validators       = 4 [(gogoproto.nullable) = false];
+ * bytes                     app_state_bytes  = 5;
+ * int64                     initial_height   = 6;
+ * }
+ */
+export interface RequestQuery {
+    data: Uint8Array;
+    path: string;
+    height: bigint;
+    prove: boolean;
+}
+export interface RequestQueryProtoMsg {
+    typeUrl: '/tendermint.abci.RequestQuery';
+    value: Uint8Array;
+}
+/**
+ * message Request {
+ * oneof value {
+ * RequestEcho               echo                 = 1;
+ * RequestFlush              flush                = 2;
+ * RequestInfo               info                 = 3;
+ * RequestSetOption          set_option           = 4;
+ * RequestInitChain          init_chain           = 5;
+ * RequestQuery              query                = 6;
+ * RequestBeginBlock         begin_block          = 7;
+ * RequestCheckTx            check_tx             = 8;
+ * RequestDeliverTx          deliver_tx           = 9;
+ * RequestEndBlock           end_block            = 10;
+ * RequestCommit             commit               = 11;
+ * RequestListSnapshots      list_snapshots       = 12;
+ * RequestOfferSnapshot      offer_snapshot       = 13;
+ * RequestLoadSnapshotChunk  load_snapshot_chunk  = 14;
+ * RequestApplySnapshotChunk apply_snapshot_chunk = 15;
+ * }
+ * }
+ *
+ * message RequestEcho {
+ * string message = 1;
+ * }
+ *
+ * message RequestFlush {}
+ *
+ * message RequestInfo {
+ * string version       = 1;
+ * uint64 block_version = 2;
+ * uint64 p2p_version   = 3;
+ * }
+ *
+ * nondeterministic
+ * message RequestSetOption {
+ * string key   = 1;
+ * string value = 2;
+ * }
+ *
+ * message RequestInitChain {
+ * google.protobuf.Timestamp time             = 1 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
+ * string                    chain_id         = 2;
+ * ConsensusParams           consensus_params = 3;
+ * repeated ValidatorUpdate  validators       = 4 [(gogoproto.nullable) = false];
+ * bytes                     app_state_bytes  = 5;
+ * int64                     initial_height   = 6;
+ * }
+ */
+export interface RequestQuerySDKType {
+    data: Uint8Array;
+    path: string;
+    height: bigint;
+    prove: boolean;
+}
+export interface RequestBeginBlock {
+    hash: Uint8Array;
+    header: Header;
+    lastCommitInfo: LastCommitInfo;
+    byzantineValidators: Evidence[];
+}
+export interface RequestBeginBlockProtoMsg {
+    typeUrl: '/tendermint.abci.RequestBeginBlock';
+    value: Uint8Array;
+}
+export interface RequestBeginBlockSDKType {
+    hash: Uint8Array;
+    header: HeaderSDKType;
+    last_commit_info: LastCommitInfoSDKType;
+    byzantine_validators: EvidenceSDKType[];
+}
+export interface RequestCheckTx {
+    tx: Uint8Array;
+    type: CheckTxType;
+}
+export interface RequestCheckTxProtoMsg {
+    typeUrl: '/tendermint.abci.RequestCheckTx';
+    value: Uint8Array;
+}
+export interface RequestCheckTxSDKType {
+    tx: Uint8Array;
+    type: CheckTxType;
+}
+export interface RequestDeliverTx {
+    tx: Uint8Array;
+}
+export interface RequestDeliverTxProtoMsg {
+    typeUrl: '/tendermint.abci.RequestDeliverTx';
+    value: Uint8Array;
+}
+export interface RequestDeliverTxSDKType {
+    tx: Uint8Array;
+}
+export interface RequestEndBlock {
+    height: bigint;
+}
+export interface RequestEndBlockProtoMsg {
+    typeUrl: '/tendermint.abci.RequestEndBlock';
+    value: Uint8Array;
+}
+export interface RequestEndBlockSDKType {
+    height: bigint;
+}
+export interface RequestCommit {
+}
+export interface RequestCommitProtoMsg {
+    typeUrl: '/tendermint.abci.RequestCommit';
+    value: Uint8Array;
+}
+export interface RequestCommitSDKType {
+}
+/**
+ * lists available snapshots
+ * message RequestListSnapshots {}
+ *
+ * offers a snapshot to the application
+ * message RequestOfferSnapshot {
+ * Snapshot snapshot = 1; // snapshot offered by peers
+ * bytes    app_hash = 2; // light client-verified app hash for snapshot height
+ * }
+ *
+ * loads a snapshot chunk
+ * message RequestLoadSnapshotChunk {
+ * uint64 height = 1;
+ * uint32 format = 2;
+ * uint32 chunk  = 3;
+ * }
+ *
+ * Applies a snapshot chunk
+ * message RequestApplySnapshotChunk {
+ * uint32 index  = 1;
+ * bytes  chunk  = 2;
+ * string sender = 3;
+ * }
+ *
+ * ----------------------------------------
+ * Response types
+ *
+ * message Response {
+ * oneof value {
+ * ResponseException          exception            = 1;
+ * ResponseEcho               echo                 = 2;
+ * ResponseFlush              flush                = 3;
+ * ResponseInfo               info                 = 4;
+ * ResponseSetOption          set_option           = 5;
+ * ResponseInitChain          init_chain           = 6;
+ * ResponseQuery              query                = 7;
+ * ResponseBeginBlock         begin_block          = 8;
+ * ResponseCheckTx            check_tx             = 9;
+ * ResponseDeliverTx          deliver_tx           = 10;
+ * ResponseEndBlock           end_block            = 11;
+ * ResponseCommit             commit               = 12;
+ * ResponseListSnapshots      list_snapshots       = 13;
+ * ResponseOfferSnapshot      offer_snapshot       = 14;
+ * ResponseLoadSnapshotChunk  load_snapshot_chunk  = 15;
+ * ResponseApplySnapshotChunk apply_snapshot_chunk = 16;
+ * }
+ * }
+ *
+ * nondeterministic
+ * message ResponseException {
+ * string error = 1;
+ * }
+ *
+ * message ResponseEcho {
+ * string message = 1;
+ * }
+ *
+ * message ResponseFlush {}
+ *
+ * message ResponseInfo {
+ * string data = 1;
+ *
+ * string version     = 2;
+ * uint64 app_version = 3;
+ *
+ * int64 last_block_height   = 4;
+ * bytes last_block_app_hash = 5;
+ * }
+ *
+ * nondeterministic
+ * message ResponseSetOption {
+ * uint32 code = 1;
+ * bytes data = 2;
+ * string log  = 3;
+ * string info = 4;
+ * }
+ *
+ * message ResponseInitChain {
+ * ConsensusParams          consensus_params = 1;
+ * repeated ValidatorUpdate validators       = 2 [(gogoproto.nullable) = false];
+ * bytes                    app_hash         = 3;
+ * }
+ */
+export interface ResponseQuery {
+    code: number;
+    /** bytes data = 2; // use "value" instead. */
+    log: string;
+    /** nondeterministic */
+    info: string;
+    index: bigint;
+    key: Uint8Array;
+    value: Uint8Array;
+    proofOps?: ProofOps;
+    height: bigint;
+    codespace: string;
+}
+export interface ResponseQueryProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseQuery';
+    value: Uint8Array;
+}
+/**
+ * lists available snapshots
+ * message RequestListSnapshots {}
+ *
+ * offers a snapshot to the application
+ * message RequestOfferSnapshot {
+ * Snapshot snapshot = 1; // snapshot offered by peers
+ * bytes    app_hash = 2; // light client-verified app hash for snapshot height
+ * }
+ *
+ * loads a snapshot chunk
+ * message RequestLoadSnapshotChunk {
+ * uint64 height = 1;
+ * uint32 format = 2;
+ * uint32 chunk  = 3;
+ * }
+ *
+ * Applies a snapshot chunk
+ * message RequestApplySnapshotChunk {
+ * uint32 index  = 1;
+ * bytes  chunk  = 2;
+ * string sender = 3;
+ * }
+ *
+ * ----------------------------------------
+ * Response types
+ *
+ * message Response {
+ * oneof value {
+ * ResponseException          exception            = 1;
+ * ResponseEcho               echo                 = 2;
+ * ResponseFlush              flush                = 3;
+ * ResponseInfo               info                 = 4;
+ * ResponseSetOption          set_option           = 5;
+ * ResponseInitChain          init_chain           = 6;
+ * ResponseQuery              query                = 7;
+ * ResponseBeginBlock         begin_block          = 8;
+ * ResponseCheckTx            check_tx             = 9;
+ * ResponseDeliverTx          deliver_tx           = 10;
+ * ResponseEndBlock           end_block            = 11;
+ * ResponseCommit             commit               = 12;
+ * ResponseListSnapshots      list_snapshots       = 13;
+ * ResponseOfferSnapshot      offer_snapshot       = 14;
+ * ResponseLoadSnapshotChunk  load_snapshot_chunk  = 15;
+ * ResponseApplySnapshotChunk apply_snapshot_chunk = 16;
+ * }
+ * }
+ *
+ * nondeterministic
+ * message ResponseException {
+ * string error = 1;
+ * }
+ *
+ * message ResponseEcho {
+ * string message = 1;
+ * }
+ *
+ * message ResponseFlush {}
+ *
+ * message ResponseInfo {
+ * string data = 1;
+ *
+ * string version     = 2;
+ * uint64 app_version = 3;
+ *
+ * int64 last_block_height   = 4;
+ * bytes last_block_app_hash = 5;
+ * }
+ *
+ * nondeterministic
+ * message ResponseSetOption {
+ * uint32 code = 1;
+ * bytes data = 2;
+ * string log  = 3;
+ * string info = 4;
+ * }
+ *
+ * message ResponseInitChain {
+ * ConsensusParams          consensus_params = 1;
+ * repeated ValidatorUpdate validators       = 2 [(gogoproto.nullable) = false];
+ * bytes                    app_hash         = 3;
+ * }
+ */
+export interface ResponseQuerySDKType {
+    code: number;
+    log: string;
+    info: string;
+    index: bigint;
+    key: Uint8Array;
+    value: Uint8Array;
+    proof_ops?: ProofOpsSDKType;
+    height: bigint;
+    codespace: string;
+}
+export interface ResponseBeginBlock {
+    events: Event[];
+}
+export interface ResponseBeginBlockProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseBeginBlock';
+    value: Uint8Array;
+}
+export interface ResponseBeginBlockSDKType {
+    events: EventSDKType[];
+}
+export interface ResponseCheckTx {
+    code: number;
+    data: Uint8Array;
+    /** nondeterministic */
+    log: string;
+    /** nondeterministic */
+    info: string;
+    gasWanted: bigint;
+    gasUsed: bigint;
+    events: Event[];
+    codespace: string;
+}
+export interface ResponseCheckTxProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseCheckTx';
+    value: Uint8Array;
+}
+export interface ResponseCheckTxSDKType {
+    code: number;
+    data: Uint8Array;
+    log: string;
+    info: string;
+    gas_wanted: bigint;
+    gas_used: bigint;
+    events: EventSDKType[];
+    codespace: string;
+}
+export interface ResponseDeliverTx {
+    code: number;
+    data: Uint8Array;
+    /** nondeterministic */
+    log: string;
+    /** nondeterministic */
+    info: string;
+    gasWanted: bigint;
+    gasUsed: bigint;
+    events: Event[];
+    codespace: string;
+}
+export interface ResponseDeliverTxProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseDeliverTx';
+    value: Uint8Array;
+}
+export interface ResponseDeliverTxSDKType {
+    code: number;
+    data: Uint8Array;
+    log: string;
+    info: string;
+    gas_wanted: bigint;
+    gas_used: bigint;
+    events: EventSDKType[];
+    codespace: string;
+}
+export interface ResponseEndBlock {
+    validatorUpdates: ValidatorUpdate[];
+    consensusParamUpdates?: ConsensusParams;
+    events: Event[];
+}
+export interface ResponseEndBlockProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseEndBlock';
+    value: Uint8Array;
+}
+export interface ResponseEndBlockSDKType {
+    validator_updates: ValidatorUpdateSDKType[];
+    consensus_param_updates?: ConsensusParamsSDKType;
+    events: EventSDKType[];
+}
+export interface ResponseCommit {
+    /** reserve 1 */
+    data: Uint8Array;
+    retainHeight: bigint;
+}
+export interface ResponseCommitProtoMsg {
+    typeUrl: '/tendermint.abci.ResponseCommit';
+    value: Uint8Array;
+}
+export interface ResponseCommitSDKType {
+    data: Uint8Array;
+    retain_height: bigint;
+}
+export interface LastCommitInfo {
+    round: number;
+    votes: VoteInfo[];
+}
+export interface LastCommitInfoProtoMsg {
+    typeUrl: '/tendermint.abci.LastCommitInfo';
+    value: Uint8Array;
+}
+export interface LastCommitInfoSDKType {
+    round: number;
+    votes: VoteInfoSDKType[];
+}
+/**
+ * Event allows application developers to attach additional information to
+ * ResponseBeginBlock, ResponseEndBlock, ResponseCheckTx and ResponseDeliverTx.
+ * Later, transactions may be queried using these events.
+ */
+export interface Event {
+    type: string;
+    attributes: EventAttribute[];
+}
+export interface EventProtoMsg {
+    typeUrl: '/tendermint.abci.Event';
+    value: Uint8Array;
+}
+/**
+ * Event allows application developers to attach additional information to
+ * ResponseBeginBlock, ResponseEndBlock, ResponseCheckTx and ResponseDeliverTx.
+ * Later, transactions may be queried using these events.
+ */
+export interface EventSDKType {
+    type: string;
+    attributes: EventAttributeSDKType[];
+}
+/** EventAttribute is a single key-value pair, associated with an event. */
+export interface EventAttribute {
+    key: Uint8Array;
+    value: Uint8Array;
+    /** nondeterministic */
+    index: boolean;
+}
+export interface EventAttributeProtoMsg {
+    typeUrl: '/tendermint.abci.EventAttribute';
+    value: Uint8Array;
+}
+/** EventAttribute is a single key-value pair, associated with an event. */
+export interface EventAttributeSDKType {
+    key: Uint8Array;
+    value: Uint8Array;
+    index: boolean;
+}
+/**
+ * TxResult contains results of executing the transaction.
+ *
+ * One usage is indexing transaction results.
+ */
+export interface TxResult {
+    height: bigint;
+    index: number;
+    tx: Uint8Array;
+    result: ResponseDeliverTx;
+}
+export interface TxResultProtoMsg {
+    typeUrl: '/tendermint.abci.TxResult';
+    value: Uint8Array;
+}
+/**
+ * TxResult contains results of executing the transaction.
+ *
+ * One usage is indexing transaction results.
+ */
+export interface TxResultSDKType {
+    height: bigint;
+    index: number;
+    tx: Uint8Array;
+    result: ResponseDeliverTxSDKType;
+}
+/** Validator */
+export interface Validator {
+    /** The first 20 bytes of SHA256(public key) */
+    address: Uint8Array;
+    /** PubKey pub_key = 2 [(gogoproto.nullable)=false]; */
+    power: bigint;
+}
+export interface ValidatorProtoMsg {
+    typeUrl: '/tendermint.abci.Validator';
+    value: Uint8Array;
+}
+/** Validator */
+export interface ValidatorSDKType {
+    address: Uint8Array;
+    power: bigint;
+}
+/** ValidatorUpdate */
+export interface ValidatorUpdate {
+    pubKey: PublicKey;
+    power: bigint;
+}
+export interface ValidatorUpdateProtoMsg {
+    typeUrl: '/tendermint.abci.ValidatorUpdate';
+    value: Uint8Array;
+}
+/** ValidatorUpdate */
+export interface ValidatorUpdateSDKType {
+    pub_key: PublicKeySDKType;
+    power: bigint;
+}
+/** VoteInfo */
+export interface VoteInfo {
+    validator: Validator;
+    signedLastBlock: boolean;
+}
+export interface VoteInfoProtoMsg {
+    typeUrl: '/tendermint.abci.VoteInfo';
+    value: Uint8Array;
+}
+/** VoteInfo */
+export interface VoteInfoSDKType {
+    validator: ValidatorSDKType;
+    signed_last_block: boolean;
+}
+export interface Evidence {
+    type: EvidenceType;
+    /** The offending validator */
+    validator: Validator;
+    /** The height when the offense occurred */
+    height: bigint;
+    /** The corresponding time where the offense occurred */
+    time: Timestamp;
+    /**
+     * Total voting power of the validator set in case the ABCI application does
+     * not store historical validators.
+     * https://github.com/tendermint/tendermint/issues/4581
+     */
+    totalVotingPower: bigint;
+}
+export interface EvidenceProtoMsg {
+    typeUrl: '/tendermint.abci.Evidence';
+    value: Uint8Array;
+}
+export interface EvidenceSDKType {
+    type: EvidenceType;
+    validator: ValidatorSDKType;
+    height: bigint;
+    time: TimestampSDKType;
+    total_voting_power: bigint;
+}
+export declare const RequestQuery: {
+    typeUrl: "/tendermint.abci.RequestQuery";
+    encode(message: RequestQuery, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestQuery;
+    fromJSON(object: any): RequestQuery;
+    toJSON(message: RequestQuery): JsonSafe<RequestQuery>;
+    fromPartial(object: Partial<RequestQuery>): RequestQuery;
+    fromProtoMsg(message: RequestQueryProtoMsg): RequestQuery;
+    toProto(message: RequestQuery): Uint8Array;
+    toProtoMsg(message: RequestQuery): RequestQueryProtoMsg;
+};
+export declare const RequestBeginBlock: {
+    typeUrl: "/tendermint.abci.RequestBeginBlock";
+    encode(message: RequestBeginBlock, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestBeginBlock;
+    fromJSON(object: any): RequestBeginBlock;
+    toJSON(message: RequestBeginBlock): JsonSafe<RequestBeginBlock>;
+    fromPartial(object: Partial<RequestBeginBlock>): RequestBeginBlock;
+    fromProtoMsg(message: RequestBeginBlockProtoMsg): RequestBeginBlock;
+    toProto(message: RequestBeginBlock): Uint8Array;
+    toProtoMsg(message: RequestBeginBlock): RequestBeginBlockProtoMsg;
+};
+export declare const RequestCheckTx: {
+    typeUrl: "/tendermint.abci.RequestCheckTx";
+    encode(message: RequestCheckTx, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestCheckTx;
+    fromJSON(object: any): RequestCheckTx;
+    toJSON(message: RequestCheckTx): JsonSafe<RequestCheckTx>;
+    fromPartial(object: Partial<RequestCheckTx>): RequestCheckTx;
+    fromProtoMsg(message: RequestCheckTxProtoMsg): RequestCheckTx;
+    toProto(message: RequestCheckTx): Uint8Array;
+    toProtoMsg(message: RequestCheckTx): RequestCheckTxProtoMsg;
+};
+export declare const RequestDeliverTx: {
+    typeUrl: "/tendermint.abci.RequestDeliverTx";
+    encode(message: RequestDeliverTx, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestDeliverTx;
+    fromJSON(object: any): RequestDeliverTx;
+    toJSON(message: RequestDeliverTx): JsonSafe<RequestDeliverTx>;
+    fromPartial(object: Partial<RequestDeliverTx>): RequestDeliverTx;
+    fromProtoMsg(message: RequestDeliverTxProtoMsg): RequestDeliverTx;
+    toProto(message: RequestDeliverTx): Uint8Array;
+    toProtoMsg(message: RequestDeliverTx): RequestDeliverTxProtoMsg;
+};
+export declare const RequestEndBlock: {
+    typeUrl: "/tendermint.abci.RequestEndBlock";
+    encode(message: RequestEndBlock, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestEndBlock;
+    fromJSON(object: any): RequestEndBlock;
+    toJSON(message: RequestEndBlock): JsonSafe<RequestEndBlock>;
+    fromPartial(object: Partial<RequestEndBlock>): RequestEndBlock;
+    fromProtoMsg(message: RequestEndBlockProtoMsg): RequestEndBlock;
+    toProto(message: RequestEndBlock): Uint8Array;
+    toProtoMsg(message: RequestEndBlock): RequestEndBlockProtoMsg;
+};
+export declare const RequestCommit: {
+    typeUrl: "/tendermint.abci.RequestCommit";
+    encode(_: RequestCommit, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RequestCommit;
+    fromJSON(_: any): RequestCommit;
+    toJSON(_: RequestCommit): JsonSafe<RequestCommit>;
+    fromPartial(_: Partial<RequestCommit>): RequestCommit;
+    fromProtoMsg(message: RequestCommitProtoMsg): RequestCommit;
+    toProto(message: RequestCommit): Uint8Array;
+    toProtoMsg(message: RequestCommit): RequestCommitProtoMsg;
+};
+export declare const ResponseQuery: {
+    typeUrl: "/tendermint.abci.ResponseQuery";
+    encode(message: ResponseQuery, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseQuery;
+    fromJSON(object: any): ResponseQuery;
+    toJSON(message: ResponseQuery): JsonSafe<ResponseQuery>;
+    fromPartial(object: Partial<ResponseQuery>): ResponseQuery;
+    fromProtoMsg(message: ResponseQueryProtoMsg): ResponseQuery;
+    toProto(message: ResponseQuery): Uint8Array;
+    toProtoMsg(message: ResponseQuery): ResponseQueryProtoMsg;
+};
+export declare const ResponseBeginBlock: {
+    typeUrl: "/tendermint.abci.ResponseBeginBlock";
+    encode(message: ResponseBeginBlock, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseBeginBlock;
+    fromJSON(object: any): ResponseBeginBlock;
+    toJSON(message: ResponseBeginBlock): JsonSafe<ResponseBeginBlock>;
+    fromPartial(object: Partial<ResponseBeginBlock>): ResponseBeginBlock;
+    fromProtoMsg(message: ResponseBeginBlockProtoMsg): ResponseBeginBlock;
+    toProto(message: ResponseBeginBlock): Uint8Array;
+    toProtoMsg(message: ResponseBeginBlock): ResponseBeginBlockProtoMsg;
+};
+export declare const ResponseCheckTx: {
+    typeUrl: "/tendermint.abci.ResponseCheckTx";
+    encode(message: ResponseCheckTx, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseCheckTx;
+    fromJSON(object: any): ResponseCheckTx;
+    toJSON(message: ResponseCheckTx): JsonSafe<ResponseCheckTx>;
+    fromPartial(object: Partial<ResponseCheckTx>): ResponseCheckTx;
+    fromProtoMsg(message: ResponseCheckTxProtoMsg): ResponseCheckTx;
+    toProto(message: ResponseCheckTx): Uint8Array;
+    toProtoMsg(message: ResponseCheckTx): ResponseCheckTxProtoMsg;
+};
+export declare const ResponseDeliverTx: {
+    typeUrl: "/tendermint.abci.ResponseDeliverTx";
+    encode(message: ResponseDeliverTx, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseDeliverTx;
+    fromJSON(object: any): ResponseDeliverTx;
+    toJSON(message: ResponseDeliverTx): JsonSafe<ResponseDeliverTx>;
+    fromPartial(object: Partial<ResponseDeliverTx>): ResponseDeliverTx;
+    fromProtoMsg(message: ResponseDeliverTxProtoMsg): ResponseDeliverTx;
+    toProto(message: ResponseDeliverTx): Uint8Array;
+    toProtoMsg(message: ResponseDeliverTx): ResponseDeliverTxProtoMsg;
+};
+export declare const ResponseEndBlock: {
+    typeUrl: "/tendermint.abci.ResponseEndBlock";
+    encode(message: ResponseEndBlock, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseEndBlock;
+    fromJSON(object: any): ResponseEndBlock;
+    toJSON(message: ResponseEndBlock): JsonSafe<ResponseEndBlock>;
+    fromPartial(object: Partial<ResponseEndBlock>): ResponseEndBlock;
+    fromProtoMsg(message: ResponseEndBlockProtoMsg): ResponseEndBlock;
+    toProto(message: ResponseEndBlock): Uint8Array;
+    toProtoMsg(message: ResponseEndBlock): ResponseEndBlockProtoMsg;
+};
+export declare const ResponseCommit: {
+    typeUrl: "/tendermint.abci.ResponseCommit";
+    encode(message: ResponseCommit, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ResponseCommit;
+    fromJSON(object: any): ResponseCommit;
+    toJSON(message: ResponseCommit): JsonSafe<ResponseCommit>;
+    fromPartial(object: Partial<ResponseCommit>): ResponseCommit;
+    fromProtoMsg(message: ResponseCommitProtoMsg): ResponseCommit;
+    toProto(message: ResponseCommit): Uint8Array;
+    toProtoMsg(message: ResponseCommit): ResponseCommitProtoMsg;
+};
+export declare const LastCommitInfo: {
+    typeUrl: "/tendermint.abci.LastCommitInfo";
+    encode(message: LastCommitInfo, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): LastCommitInfo;
+    fromJSON(object: any): LastCommitInfo;
+    toJSON(message: LastCommitInfo): JsonSafe<LastCommitInfo>;
+    fromPartial(object: Partial<LastCommitInfo>): LastCommitInfo;
+    fromProtoMsg(message: LastCommitInfoProtoMsg): LastCommitInfo;
+    toProto(message: LastCommitInfo): Uint8Array;
+    toProtoMsg(message: LastCommitInfo): LastCommitInfoProtoMsg;
+};
+export declare const Event: {
+    typeUrl: "/tendermint.abci.Event";
+    encode(message: Event, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Event;
+    fromJSON(object: any): Event;
+    toJSON(message: Event): JsonSafe<Event>;
+    fromPartial(object: Partial<Event>): Event;
+    fromProtoMsg(message: EventProtoMsg): Event;
+    toProto(message: Event): Uint8Array;
+    toProtoMsg(message: Event): EventProtoMsg;
+};
+export declare const EventAttribute: {
+    typeUrl: "/tendermint.abci.EventAttribute";
+    encode(message: EventAttribute, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): EventAttribute;
+    fromJSON(object: any): EventAttribute;
+    toJSON(message: EventAttribute): JsonSafe<EventAttribute>;
+    fromPartial(object: Partial<EventAttribute>): EventAttribute;
+    fromProtoMsg(message: EventAttributeProtoMsg): EventAttribute;
+    toProto(message: EventAttribute): Uint8Array;
+    toProtoMsg(message: EventAttribute): EventAttributeProtoMsg;
+};
+export declare const TxResult: {
+    typeUrl: "/tendermint.abci.TxResult";
+    encode(message: TxResult, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): TxResult;
+    fromJSON(object: any): TxResult;
+    toJSON(message: TxResult): JsonSafe<TxResult>;
+    fromPartial(object: Partial<TxResult>): TxResult;
+    fromProtoMsg(message: TxResultProtoMsg): TxResult;
+    toProto(message: TxResult): Uint8Array;
+    toProtoMsg(message: TxResult): TxResultProtoMsg;
+};
+export declare const Validator: {
+    typeUrl: "/tendermint.abci.Validator";
+    encode(message: Validator, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Validator;
+    fromJSON(object: any): Validator;
+    toJSON(message: Validator): JsonSafe<Validator>;
+    fromPartial(object: Partial<Validator>): Validator;
+    fromProtoMsg(message: ValidatorProtoMsg): Validator;
+    toProto(message: Validator): Uint8Array;
+    toProtoMsg(message: Validator): ValidatorProtoMsg;
+};
+export declare const ValidatorUpdate: {
+    typeUrl: "/tendermint.abci.ValidatorUpdate";
+    encode(message: ValidatorUpdate, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ValidatorUpdate;
+    fromJSON(object: any): ValidatorUpdate;
+    toJSON(message: ValidatorUpdate): JsonSafe<ValidatorUpdate>;
+    fromPartial(object: Partial<ValidatorUpdate>): ValidatorUpdate;
+    fromProtoMsg(message: ValidatorUpdateProtoMsg): ValidatorUpdate;
+    toProto(message: ValidatorUpdate): Uint8Array;
+    toProtoMsg(message: ValidatorUpdate): ValidatorUpdateProtoMsg;
+};
+export declare const VoteInfo: {
+    typeUrl: "/tendermint.abci.VoteInfo";
+    encode(message: VoteInfo, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): VoteInfo;
+    fromJSON(object: any): VoteInfo;
+    toJSON(message: VoteInfo): JsonSafe<VoteInfo>;
+    fromPartial(object: Partial<VoteInfo>): VoteInfo;
+    fromProtoMsg(message: VoteInfoProtoMsg): VoteInfo;
+    toProto(message: VoteInfo): Uint8Array;
+    toProtoMsg(message: VoteInfo): VoteInfoProtoMsg;
+};
+export declare const Evidence: {
+    typeUrl: "/tendermint.abci.Evidence";
+    encode(message: Evidence, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Evidence;
+    fromJSON(object: any): Evidence;
+    toJSON(message: Evidence): JsonSafe<Evidence>;
+    fromPartial(object: Partial<Evidence>): Evidence;
+    fromProtoMsg(message: EvidenceProtoMsg): Evidence;
+    toProto(message: Evidence): Uint8Array;
+    toProtoMsg(message: Evidence): EvidenceProtoMsg;
+};
+//# sourceMappingURL=types.d.ts.map