import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3, Timestamp } from "@bufbuild/protobuf";
import { ConsensusParams } from "../types/params_pb.js";
import { Header } from "../types/types_pb.js";
import { ProofOps } from "../crypto/proof_pb.js";
import { PublicKey } from "../crypto/keys_pb.js";
export declare enum CheckTxType {
    NEW = 0,
    RECHECK = 1
}
export declare enum MisbehaviorType {
    UNKNOWN = 0,
    DUPLICATE_VOTE = 1,
    LIGHT_CLIENT_ATTACK = 2
}
export declare class Request extends Message<Request> {
    value: {
        value: RequestEcho;
        case: "echo";
    } | {
        value: RequestFlush;
        case: "flush";
    } | {
        value: RequestInfo;
        case: "info";
    } | {
        value: RequestInitChain;
        case: "initChain";
    } | {
        value: RequestQuery;
        case: "query";
    } | {
        value: RequestBeginBlock;
        case: "beginBlock";
    } | {
        value: RequestCheckTx;
        case: "checkTx";
    } | {
        value: RequestDeliverTx;
        case: "deliverTx";
    } | {
        value: RequestEndBlock;
        case: "endBlock";
    } | {
        value: RequestCommit;
        case: "commit";
    } | {
        value: RequestListSnapshots;
        case: "listSnapshots";
    } | {
        value: RequestOfferSnapshot;
        case: "offerSnapshot";
    } | {
        value: RequestLoadSnapshotChunk;
        case: "loadSnapshotChunk";
    } | {
        value: RequestApplySnapshotChunk;
        case: "applySnapshotChunk";
    } | {
        value: RequestPrepareProposal;
        case: "prepareProposal";
    } | {
        value: RequestProcessProposal;
        case: "processProposal";
    } | {
        case: undefined;
        value?: undefined;
    };
    constructor(data?: PartialMessage<Request>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.Request";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Request;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Request;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Request;
    static equals(a: Request | PlainMessage<Request> | undefined, b: Request | PlainMessage<Request> | undefined): boolean;
}
export declare class RequestEcho extends Message<RequestEcho> {
    message: string;
    constructor(data?: PartialMessage<RequestEcho>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestEcho";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestEcho;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestEcho;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestEcho;
    static equals(a: RequestEcho | PlainMessage<RequestEcho> | undefined, b: RequestEcho | PlainMessage<RequestEcho> | undefined): boolean;
}
export declare class RequestFlush extends Message<RequestFlush> {
    constructor(data?: PartialMessage<RequestFlush>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestFlush";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestFlush;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestFlush;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestFlush;
    static equals(a: RequestFlush | PlainMessage<RequestFlush> | undefined, b: RequestFlush | PlainMessage<RequestFlush> | undefined): boolean;
}
export declare class RequestInfo extends Message<RequestInfo> {
    version: string;
    blockVersion: bigint;
    p2pVersion: bigint;
    abciVersion: string;
    constructor(data?: PartialMessage<RequestInfo>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestInfo";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestInfo;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestInfo;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestInfo;
    static equals(a: RequestInfo | PlainMessage<RequestInfo> | undefined, b: RequestInfo | PlainMessage<RequestInfo> | undefined): boolean;
}
export declare class RequestInitChain extends Message<RequestInitChain> {
    time?: Timestamp;
    chainId: string;
    consensusParams?: ConsensusParams;
    validators: ValidatorUpdate[];
    appStateBytes: Uint8Array;
    initialHeight: bigint;
    constructor(data?: PartialMessage<RequestInitChain>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestInitChain";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestInitChain;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestInitChain;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestInitChain;
    static equals(a: RequestInitChain | PlainMessage<RequestInitChain> | undefined, b: RequestInitChain | PlainMessage<RequestInitChain> | undefined): boolean;
}
export declare class RequestQuery extends Message<RequestQuery> {
    data: Uint8Array;
    path: string;
    height: bigint;
    prove: boolean;
    constructor(data?: PartialMessage<RequestQuery>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestQuery";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestQuery;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestQuery;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestQuery;
    static equals(a: RequestQuery | PlainMessage<RequestQuery> | undefined, b: RequestQuery | PlainMessage<RequestQuery> | undefined): boolean;
}
export declare class RequestBeginBlock extends Message<RequestBeginBlock> {
    hash: Uint8Array;
    header?: Header;
    lastCommitInfo?: CommitInfo;
    byzantineValidators: Misbehavior[];
    constructor(data?: PartialMessage<RequestBeginBlock>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestBeginBlock";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestBeginBlock;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestBeginBlock;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestBeginBlock;
    static equals(a: RequestBeginBlock | PlainMessage<RequestBeginBlock> | undefined, b: RequestBeginBlock | PlainMessage<RequestBeginBlock> | undefined): boolean;
}
export declare class RequestCheckTx extends Message<RequestCheckTx> {
    tx: Uint8Array;
    type: CheckTxType;
    constructor(data?: PartialMessage<RequestCheckTx>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestCheckTx";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestCheckTx;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestCheckTx;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestCheckTx;
    static equals(a: RequestCheckTx | PlainMessage<RequestCheckTx> | undefined, b: RequestCheckTx | PlainMessage<RequestCheckTx> | undefined): boolean;
}
export declare class RequestDeliverTx extends Message<RequestDeliverTx> {
    tx: Uint8Array;
    constructor(data?: PartialMessage<RequestDeliverTx>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestDeliverTx";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestDeliverTx;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestDeliverTx;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestDeliverTx;
    static equals(a: RequestDeliverTx | PlainMessage<RequestDeliverTx> | undefined, b: RequestDeliverTx | PlainMessage<RequestDeliverTx> | undefined): boolean;
}
export declare class RequestEndBlock extends Message<RequestEndBlock> {
    height: bigint;
    constructor(data?: PartialMessage<RequestEndBlock>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestEndBlock";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestEndBlock;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestEndBlock;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestEndBlock;
    static equals(a: RequestEndBlock | PlainMessage<RequestEndBlock> | undefined, b: RequestEndBlock | PlainMessage<RequestEndBlock> | undefined): boolean;
}
export declare class RequestCommit extends Message<RequestCommit> {
    constructor(data?: PartialMessage<RequestCommit>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestCommit";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestCommit;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestCommit;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestCommit;
    static equals(a: RequestCommit | PlainMessage<RequestCommit> | undefined, b: RequestCommit | PlainMessage<RequestCommit> | undefined): boolean;
}
export declare class RequestListSnapshots extends Message<RequestListSnapshots> {
    constructor(data?: PartialMessage<RequestListSnapshots>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestListSnapshots";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestListSnapshots;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestListSnapshots;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestListSnapshots;
    static equals(a: RequestListSnapshots | PlainMessage<RequestListSnapshots> | undefined, b: RequestListSnapshots | PlainMessage<RequestListSnapshots> | undefined): boolean;
}
export declare class RequestOfferSnapshot extends Message<RequestOfferSnapshot> {
    snapshot?: Snapshot;
    appHash: Uint8Array;
    constructor(data?: PartialMessage<RequestOfferSnapshot>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestOfferSnapshot";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestOfferSnapshot;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestOfferSnapshot;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestOfferSnapshot;
    static equals(a: RequestOfferSnapshot | PlainMessage<RequestOfferSnapshot> | undefined, b: RequestOfferSnapshot | PlainMessage<RequestOfferSnapshot> | undefined): boolean;
}
export declare class RequestLoadSnapshotChunk extends Message<RequestLoadSnapshotChunk> {
    height: bigint;
    format: number;
    chunk: number;
    constructor(data?: PartialMessage<RequestLoadSnapshotChunk>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestLoadSnapshotChunk";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestLoadSnapshotChunk;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestLoadSnapshotChunk;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestLoadSnapshotChunk;
    static equals(a: RequestLoadSnapshotChunk | PlainMessage<RequestLoadSnapshotChunk> | undefined, b: RequestLoadSnapshotChunk | PlainMessage<RequestLoadSnapshotChunk> | undefined): boolean;
}
export declare class RequestApplySnapshotChunk extends Message<RequestApplySnapshotChunk> {
    index: number;
    chunk: Uint8Array;
    sender: string;
    constructor(data?: PartialMessage<RequestApplySnapshotChunk>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestApplySnapshotChunk";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestApplySnapshotChunk;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestApplySnapshotChunk;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestApplySnapshotChunk;
    static equals(a: RequestApplySnapshotChunk | PlainMessage<RequestApplySnapshotChunk> | undefined, b: RequestApplySnapshotChunk | PlainMessage<RequestApplySnapshotChunk> | undefined): boolean;
}
export declare class RequestPrepareProposal extends Message<RequestPrepareProposal> {
    maxTxBytes: bigint;
    txs: Uint8Array[];
    localLastCommit?: ExtendedCommitInfo;
    misbehavior: Misbehavior[];
    height: bigint;
    time?: Timestamp;
    nextValidatorsHash: Uint8Array;
    proposerAddress: Uint8Array;
    constructor(data?: PartialMessage<RequestPrepareProposal>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestPrepareProposal";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestPrepareProposal;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestPrepareProposal;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestPrepareProposal;
    static equals(a: RequestPrepareProposal | PlainMessage<RequestPrepareProposal> | undefined, b: RequestPrepareProposal | PlainMessage<RequestPrepareProposal> | undefined): boolean;
}
export declare class RequestProcessProposal extends Message<RequestProcessProposal> {
    txs: Uint8Array[];
    proposedLastCommit?: CommitInfo;
    misbehavior: Misbehavior[];
    hash: Uint8Array;
    height: bigint;
    time?: Timestamp;
    nextValidatorsHash: Uint8Array;
    proposerAddress: Uint8Array;
    constructor(data?: PartialMessage<RequestProcessProposal>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.RequestProcessProposal";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RequestProcessProposal;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RequestProcessProposal;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RequestProcessProposal;
    static equals(a: RequestProcessProposal | PlainMessage<RequestProcessProposal> | undefined, b: RequestProcessProposal | PlainMessage<RequestProcessProposal> | undefined): boolean;
}
export declare class Response extends Message<Response> {
    value: {
        value: ResponseException;
        case: "exception";
    } | {
        value: ResponseEcho;
        case: "echo";
    } | {
        value: ResponseFlush;
        case: "flush";
    } | {
        value: ResponseInfo;
        case: "info";
    } | {
        value: ResponseInitChain;
        case: "initChain";
    } | {
        value: ResponseQuery;
        case: "query";
    } | {
        value: ResponseBeginBlock;
        case: "beginBlock";
    } | {
        value: ResponseCheckTx;
        case: "checkTx";
    } | {
        value: ResponseDeliverTx;
        case: "deliverTx";
    } | {
        value: ResponseEndBlock;
        case: "endBlock";
    } | {
        value: ResponseCommit;
        case: "commit";
    } | {
        value: ResponseListSnapshots;
        case: "listSnapshots";
    } | {
        value: ResponseOfferSnapshot;
        case: "offerSnapshot";
    } | {
        value: ResponseLoadSnapshotChunk;
        case: "loadSnapshotChunk";
    } | {
        value: ResponseApplySnapshotChunk;
        case: "applySnapshotChunk";
    } | {
        value: ResponsePrepareProposal;
        case: "prepareProposal";
    } | {
        value: ResponseProcessProposal;
        case: "processProposal";
    } | {
        case: undefined;
        value?: undefined;
    };
    constructor(data?: PartialMessage<Response>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.Response";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Response;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Response;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Response;
    static equals(a: Response | PlainMessage<Response> | undefined, b: Response | PlainMessage<Response> | undefined): boolean;
}
export declare class ResponseException extends Message<ResponseException> {
    error: string;
    constructor(data?: PartialMessage<ResponseException>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseException";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseException;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseException;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseException;
    static equals(a: ResponseException | PlainMessage<ResponseException> | undefined, b: ResponseException | PlainMessage<ResponseException> | undefined): boolean;
}
export declare class ResponseEcho extends Message<ResponseEcho> {
    message: string;
    constructor(data?: PartialMessage<ResponseEcho>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseEcho";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseEcho;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseEcho;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseEcho;
    static equals(a: ResponseEcho | PlainMessage<ResponseEcho> | undefined, b: ResponseEcho | PlainMessage<ResponseEcho> | undefined): boolean;
}
export declare class ResponseFlush extends Message<ResponseFlush> {
    constructor(data?: PartialMessage<ResponseFlush>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseFlush";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseFlush;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseFlush;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseFlush;
    static equals(a: ResponseFlush | PlainMessage<ResponseFlush> | undefined, b: ResponseFlush | PlainMessage<ResponseFlush> | undefined): boolean;
}
export declare class ResponseInfo extends Message<ResponseInfo> {
    data: string;
    version: string;
    appVersion: bigint;
    lastBlockHeight: bigint;
    lastBlockAppHash: Uint8Array;
    constructor(data?: PartialMessage<ResponseInfo>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseInfo";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseInfo;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseInfo;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseInfo;
    static equals(a: ResponseInfo | PlainMessage<ResponseInfo> | undefined, b: ResponseInfo | PlainMessage<ResponseInfo> | undefined): boolean;
}
export declare class ResponseInitChain extends Message<ResponseInitChain> {
    consensusParams?: ConsensusParams;
    validators: ValidatorUpdate[];
    appHash: Uint8Array;
    constructor(data?: PartialMessage<ResponseInitChain>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseInitChain";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseInitChain;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseInitChain;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseInitChain;
    static equals(a: ResponseInitChain | PlainMessage<ResponseInitChain> | undefined, b: ResponseInitChain | PlainMessage<ResponseInitChain> | undefined): boolean;
}
export declare class ResponseQuery extends Message<ResponseQuery> {
    code: number;
    log: string;
    info: string;
    index: bigint;
    key: Uint8Array;
    value: Uint8Array;
    proofOps?: ProofOps;
    height: bigint;
    codespace: string;
    constructor(data?: PartialMessage<ResponseQuery>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseQuery";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseQuery;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseQuery;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseQuery;
    static equals(a: ResponseQuery | PlainMessage<ResponseQuery> | undefined, b: ResponseQuery | PlainMessage<ResponseQuery> | undefined): boolean;
}
export declare class ResponseBeginBlock extends Message<ResponseBeginBlock> {
    events: Event[];
    constructor(data?: PartialMessage<ResponseBeginBlock>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseBeginBlock";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseBeginBlock;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseBeginBlock;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseBeginBlock;
    static equals(a: ResponseBeginBlock | PlainMessage<ResponseBeginBlock> | undefined, b: ResponseBeginBlock | PlainMessage<ResponseBeginBlock> | undefined): boolean;
}
export declare class ResponseCheckTx extends Message<ResponseCheckTx> {
    code: number;
    data: Uint8Array;
    log: string;
    info: string;
    gasWanted: bigint;
    gasUsed: bigint;
    events: Event[];
    codespace: string;
    sender: string;
    priority: bigint;
    mempoolError: string;
    constructor(data?: PartialMessage<ResponseCheckTx>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseCheckTx";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseCheckTx;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseCheckTx;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseCheckTx;
    static equals(a: ResponseCheckTx | PlainMessage<ResponseCheckTx> | undefined, b: ResponseCheckTx | PlainMessage<ResponseCheckTx> | undefined): boolean;
}
export declare class ResponseDeliverTx extends Message<ResponseDeliverTx> {
    code: number;
    data: Uint8Array;
    log: string;
    info: string;
    gasWanted: bigint;
    gasUsed: bigint;
    events: Event[];
    codespace: string;
    constructor(data?: PartialMessage<ResponseDeliverTx>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseDeliverTx";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseDeliverTx;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseDeliverTx;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseDeliverTx;
    static equals(a: ResponseDeliverTx | PlainMessage<ResponseDeliverTx> | undefined, b: ResponseDeliverTx | PlainMessage<ResponseDeliverTx> | undefined): boolean;
}
export declare class ResponseEndBlock extends Message<ResponseEndBlock> {
    validatorUpdates: ValidatorUpdate[];
    consensusParamUpdates?: ConsensusParams;
    events: Event[];
    constructor(data?: PartialMessage<ResponseEndBlock>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseEndBlock";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseEndBlock;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseEndBlock;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseEndBlock;
    static equals(a: ResponseEndBlock | PlainMessage<ResponseEndBlock> | undefined, b: ResponseEndBlock | PlainMessage<ResponseEndBlock> | undefined): boolean;
}
export declare class ResponseCommit extends Message<ResponseCommit> {
    data: Uint8Array;
    retainHeight: bigint;
    constructor(data?: PartialMessage<ResponseCommit>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseCommit";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseCommit;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseCommit;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseCommit;
    static equals(a: ResponseCommit | PlainMessage<ResponseCommit> | undefined, b: ResponseCommit | PlainMessage<ResponseCommit> | undefined): boolean;
}
export declare class ResponseListSnapshots extends Message<ResponseListSnapshots> {
    snapshots: Snapshot[];
    constructor(data?: PartialMessage<ResponseListSnapshots>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseListSnapshots";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseListSnapshots;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseListSnapshots;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseListSnapshots;
    static equals(a: ResponseListSnapshots | PlainMessage<ResponseListSnapshots> | undefined, b: ResponseListSnapshots | PlainMessage<ResponseListSnapshots> | undefined): boolean;
}
export declare class ResponseOfferSnapshot extends Message<ResponseOfferSnapshot> {
    result: ResponseOfferSnapshot_Result;
    constructor(data?: PartialMessage<ResponseOfferSnapshot>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseOfferSnapshot";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseOfferSnapshot;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseOfferSnapshot;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseOfferSnapshot;
    static equals(a: ResponseOfferSnapshot | PlainMessage<ResponseOfferSnapshot> | undefined, b: ResponseOfferSnapshot | PlainMessage<ResponseOfferSnapshot> | undefined): boolean;
}
export declare enum ResponseOfferSnapshot_Result {
    UNKNOWN = 0,
    ACCEPT = 1,
    ABORT = 2,
    REJECT = 3,
    REJECT_FORMAT = 4,
    REJECT_SENDER = 5
}
export declare class ResponseLoadSnapshotChunk extends Message<ResponseLoadSnapshotChunk> {
    chunk: Uint8Array;
    constructor(data?: PartialMessage<ResponseLoadSnapshotChunk>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseLoadSnapshotChunk";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseLoadSnapshotChunk;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseLoadSnapshotChunk;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseLoadSnapshotChunk;
    static equals(a: ResponseLoadSnapshotChunk | PlainMessage<ResponseLoadSnapshotChunk> | undefined, b: ResponseLoadSnapshotChunk | PlainMessage<ResponseLoadSnapshotChunk> | undefined): boolean;
}
export declare class ResponseApplySnapshotChunk extends Message<ResponseApplySnapshotChunk> {
    result: ResponseApplySnapshotChunk_Result;
    refetchChunks: number[];
    rejectSenders: string[];
    constructor(data?: PartialMessage<ResponseApplySnapshotChunk>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseApplySnapshotChunk";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseApplySnapshotChunk;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseApplySnapshotChunk;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseApplySnapshotChunk;
    static equals(a: ResponseApplySnapshotChunk | PlainMessage<ResponseApplySnapshotChunk> | undefined, b: ResponseApplySnapshotChunk | PlainMessage<ResponseApplySnapshotChunk> | undefined): boolean;
}
export declare enum ResponseApplySnapshotChunk_Result {
    UNKNOWN = 0,
    ACCEPT = 1,
    ABORT = 2,
    RETRY = 3,
    RETRY_SNAPSHOT = 4,
    REJECT_SNAPSHOT = 5
}
export declare class ResponsePrepareProposal extends Message<ResponsePrepareProposal> {
    txs: Uint8Array[];
    constructor(data?: PartialMessage<ResponsePrepareProposal>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponsePrepareProposal";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponsePrepareProposal;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponsePrepareProposal;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponsePrepareProposal;
    static equals(a: ResponsePrepareProposal | PlainMessage<ResponsePrepareProposal> | undefined, b: ResponsePrepareProposal | PlainMessage<ResponsePrepareProposal> | undefined): boolean;
}
export declare class ResponseProcessProposal extends Message<ResponseProcessProposal> {
    status: ResponseProcessProposal_ProposalStatus;
    constructor(data?: PartialMessage<ResponseProcessProposal>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ResponseProcessProposal";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ResponseProcessProposal;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ResponseProcessProposal;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ResponseProcessProposal;
    static equals(a: ResponseProcessProposal | PlainMessage<ResponseProcessProposal> | undefined, b: ResponseProcessProposal | PlainMessage<ResponseProcessProposal> | undefined): boolean;
}
export declare enum ResponseProcessProposal_ProposalStatus {
    UNKNOWN = 0,
    ACCEPT = 1,
    REJECT = 2
}
export declare class CommitInfo extends Message<CommitInfo> {
    round: number;
    votes: VoteInfo[];
    constructor(data?: PartialMessage<CommitInfo>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.CommitInfo";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CommitInfo;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CommitInfo;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CommitInfo;
    static equals(a: CommitInfo | PlainMessage<CommitInfo> | undefined, b: CommitInfo | PlainMessage<CommitInfo> | undefined): boolean;
}
export declare class ExtendedCommitInfo extends Message<ExtendedCommitInfo> {
    round: number;
    votes: ExtendedVoteInfo[];
    constructor(data?: PartialMessage<ExtendedCommitInfo>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ExtendedCommitInfo";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExtendedCommitInfo;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExtendedCommitInfo;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExtendedCommitInfo;
    static equals(a: ExtendedCommitInfo | PlainMessage<ExtendedCommitInfo> | undefined, b: ExtendedCommitInfo | PlainMessage<ExtendedCommitInfo> | undefined): boolean;
}
export declare class Event extends Message<Event> {
    type: string;
    attributes: EventAttribute[];
    constructor(data?: PartialMessage<Event>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.Event";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Event;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Event;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Event;
    static equals(a: Event | PlainMessage<Event> | undefined, b: Event | PlainMessage<Event> | undefined): boolean;
}
export declare class EventAttribute extends Message<EventAttribute> {
    key: string;
    value: string;
    index: boolean;
    constructor(data?: PartialMessage<EventAttribute>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.EventAttribute";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EventAttribute;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EventAttribute;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EventAttribute;
    static equals(a: EventAttribute | PlainMessage<EventAttribute> | undefined, b: EventAttribute | PlainMessage<EventAttribute> | undefined): boolean;
}
export declare class TxResult extends Message<TxResult> {
    height: bigint;
    index: number;
    tx: Uint8Array;
    result?: ResponseDeliverTx;
    constructor(data?: PartialMessage<TxResult>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.TxResult";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): TxResult;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): TxResult;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): TxResult;
    static equals(a: TxResult | PlainMessage<TxResult> | undefined, b: TxResult | PlainMessage<TxResult> | undefined): boolean;
}
export declare class Validator extends Message<Validator> {
    address: Uint8Array;
    power: bigint;
    constructor(data?: PartialMessage<Validator>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.Validator";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Validator;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Validator;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Validator;
    static equals(a: Validator | PlainMessage<Validator> | undefined, b: Validator | PlainMessage<Validator> | undefined): boolean;
}
export declare class ValidatorUpdate extends Message<ValidatorUpdate> {
    pubKey?: PublicKey;
    power: bigint;
    constructor(data?: PartialMessage<ValidatorUpdate>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ValidatorUpdate";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ValidatorUpdate;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ValidatorUpdate;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ValidatorUpdate;
    static equals(a: ValidatorUpdate | PlainMessage<ValidatorUpdate> | undefined, b: ValidatorUpdate | PlainMessage<ValidatorUpdate> | undefined): boolean;
}
export declare class VoteInfo extends Message<VoteInfo> {
    validator?: Validator;
    signedLastBlock: boolean;
    constructor(data?: PartialMessage<VoteInfo>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.VoteInfo";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): VoteInfo;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): VoteInfo;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): VoteInfo;
    static equals(a: VoteInfo | PlainMessage<VoteInfo> | undefined, b: VoteInfo | PlainMessage<VoteInfo> | undefined): boolean;
}
export declare class ExtendedVoteInfo extends Message<ExtendedVoteInfo> {
    validator?: Validator;
    signedLastBlock: boolean;
    voteExtension: Uint8Array;
    constructor(data?: PartialMessage<ExtendedVoteInfo>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.ExtendedVoteInfo";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExtendedVoteInfo;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExtendedVoteInfo;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExtendedVoteInfo;
    static equals(a: ExtendedVoteInfo | PlainMessage<ExtendedVoteInfo> | undefined, b: ExtendedVoteInfo | PlainMessage<ExtendedVoteInfo> | undefined): boolean;
}
export declare class Misbehavior extends Message<Misbehavior> {
    type: MisbehaviorType;
    validator?: Validator;
    height: bigint;
    time?: Timestamp;
    totalVotingPower: bigint;
    constructor(data?: PartialMessage<Misbehavior>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.Misbehavior";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Misbehavior;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Misbehavior;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Misbehavior;
    static equals(a: Misbehavior | PlainMessage<Misbehavior> | undefined, b: Misbehavior | PlainMessage<Misbehavior> | undefined): boolean;
}
export declare class Snapshot extends Message<Snapshot> {
    height: bigint;
    format: number;
    chunks: number;
    hash: Uint8Array;
    metadata: Uint8Array;
    constructor(data?: PartialMessage<Snapshot>);
    static readonly runtime: typeof proto3;
    static readonly typeName = "tendermint.abci.Snapshot";
    static readonly fields: FieldList;
    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Snapshot;
    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Snapshot;
    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Snapshot;
    static equals(a: Snapshot | PlainMessage<Snapshot> | undefined, b: Snapshot | PlainMessage<Snapshot> | undefined): boolean;
}
//# sourceMappingURL=types_pb.d.ts.map