Variable abciConst

abci: {
    CheckTxType: any;
    EvidenceType: any;
    ResponseApplySnapshotChunk_Result: any;
    ResponseOfferSnapshot_Result: any;
    BlockParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): BlockParams;
        encode(message: BlockParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: BlockParamsAmino): BlockParams;
        fromAminoMsg(object: BlockParamsAminoMsg): BlockParams;
        fromPartial(object: {
            maxBytes?: bigint;
            maxGas?: bigint;
        }): BlockParams;
        fromProtoMsg(message: BlockParamsProtoMsg): BlockParams;
        toAmino(message: BlockParams): BlockParamsAmino;
        toProto(message: BlockParams): Uint8Array;
        toProtoMsg(message: BlockParams): BlockParamsProtoMsg;
    };
    CheckTxTypeAmino: typeof CheckTxType;
    CheckTxTypeSDKType: typeof CheckTxType;
    ConsensusParams: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ConsensusParams;
        encode(message: ConsensusParams, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ConsensusParamsAmino): ConsensusParams;
        fromAminoMsg(object: ConsensusParamsAminoMsg): ConsensusParams;
        fromPartial(object: {
            block?: {
                maxBytes?: bigint;
                maxGas?: bigint;
            };
            evidence?: {
                maxAgeDuration?: {
                    nanos?: number;
                    seconds?: bigint;
                };
                maxAgeNumBlocks?: bigint;
                maxBytes?: bigint;
            };
            validator?: {
                pubKeyTypes?: string[];
            };
            version?: {
                appVersion?: bigint;
            };
        }): ConsensusParams;
        fromProtoMsg(message: ConsensusParamsProtoMsg): ConsensusParams;
        toAmino(message: ConsensusParams): ConsensusParamsAmino;
        toProto(message: ConsensusParams): Uint8Array;
        toProtoMsg(message: ConsensusParams): ConsensusParamsProtoMsg;
    };
    Event: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Event;
        encode(message: Event, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: EventAmino): Event;
        fromAminoMsg(object: EventAminoMsg): Event;
        fromPartial(object: {
            attributes?: {
                index?: boolean;
                key?: Uint8Array;
                value?: Uint8Array;
            }[];
            type?: string;
        }): Event;
        fromProtoMsg(message: EventProtoMsg): Event;
        toAmino(message: Event): EventAmino;
        toProto(message: Event): Uint8Array;
        toProtoMsg(message: Event): EventProtoMsg;
    };
    EventAttribute: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): EventAttribute;
        encode(message: EventAttribute, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: EventAttributeAmino): EventAttribute;
        fromAminoMsg(object: EventAttributeAminoMsg): EventAttribute;
        fromPartial(object: {
            index?: boolean;
            key?: Uint8Array;
            value?: Uint8Array;
        }): EventAttribute;
        fromProtoMsg(message: EventAttributeProtoMsg): EventAttribute;
        toAmino(message: EventAttribute): EventAttributeAmino;
        toProto(message: EventAttribute): Uint8Array;
        toProtoMsg(message: EventAttribute): EventAttributeProtoMsg;
    };
    Evidence: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Evidence;
        encode(message: Evidence, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: EvidenceAmino): Evidence;
        fromAminoMsg(object: EvidenceAminoMsg): Evidence;
        fromPartial(object: {
            height?: bigint;
            time?: Date;
            totalVotingPower?: bigint;
            type?: EvidenceType;
            validator?: {
                address?: Uint8Array;
                power?: bigint;
            };
        }): Evidence;
        fromProtoMsg(message: EvidenceProtoMsg): Evidence;
        toAmino(message: Evidence): EvidenceAmino;
        toProto(message: Evidence): Uint8Array;
        toProtoMsg(message: Evidence): EvidenceProtoMsg;
    };
    EvidenceTypeAmino: typeof EvidenceType;
    EvidenceTypeSDKType: typeof EvidenceType;
    LastCommitInfo: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): LastCommitInfo;
        encode(message: LastCommitInfo, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: LastCommitInfoAmino): LastCommitInfo;
        fromAminoMsg(object: LastCommitInfoAminoMsg): LastCommitInfo;
        fromPartial(object: {
            round?: number;
            votes?: {
                signedLastBlock?: boolean;
                validator?: {
                    address?: Uint8Array;
                    power?: bigint;
                };
            }[];
        }): LastCommitInfo;
        fromProtoMsg(message: LastCommitInfoProtoMsg): LastCommitInfo;
        toAmino(message: LastCommitInfo): LastCommitInfoAmino;
        toProto(message: LastCommitInfo): Uint8Array;
        toProtoMsg(message: LastCommitInfo): LastCommitInfoProtoMsg;
    };
    Request: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Request;
        encode(message: Request, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RequestAmino): Request;
        fromAminoMsg(object: RequestAminoMsg): Request;
        fromPartial(object: {
            applySnapshotChunk?: {
                chunk?: Uint8Array;
                index?: number;
                sender?: string;
            };
            beginBlock?: {
                byzantineValidators?: {
                    height?: bigint;
                    time?: Date;
                    totalVotingPower?: bigint;
                    type?: EvidenceType;
                    validator?: {
                        address?: (...) | (...);
                        power?: (...) | (...);
                    };
                }[];
                hash?: Uint8Array;
                header?: {
                    appHash?: Uint8Array;
                    chainId?: string;
                    consensusHash?: Uint8Array;
                    dataHash?: Uint8Array;
                    evidenceHash?: Uint8Array;
                    height?: bigint;
                    lastBlockId?: {
                        hash?: Uint8Array;
                        partSetHeader?: {
                            hash?: ...;
                            total?: ...;
                        };
                    };
                    lastCommitHash?: Uint8Array;
                    lastResultsHash?: Uint8Array;
                    nextValidatorsHash?: Uint8Array;
                    proposerAddress?: Uint8Array;
                    time?: Date;
                    validatorsHash?: Uint8Array;
                    version?: {
                        app?: bigint;
                        block?: bigint;
                    };
                };
                lastCommitInfo?: {
                    round?: number;
                    votes?: {
                        signedLastBlock?: (...) | (...) | (...);
                        validator?: (...) | (...);
                    }[];
                };
            };
            checkTx?: {
                tx?: Uint8Array;
                type?: CheckTxType;
            };
            commit?: {};
            deliverTx?: {
                tx?: Uint8Array;
            };
            echo?: {
                message?: string;
            };
            endBlock?: {
                height?: bigint;
            };
            flush?: {};
            info?: {
                blockVersion?: bigint;
                p2pVersion?: bigint;
                version?: string;
            };
            initChain?: {
                appStateBytes?: Uint8Array;
                chainId?: string;
                consensusParams?: {
                    block?: {
                        maxBytes?: bigint;
                        maxGas?: bigint;
                    };
                    evidence?: {
                        maxAgeDuration?: {
                            nanos?: ...;
                            seconds?: ...;
                        };
                        maxAgeNumBlocks?: bigint;
                        maxBytes?: bigint;
                    };
                    validator?: {
                        pubKeyTypes?: (...)[];
                    };
                    version?: {
                        appVersion?: bigint;
                    };
                };
                initialHeight?: bigint;
                time?: Date;
                validators?: {
                    power?: bigint;
                    pubKey?: {
                        ed25519?: (...) | (...);
                        secp256k1?: (...) | (...);
                    };
                }[];
            };
            listSnapshots?: {};
            loadSnapshotChunk?: {
                chunk?: number;
                format?: number;
                height?: bigint;
            };
            offerSnapshot?: {
                appHash?: Uint8Array;
                snapshot?: {
                    chunks?: number;
                    format?: number;
                    hash?: Uint8Array;
                    height?: bigint;
                    metadata?: Uint8Array;
                };
            };
            query?: {
                data?: Uint8Array;
                height?: bigint;
                path?: string;
                prove?: boolean;
            };
            setOption?: {
                key?: string;
                value?: string;
            };
        }): Request;
        fromProtoMsg(message: RequestProtoMsg): Request;
        toAmino(message: Request): RequestAmino;
        toProto(message: Request): Uint8Array;
        toProtoMsg(message: Request): RequestProtoMsg;
    };
    RequestApplySnapshotChunk: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestApplySnapshotChunk;
        encode(message: RequestApplySnapshotChunk, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RequestApplySnapshotChunkAmino): RequestApplySnapshotChunk;
        fromAminoMsg(object: RequestApplySnapshotChunkAminoMsg): RequestApplySnapshotChunk;
        fromPartial(object: {
            chunk?: Uint8Array;
            index?: number;
            sender?: string;
        }): RequestApplySnapshotChunk;
        fromProtoMsg(message: RequestApplySnapshotChunkProtoMsg): RequestApplySnapshotChunk;
        toAmino(message: RequestApplySnapshotChunk): RequestApplySnapshotChunkAmino;
        toProto(message: RequestApplySnapshotChunk): Uint8Array;
        toProtoMsg(message: RequestApplySnapshotChunk): RequestApplySnapshotChunkProtoMsg;
    };
    RequestBeginBlock: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestBeginBlock;
        encode(message: RequestBeginBlock, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RequestBeginBlockAmino): RequestBeginBlock;
        fromAminoMsg(object: RequestBeginBlockAminoMsg): RequestBeginBlock;
        fromPartial(object: {
            byzantineValidators?: {
                height?: bigint;
                time?: Date;
                totalVotingPower?: bigint;
                type?: EvidenceType;
                validator?: {
                    address?: Uint8Array;
                    power?: bigint;
                };
            }[];
            hash?: Uint8Array;
            header?: {
                appHash?: Uint8Array;
                chainId?: string;
                consensusHash?: Uint8Array;
                dataHash?: Uint8Array;
                evidenceHash?: Uint8Array;
                height?: bigint;
                lastBlockId?: {
                    hash?: Uint8Array;
                    partSetHeader?: {
                        hash?: Uint8Array;
                        total?: number;
                    };
                };
                lastCommitHash?: Uint8Array;
                lastResultsHash?: Uint8Array;
                nextValidatorsHash?: Uint8Array;
                proposerAddress?: Uint8Array;
                time?: Date;
                validatorsHash?: Uint8Array;
                version?: {
                    app?: bigint;
                    block?: bigint;
                };
            };
            lastCommitInfo?: {
                round?: number;
                votes?: {
                    signedLastBlock?: boolean;
                    validator?: {
                        address?: (...) | (...);
                        power?: (...) | (...);
                    };
                }[];
            };
        }): RequestBeginBlock;
        fromProtoMsg(message: RequestBeginBlockProtoMsg): RequestBeginBlock;
        toAmino(message: RequestBeginBlock): RequestBeginBlockAmino;
        toProto(message: RequestBeginBlock): Uint8Array;
        toProtoMsg(message: RequestBeginBlock): RequestBeginBlockProtoMsg;
    };
    RequestCheckTx: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestCheckTx;
        encode(message: RequestCheckTx, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RequestCheckTxAmino): RequestCheckTx;
        fromAminoMsg(object: RequestCheckTxAminoMsg): RequestCheckTx;
        fromPartial(object: {
            tx?: Uint8Array;
            type?: CheckTxType;
        }): RequestCheckTx;
        fromProtoMsg(message: RequestCheckTxProtoMsg): RequestCheckTx;
        toAmino(message: RequestCheckTx): RequestCheckTxAmino;
        toProto(message: RequestCheckTx): Uint8Array;
        toProtoMsg(message: RequestCheckTx): RequestCheckTxProtoMsg;
    };
    RequestCommit: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestCommit;
        encode(_: RequestCommit, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: RequestCommitAmino): RequestCommit;
        fromAminoMsg(object: RequestCommitAminoMsg): RequestCommit;
        fromPartial(_: {}): RequestCommit;
        fromProtoMsg(message: RequestCommitProtoMsg): RequestCommit;
        toAmino(_: RequestCommit): RequestCommitAmino;
        toProto(message: RequestCommit): Uint8Array;
        toProtoMsg(message: RequestCommit): RequestCommitProtoMsg;
    };
    RequestDeliverTx: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestDeliverTx;
        encode(message: RequestDeliverTx, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RequestDeliverTxAmino): RequestDeliverTx;
        fromAminoMsg(object: RequestDeliverTxAminoMsg): RequestDeliverTx;
        fromPartial(object: {
            tx?: Uint8Array;
        }): RequestDeliverTx;
        fromProtoMsg(message: RequestDeliverTxProtoMsg): RequestDeliverTx;
        toAmino(message: RequestDeliverTx): RequestDeliverTxAmino;
        toProto(message: RequestDeliverTx): Uint8Array;
        toProtoMsg(message: RequestDeliverTx): RequestDeliverTxProtoMsg;
    };
    RequestEcho: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestEcho;
        encode(message: RequestEcho, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RequestEchoAmino): RequestEcho;
        fromAminoMsg(object: RequestEchoAminoMsg): RequestEcho;
        fromPartial(object: {
            message?: string;
        }): RequestEcho;
        fromProtoMsg(message: RequestEchoProtoMsg): RequestEcho;
        toAmino(message: RequestEcho): RequestEchoAmino;
        toProto(message: RequestEcho): Uint8Array;
        toProtoMsg(message: RequestEcho): RequestEchoProtoMsg;
    };
    RequestEndBlock: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestEndBlock;
        encode(message: RequestEndBlock, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RequestEndBlockAmino): RequestEndBlock;
        fromAminoMsg(object: RequestEndBlockAminoMsg): RequestEndBlock;
        fromPartial(object: {
            height?: bigint;
        }): RequestEndBlock;
        fromProtoMsg(message: RequestEndBlockProtoMsg): RequestEndBlock;
        toAmino(message: RequestEndBlock): RequestEndBlockAmino;
        toProto(message: RequestEndBlock): Uint8Array;
        toProtoMsg(message: RequestEndBlock): RequestEndBlockProtoMsg;
    };
    RequestFlush: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestFlush;
        encode(_: RequestFlush, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: RequestFlushAmino): RequestFlush;
        fromAminoMsg(object: RequestFlushAminoMsg): RequestFlush;
        fromPartial(_: {}): RequestFlush;
        fromProtoMsg(message: RequestFlushProtoMsg): RequestFlush;
        toAmino(_: RequestFlush): RequestFlushAmino;
        toProto(message: RequestFlush): Uint8Array;
        toProtoMsg(message: RequestFlush): RequestFlushProtoMsg;
    };
    RequestInfo: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestInfo;
        encode(message: RequestInfo, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RequestInfoAmino): RequestInfo;
        fromAminoMsg(object: RequestInfoAminoMsg): RequestInfo;
        fromPartial(object: {
            blockVersion?: bigint;
            p2pVersion?: bigint;
            version?: string;
        }): RequestInfo;
        fromProtoMsg(message: RequestInfoProtoMsg): RequestInfo;
        toAmino(message: RequestInfo): RequestInfoAmino;
        toProto(message: RequestInfo): Uint8Array;
        toProtoMsg(message: RequestInfo): RequestInfoProtoMsg;
    };
    RequestInitChain: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestInitChain;
        encode(message: RequestInitChain, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RequestInitChainAmino): RequestInitChain;
        fromAminoMsg(object: RequestInitChainAminoMsg): RequestInitChain;
        fromPartial(object: {
            appStateBytes?: Uint8Array;
            chainId?: string;
            consensusParams?: {
                block?: {
                    maxBytes?: bigint;
                    maxGas?: bigint;
                };
                evidence?: {
                    maxAgeDuration?: {
                        nanos?: number;
                        seconds?: bigint;
                    };
                    maxAgeNumBlocks?: bigint;
                    maxBytes?: bigint;
                };
                validator?: {
                    pubKeyTypes?: string[];
                };
                version?: {
                    appVersion?: bigint;
                };
            };
            initialHeight?: bigint;
            time?: Date;
            validators?: {
                power?: bigint;
                pubKey?: {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                };
            }[];
        }): RequestInitChain;
        fromProtoMsg(message: RequestInitChainProtoMsg): RequestInitChain;
        toAmino(message: RequestInitChain): RequestInitChainAmino;
        toProto(message: RequestInitChain): Uint8Array;
        toProtoMsg(message: RequestInitChain): RequestInitChainProtoMsg;
    };
    RequestListSnapshots: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestListSnapshots;
        encode(_: RequestListSnapshots, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: RequestListSnapshotsAmino): RequestListSnapshots;
        fromAminoMsg(object: RequestListSnapshotsAminoMsg): RequestListSnapshots;
        fromPartial(_: {}): RequestListSnapshots;
        fromProtoMsg(message: RequestListSnapshotsProtoMsg): RequestListSnapshots;
        toAmino(_: RequestListSnapshots): RequestListSnapshotsAmino;
        toProto(message: RequestListSnapshots): Uint8Array;
        toProtoMsg(message: RequestListSnapshots): RequestListSnapshotsProtoMsg;
    };
    RequestLoadSnapshotChunk: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestLoadSnapshotChunk;
        encode(message: RequestLoadSnapshotChunk, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RequestLoadSnapshotChunkAmino): RequestLoadSnapshotChunk;
        fromAminoMsg(object: RequestLoadSnapshotChunkAminoMsg): RequestLoadSnapshotChunk;
        fromPartial(object: {
            chunk?: number;
            format?: number;
            height?: bigint;
        }): RequestLoadSnapshotChunk;
        fromProtoMsg(message: RequestLoadSnapshotChunkProtoMsg): RequestLoadSnapshotChunk;
        toAmino(message: RequestLoadSnapshotChunk): RequestLoadSnapshotChunkAmino;
        toProto(message: RequestLoadSnapshotChunk): Uint8Array;
        toProtoMsg(message: RequestLoadSnapshotChunk): RequestLoadSnapshotChunkProtoMsg;
    };
    RequestOfferSnapshot: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestOfferSnapshot;
        encode(message: RequestOfferSnapshot, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RequestOfferSnapshotAmino): RequestOfferSnapshot;
        fromAminoMsg(object: RequestOfferSnapshotAminoMsg): RequestOfferSnapshot;
        fromPartial(object: {
            appHash?: Uint8Array;
            snapshot?: {
                chunks?: number;
                format?: number;
                hash?: Uint8Array;
                height?: bigint;
                metadata?: Uint8Array;
            };
        }): RequestOfferSnapshot;
        fromProtoMsg(message: RequestOfferSnapshotProtoMsg): RequestOfferSnapshot;
        toAmino(message: RequestOfferSnapshot): RequestOfferSnapshotAmino;
        toProto(message: RequestOfferSnapshot): Uint8Array;
        toProtoMsg(message: RequestOfferSnapshot): RequestOfferSnapshotProtoMsg;
    };
    RequestQuery: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestQuery;
        encode(message: RequestQuery, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RequestQueryAmino): RequestQuery;
        fromAminoMsg(object: RequestQueryAminoMsg): RequestQuery;
        fromPartial(object: {
            data?: Uint8Array;
            height?: bigint;
            path?: string;
            prove?: boolean;
        }): RequestQuery;
        fromProtoMsg(message: RequestQueryProtoMsg): RequestQuery;
        toAmino(message: RequestQuery): RequestQueryAmino;
        toProto(message: RequestQuery): Uint8Array;
        toProtoMsg(message: RequestQuery): RequestQueryProtoMsg;
    };
    RequestSetOption: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): RequestSetOption;
        encode(message: RequestSetOption, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: RequestSetOptionAmino): RequestSetOption;
        fromAminoMsg(object: RequestSetOptionAminoMsg): RequestSetOption;
        fromPartial(object: {
            key?: string;
            value?: string;
        }): RequestSetOption;
        fromProtoMsg(message: RequestSetOptionProtoMsg): RequestSetOption;
        toAmino(message: RequestSetOption): RequestSetOptionAmino;
        toProto(message: RequestSetOption): Uint8Array;
        toProtoMsg(message: RequestSetOption): RequestSetOptionProtoMsg;
    };
    Response: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Response;
        encode(message: Response, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseAmino): Response;
        fromAminoMsg(object: ResponseAminoMsg): Response;
        fromPartial(object: {
            applySnapshotChunk?: {
                refetchChunks?: number[];
                rejectSenders?: string[];
                result?: ResponseApplySnapshotChunk_Result;
            };
            beginBlock?: {
                events?: {
                    attributes?: {
                        index?: ...;
                        key?: ...;
                        value?: ...;
                    }[];
                    type?: string;
                }[];
            };
            checkTx?: {
                code?: number;
                codespace?: string;
                data?: Uint8Array;
                events?: {
                    attributes?: {
                        index?: ...;
                        key?: ...;
                        value?: ...;
                    }[];
                    type?: string;
                }[];
                gasUsed?: bigint;
                gasWanted?: bigint;
                info?: string;
                log?: string;
            };
            commit?: {
                data?: Uint8Array;
                retainHeight?: bigint;
            };
            deliverTx?: {
                code?: number;
                codespace?: string;
                data?: Uint8Array;
                events?: {
                    attributes?: {
                        index?: ...;
                        key?: ...;
                        value?: ...;
                    }[];
                    type?: string;
                }[];
                gasUsed?: bigint;
                gasWanted?: bigint;
                info?: string;
                log?: string;
            };
            echo?: {
                message?: string;
            };
            endBlock?: {
                consensusParamUpdates?: {
                    block?: {
                        maxBytes?: bigint;
                        maxGas?: bigint;
                    };
                    evidence?: {
                        maxAgeDuration?: {
                            nanos?: ...;
                            seconds?: ...;
                        };
                        maxAgeNumBlocks?: bigint;
                        maxBytes?: bigint;
                    };
                    validator?: {
                        pubKeyTypes?: (...)[];
                    };
                    version?: {
                        appVersion?: bigint;
                    };
                };
                events?: {
                    attributes?: {
                        index?: ...;
                        key?: ...;
                        value?: ...;
                    }[];
                    type?: string;
                }[];
                validatorUpdates?: {
                    power?: bigint;
                    pubKey?: {
                        ed25519?: (...) | (...);
                        secp256k1?: (...) | (...);
                    };
                }[];
            };
            exception?: {
                error?: string;
            };
            flush?: {};
            info?: {
                appVersion?: bigint;
                data?: string;
                lastBlockAppHash?: Uint8Array;
                lastBlockHeight?: bigint;
                version?: string;
            };
            initChain?: {
                appHash?: Uint8Array;
                consensusParams?: {
                    block?: {
                        maxBytes?: bigint;
                        maxGas?: bigint;
                    };
                    evidence?: {
                        maxAgeDuration?: {
                            nanos?: ...;
                            seconds?: ...;
                        };
                        maxAgeNumBlocks?: bigint;
                        maxBytes?: bigint;
                    };
                    validator?: {
                        pubKeyTypes?: (...)[];
                    };
                    version?: {
                        appVersion?: bigint;
                    };
                };
                validators?: {
                    power?: bigint;
                    pubKey?: {
                        ed25519?: (...) | (...);
                        secp256k1?: (...) | (...);
                    };
                }[];
            };
            listSnapshots?: {
                snapshots?: {
                    chunks?: number;
                    format?: number;
                    hash?: Uint8Array;
                    height?: bigint;
                    metadata?: Uint8Array;
                }[];
            };
            loadSnapshotChunk?: {
                chunk?: Uint8Array;
            };
            offerSnapshot?: {
                result?: ResponseOfferSnapshot_Result;
            };
            query?: {
                code?: number;
                codespace?: string;
                height?: bigint;
                index?: bigint;
                info?: string;
                key?: Uint8Array;
                log?: string;
                proofOps?: {
                    ops?: {
                        data?: (...) | (...);
                        key?: (...) | (...);
                        type?: (...) | (...);
                    }[];
                };
                value?: Uint8Array;
            };
            setOption?: {
                code?: number;
                info?: string;
                log?: string;
            };
        }): Response;
        fromProtoMsg(message: ResponseProtoMsg): Response;
        toAmino(message: Response): ResponseAmino;
        toProto(message: Response): Uint8Array;
        toProtoMsg(message: Response): ResponseProtoMsg;
    };
    ResponseApplySnapshotChunk: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseApplySnapshotChunk;
        encode(message: ResponseApplySnapshotChunk, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseApplySnapshotChunkAmino): ResponseApplySnapshotChunk;
        fromAminoMsg(object: ResponseApplySnapshotChunkAminoMsg): ResponseApplySnapshotChunk;
        fromPartial(object: {
            refetchChunks?: number[];
            rejectSenders?: string[];
            result?: ResponseApplySnapshotChunk_Result;
        }): ResponseApplySnapshotChunk;
        fromProtoMsg(message: ResponseApplySnapshotChunkProtoMsg): ResponseApplySnapshotChunk;
        toAmino(message: ResponseApplySnapshotChunk): ResponseApplySnapshotChunkAmino;
        toProto(message: ResponseApplySnapshotChunk): Uint8Array;
        toProtoMsg(message: ResponseApplySnapshotChunk): ResponseApplySnapshotChunkProtoMsg;
    };
    ResponseApplySnapshotChunk_ResultAmino: typeof ResponseApplySnapshotChunk_Result;
    ResponseApplySnapshotChunk_ResultSDKType: typeof ResponseApplySnapshotChunk_Result;
    ResponseBeginBlock: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseBeginBlock;
        encode(message: ResponseBeginBlock, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseBeginBlockAmino): ResponseBeginBlock;
        fromAminoMsg(object: ResponseBeginBlockAminoMsg): ResponseBeginBlock;
        fromPartial(object: {
            events?: {
                attributes?: {
                    index?: boolean;
                    key?: Uint8Array;
                    value?: Uint8Array;
                }[];
                type?: string;
            }[];
        }): ResponseBeginBlock;
        fromProtoMsg(message: ResponseBeginBlockProtoMsg): ResponseBeginBlock;
        toAmino(message: ResponseBeginBlock): ResponseBeginBlockAmino;
        toProto(message: ResponseBeginBlock): Uint8Array;
        toProtoMsg(message: ResponseBeginBlock): ResponseBeginBlockProtoMsg;
    };
    ResponseCheckTx: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseCheckTx;
        encode(message: ResponseCheckTx, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseCheckTxAmino): ResponseCheckTx;
        fromAminoMsg(object: ResponseCheckTxAminoMsg): ResponseCheckTx;
        fromPartial(object: {
            code?: number;
            codespace?: string;
            data?: Uint8Array;
            events?: {
                attributes?: {
                    index?: boolean;
                    key?: Uint8Array;
                    value?: Uint8Array;
                }[];
                type?: string;
            }[];
            gasUsed?: bigint;
            gasWanted?: bigint;
            info?: string;
            log?: string;
        }): ResponseCheckTx;
        fromProtoMsg(message: ResponseCheckTxProtoMsg): ResponseCheckTx;
        toAmino(message: ResponseCheckTx): ResponseCheckTxAmino;
        toProto(message: ResponseCheckTx): Uint8Array;
        toProtoMsg(message: ResponseCheckTx): ResponseCheckTxProtoMsg;
    };
    ResponseCommit: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseCommit;
        encode(message: ResponseCommit, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseCommitAmino): ResponseCommit;
        fromAminoMsg(object: ResponseCommitAminoMsg): ResponseCommit;
        fromPartial(object: {
            data?: Uint8Array;
            retainHeight?: bigint;
        }): ResponseCommit;
        fromProtoMsg(message: ResponseCommitProtoMsg): ResponseCommit;
        toAmino(message: ResponseCommit): ResponseCommitAmino;
        toProto(message: ResponseCommit): Uint8Array;
        toProtoMsg(message: ResponseCommit): ResponseCommitProtoMsg;
    };
    ResponseDeliverTx: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseDeliverTx;
        encode(message: ResponseDeliverTx, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseDeliverTxAmino): ResponseDeliverTx;
        fromAminoMsg(object: ResponseDeliverTxAminoMsg): ResponseDeliverTx;
        fromPartial(object: {
            code?: number;
            codespace?: string;
            data?: Uint8Array;
            events?: {
                attributes?: {
                    index?: boolean;
                    key?: Uint8Array;
                    value?: Uint8Array;
                }[];
                type?: string;
            }[];
            gasUsed?: bigint;
            gasWanted?: bigint;
            info?: string;
            log?: string;
        }): ResponseDeliverTx;
        fromProtoMsg(message: ResponseDeliverTxProtoMsg): ResponseDeliverTx;
        toAmino(message: ResponseDeliverTx): ResponseDeliverTxAmino;
        toProto(message: ResponseDeliverTx): Uint8Array;
        toProtoMsg(message: ResponseDeliverTx): ResponseDeliverTxProtoMsg;
    };
    ResponseEcho: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseEcho;
        encode(message: ResponseEcho, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseEchoAmino): ResponseEcho;
        fromAminoMsg(object: ResponseEchoAminoMsg): ResponseEcho;
        fromPartial(object: {
            message?: string;
        }): ResponseEcho;
        fromProtoMsg(message: ResponseEchoProtoMsg): ResponseEcho;
        toAmino(message: ResponseEcho): ResponseEchoAmino;
        toProto(message: ResponseEcho): Uint8Array;
        toProtoMsg(message: ResponseEcho): ResponseEchoProtoMsg;
    };
    ResponseEndBlock: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseEndBlock;
        encode(message: ResponseEndBlock, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseEndBlockAmino): ResponseEndBlock;
        fromAminoMsg(object: ResponseEndBlockAminoMsg): ResponseEndBlock;
        fromPartial(object: {
            consensusParamUpdates?: {
                block?: {
                    maxBytes?: bigint;
                    maxGas?: bigint;
                };
                evidence?: {
                    maxAgeDuration?: {
                        nanos?: number;
                        seconds?: bigint;
                    };
                    maxAgeNumBlocks?: bigint;
                    maxBytes?: bigint;
                };
                validator?: {
                    pubKeyTypes?: string[];
                };
                version?: {
                    appVersion?: bigint;
                };
            };
            events?: {
                attributes?: {
                    index?: boolean;
                    key?: Uint8Array;
                    value?: Uint8Array;
                }[];
                type?: string;
            }[];
            validatorUpdates?: {
                power?: bigint;
                pubKey?: {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                };
            }[];
        }): ResponseEndBlock;
        fromProtoMsg(message: ResponseEndBlockProtoMsg): ResponseEndBlock;
        toAmino(message: ResponseEndBlock): ResponseEndBlockAmino;
        toProto(message: ResponseEndBlock): Uint8Array;
        toProtoMsg(message: ResponseEndBlock): ResponseEndBlockProtoMsg;
    };
    ResponseException: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseException;
        encode(message: ResponseException, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseExceptionAmino): ResponseException;
        fromAminoMsg(object: ResponseExceptionAminoMsg): ResponseException;
        fromPartial(object: {
            error?: string;
        }): ResponseException;
        fromProtoMsg(message: ResponseExceptionProtoMsg): ResponseException;
        toAmino(message: ResponseException): ResponseExceptionAmino;
        toProto(message: ResponseException): Uint8Array;
        toProtoMsg(message: ResponseException): ResponseExceptionProtoMsg;
    };
    ResponseFlush: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseFlush;
        encode(_: ResponseFlush, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: ResponseFlushAmino): ResponseFlush;
        fromAminoMsg(object: ResponseFlushAminoMsg): ResponseFlush;
        fromPartial(_: {}): ResponseFlush;
        fromProtoMsg(message: ResponseFlushProtoMsg): ResponseFlush;
        toAmino(_: ResponseFlush): ResponseFlushAmino;
        toProto(message: ResponseFlush): Uint8Array;
        toProtoMsg(message: ResponseFlush): ResponseFlushProtoMsg;
    };
    ResponseInfo: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseInfo;
        encode(message: ResponseInfo, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseInfoAmino): ResponseInfo;
        fromAminoMsg(object: ResponseInfoAminoMsg): ResponseInfo;
        fromPartial(object: {
            appVersion?: bigint;
            data?: string;
            lastBlockAppHash?: Uint8Array;
            lastBlockHeight?: bigint;
            version?: string;
        }): ResponseInfo;
        fromProtoMsg(message: ResponseInfoProtoMsg): ResponseInfo;
        toAmino(message: ResponseInfo): ResponseInfoAmino;
        toProto(message: ResponseInfo): Uint8Array;
        toProtoMsg(message: ResponseInfo): ResponseInfoProtoMsg;
    };
    ResponseInitChain: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseInitChain;
        encode(message: ResponseInitChain, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseInitChainAmino): ResponseInitChain;
        fromAminoMsg(object: ResponseInitChainAminoMsg): ResponseInitChain;
        fromPartial(object: {
            appHash?: Uint8Array;
            consensusParams?: {
                block?: {
                    maxBytes?: bigint;
                    maxGas?: bigint;
                };
                evidence?: {
                    maxAgeDuration?: {
                        nanos?: number;
                        seconds?: bigint;
                    };
                    maxAgeNumBlocks?: bigint;
                    maxBytes?: bigint;
                };
                validator?: {
                    pubKeyTypes?: string[];
                };
                version?: {
                    appVersion?: bigint;
                };
            };
            validators?: {
                power?: bigint;
                pubKey?: {
                    ed25519?: Uint8Array;
                    secp256k1?: Uint8Array;
                };
            }[];
        }): ResponseInitChain;
        fromProtoMsg(message: ResponseInitChainProtoMsg): ResponseInitChain;
        toAmino(message: ResponseInitChain): ResponseInitChainAmino;
        toProto(message: ResponseInitChain): Uint8Array;
        toProtoMsg(message: ResponseInitChain): ResponseInitChainProtoMsg;
    };
    ResponseListSnapshots: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseListSnapshots;
        encode(message: ResponseListSnapshots, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseListSnapshotsAmino): ResponseListSnapshots;
        fromAminoMsg(object: ResponseListSnapshotsAminoMsg): ResponseListSnapshots;
        fromPartial(object: {
            snapshots?: {
                chunks?: number;
                format?: number;
                hash?: Uint8Array;
                height?: bigint;
                metadata?: Uint8Array;
            }[];
        }): ResponseListSnapshots;
        fromProtoMsg(message: ResponseListSnapshotsProtoMsg): ResponseListSnapshots;
        toAmino(message: ResponseListSnapshots): ResponseListSnapshotsAmino;
        toProto(message: ResponseListSnapshots): Uint8Array;
        toProtoMsg(message: ResponseListSnapshots): ResponseListSnapshotsProtoMsg;
    };
    ResponseLoadSnapshotChunk: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseLoadSnapshotChunk;
        encode(message: ResponseLoadSnapshotChunk, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseLoadSnapshotChunkAmino): ResponseLoadSnapshotChunk;
        fromAminoMsg(object: ResponseLoadSnapshotChunkAminoMsg): ResponseLoadSnapshotChunk;
        fromPartial(object: {
            chunk?: Uint8Array;
        }): ResponseLoadSnapshotChunk;
        fromProtoMsg(message: ResponseLoadSnapshotChunkProtoMsg): ResponseLoadSnapshotChunk;
        toAmino(message: ResponseLoadSnapshotChunk): ResponseLoadSnapshotChunkAmino;
        toProto(message: ResponseLoadSnapshotChunk): Uint8Array;
        toProtoMsg(message: ResponseLoadSnapshotChunk): ResponseLoadSnapshotChunkProtoMsg;
    };
    ResponseOfferSnapshot: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseOfferSnapshot;
        encode(message: ResponseOfferSnapshot, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseOfferSnapshotAmino): ResponseOfferSnapshot;
        fromAminoMsg(object: ResponseOfferSnapshotAminoMsg): ResponseOfferSnapshot;
        fromPartial(object: {
            result?: ResponseOfferSnapshot_Result;
        }): ResponseOfferSnapshot;
        fromProtoMsg(message: ResponseOfferSnapshotProtoMsg): ResponseOfferSnapshot;
        toAmino(message: ResponseOfferSnapshot): ResponseOfferSnapshotAmino;
        toProto(message: ResponseOfferSnapshot): Uint8Array;
        toProtoMsg(message: ResponseOfferSnapshot): ResponseOfferSnapshotProtoMsg;
    };
    ResponseOfferSnapshot_ResultAmino: typeof ResponseOfferSnapshot_Result;
    ResponseOfferSnapshot_ResultSDKType: typeof ResponseOfferSnapshot_Result;
    ResponseQuery: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseQuery;
        encode(message: ResponseQuery, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseQueryAmino): ResponseQuery;
        fromAminoMsg(object: ResponseQueryAminoMsg): ResponseQuery;
        fromPartial(object: {
            code?: number;
            codespace?: string;
            height?: bigint;
            index?: bigint;
            info?: string;
            key?: Uint8Array;
            log?: string;
            proofOps?: {
                ops?: {
                    data?: Uint8Array;
                    key?: Uint8Array;
                    type?: string;
                }[];
            };
            value?: Uint8Array;
        }): ResponseQuery;
        fromProtoMsg(message: ResponseQueryProtoMsg): ResponseQuery;
        toAmino(message: ResponseQuery): ResponseQueryAmino;
        toProto(message: ResponseQuery): Uint8Array;
        toProtoMsg(message: ResponseQuery): ResponseQueryProtoMsg;
    };
    ResponseSetOption: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ResponseSetOption;
        encode(message: ResponseSetOption, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ResponseSetOptionAmino): ResponseSetOption;
        fromAminoMsg(object: ResponseSetOptionAminoMsg): ResponseSetOption;
        fromPartial(object: {
            code?: number;
            info?: string;
            log?: string;
        }): ResponseSetOption;
        fromProtoMsg(message: ResponseSetOptionProtoMsg): ResponseSetOption;
        toAmino(message: ResponseSetOption): ResponseSetOptionAmino;
        toProto(message: ResponseSetOption): Uint8Array;
        toProtoMsg(message: ResponseSetOption): ResponseSetOptionProtoMsg;
    };
    Snapshot: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Snapshot;
        encode(message: Snapshot, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: SnapshotAmino): Snapshot;
        fromAminoMsg(object: SnapshotAminoMsg): Snapshot;
        fromPartial(object: {
            chunks?: number;
            format?: number;
            hash?: Uint8Array;
            height?: bigint;
            metadata?: Uint8Array;
        }): Snapshot;
        fromProtoMsg(message: SnapshotProtoMsg): Snapshot;
        toAmino(message: Snapshot): SnapshotAmino;
        toProto(message: Snapshot): Uint8Array;
        toProtoMsg(message: Snapshot): SnapshotProtoMsg;
    };
    TxResult: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): TxResult;
        encode(message: TxResult, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: TxResultAmino): TxResult;
        fromAminoMsg(object: TxResultAminoMsg): TxResult;
        fromPartial(object: {
            height?: bigint;
            index?: number;
            result?: {
                code?: number;
                codespace?: string;
                data?: Uint8Array;
                events?: {
                    attributes?: {
                        index?: ...;
                        key?: ...;
                        value?: ...;
                    }[];
                    type?: string;
                }[];
                gasUsed?: bigint;
                gasWanted?: bigint;
                info?: string;
                log?: string;
            };
            tx?: Uint8Array;
        }): TxResult;
        fromProtoMsg(message: TxResultProtoMsg): TxResult;
        toAmino(message: TxResult): TxResultAmino;
        toProto(message: TxResult): Uint8Array;
        toProtoMsg(message: TxResult): TxResultProtoMsg;
    };
    Validator: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Validator;
        encode(message: Validator, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ValidatorAmino): Validator;
        fromAminoMsg(object: ValidatorAminoMsg): Validator;
        fromPartial(object: {
            address?: Uint8Array;
            power?: bigint;
        }): Validator;
        fromProtoMsg(message: ValidatorProtoMsg): Validator;
        toAmino(message: Validator): ValidatorAmino;
        toProto(message: Validator): Uint8Array;
        toProtoMsg(message: Validator): ValidatorProtoMsg;
    };
    ValidatorUpdate: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ValidatorUpdate;
        encode(message: ValidatorUpdate, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ValidatorUpdateAmino): ValidatorUpdate;
        fromAminoMsg(object: ValidatorUpdateAminoMsg): ValidatorUpdate;
        fromPartial(object: {
            power?: bigint;
            pubKey?: {
                ed25519?: Uint8Array;
                secp256k1?: Uint8Array;
            };
        }): ValidatorUpdate;
        fromProtoMsg(message: ValidatorUpdateProtoMsg): ValidatorUpdate;
        toAmino(message: ValidatorUpdate): ValidatorUpdateAmino;
        toProto(message: ValidatorUpdate): Uint8Array;
        toProtoMsg(message: ValidatorUpdate): ValidatorUpdateProtoMsg;
    };
    VoteInfo: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): VoteInfo;
        encode(message: VoteInfo, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: VoteInfoAmino): VoteInfo;
        fromAminoMsg(object: VoteInfoAminoMsg): VoteInfo;
        fromPartial(object: {
            signedLastBlock?: boolean;
            validator?: {
                address?: Uint8Array;
                power?: bigint;
            };
        }): VoteInfo;
        fromProtoMsg(message: VoteInfoProtoMsg): VoteInfo;
        toAmino(message: VoteInfo): VoteInfoAmino;
        toProto(message: VoteInfo): Uint8Array;
        toProtoMsg(message: VoteInfo): VoteInfoProtoMsg;
    };
    checkTxTypeFromJSON(object: any): CheckTxType;
    checkTxTypeToJSON(object: CheckTxType): string;
    evidenceTypeFromJSON(object: any): EvidenceType;
    evidenceTypeToJSON(object: EvidenceType): string;
    responseApplySnapshotChunk_ResultFromJSON(object: any): ResponseApplySnapshotChunk_Result;
    responseApplySnapshotChunk_ResultToJSON(object: ResponseApplySnapshotChunk_Result): string;
    responseOfferSnapshot_ResultFromJSON(object: any): ResponseOfferSnapshot_Result;
    responseOfferSnapshot_ResultToJSON(object: ResponseOfferSnapshot_Result): string;
} = ...