import { Timestamp, TimestampSDKType } from "../../google/protobuf/timestamp";
import { Header, HeaderSDKType } from "../types/types";
import { ProofOps, ProofOpsSDKType } from "../crypto/proof";
import { EvidenceParams, EvidenceParamsSDKType, ValidatorParams, ValidatorParamsSDKType, VersionParams, VersionParamsSDKType } from "../types/params";
import { PublicKey, PublicKeySDKType } from "../crypto/keys";
import { BinaryReader, BinaryWriter } from "../../binary";
import { TxRpc } from "../../types";
import { QueryClient } from "@cosmjs/stargate";
export declare const protobufPackage = "tendermint.abci";
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 ResponseOfferSnapshot_Result {
    /** UNKNOWN - Unknown result, abort all snapshot restoration */
    UNKNOWN = 0,
    /** ACCEPT - Snapshot accepted, apply chunks */
    ACCEPT = 1,
    /** ABORT - Abort all snapshot restoration */
    ABORT = 2,
    /** REJECT - Reject this specific snapshot, try others */
    REJECT = 3,
    /** REJECT_FORMAT - Reject all snapshots of this format, try others */
    REJECT_FORMAT = 4,
    /** REJECT_SENDER - Reject all snapshots from the sender(s), try others */
    REJECT_SENDER = 5,
    UNRECOGNIZED = -1
}
export declare const ResponseOfferSnapshot_ResultSDKType: typeof ResponseOfferSnapshot_Result;
export declare function responseOfferSnapshot_ResultFromJSON(object: any): ResponseOfferSnapshot_Result;
export declare function responseOfferSnapshot_ResultToJSON(object: ResponseOfferSnapshot_Result): string;
export declare enum ResponseApplySnapshotChunk_Result {
    /** UNKNOWN - Unknown result, abort all snapshot restoration */
    UNKNOWN = 0,
    /** ACCEPT - Chunk successfully accepted */
    ACCEPT = 1,
    /** ABORT - Abort all snapshot restoration */
    ABORT = 2,
    /** RETRY - Retry chunk (combine with refetch and reject) */
    RETRY = 3,
    /** RETRY_SNAPSHOT - Retry snapshot (combine with refetch and reject) */
    RETRY_SNAPSHOT = 4,
    /** REJECT_SNAPSHOT - Reject this snapshot, try others */
    REJECT_SNAPSHOT = 5,
    UNRECOGNIZED = -1
}
export declare const ResponseApplySnapshotChunk_ResultSDKType: typeof ResponseApplySnapshotChunk_Result;
export declare function responseApplySnapshotChunk_ResultFromJSON(object: any): ResponseApplySnapshotChunk_Result;
export declare function responseApplySnapshotChunk_ResultToJSON(object: ResponseApplySnapshotChunk_Result): 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;
export interface Request {
    echo?: RequestEcho | undefined;
    flush?: RequestFlush | undefined;
    info?: RequestInfo | undefined;
    setOption?: RequestSetOption | undefined;
    initChain?: RequestInitChain | undefined;
    query?: RequestQuery | undefined;
    beginBlock?: RequestBeginBlock | undefined;
    checkTx?: RequestCheckTx | undefined;
    deliverTx?: RequestDeliverTx | undefined;
    endBlock?: RequestEndBlock | undefined;
    commit?: RequestCommit | undefined;
    listSnapshots?: RequestListSnapshots | undefined;
    offerSnapshot?: RequestOfferSnapshot | undefined;
    loadSnapshotChunk?: RequestLoadSnapshotChunk | undefined;
    applySnapshotChunk?: RequestApplySnapshotChunk | undefined;
}
export interface RequestSDKType {
    echo?: RequestEchoSDKType | undefined;
    flush?: RequestFlushSDKType | undefined;
    info?: RequestInfoSDKType | undefined;
    set_option?: RequestSetOptionSDKType | undefined;
    init_chain?: RequestInitChainSDKType | undefined;
    query?: RequestQuerySDKType | undefined;
    begin_block?: RequestBeginBlockSDKType | undefined;
    check_tx?: RequestCheckTxSDKType | undefined;
    deliver_tx?: RequestDeliverTxSDKType | undefined;
    end_block?: RequestEndBlockSDKType | undefined;
    commit?: RequestCommitSDKType | undefined;
    list_snapshots?: RequestListSnapshotsSDKType | undefined;
    offer_snapshot?: RequestOfferSnapshotSDKType | undefined;
    load_snapshot_chunk?: RequestLoadSnapshotChunkSDKType | undefined;
    apply_snapshot_chunk?: RequestApplySnapshotChunkSDKType | undefined;
}
export interface RequestEcho {
    message: string;
}
export interface RequestEchoSDKType {
    message: string;
}
export interface RequestFlush {
}
export interface RequestFlushSDKType {
}
export interface RequestInfo {
    version: string;
    blockVersion: bigint;
    p2pVersion: bigint;
}
export interface RequestInfoSDKType {
    version: string;
    block_version: bigint;
    p2p_version: bigint;
}
/** nondeterministic */
export interface RequestSetOption {
    key: string;
    value: string;
}
/** nondeterministic */
export interface RequestSetOptionSDKType {
    key: string;
    value: string;
}
export interface RequestInitChain {
    time: Timestamp | undefined;
    chainId: string;
    consensusParams?: ConsensusParams | undefined;
    validators: ValidatorUpdate[];
    appStateBytes: Uint8Array;
    initialHeight: bigint;
}
export interface RequestInitChainSDKType {
    time: TimestampSDKType | undefined;
    chain_id: string;
    consensus_params?: ConsensusParamsSDKType | undefined;
    validators: ValidatorUpdateSDKType[];
    app_state_bytes: Uint8Array;
    initial_height: bigint;
}
export interface RequestQuery {
    data: Uint8Array;
    path: string;
    height: bigint;
    prove: boolean;
}
export interface RequestQuerySDKType {
    data: Uint8Array;
    path: string;
    height: bigint;
    prove: boolean;
}
export interface RequestBeginBlock {
    hash: Uint8Array;
    header: Header | undefined;
    lastCommitInfo: LastCommitInfo | undefined;
    byzantineValidators: Evidence[];
}
export interface RequestBeginBlockSDKType {
    hash: Uint8Array;
    header: HeaderSDKType | undefined;
    last_commit_info: LastCommitInfoSDKType | undefined;
    byzantine_validators: EvidenceSDKType[];
}
export interface RequestCheckTx {
    tx: Uint8Array;
    type: CheckTxType;
}
export interface RequestCheckTxSDKType {
    tx: Uint8Array;
    type: CheckTxType;
}
export interface RequestDeliverTx {
    tx: Uint8Array;
}
export interface RequestDeliverTxSDKType {
    tx: Uint8Array;
}
export interface RequestEndBlock {
    height: bigint;
}
export interface RequestEndBlockSDKType {
    height: bigint;
}
export interface RequestCommit {
}
export interface RequestCommitSDKType {
}
/** lists available snapshots */
export interface RequestListSnapshots {
}
/** lists available snapshots */
export interface RequestListSnapshotsSDKType {
}
/** offers a snapshot to the application */
export interface RequestOfferSnapshot {
    /** snapshot offered by peers */
    snapshot?: Snapshot | undefined;
    /** light client-verified app hash for snapshot height */
    appHash: Uint8Array;
}
/** offers a snapshot to the application */
export interface RequestOfferSnapshotSDKType {
    snapshot?: SnapshotSDKType | undefined;
    app_hash: Uint8Array;
}
/** loads a snapshot chunk */
export interface RequestLoadSnapshotChunk {
    height: bigint;
    format: number;
    chunk: number;
}
/** loads a snapshot chunk */
export interface RequestLoadSnapshotChunkSDKType {
    height: bigint;
    format: number;
    chunk: number;
}
/** Applies a snapshot chunk */
export interface RequestApplySnapshotChunk {
    index: number;
    chunk: Uint8Array;
    sender: string;
}
/** Applies a snapshot chunk */
export interface RequestApplySnapshotChunkSDKType {
    index: number;
    chunk: Uint8Array;
    sender: string;
}
export interface Response {
    exception?: ResponseException | undefined;
    echo?: ResponseEcho | undefined;
    flush?: ResponseFlush | undefined;
    info?: ResponseInfo | undefined;
    setOption?: ResponseSetOption | undefined;
    initChain?: ResponseInitChain | undefined;
    query?: ResponseQuery | undefined;
    beginBlock?: ResponseBeginBlock | undefined;
    checkTx?: ResponseCheckTx | undefined;
    deliverTx?: ResponseDeliverTx | undefined;
    endBlock?: ResponseEndBlock | undefined;
    commit?: ResponseCommit | undefined;
    listSnapshots?: ResponseListSnapshots | undefined;
    offerSnapshot?: ResponseOfferSnapshot | undefined;
    loadSnapshotChunk?: ResponseLoadSnapshotChunk | undefined;
    applySnapshotChunk?: ResponseApplySnapshotChunk | undefined;
}
export interface ResponseSDKType {
    exception?: ResponseExceptionSDKType | undefined;
    echo?: ResponseEchoSDKType | undefined;
    flush?: ResponseFlushSDKType | undefined;
    info?: ResponseInfoSDKType | undefined;
    set_option?: ResponseSetOptionSDKType | undefined;
    init_chain?: ResponseInitChainSDKType | undefined;
    query?: ResponseQuerySDKType | undefined;
    begin_block?: ResponseBeginBlockSDKType | undefined;
    check_tx?: ResponseCheckTxSDKType | undefined;
    deliver_tx?: ResponseDeliverTxSDKType | undefined;
    end_block?: ResponseEndBlockSDKType | undefined;
    commit?: ResponseCommitSDKType | undefined;
    list_snapshots?: ResponseListSnapshotsSDKType | undefined;
    offer_snapshot?: ResponseOfferSnapshotSDKType | undefined;
    load_snapshot_chunk?: ResponseLoadSnapshotChunkSDKType | undefined;
    apply_snapshot_chunk?: ResponseApplySnapshotChunkSDKType | undefined;
}
/** nondeterministic */
export interface ResponseException {
    error: string;
}
/** nondeterministic */
export interface ResponseExceptionSDKType {
    error: string;
}
export interface ResponseEcho {
    message: string;
}
export interface ResponseEchoSDKType {
    message: string;
}
export interface ResponseFlush {
}
export interface ResponseFlushSDKType {
}
export interface ResponseInfo {
    data: string;
    version: string;
    appVersion: bigint;
    lastBlockHeight: bigint;
    lastBlockAppHash: Uint8Array;
}
export interface ResponseInfoSDKType {
    data: string;
    version: string;
    app_version: bigint;
    last_block_height: bigint;
    last_block_app_hash: Uint8Array;
}
/** nondeterministic */
export interface ResponseSetOption {
    code: number;
    /** bytes data = 2; */
    log: string;
    info: string;
}
/** nondeterministic */
export interface ResponseSetOptionSDKType {
    code: number;
    log: string;
    info: string;
}
export interface ResponseInitChain {
    consensusParams?: ConsensusParams | undefined;
    validators: ValidatorUpdate[];
    appHash: Uint8Array;
}
export interface ResponseInitChainSDKType {
    consensus_params?: ConsensusParamsSDKType | undefined;
    validators: ValidatorUpdateSDKType[];
    app_hash: Uint8Array;
}
export interface ResponseQuery {
    code: number;
    /** bytes data = 2; // use "value" instead. */
    log: string;
    /** nondeterministic */
    info: string;
    index: bigint;
    key: Uint8Array;
    value: Uint8Array;
    proofOps?: ProofOps | undefined;
    height: bigint;
    codespace: string;
}
export interface ResponseQuerySDKType {
    code: number;
    log: string;
    info: string;
    index: bigint;
    key: Uint8Array;
    value: Uint8Array;
    proof_ops?: ProofOpsSDKType | undefined;
    height: bigint;
    codespace: string;
}
export interface ResponseBeginBlock {
    events: Event[];
}
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;
    sender: string;
    priority: bigint;
    /**
     * mempool_error is set by CometBFT.
     * ABCI applictions creating a ResponseCheckTX should not set mempool_error.
     */
    mempoolError: string;
}
export interface ResponseCheckTxSDKType {
    code: number;
    data: Uint8Array;
    log: string;
    info: string;
    gas_wanted: bigint;
    gas_used: bigint;
    events: EventSDKType[];
    codespace: string;
    sender: string;
    priority: bigint;
    mempool_error: string;
}
export interface ResponseDeliverTx {
    code: number;
    data: Uint8Array;
    /** nondeterministic */
    log: string;
    /** nondeterministic */
    info: string;
    gasWanted: bigint;
    gasUsed: bigint;
    events: Event[];
    codespace: string;
}
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 | undefined;
    events: Event[];
}
export interface ResponseEndBlockSDKType {
    validator_updates: ValidatorUpdateSDKType[];
    consensus_param_updates?: ConsensusParamsSDKType | undefined;
    events: EventSDKType[];
}
export interface ResponseCommit {
    /** reserve 1 */
    data: Uint8Array;
    retainHeight: bigint;
}
export interface ResponseCommitSDKType {
    data: Uint8Array;
    retain_height: bigint;
}
export interface ResponseListSnapshots {
    snapshots: Snapshot[];
}
export interface ResponseListSnapshotsSDKType {
    snapshots: SnapshotSDKType[];
}
export interface ResponseOfferSnapshot {
    result: ResponseOfferSnapshot_Result;
}
export interface ResponseOfferSnapshotSDKType {
    result: ResponseOfferSnapshot_Result;
}
export interface ResponseLoadSnapshotChunk {
    chunk: Uint8Array;
}
export interface ResponseLoadSnapshotChunkSDKType {
    chunk: Uint8Array;
}
export interface ResponseApplySnapshotChunk {
    result: ResponseApplySnapshotChunk_Result;
    /** Chunks to refetch and reapply */
    refetchChunks: number[];
    /** Chunk senders to reject and ban */
    rejectSenders: string[];
}
export interface ResponseApplySnapshotChunkSDKType {
    result: ResponseApplySnapshotChunk_Result;
    refetch_chunks: number[];
    reject_senders: string[];
}
/**
 * ConsensusParams contains all consensus-relevant parameters
 * that can be adjusted by the abci app
 */
export interface ConsensusParams {
    block?: BlockParams | undefined;
    evidence?: EvidenceParams | undefined;
    validator?: ValidatorParams | undefined;
    version?: VersionParams | undefined;
}
/**
 * ConsensusParams contains all consensus-relevant parameters
 * that can be adjusted by the abci app
 */
export interface ConsensusParamsSDKType {
    block?: BlockParamsSDKType | undefined;
    evidence?: EvidenceParamsSDKType | undefined;
    validator?: ValidatorParamsSDKType | undefined;
    version?: VersionParamsSDKType | undefined;
}
/** BlockParams contains limits on the block size. */
export interface BlockParams {
    /** Note: must be greater than 0 */
    maxBytes: bigint;
    /** Note: must be greater or equal to -1 */
    maxGas: bigint;
}
/** BlockParams contains limits on the block size. */
export interface BlockParamsSDKType {
    max_bytes: bigint;
    max_gas: bigint;
}
export interface LastCommitInfo {
    round: number;
    votes: VoteInfo[];
}
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[];
}
/**
 * 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;
}
/** 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 | undefined;
}
/**
 * TxResult contains results of executing the transaction.
 *
 * One usage is indexing transaction results.
 */
export interface TxResultSDKType {
    height: bigint;
    index: number;
    tx: Uint8Array;
    result: ResponseDeliverTxSDKType | undefined;
}
/** Validator */
export interface Validator {
    /**
     * The first 20 bytes of SHA256(public key)
     * PubKey pub_key = 2 [(gogoproto.nullable)=false];
     */
    address: Uint8Array;
    /** The voting power */
    power: bigint;
}
/** Validator */
export interface ValidatorSDKType {
    address: Uint8Array;
    power: bigint;
}
/** ValidatorUpdate */
export interface ValidatorUpdate {
    pubKey: PublicKey | undefined;
    power: bigint;
}
/** ValidatorUpdate */
export interface ValidatorUpdateSDKType {
    pub_key: PublicKeySDKType | undefined;
    power: bigint;
}
/** VoteInfo */
export interface VoteInfo {
    validator: Validator | undefined;
    signedLastBlock: boolean;
}
/** VoteInfo */
export interface VoteInfoSDKType {
    validator: ValidatorSDKType | undefined;
    signed_last_block: boolean;
}
export interface Evidence {
    type: EvidenceType;
    /** The offending validator */
    validator: Validator | undefined;
    /** The height when the offense occurred */
    height: bigint;
    /** The corresponding time where the offense occurred */
    time: Timestamp | undefined;
    /**
     * 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 EvidenceSDKType {
    type: EvidenceType;
    validator: ValidatorSDKType | undefined;
    height: bigint;
    time: TimestampSDKType | undefined;
    total_voting_power: bigint;
}
export interface Snapshot {
    /** The height at which the snapshot was taken */
    height: bigint;
    /** The application-specific snapshot format */
    format: number;
    /** Number of chunks in the snapshot */
    chunks: number;
    /** Arbitrary snapshot hash, equal only if identical */
    hash: Uint8Array;
    /** Arbitrary application metadata */
    metadata: Uint8Array;
}
export interface SnapshotSDKType {
    height: bigint;
    format: number;
    chunks: number;
    hash: Uint8Array;
    metadata: Uint8Array;
}
export declare const Request: {
    typeUrl: string;
    encode(message: Request, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Request;
    fromJSON(object: any): Request;
    toJSON(message: Request): unknown;
    fromPartial<I extends Partial<Request> & {
        echo?: RequestEcho & {
            message: string;
        } & Record<Exclude<keyof I["echo"], "message">, never>;
        flush?: RequestFlush & {} & Record<Exclude<keyof I["flush"], never>, never>;
        info?: RequestInfo & {
            version: string;
            blockVersion: bigint;
            p2pVersion: bigint;
        } & Record<Exclude<keyof I["info"], keyof RequestInfo>, never>;
        setOption?: RequestSetOption & {
            key: string;
            value: string;
        } & Record<Exclude<keyof I["setOption"], keyof RequestSetOption>, never>;
        initChain?: RequestInitChain & {
            time: Timestamp & {
                seconds: bigint;
                nanos: number;
            } & Record<Exclude<keyof I["initChain"]["time"], keyof Timestamp>, never>;
            chainId: string;
            consensusParams?: ConsensusParams & {
                block?: BlockParams & {
                    maxBytes: bigint;
                    maxGas: bigint;
                } & Record<Exclude<keyof I["initChain"]["consensusParams"]["block"], keyof BlockParams>, never>;
                evidence?: EvidenceParams & {
                    maxAgeNumBlocks: bigint;
                    maxAgeDuration: import("../../google/protobuf/duration").Duration & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I["initChain"]["consensusParams"]["evidence"]["maxAgeDuration"], keyof import("../../google/protobuf/duration").Duration>, never>;
                    maxBytes: bigint;
                } & Record<Exclude<keyof I["initChain"]["consensusParams"]["evidence"], keyof EvidenceParams>, never>;
                validator?: ValidatorParams & {
                    pubKeyTypes: string[] & Record<Exclude<keyof I["initChain"]["consensusParams"]["validator"]["pubKeyTypes"], keyof string[]>, never>;
                } & Record<Exclude<keyof I["initChain"]["consensusParams"]["validator"], "pubKeyTypes">, never>;
                version?: VersionParams & {
                    appVersion: bigint;
                } & Record<Exclude<keyof I["initChain"]["consensusParams"]["version"], "appVersion">, never>;
            } & Record<Exclude<keyof I["initChain"]["consensusParams"], keyof ConsensusParams>, never>;
            validators: ValidatorUpdate[] & (ValidatorUpdate & {
                pubKey: PublicKey & {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                } & Record<Exclude<keyof I["initChain"]["validators"][number]["pubKey"], keyof PublicKey>, never>;
                power: bigint;
            } & Record<Exclude<keyof I["initChain"]["validators"][number], keyof ValidatorUpdate>, never>)[] & Record<Exclude<keyof I["initChain"]["validators"], keyof ValidatorUpdate[]>, never>;
            appStateBytes: Uint8Array;
            initialHeight: bigint;
        } & Record<Exclude<keyof I["initChain"], keyof RequestInitChain>, never>;
        query?: RequestQuery & {
            data: Uint8Array;
            path: string;
            height: bigint;
            prove: boolean;
        } & Record<Exclude<keyof I["query"], keyof RequestQuery>, never>;
        beginBlock?: RequestBeginBlock & {
            hash: Uint8Array;
            header: Header & {
                version: import("../version/types").Consensus & {
                    block: bigint;
                    app: bigint;
                } & Record<Exclude<keyof I["beginBlock"]["header"]["version"], keyof import("../version/types").Consensus>, never>;
                chainId: string;
                height: bigint;
                time: Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I["beginBlock"]["header"]["time"], keyof Timestamp>, never>;
                lastBlockId: import("../types/types").BlockID & {
                    hash: Uint8Array;
                    partSetHeader: import("../types/types").PartSetHeader & {
                        total: number;
                        hash: Uint8Array;
                    } & Record<Exclude<keyof I["beginBlock"]["header"]["lastBlockId"]["partSetHeader"], keyof import("../types/types").PartSetHeader>, never>;
                } & Record<Exclude<keyof I["beginBlock"]["header"]["lastBlockId"], keyof import("../types/types").BlockID>, never>;
                lastCommitHash: Uint8Array;
                dataHash: Uint8Array;
                validatorsHash: Uint8Array;
                nextValidatorsHash: Uint8Array;
                consensusHash: Uint8Array;
                appHash: Uint8Array;
                lastResultsHash: Uint8Array;
                evidenceHash: Uint8Array;
                proposerAddress: Uint8Array;
            } & Record<Exclude<keyof I["beginBlock"]["header"], keyof Header>, never>;
            lastCommitInfo: LastCommitInfo & {
                round: number;
                votes: VoteInfo[] & (VoteInfo & {
                    validator: Validator & {
                        address: Uint8Array;
                        power: bigint;
                    } & Record<Exclude<keyof I["beginBlock"]["lastCommitInfo"]["votes"][number]["validator"], keyof Validator>, never>;
                    signedLastBlock: boolean;
                } & Record<Exclude<keyof I["beginBlock"]["lastCommitInfo"]["votes"][number], keyof VoteInfo>, never>)[] & Record<Exclude<keyof I["beginBlock"]["lastCommitInfo"]["votes"], keyof VoteInfo[]>, never>;
            } & Record<Exclude<keyof I["beginBlock"]["lastCommitInfo"], keyof LastCommitInfo>, never>;
            byzantineValidators: Evidence[] & (Evidence & {
                type: EvidenceType;
                validator: Validator & {
                    address: Uint8Array;
                    power: bigint;
                } & Record<Exclude<keyof I["beginBlock"]["byzantineValidators"][number]["validator"], keyof Validator>, never>;
                height: bigint;
                time: Timestamp & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I["beginBlock"]["byzantineValidators"][number]["time"], keyof Timestamp>, never>;
                totalVotingPower: bigint;
            } & Record<Exclude<keyof I["beginBlock"]["byzantineValidators"][number], keyof Evidence>, never>)[] & Record<Exclude<keyof I["beginBlock"]["byzantineValidators"], keyof Evidence[]>, never>;
        } & Record<Exclude<keyof I["beginBlock"], keyof RequestBeginBlock>, never>;
        checkTx?: RequestCheckTx & {
            tx: Uint8Array;
            type: CheckTxType;
        } & Record<Exclude<keyof I["checkTx"], keyof RequestCheckTx>, never>;
        deliverTx?: RequestDeliverTx & {
            tx: Uint8Array;
        } & Record<Exclude<keyof I["deliverTx"], "tx">, never>;
        endBlock?: RequestEndBlock & {
            height: bigint;
        } & Record<Exclude<keyof I["endBlock"], "height">, never>;
        commit?: RequestCommit & {} & Record<Exclude<keyof I["commit"], never>, never>;
        listSnapshots?: RequestListSnapshots & {} & Record<Exclude<keyof I["listSnapshots"], never>, never>;
        offerSnapshot?: RequestOfferSnapshot & {
            snapshot?: Snapshot & {
                height: bigint;
                format: number;
                chunks: number;
                hash: Uint8Array;
                metadata: Uint8Array;
            } & Record<Exclude<keyof I["offerSnapshot"]["snapshot"], keyof Snapshot>, never>;
            appHash: Uint8Array;
        } & Record<Exclude<keyof I["offerSnapshot"], keyof RequestOfferSnapshot>, never>;
        loadSnapshotChunk?: RequestLoadSnapshotChunk & {
            height: bigint;
            format: number;
            chunk: number;
        } & Record<Exclude<keyof I["loadSnapshotChunk"], keyof RequestLoadSnapshotChunk>, never>;
        applySnapshotChunk?: RequestApplySnapshotChunk & {
            index: number;
            chunk: Uint8Array;
            sender: string;
        } & Record<Exclude<keyof I["applySnapshotChunk"], keyof RequestApplySnapshotChunk>, never>;
    } & Record<Exclude<keyof I, keyof Request>, never>>(object: I): Request;
};
export declare const RequestEcho: {
    typeUrl: string;
    encode(message: RequestEcho, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestEcho;
    fromJSON(object: any): RequestEcho;
    toJSON(message: RequestEcho): unknown;
    fromPartial<I extends Partial<RequestEcho> & {
        message?: string;
    } & Record<Exclude<keyof I, "message">, never>>(object: I): RequestEcho;
};
export declare const RequestFlush: {
    typeUrl: string;
    encode(_: RequestFlush, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestFlush;
    fromJSON(_: any): RequestFlush;
    toJSON(_: RequestFlush): unknown;
    fromPartial<I extends Partial<RequestFlush> & {} & Record<Exclude<keyof I, never>, never>>(_: I): RequestFlush;
};
export declare const RequestInfo: {
    typeUrl: string;
    encode(message: RequestInfo, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestInfo;
    fromJSON(object: any): RequestInfo;
    toJSON(message: RequestInfo): unknown;
    fromPartial<I extends Partial<RequestInfo> & {
        version?: string;
        blockVersion?: bigint;
        p2pVersion?: bigint;
    } & Record<Exclude<keyof I, keyof RequestInfo>, never>>(object: I): RequestInfo;
};
export declare const RequestSetOption: {
    typeUrl: string;
    encode(message: RequestSetOption, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestSetOption;
    fromJSON(object: any): RequestSetOption;
    toJSON(message: RequestSetOption): unknown;
    fromPartial<I extends Partial<RequestSetOption> & {
        key?: string;
        value?: string;
    } & Record<Exclude<keyof I, keyof RequestSetOption>, never>>(object: I): RequestSetOption;
};
export declare const RequestInitChain: {
    typeUrl: string;
    encode(message: RequestInitChain, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestInitChain;
    fromJSON(object: any): RequestInitChain;
    toJSON(message: RequestInitChain): unknown;
    fromPartial<I extends Partial<RequestInitChain> & {
        time?: Timestamp & {
            seconds: bigint;
            nanos: number;
        } & Record<Exclude<keyof I["time"], keyof Timestamp>, never>;
        chainId?: string;
        consensusParams?: ConsensusParams & {
            block?: BlockParams & {
                maxBytes: bigint;
                maxGas: bigint;
            } & Record<Exclude<keyof I["consensusParams"]["block"], keyof BlockParams>, never>;
            evidence?: EvidenceParams & {
                maxAgeNumBlocks: bigint;
                maxAgeDuration: import("../../google/protobuf/duration").Duration & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I["consensusParams"]["evidence"]["maxAgeDuration"], keyof import("../../google/protobuf/duration").Duration>, never>;
                maxBytes: bigint;
            } & Record<Exclude<keyof I["consensusParams"]["evidence"], keyof EvidenceParams>, never>;
            validator?: ValidatorParams & {
                pubKeyTypes: string[] & Record<Exclude<keyof I["consensusParams"]["validator"]["pubKeyTypes"], keyof string[]>, never>;
            } & Record<Exclude<keyof I["consensusParams"]["validator"], "pubKeyTypes">, never>;
            version?: VersionParams & {
                appVersion: bigint;
            } & Record<Exclude<keyof I["consensusParams"]["version"], "appVersion">, never>;
        } & Record<Exclude<keyof I["consensusParams"], keyof ConsensusParams>, never>;
        validators?: ValidatorUpdate[] & (ValidatorUpdate & {
            pubKey: PublicKey & {
                ed25519?: Uint8Array;
                secp256k1?: Uint8Array;
            } & Record<Exclude<keyof I["validators"][number]["pubKey"], keyof PublicKey>, never>;
            power: bigint;
        } & Record<Exclude<keyof I["validators"][number], keyof ValidatorUpdate>, never>)[] & Record<Exclude<keyof I["validators"], keyof ValidatorUpdate[]>, never>;
        appStateBytes?: Uint8Array;
        initialHeight?: bigint;
    } & Record<Exclude<keyof I, keyof RequestInitChain>, never>>(object: I): RequestInitChain;
};
export declare const RequestQuery: {
    typeUrl: string;
    encode(message: RequestQuery, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestQuery;
    fromJSON(object: any): RequestQuery;
    toJSON(message: RequestQuery): unknown;
    fromPartial<I extends Partial<RequestQuery> & {
        data?: Uint8Array;
        path?: string;
        height?: bigint;
        prove?: boolean;
    } & Record<Exclude<keyof I, keyof RequestQuery>, never>>(object: I): RequestQuery;
};
export declare const RequestBeginBlock: {
    typeUrl: string;
    encode(message: RequestBeginBlock, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestBeginBlock;
    fromJSON(object: any): RequestBeginBlock;
    toJSON(message: RequestBeginBlock): unknown;
    fromPartial<I extends Partial<RequestBeginBlock> & {
        hash?: Uint8Array;
        header?: Header & {
            version: import("../version/types").Consensus & {
                block: bigint;
                app: bigint;
            } & Record<Exclude<keyof I["header"]["version"], keyof import("../version/types").Consensus>, never>;
            chainId: string;
            height: bigint;
            time: Timestamp & {
                seconds: bigint;
                nanos: number;
            } & Record<Exclude<keyof I["header"]["time"], keyof Timestamp>, never>;
            lastBlockId: import("../types/types").BlockID & {
                hash: Uint8Array;
                partSetHeader: import("../types/types").PartSetHeader & {
                    total: number;
                    hash: Uint8Array;
                } & Record<Exclude<keyof I["header"]["lastBlockId"]["partSetHeader"], keyof import("../types/types").PartSetHeader>, never>;
            } & Record<Exclude<keyof I["header"]["lastBlockId"], keyof import("../types/types").BlockID>, never>;
            lastCommitHash: Uint8Array;
            dataHash: Uint8Array;
            validatorsHash: Uint8Array;
            nextValidatorsHash: Uint8Array;
            consensusHash: Uint8Array;
            appHash: Uint8Array;
            lastResultsHash: Uint8Array;
            evidenceHash: Uint8Array;
            proposerAddress: Uint8Array;
        } & Record<Exclude<keyof I["header"], keyof Header>, never>;
        lastCommitInfo?: LastCommitInfo & {
            round: number;
            votes: VoteInfo[] & (VoteInfo & {
                validator: Validator & {
                    address: Uint8Array;
                    power: bigint;
                } & Record<Exclude<keyof I["lastCommitInfo"]["votes"][number]["validator"], keyof Validator>, never>;
                signedLastBlock: boolean;
            } & Record<Exclude<keyof I["lastCommitInfo"]["votes"][number], keyof VoteInfo>, never>)[] & Record<Exclude<keyof I["lastCommitInfo"]["votes"], keyof VoteInfo[]>, never>;
        } & Record<Exclude<keyof I["lastCommitInfo"], keyof LastCommitInfo>, never>;
        byzantineValidators?: Evidence[] & (Evidence & {
            type: EvidenceType;
            validator: Validator & {
                address: Uint8Array;
                power: bigint;
            } & Record<Exclude<keyof I["byzantineValidators"][number]["validator"], keyof Validator>, never>;
            height: bigint;
            time: Timestamp & {
                seconds: bigint;
                nanos: number;
            } & Record<Exclude<keyof I["byzantineValidators"][number]["time"], keyof Timestamp>, never>;
            totalVotingPower: bigint;
        } & Record<Exclude<keyof I["byzantineValidators"][number], keyof Evidence>, never>)[] & Record<Exclude<keyof I["byzantineValidators"], keyof Evidence[]>, never>;
    } & Record<Exclude<keyof I, keyof RequestBeginBlock>, never>>(object: I): RequestBeginBlock;
};
export declare const RequestCheckTx: {
    typeUrl: string;
    encode(message: RequestCheckTx, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestCheckTx;
    fromJSON(object: any): RequestCheckTx;
    toJSON(message: RequestCheckTx): unknown;
    fromPartial<I extends Partial<RequestCheckTx> & {
        tx?: Uint8Array;
        type?: CheckTxType;
    } & Record<Exclude<keyof I, keyof RequestCheckTx>, never>>(object: I): RequestCheckTx;
};
export declare const RequestDeliverTx: {
    typeUrl: string;
    encode(message: RequestDeliverTx, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestDeliverTx;
    fromJSON(object: any): RequestDeliverTx;
    toJSON(message: RequestDeliverTx): unknown;
    fromPartial<I extends Partial<RequestDeliverTx> & {
        tx?: Uint8Array;
    } & Record<Exclude<keyof I, "tx">, never>>(object: I): RequestDeliverTx;
};
export declare const RequestEndBlock: {
    typeUrl: string;
    encode(message: RequestEndBlock, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestEndBlock;
    fromJSON(object: any): RequestEndBlock;
    toJSON(message: RequestEndBlock): unknown;
    fromPartial<I extends Partial<RequestEndBlock> & {
        height?: bigint;
    } & Record<Exclude<keyof I, "height">, never>>(object: I): RequestEndBlock;
};
export declare const RequestCommit: {
    typeUrl: string;
    encode(_: RequestCommit, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestCommit;
    fromJSON(_: any): RequestCommit;
    toJSON(_: RequestCommit): unknown;
    fromPartial<I extends Partial<RequestCommit> & {} & Record<Exclude<keyof I, never>, never>>(_: I): RequestCommit;
};
export declare const RequestListSnapshots: {
    typeUrl: string;
    encode(_: RequestListSnapshots, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestListSnapshots;
    fromJSON(_: any): RequestListSnapshots;
    toJSON(_: RequestListSnapshots): unknown;
    fromPartial<I extends Partial<RequestListSnapshots> & {} & Record<Exclude<keyof I, never>, never>>(_: I): RequestListSnapshots;
};
export declare const RequestOfferSnapshot: {
    typeUrl: string;
    encode(message: RequestOfferSnapshot, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestOfferSnapshot;
    fromJSON(object: any): RequestOfferSnapshot;
    toJSON(message: RequestOfferSnapshot): unknown;
    fromPartial<I extends Partial<RequestOfferSnapshot> & {
        snapshot?: Snapshot & {
            height: bigint;
            format: number;
            chunks: number;
            hash: Uint8Array;
            metadata: Uint8Array;
        } & Record<Exclude<keyof I["snapshot"], keyof Snapshot>, never>;
        appHash?: Uint8Array;
    } & Record<Exclude<keyof I, keyof RequestOfferSnapshot>, never>>(object: I): RequestOfferSnapshot;
};
export declare const RequestLoadSnapshotChunk: {
    typeUrl: string;
    encode(message: RequestLoadSnapshotChunk, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestLoadSnapshotChunk;
    fromJSON(object: any): RequestLoadSnapshotChunk;
    toJSON(message: RequestLoadSnapshotChunk): unknown;
    fromPartial<I extends Partial<RequestLoadSnapshotChunk> & {
        height?: bigint;
        format?: number;
        chunk?: number;
    } & Record<Exclude<keyof I, keyof RequestLoadSnapshotChunk>, never>>(object: I): RequestLoadSnapshotChunk;
};
export declare const RequestApplySnapshotChunk: {
    typeUrl: string;
    encode(message: RequestApplySnapshotChunk, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): RequestApplySnapshotChunk;
    fromJSON(object: any): RequestApplySnapshotChunk;
    toJSON(message: RequestApplySnapshotChunk): unknown;
    fromPartial<I extends Partial<RequestApplySnapshotChunk> & {
        index?: number;
        chunk?: Uint8Array;
        sender?: string;
    } & Record<Exclude<keyof I, keyof RequestApplySnapshotChunk>, never>>(object: I): RequestApplySnapshotChunk;
};
export declare const Response: {
    typeUrl: string;
    encode(message: Response, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Response;
    fromJSON(object: any): Response;
    toJSON(message: Response): unknown;
    fromPartial<I extends Partial<Response> & {
        exception?: ResponseException & {
            error: string;
        } & Record<Exclude<keyof I["exception"], "error">, never>;
        echo?: ResponseEcho & {
            message: string;
        } & Record<Exclude<keyof I["echo"], "message">, never>;
        flush?: ResponseFlush & {} & Record<Exclude<keyof I["flush"], never>, never>;
        info?: ResponseInfo & {
            data: string;
            version: string;
            appVersion: bigint;
            lastBlockHeight: bigint;
            lastBlockAppHash: Uint8Array;
        } & Record<Exclude<keyof I["info"], keyof ResponseInfo>, never>;
        setOption?: ResponseSetOption & {
            code: number;
            log: string;
            info: string;
        } & Record<Exclude<keyof I["setOption"], keyof ResponseSetOption>, never>;
        initChain?: ResponseInitChain & {
            consensusParams?: ConsensusParams & {
                block?: BlockParams & {
                    maxBytes: bigint;
                    maxGas: bigint;
                } & Record<Exclude<keyof I["initChain"]["consensusParams"]["block"], keyof BlockParams>, never>;
                evidence?: EvidenceParams & {
                    maxAgeNumBlocks: bigint;
                    maxAgeDuration: import("../../google/protobuf/duration").Duration & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I["initChain"]["consensusParams"]["evidence"]["maxAgeDuration"], keyof import("../../google/protobuf/duration").Duration>, never>;
                    maxBytes: bigint;
                } & Record<Exclude<keyof I["initChain"]["consensusParams"]["evidence"], keyof EvidenceParams>, never>;
                validator?: ValidatorParams & {
                    pubKeyTypes: string[] & Record<Exclude<keyof I["initChain"]["consensusParams"]["validator"]["pubKeyTypes"], keyof string[]>, never>;
                } & Record<Exclude<keyof I["initChain"]["consensusParams"]["validator"], "pubKeyTypes">, never>;
                version?: VersionParams & {
                    appVersion: bigint;
                } & Record<Exclude<keyof I["initChain"]["consensusParams"]["version"], "appVersion">, never>;
            } & Record<Exclude<keyof I["initChain"]["consensusParams"], keyof ConsensusParams>, never>;
            validators: ValidatorUpdate[] & (ValidatorUpdate & {
                pubKey: PublicKey & {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                } & Record<Exclude<keyof I["initChain"]["validators"][number]["pubKey"], keyof PublicKey>, never>;
                power: bigint;
            } & Record<Exclude<keyof I["initChain"]["validators"][number], keyof ValidatorUpdate>, never>)[] & Record<Exclude<keyof I["initChain"]["validators"], keyof ValidatorUpdate[]>, never>;
            appHash: Uint8Array;
        } & Record<Exclude<keyof I["initChain"], keyof ResponseInitChain>, never>;
        query?: ResponseQuery & {
            code: number;
            log: string;
            info: string;
            index: bigint;
            key: Uint8Array;
            value: Uint8Array;
            proofOps?: ProofOps & {
                ops: import("../crypto/proof").ProofOp[] & (import("../crypto/proof").ProofOp & {
                    type: string;
                    key: Uint8Array;
                    data: Uint8Array;
                } & Record<Exclude<keyof I["query"]["proofOps"]["ops"][number], keyof import("../crypto/proof").ProofOp>, never>)[] & Record<Exclude<keyof I["query"]["proofOps"]["ops"], keyof import("../crypto/proof").ProofOp[]>, never>;
            } & Record<Exclude<keyof I["query"]["proofOps"], "ops">, never>;
            height: bigint;
            codespace: string;
        } & Record<Exclude<keyof I["query"], keyof ResponseQuery>, never>;
        beginBlock?: ResponseBeginBlock & {
            events: Event[] & (Event & {
                type: string;
                attributes: EventAttribute[] & (EventAttribute & {
                    key: Uint8Array;
                    value: Uint8Array;
                    index: boolean;
                } & Record<Exclude<keyof I["beginBlock"]["events"][number]["attributes"][number], keyof EventAttribute>, never>)[] & Record<Exclude<keyof I["beginBlock"]["events"][number]["attributes"], keyof EventAttribute[]>, never>;
            } & Record<Exclude<keyof I["beginBlock"]["events"][number], keyof Event>, never>)[] & Record<Exclude<keyof I["beginBlock"]["events"], keyof Event[]>, never>;
        } & Record<Exclude<keyof I["beginBlock"], "events">, never>;
        checkTx?: ResponseCheckTx & {
            code: number;
            data: Uint8Array;
            log: string;
            info: string;
            gasWanted: bigint;
            gasUsed: bigint;
            events: Event[] & (Event & {
                type: string;
                attributes: EventAttribute[] & (EventAttribute & {
                    key: Uint8Array;
                    value: Uint8Array;
                    index: boolean;
                } & Record<Exclude<keyof I["checkTx"]["events"][number]["attributes"][number], keyof EventAttribute>, never>)[] & Record<Exclude<keyof I["checkTx"]["events"][number]["attributes"], keyof EventAttribute[]>, never>;
            } & Record<Exclude<keyof I["checkTx"]["events"][number], keyof Event>, never>)[] & Record<Exclude<keyof I["checkTx"]["events"], keyof Event[]>, never>;
            codespace: string;
            sender: string;
            priority: bigint;
            mempoolError: string;
        } & Record<Exclude<keyof I["checkTx"], keyof ResponseCheckTx>, never>;
        deliverTx?: ResponseDeliverTx & {
            code: number;
            data: Uint8Array;
            log: string;
            info: string;
            gasWanted: bigint;
            gasUsed: bigint;
            events: Event[] & (Event & {
                type: string;
                attributes: EventAttribute[] & (EventAttribute & {
                    key: Uint8Array;
                    value: Uint8Array;
                    index: boolean;
                } & Record<Exclude<keyof I["deliverTx"]["events"][number]["attributes"][number], keyof EventAttribute>, never>)[] & Record<Exclude<keyof I["deliverTx"]["events"][number]["attributes"], keyof EventAttribute[]>, never>;
            } & Record<Exclude<keyof I["deliverTx"]["events"][number], keyof Event>, never>)[] & Record<Exclude<keyof I["deliverTx"]["events"], keyof Event[]>, never>;
            codespace: string;
        } & Record<Exclude<keyof I["deliverTx"], keyof ResponseDeliverTx>, never>;
        endBlock?: ResponseEndBlock & {
            validatorUpdates: ValidatorUpdate[] & (ValidatorUpdate & {
                pubKey: PublicKey & {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                } & Record<Exclude<keyof I["endBlock"]["validatorUpdates"][number]["pubKey"], keyof PublicKey>, never>;
                power: bigint;
            } & Record<Exclude<keyof I["endBlock"]["validatorUpdates"][number], keyof ValidatorUpdate>, never>)[] & Record<Exclude<keyof I["endBlock"]["validatorUpdates"], keyof ValidatorUpdate[]>, never>;
            consensusParamUpdates?: ConsensusParams & {
                block?: BlockParams & {
                    maxBytes: bigint;
                    maxGas: bigint;
                } & Record<Exclude<keyof I["endBlock"]["consensusParamUpdates"]["block"], keyof BlockParams>, never>;
                evidence?: EvidenceParams & {
                    maxAgeNumBlocks: bigint;
                    maxAgeDuration: import("../../google/protobuf/duration").Duration & {
                        seconds: bigint;
                        nanos: number;
                    } & Record<Exclude<keyof I["endBlock"]["consensusParamUpdates"]["evidence"]["maxAgeDuration"], keyof import("../../google/protobuf/duration").Duration>, never>;
                    maxBytes: bigint;
                } & Record<Exclude<keyof I["endBlock"]["consensusParamUpdates"]["evidence"], keyof EvidenceParams>, never>;
                validator?: ValidatorParams & {
                    pubKeyTypes: string[] & Record<Exclude<keyof I["endBlock"]["consensusParamUpdates"]["validator"]["pubKeyTypes"], keyof string[]>, never>;
                } & Record<Exclude<keyof I["endBlock"]["consensusParamUpdates"]["validator"], "pubKeyTypes">, never>;
                version?: VersionParams & {
                    appVersion: bigint;
                } & Record<Exclude<keyof I["endBlock"]["consensusParamUpdates"]["version"], "appVersion">, never>;
            } & Record<Exclude<keyof I["endBlock"]["consensusParamUpdates"], keyof ConsensusParams>, never>;
            events: Event[] & (Event & {
                type: string;
                attributes: EventAttribute[] & (EventAttribute & {
                    key: Uint8Array;
                    value: Uint8Array;
                    index: boolean;
                } & Record<Exclude<keyof I["endBlock"]["events"][number]["attributes"][number], keyof EventAttribute>, never>)[] & Record<Exclude<keyof I["endBlock"]["events"][number]["attributes"], keyof EventAttribute[]>, never>;
            } & Record<Exclude<keyof I["endBlock"]["events"][number], keyof Event>, never>)[] & Record<Exclude<keyof I["endBlock"]["events"], keyof Event[]>, never>;
        } & Record<Exclude<keyof I["endBlock"], keyof ResponseEndBlock>, never>;
        commit?: ResponseCommit & {
            data: Uint8Array;
            retainHeight: bigint;
        } & Record<Exclude<keyof I["commit"], keyof ResponseCommit>, never>;
        listSnapshots?: ResponseListSnapshots & {
            snapshots: Snapshot[] & (Snapshot & {
                height: bigint;
                format: number;
                chunks: number;
                hash: Uint8Array;
                metadata: Uint8Array;
            } & Record<Exclude<keyof I["listSnapshots"]["snapshots"][number], keyof Snapshot>, never>)[] & Record<Exclude<keyof I["listSnapshots"]["snapshots"], keyof Snapshot[]>, never>;
        } & Record<Exclude<keyof I["listSnapshots"], "snapshots">, never>;
        offerSnapshot?: ResponseOfferSnapshot & {
            result: ResponseOfferSnapshot_Result;
        } & Record<Exclude<keyof I["offerSnapshot"], "result">, never>;
        loadSnapshotChunk?: ResponseLoadSnapshotChunk & {
            chunk: Uint8Array;
        } & Record<Exclude<keyof I["loadSnapshotChunk"], "chunk">, never>;
        applySnapshotChunk?: ResponseApplySnapshotChunk & {
            result: ResponseApplySnapshotChunk_Result;
            refetchChunks: number[] & Record<Exclude<keyof I["applySnapshotChunk"]["refetchChunks"], keyof number[]>, never>;
            rejectSenders: string[] & Record<Exclude<keyof I["applySnapshotChunk"]["rejectSenders"], keyof string[]>, never>;
        } & Record<Exclude<keyof I["applySnapshotChunk"], keyof ResponseApplySnapshotChunk>, never>;
    } & Record<Exclude<keyof I, keyof Response>, never>>(object: I): Response;
};
export declare const ResponseException: {
    typeUrl: string;
    encode(message: ResponseException, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseException;
    fromJSON(object: any): ResponseException;
    toJSON(message: ResponseException): unknown;
    fromPartial<I extends Partial<ResponseException> & {
        error?: string;
    } & Record<Exclude<keyof I, "error">, never>>(object: I): ResponseException;
};
export declare const ResponseEcho: {
    typeUrl: string;
    encode(message: ResponseEcho, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseEcho;
    fromJSON(object: any): ResponseEcho;
    toJSON(message: ResponseEcho): unknown;
    fromPartial<I extends Partial<ResponseEcho> & {
        message?: string;
    } & Record<Exclude<keyof I, "message">, never>>(object: I): ResponseEcho;
};
export declare const ResponseFlush: {
    typeUrl: string;
    encode(_: ResponseFlush, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseFlush;
    fromJSON(_: any): ResponseFlush;
    toJSON(_: ResponseFlush): unknown;
    fromPartial<I extends Partial<ResponseFlush> & {} & Record<Exclude<keyof I, never>, never>>(_: I): ResponseFlush;
};
export declare const ResponseInfo: {
    typeUrl: string;
    encode(message: ResponseInfo, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseInfo;
    fromJSON(object: any): ResponseInfo;
    toJSON(message: ResponseInfo): unknown;
    fromPartial<I extends Partial<ResponseInfo> & {
        data?: string;
        version?: string;
        appVersion?: bigint;
        lastBlockHeight?: bigint;
        lastBlockAppHash?: Uint8Array;
    } & Record<Exclude<keyof I, keyof ResponseInfo>, never>>(object: I): ResponseInfo;
};
export declare const ResponseSetOption: {
    typeUrl: string;
    encode(message: ResponseSetOption, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseSetOption;
    fromJSON(object: any): ResponseSetOption;
    toJSON(message: ResponseSetOption): unknown;
    fromPartial<I extends Partial<ResponseSetOption> & {
        code?: number;
        log?: string;
        info?: string;
    } & Record<Exclude<keyof I, keyof ResponseSetOption>, never>>(object: I): ResponseSetOption;
};
export declare const ResponseInitChain: {
    typeUrl: string;
    encode(message: ResponseInitChain, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseInitChain;
    fromJSON(object: any): ResponseInitChain;
    toJSON(message: ResponseInitChain): unknown;
    fromPartial<I extends Partial<ResponseInitChain> & {
        consensusParams?: ConsensusParams & {
            block?: BlockParams & {
                maxBytes: bigint;
                maxGas: bigint;
            } & Record<Exclude<keyof I["consensusParams"]["block"], keyof BlockParams>, never>;
            evidence?: EvidenceParams & {
                maxAgeNumBlocks: bigint;
                maxAgeDuration: import("../../google/protobuf/duration").Duration & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I["consensusParams"]["evidence"]["maxAgeDuration"], keyof import("../../google/protobuf/duration").Duration>, never>;
                maxBytes: bigint;
            } & Record<Exclude<keyof I["consensusParams"]["evidence"], keyof EvidenceParams>, never>;
            validator?: ValidatorParams & {
                pubKeyTypes: string[] & Record<Exclude<keyof I["consensusParams"]["validator"]["pubKeyTypes"], keyof string[]>, never>;
            } & Record<Exclude<keyof I["consensusParams"]["validator"], "pubKeyTypes">, never>;
            version?: VersionParams & {
                appVersion: bigint;
            } & Record<Exclude<keyof I["consensusParams"]["version"], "appVersion">, never>;
        } & Record<Exclude<keyof I["consensusParams"], keyof ConsensusParams>, never>;
        validators?: ValidatorUpdate[] & (ValidatorUpdate & {
            pubKey: PublicKey & {
                ed25519?: Uint8Array;
                secp256k1?: Uint8Array;
            } & Record<Exclude<keyof I["validators"][number]["pubKey"], keyof PublicKey>, never>;
            power: bigint;
        } & Record<Exclude<keyof I["validators"][number], keyof ValidatorUpdate>, never>)[] & Record<Exclude<keyof I["validators"], keyof ValidatorUpdate[]>, never>;
        appHash?: Uint8Array;
    } & Record<Exclude<keyof I, keyof ResponseInitChain>, never>>(object: I): ResponseInitChain;
};
export declare const ResponseQuery: {
    typeUrl: string;
    encode(message: ResponseQuery, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseQuery;
    fromJSON(object: any): ResponseQuery;
    toJSON(message: ResponseQuery): unknown;
    fromPartial<I extends Partial<ResponseQuery> & {
        code?: number;
        log?: string;
        info?: string;
        index?: bigint;
        key?: Uint8Array;
        value?: Uint8Array;
        proofOps?: ProofOps & {
            ops: import("../crypto/proof").ProofOp[] & (import("../crypto/proof").ProofOp & {
                type: string;
                key: Uint8Array;
                data: Uint8Array;
            } & Record<Exclude<keyof I["proofOps"]["ops"][number], keyof import("../crypto/proof").ProofOp>, never>)[] & Record<Exclude<keyof I["proofOps"]["ops"], keyof import("../crypto/proof").ProofOp[]>, never>;
        } & Record<Exclude<keyof I["proofOps"], "ops">, never>;
        height?: bigint;
        codespace?: string;
    } & Record<Exclude<keyof I, keyof ResponseQuery>, never>>(object: I): ResponseQuery;
};
export declare const ResponseBeginBlock: {
    typeUrl: string;
    encode(message: ResponseBeginBlock, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseBeginBlock;
    fromJSON(object: any): ResponseBeginBlock;
    toJSON(message: ResponseBeginBlock): unknown;
    fromPartial<I extends Partial<ResponseBeginBlock> & {
        events?: Event[] & (Event & {
            type: string;
            attributes: EventAttribute[] & (EventAttribute & {
                key: Uint8Array;
                value: Uint8Array;
                index: boolean;
            } & Record<Exclude<keyof I["events"][number]["attributes"][number], keyof EventAttribute>, never>)[] & Record<Exclude<keyof I["events"][number]["attributes"], keyof EventAttribute[]>, never>;
        } & Record<Exclude<keyof I["events"][number], keyof Event>, never>)[] & Record<Exclude<keyof I["events"], keyof Event[]>, never>;
    } & Record<Exclude<keyof I, "events">, never>>(object: I): ResponseBeginBlock;
};
export declare const ResponseCheckTx: {
    typeUrl: string;
    encode(message: ResponseCheckTx, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseCheckTx;
    fromJSON(object: any): ResponseCheckTx;
    toJSON(message: ResponseCheckTx): unknown;
    fromPartial<I extends Partial<ResponseCheckTx> & {
        code?: number;
        data?: Uint8Array;
        log?: string;
        info?: string;
        gasWanted?: bigint;
        gasUsed?: bigint;
        events?: Event[] & (Event & {
            type: string;
            attributes: EventAttribute[] & (EventAttribute & {
                key: Uint8Array;
                value: Uint8Array;
                index: boolean;
            } & Record<Exclude<keyof I["events"][number]["attributes"][number], keyof EventAttribute>, never>)[] & Record<Exclude<keyof I["events"][number]["attributes"], keyof EventAttribute[]>, never>;
        } & Record<Exclude<keyof I["events"][number], keyof Event>, never>)[] & Record<Exclude<keyof I["events"], keyof Event[]>, never>;
        codespace?: string;
        sender?: string;
        priority?: bigint;
        mempoolError?: string;
    } & Record<Exclude<keyof I, keyof ResponseCheckTx>, never>>(object: I): ResponseCheckTx;
};
export declare const ResponseDeliverTx: {
    typeUrl: string;
    encode(message: ResponseDeliverTx, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseDeliverTx;
    fromJSON(object: any): ResponseDeliverTx;
    toJSON(message: ResponseDeliverTx): unknown;
    fromPartial<I extends Partial<ResponseDeliverTx> & {
        code?: number;
        data?: Uint8Array;
        log?: string;
        info?: string;
        gasWanted?: bigint;
        gasUsed?: bigint;
        events?: Event[] & (Event & {
            type: string;
            attributes: EventAttribute[] & (EventAttribute & {
                key: Uint8Array;
                value: Uint8Array;
                index: boolean;
            } & Record<Exclude<keyof I["events"][number]["attributes"][number], keyof EventAttribute>, never>)[] & Record<Exclude<keyof I["events"][number]["attributes"], keyof EventAttribute[]>, never>;
        } & Record<Exclude<keyof I["events"][number], keyof Event>, never>)[] & Record<Exclude<keyof I["events"], keyof Event[]>, never>;
        codespace?: string;
    } & Record<Exclude<keyof I, keyof ResponseDeliverTx>, never>>(object: I): ResponseDeliverTx;
};
export declare const ResponseEndBlock: {
    typeUrl: string;
    encode(message: ResponseEndBlock, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseEndBlock;
    fromJSON(object: any): ResponseEndBlock;
    toJSON(message: ResponseEndBlock): unknown;
    fromPartial<I extends Partial<ResponseEndBlock> & {
        validatorUpdates?: ValidatorUpdate[] & (ValidatorUpdate & {
            pubKey: PublicKey & {
                ed25519?: Uint8Array;
                secp256k1?: Uint8Array;
            } & Record<Exclude<keyof I["validatorUpdates"][number]["pubKey"], keyof PublicKey>, never>;
            power: bigint;
        } & Record<Exclude<keyof I["validatorUpdates"][number], keyof ValidatorUpdate>, never>)[] & Record<Exclude<keyof I["validatorUpdates"], keyof ValidatorUpdate[]>, never>;
        consensusParamUpdates?: ConsensusParams & {
            block?: BlockParams & {
                maxBytes: bigint;
                maxGas: bigint;
            } & Record<Exclude<keyof I["consensusParamUpdates"]["block"], keyof BlockParams>, never>;
            evidence?: EvidenceParams & {
                maxAgeNumBlocks: bigint;
                maxAgeDuration: import("../../google/protobuf/duration").Duration & {
                    seconds: bigint;
                    nanos: number;
                } & Record<Exclude<keyof I["consensusParamUpdates"]["evidence"]["maxAgeDuration"], keyof import("../../google/protobuf/duration").Duration>, never>;
                maxBytes: bigint;
            } & Record<Exclude<keyof I["consensusParamUpdates"]["evidence"], keyof EvidenceParams>, never>;
            validator?: ValidatorParams & {
                pubKeyTypes: string[] & Record<Exclude<keyof I["consensusParamUpdates"]["validator"]["pubKeyTypes"], keyof string[]>, never>;
            } & Record<Exclude<keyof I["consensusParamUpdates"]["validator"], "pubKeyTypes">, never>;
            version?: VersionParams & {
                appVersion: bigint;
            } & Record<Exclude<keyof I["consensusParamUpdates"]["version"], "appVersion">, never>;
        } & Record<Exclude<keyof I["consensusParamUpdates"], keyof ConsensusParams>, never>;
        events?: Event[] & (Event & {
            type: string;
            attributes: EventAttribute[] & (EventAttribute & {
                key: Uint8Array;
                value: Uint8Array;
                index: boolean;
            } & Record<Exclude<keyof I["events"][number]["attributes"][number], keyof EventAttribute>, never>)[] & Record<Exclude<keyof I["events"][number]["attributes"], keyof EventAttribute[]>, never>;
        } & Record<Exclude<keyof I["events"][number], keyof Event>, never>)[] & Record<Exclude<keyof I["events"], keyof Event[]>, never>;
    } & Record<Exclude<keyof I, keyof ResponseEndBlock>, never>>(object: I): ResponseEndBlock;
};
export declare const ResponseCommit: {
    typeUrl: string;
    encode(message: ResponseCommit, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseCommit;
    fromJSON(object: any): ResponseCommit;
    toJSON(message: ResponseCommit): unknown;
    fromPartial<I extends Partial<ResponseCommit> & {
        data?: Uint8Array;
        retainHeight?: bigint;
    } & Record<Exclude<keyof I, keyof ResponseCommit>, never>>(object: I): ResponseCommit;
};
export declare const ResponseListSnapshots: {
    typeUrl: string;
    encode(message: ResponseListSnapshots, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseListSnapshots;
    fromJSON(object: any): ResponseListSnapshots;
    toJSON(message: ResponseListSnapshots): unknown;
    fromPartial<I extends Partial<ResponseListSnapshots> & {
        snapshots?: Snapshot[] & (Snapshot & {
            height: bigint;
            format: number;
            chunks: number;
            hash: Uint8Array;
            metadata: Uint8Array;
        } & Record<Exclude<keyof I["snapshots"][number], keyof Snapshot>, never>)[] & Record<Exclude<keyof I["snapshots"], keyof Snapshot[]>, never>;
    } & Record<Exclude<keyof I, "snapshots">, never>>(object: I): ResponseListSnapshots;
};
export declare const ResponseOfferSnapshot: {
    typeUrl: string;
    encode(message: ResponseOfferSnapshot, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseOfferSnapshot;
    fromJSON(object: any): ResponseOfferSnapshot;
    toJSON(message: ResponseOfferSnapshot): unknown;
    fromPartial<I extends Partial<ResponseOfferSnapshot> & {
        result?: ResponseOfferSnapshot_Result;
    } & Record<Exclude<keyof I, "result">, never>>(object: I): ResponseOfferSnapshot;
};
export declare const ResponseLoadSnapshotChunk: {
    typeUrl: string;
    encode(message: ResponseLoadSnapshotChunk, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseLoadSnapshotChunk;
    fromJSON(object: any): ResponseLoadSnapshotChunk;
    toJSON(message: ResponseLoadSnapshotChunk): unknown;
    fromPartial<I extends Partial<ResponseLoadSnapshotChunk> & {
        chunk?: Uint8Array;
    } & Record<Exclude<keyof I, "chunk">, never>>(object: I): ResponseLoadSnapshotChunk;
};
export declare const ResponseApplySnapshotChunk: {
    typeUrl: string;
    encode(message: ResponseApplySnapshotChunk, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ResponseApplySnapshotChunk;
    fromJSON(object: any): ResponseApplySnapshotChunk;
    toJSON(message: ResponseApplySnapshotChunk): unknown;
    fromPartial<I extends Partial<ResponseApplySnapshotChunk> & {
        result?: ResponseApplySnapshotChunk_Result;
        refetchChunks?: number[] & Record<Exclude<keyof I["refetchChunks"], keyof number[]>, never>;
        rejectSenders?: string[] & Record<Exclude<keyof I["rejectSenders"], keyof string[]>, never>;
    } & Record<Exclude<keyof I, keyof ResponseApplySnapshotChunk>, never>>(object: I): ResponseApplySnapshotChunk;
};
export declare const ConsensusParams: {
    typeUrl: string;
    encode(message: ConsensusParams, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ConsensusParams;
    fromJSON(object: any): ConsensusParams;
    toJSON(message: ConsensusParams): unknown;
    fromPartial<I extends Partial<ConsensusParams> & {
        block?: BlockParams & {
            maxBytes: bigint;
            maxGas: bigint;
        } & Record<Exclude<keyof I["block"], keyof BlockParams>, never>;
        evidence?: EvidenceParams & {
            maxAgeNumBlocks: bigint;
            maxAgeDuration: import("../../google/protobuf/duration").Duration & {
                seconds: bigint;
                nanos: number;
            } & Record<Exclude<keyof I["evidence"]["maxAgeDuration"], keyof import("../../google/protobuf/duration").Duration>, never>;
            maxBytes: bigint;
        } & Record<Exclude<keyof I["evidence"], keyof EvidenceParams>, never>;
        validator?: ValidatorParams & {
            pubKeyTypes: string[] & Record<Exclude<keyof I["validator"]["pubKeyTypes"], keyof string[]>, never>;
        } & Record<Exclude<keyof I["validator"], "pubKeyTypes">, never>;
        version?: VersionParams & {
            appVersion: bigint;
        } & Record<Exclude<keyof I["version"], "appVersion">, never>;
    } & Record<Exclude<keyof I, keyof ConsensusParams>, never>>(object: I): ConsensusParams;
};
export declare const BlockParams: {
    typeUrl: string;
    encode(message: BlockParams, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): BlockParams;
    fromJSON(object: any): BlockParams;
    toJSON(message: BlockParams): unknown;
    fromPartial<I extends Partial<BlockParams> & {
        maxBytes?: bigint;
        maxGas?: bigint;
    } & Record<Exclude<keyof I, keyof BlockParams>, never>>(object: I): BlockParams;
};
export declare const LastCommitInfo: {
    typeUrl: string;
    encode(message: LastCommitInfo, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): LastCommitInfo;
    fromJSON(object: any): LastCommitInfo;
    toJSON(message: LastCommitInfo): unknown;
    fromPartial<I extends Partial<LastCommitInfo> & {
        round?: number;
        votes?: VoteInfo[] & (VoteInfo & {
            validator: Validator & {
                address: Uint8Array;
                power: bigint;
            } & Record<Exclude<keyof I["votes"][number]["validator"], keyof Validator>, never>;
            signedLastBlock: boolean;
        } & Record<Exclude<keyof I["votes"][number], keyof VoteInfo>, never>)[] & Record<Exclude<keyof I["votes"], keyof VoteInfo[]>, never>;
    } & Record<Exclude<keyof I, keyof LastCommitInfo>, never>>(object: I): LastCommitInfo;
};
export declare const Event: {
    typeUrl: string;
    encode(message: Event, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Event;
    fromJSON(object: any): Event;
    toJSON(message: Event): unknown;
    fromPartial<I extends Partial<Event> & {
        type?: string;
        attributes?: EventAttribute[] & (EventAttribute & {
            key: Uint8Array;
            value: Uint8Array;
            index: boolean;
        } & Record<Exclude<keyof I["attributes"][number], keyof EventAttribute>, never>)[] & Record<Exclude<keyof I["attributes"], keyof EventAttribute[]>, never>;
    } & Record<Exclude<keyof I, keyof Event>, never>>(object: I): Event;
};
export declare const EventAttribute: {
    typeUrl: string;
    encode(message: EventAttribute, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): EventAttribute;
    fromJSON(object: any): EventAttribute;
    toJSON(message: EventAttribute): unknown;
    fromPartial<I extends Partial<EventAttribute> & {
        key?: Uint8Array;
        value?: Uint8Array;
        index?: boolean;
    } & Record<Exclude<keyof I, keyof EventAttribute>, never>>(object: I): EventAttribute;
};
export declare const TxResult: {
    typeUrl: string;
    encode(message: TxResult, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): TxResult;
    fromJSON(object: any): TxResult;
    toJSON(message: TxResult): unknown;
    fromPartial<I extends Partial<TxResult> & {
        height?: bigint;
        index?: number;
        tx?: Uint8Array;
        result?: ResponseDeliverTx & {
            code: number;
            data: Uint8Array;
            log: string;
            info: string;
            gasWanted: bigint;
            gasUsed: bigint;
            events: Event[] & (Event & {
                type: string;
                attributes: EventAttribute[] & (EventAttribute & {
                    key: Uint8Array;
                    value: Uint8Array;
                    index: boolean;
                } & Record<Exclude<keyof I["result"]["events"][number]["attributes"][number], keyof EventAttribute>, never>)[] & Record<Exclude<keyof I["result"]["events"][number]["attributes"], keyof EventAttribute[]>, never>;
            } & Record<Exclude<keyof I["result"]["events"][number], keyof Event>, never>)[] & Record<Exclude<keyof I["result"]["events"], keyof Event[]>, never>;
            codespace: string;
        } & Record<Exclude<keyof I["result"], keyof ResponseDeliverTx>, never>;
    } & Record<Exclude<keyof I, keyof TxResult>, never>>(object: I): TxResult;
};
export declare const Validator: {
    typeUrl: string;
    encode(message: Validator, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Validator;
    fromJSON(object: any): Validator;
    toJSON(message: Validator): unknown;
    fromPartial<I extends Partial<Validator> & {
        address?: Uint8Array;
        power?: bigint;
    } & Record<Exclude<keyof I, keyof Validator>, never>>(object: I): Validator;
};
export declare const ValidatorUpdate: {
    typeUrl: string;
    encode(message: ValidatorUpdate, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): ValidatorUpdate;
    fromJSON(object: any): ValidatorUpdate;
    toJSON(message: ValidatorUpdate): unknown;
    fromPartial<I extends Partial<ValidatorUpdate> & {
        pubKey?: PublicKey & {
            ed25519?: Uint8Array;
            secp256k1?: Uint8Array;
        } & Record<Exclude<keyof I["pubKey"], keyof PublicKey>, never>;
        power?: bigint;
    } & Record<Exclude<keyof I, keyof ValidatorUpdate>, never>>(object: I): ValidatorUpdate;
};
export declare const VoteInfo: {
    typeUrl: string;
    encode(message: VoteInfo, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): VoteInfo;
    fromJSON(object: any): VoteInfo;
    toJSON(message: VoteInfo): unknown;
    fromPartial<I extends Partial<VoteInfo> & {
        validator?: Validator & {
            address: Uint8Array;
            power: bigint;
        } & Record<Exclude<keyof I["validator"], keyof Validator>, never>;
        signedLastBlock?: boolean;
    } & Record<Exclude<keyof I, keyof VoteInfo>, never>>(object: I): VoteInfo;
};
export declare const Evidence: {
    typeUrl: string;
    encode(message: Evidence, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Evidence;
    fromJSON(object: any): Evidence;
    toJSON(message: Evidence): unknown;
    fromPartial<I extends Partial<Evidence> & {
        type?: EvidenceType;
        validator?: Validator & {
            address: Uint8Array;
            power: bigint;
        } & Record<Exclude<keyof I["validator"], keyof Validator>, never>;
        height?: bigint;
        time?: Timestamp & {
            seconds: bigint;
            nanos: number;
        } & Record<Exclude<keyof I["time"], keyof Timestamp>, never>;
        totalVotingPower?: bigint;
    } & Record<Exclude<keyof I, keyof Evidence>, never>>(object: I): Evidence;
};
export declare const Snapshot: {
    typeUrl: string;
    encode(message: Snapshot, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): Snapshot;
    fromJSON(object: any): Snapshot;
    toJSON(message: Snapshot): unknown;
    fromPartial<I extends Partial<Snapshot> & {
        height?: bigint;
        format?: number;
        chunks?: number;
        hash?: Uint8Array;
        metadata?: Uint8Array;
    } & Record<Exclude<keyof I, keyof Snapshot>, never>>(object: I): Snapshot;
};
export interface ABCIApplication {
    Echo(request: RequestEcho): Promise<ResponseEcho>;
    Flush(request?: RequestFlush): Promise<ResponseFlush>;
    Info(request: RequestInfo): Promise<ResponseInfo>;
    SetOption(request: RequestSetOption): Promise<ResponseSetOption>;
    DeliverTx(request: RequestDeliverTx): Promise<ResponseDeliverTx>;
    CheckTx(request: RequestCheckTx): Promise<ResponseCheckTx>;
    Query(request: RequestQuery): Promise<ResponseQuery>;
    Commit(request?: RequestCommit): Promise<ResponseCommit>;
    InitChain(request: RequestInitChain): Promise<ResponseInitChain>;
    BeginBlock(request: RequestBeginBlock): Promise<ResponseBeginBlock>;
    EndBlock(request: RequestEndBlock): Promise<ResponseEndBlock>;
    ListSnapshots(request?: RequestListSnapshots): Promise<ResponseListSnapshots>;
    OfferSnapshot(request: RequestOfferSnapshot): Promise<ResponseOfferSnapshot>;
    LoadSnapshotChunk(request: RequestLoadSnapshotChunk): Promise<ResponseLoadSnapshotChunk>;
    ApplySnapshotChunk(request: RequestApplySnapshotChunk): Promise<ResponseApplySnapshotChunk>;
}
export declare class ABCIApplicationClientImpl implements ABCIApplication {
    private readonly rpc;
    constructor(rpc: TxRpc);
    Echo(request: RequestEcho): Promise<ResponseEcho>;
    Flush(request?: RequestFlush): Promise<ResponseFlush>;
    Info(request: RequestInfo): Promise<ResponseInfo>;
    SetOption(request: RequestSetOption): Promise<ResponseSetOption>;
    DeliverTx(request: RequestDeliverTx): Promise<ResponseDeliverTx>;
    CheckTx(request: RequestCheckTx): Promise<ResponseCheckTx>;
    Query(request: RequestQuery): Promise<ResponseQuery>;
    Commit(request?: RequestCommit): Promise<ResponseCommit>;
    InitChain(request: RequestInitChain): Promise<ResponseInitChain>;
    BeginBlock(request: RequestBeginBlock): Promise<ResponseBeginBlock>;
    EndBlock(request: RequestEndBlock): Promise<ResponseEndBlock>;
    ListSnapshots(request?: RequestListSnapshots): Promise<ResponseListSnapshots>;
    OfferSnapshot(request: RequestOfferSnapshot): Promise<ResponseOfferSnapshot>;
    LoadSnapshotChunk(request: RequestLoadSnapshotChunk): Promise<ResponseLoadSnapshotChunk>;
    ApplySnapshotChunk(request: RequestApplySnapshotChunk): Promise<ResponseApplySnapshotChunk>;
}
export declare const createRpcQueryExtension: (base: QueryClient) => {
    Echo(request: RequestEcho): Promise<ResponseEcho>;
    Flush(request?: RequestFlush): Promise<ResponseFlush>;
    Info(request: RequestInfo): Promise<ResponseInfo>;
    SetOption(request: RequestSetOption): Promise<ResponseSetOption>;
    DeliverTx(request: RequestDeliverTx): Promise<ResponseDeliverTx>;
    CheckTx(request: RequestCheckTx): Promise<ResponseCheckTx>;
    Query(request: RequestQuery): Promise<ResponseQuery>;
    Commit(request?: RequestCommit): Promise<ResponseCommit>;
    InitChain(request: RequestInitChain): Promise<ResponseInitChain>;
    BeginBlock(request: RequestBeginBlock): Promise<ResponseBeginBlock>;
    EndBlock(request: RequestEndBlock): Promise<ResponseEndBlock>;
    ListSnapshots(request?: RequestListSnapshots): Promise<ResponseListSnapshots>;
    OfferSnapshot(request: RequestOfferSnapshot): Promise<ResponseOfferSnapshot>;
    LoadSnapshotChunk(request: RequestLoadSnapshotChunk): Promise<ResponseLoadSnapshotChunk>;
    ApplySnapshotChunk(request: RequestApplySnapshotChunk): Promise<ResponseApplySnapshotChunk>;
};