Variable v1Const

v1: {
    AccessType: any;
    ContractCodeHistoryOperationType: any;
    LCDQueryClient: any;
    MsgClientImpl: any;
    QueryClientImpl: any;
    AbsoluteTxPosition: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): AbsoluteTxPosition;
        encode(message: AbsoluteTxPosition, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: AbsoluteTxPositionAmino): AbsoluteTxPosition;
        fromAminoMsg(object: AbsoluteTxPositionAminoMsg): AbsoluteTxPosition;
        fromPartial(object: {
            blockHeight?: bigint;
            txIndex?: bigint;
        }): AbsoluteTxPosition;
        fromProtoMsg(message: AbsoluteTxPositionProtoMsg): AbsoluteTxPosition;
        toAmino(message: AbsoluteTxPosition): AbsoluteTxPositionAmino;
        toAminoMsg(message: AbsoluteTxPosition): AbsoluteTxPositionAminoMsg;
        toProto(message: AbsoluteTxPosition): Uint8Array;
        toProtoMsg(message: AbsoluteTxPosition): AbsoluteTxPositionProtoMsg;
    };
    AcceptedMessageKeysFilter: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): AcceptedMessageKeysFilter;
        encode(message: AcceptedMessageKeysFilter, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: AcceptedMessageKeysFilterAmino): AcceptedMessageKeysFilter;
        fromAminoMsg(object: AcceptedMessageKeysFilterAminoMsg): AcceptedMessageKeysFilter;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.AcceptedMessageKeysFilter";
            keys?: string[];
        }): AcceptedMessageKeysFilter;
        fromProtoMsg(message: AcceptedMessageKeysFilterProtoMsg): AcceptedMessageKeysFilter;
        toAmino(message: AcceptedMessageKeysFilter): AcceptedMessageKeysFilterAmino;
        toAminoMsg(message: AcceptedMessageKeysFilter): AcceptedMessageKeysFilterAminoMsg;
        toProto(message: AcceptedMessageKeysFilter): Uint8Array;
        toProtoMsg(message: AcceptedMessageKeysFilter): AcceptedMessageKeysFilterProtoMsg;
    };
    AcceptedMessagesFilter: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): AcceptedMessagesFilter;
        encode(message: AcceptedMessagesFilter, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: AcceptedMessagesFilterAmino): AcceptedMessagesFilter;
        fromAminoMsg(object: AcceptedMessagesFilterAminoMsg): AcceptedMessagesFilter;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.AcceptedMessagesFilter";
            messages?: Uint8Array[];
        }): AcceptedMessagesFilter;
        fromProtoMsg(message: AcceptedMessagesFilterProtoMsg): AcceptedMessagesFilter;
        toAmino(message: AcceptedMessagesFilter): AcceptedMessagesFilterAmino;
        toAminoMsg(message: AcceptedMessagesFilter): AcceptedMessagesFilterAminoMsg;
        toProto(message: AcceptedMessagesFilter): Uint8Array;
        toProtoMsg(message: AcceptedMessagesFilter): AcceptedMessagesFilterProtoMsg;
    };
    AccessConfig: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): AccessConfig;
        encode(message: AccessConfig, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: AccessConfigAmino): AccessConfig;
        fromAminoMsg(object: AccessConfigAminoMsg): AccessConfig;
        fromPartial(object: {
            address?: string;
            addresses?: string[];
            permission?: AccessType;
        }): AccessConfig;
        fromProtoMsg(message: AccessConfigProtoMsg): AccessConfig;
        toAmino(message: AccessConfig): AccessConfigAmino;
        toAminoMsg(message: AccessConfig): AccessConfigAminoMsg;
        toProto(message: AccessConfig): Uint8Array;
        toProtoMsg(message: AccessConfig): AccessConfigProtoMsg;
    };
    AccessConfigUpdate: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): AccessConfigUpdate;
        encode(message: AccessConfigUpdate, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: AccessConfigUpdateAmino): AccessConfigUpdate;
        fromAminoMsg(object: AccessConfigUpdateAminoMsg): AccessConfigUpdate;
        fromPartial(object: {
            codeId?: bigint;
            instantiatePermission?: {
                address?: string;
                addresses?: string[];
                permission?: AccessType;
            };
        }): AccessConfigUpdate;
        fromProtoMsg(message: AccessConfigUpdateProtoMsg): AccessConfigUpdate;
        toAmino(message: AccessConfigUpdate): AccessConfigUpdateAmino;
        toAminoMsg(message: AccessConfigUpdate): AccessConfigUpdateAminoMsg;
        toProto(message: AccessConfigUpdate): Uint8Array;
        toProtoMsg(message: AccessConfigUpdate): AccessConfigUpdateProtoMsg;
    };
    AccessTypeAmino: typeof AccessType;
    AccessTypeParam: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): AccessTypeParam;
        encode(message: AccessTypeParam, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: AccessTypeParamAmino): AccessTypeParam;
        fromAminoMsg(object: AccessTypeParamAminoMsg): AccessTypeParam;
        fromPartial(object: {
            value?: AccessType;
        }): AccessTypeParam;
        fromProtoMsg(message: AccessTypeParamProtoMsg): AccessTypeParam;
        toAmino(message: AccessTypeParam): AccessTypeParamAmino;
        toAminoMsg(message: AccessTypeParam): AccessTypeParamAminoMsg;
        toProto(message: AccessTypeParam): Uint8Array;
        toProtoMsg(message: AccessTypeParam): AccessTypeParamProtoMsg;
    };
    AccessTypeSDKType: typeof AccessType;
    AllowAllMessagesFilter: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): AllowAllMessagesFilter;
        encode(_: AllowAllMessagesFilter, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: AllowAllMessagesFilterAmino): AllowAllMessagesFilter;
        fromAminoMsg(object: AllowAllMessagesFilterAminoMsg): AllowAllMessagesFilter;
        fromPartial(_: {
            $typeUrl?: "/cosmwasm.wasm.v1.AllowAllMessagesFilter";
        }): AllowAllMessagesFilter;
        fromProtoMsg(message: AllowAllMessagesFilterProtoMsg): AllowAllMessagesFilter;
        toAmino(_: AllowAllMessagesFilter): AllowAllMessagesFilterAmino;
        toAminoMsg(message: AllowAllMessagesFilter): AllowAllMessagesFilterAminoMsg;
        toProto(message: AllowAllMessagesFilter): Uint8Array;
        toProtoMsg(message: AllowAllMessagesFilter): AllowAllMessagesFilterProtoMsg;
    };
    AminoConverter: {
        /cosmwasm.wasm.v1.MsgClearAdmin: {
            aminoType: string;
            fromAmino: ((object: MsgClearAdminAmino) => MsgClearAdmin);
            toAmino: ((message: MsgClearAdmin) => MsgClearAdminAmino);
        };
        /cosmwasm.wasm.v1.MsgExecuteContract: {
            aminoType: string;
            fromAmino: ((object: MsgExecuteContractAmino) => MsgExecuteContract);
            toAmino: ((message: MsgExecuteContract) => MsgExecuteContractAmino);
        };
        /cosmwasm.wasm.v1.MsgInstantiateContract: {
            aminoType: string;
            fromAmino: ((object: MsgInstantiateContractAmino) => MsgInstantiateContract);
            toAmino: ((message: MsgInstantiateContract) => MsgInstantiateContractAmino);
        };
        /cosmwasm.wasm.v1.MsgInstantiateContract2: {
            aminoType: string;
            fromAmino: ((object: MsgInstantiateContract2Amino) => MsgInstantiateContract2);
            toAmino: ((message: MsgInstantiateContract2) => MsgInstantiateContract2Amino);
        };
        /cosmwasm.wasm.v1.MsgMigrateContract: {
            aminoType: string;
            fromAmino: ((object: MsgMigrateContractAmino) => MsgMigrateContract);
            toAmino: ((message: MsgMigrateContract) => MsgMigrateContractAmino);
        };
        /cosmwasm.wasm.v1.MsgStoreCode: {
            aminoType: string;
            fromAmino: ((object: MsgStoreCodeAmino) => MsgStoreCode);
            toAmino: ((message: MsgStoreCode) => MsgStoreCodeAmino);
        };
        /cosmwasm.wasm.v1.MsgUpdateAdmin: {
            aminoType: string;
            fromAmino: ((object: MsgUpdateAdminAmino) => MsgUpdateAdmin);
            toAmino: ((message: MsgUpdateAdmin) => MsgUpdateAdminAmino);
        };
    };
    ClearAdminProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ClearAdminProposal;
        encode(message: ClearAdminProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ClearAdminProposalAmino): ClearAdminProposal;
        fromAminoMsg(object: ClearAdminProposalAminoMsg): ClearAdminProposal;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.ClearAdminProposal";
            contract?: string;
            description?: string;
            title?: string;
        }): ClearAdminProposal;
        fromProtoMsg(message: ClearAdminProposalProtoMsg): ClearAdminProposal;
        toAmino(message: ClearAdminProposal): ClearAdminProposalAmino;
        toAminoMsg(message: ClearAdminProposal): ClearAdminProposalAminoMsg;
        toProto(message: ClearAdminProposal): Uint8Array;
        toProtoMsg(message: ClearAdminProposal): ClearAdminProposalProtoMsg;
    };
    Code: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Code;
        encode(message: Code, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: CodeAmino): Code;
        fromAminoMsg(object: CodeAminoMsg): Code;
        fromPartial(object: {
            codeBytes?: Uint8Array;
            codeId?: bigint;
            codeInfo?: {
                codeHash?: Uint8Array;
                creator?: string;
                instantiateConfig?: {
                    address?: string;
                    addresses?: string[];
                    permission?: AccessType;
                };
            };
            pinned?: boolean;
        }): Code;
        fromProtoMsg(message: CodeProtoMsg): Code;
        toAmino(message: Code): CodeAmino;
        toAminoMsg(message: Code): CodeAminoMsg;
        toProto(message: Code): Uint8Array;
        toProtoMsg(message: Code): CodeProtoMsg;
    };
    CodeInfo: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): CodeInfo;
        encode(message: CodeInfo, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: CodeInfoAmino): CodeInfo;
        fromAminoMsg(object: CodeInfoAminoMsg): CodeInfo;
        fromPartial(object: {
            codeHash?: Uint8Array;
            creator?: string;
            instantiateConfig?: {
                address?: string;
                addresses?: string[];
                permission?: AccessType;
            };
        }): CodeInfo;
        fromProtoMsg(message: CodeInfoProtoMsg): CodeInfo;
        toAmino(message: CodeInfo): CodeInfoAmino;
        toAminoMsg(message: CodeInfo): CodeInfoAminoMsg;
        toProto(message: CodeInfo): Uint8Array;
        toProtoMsg(message: CodeInfo): CodeInfoProtoMsg;
    };
    CodeInfoResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): CodeInfoResponse;
        encode(message: CodeInfoResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: CodeInfoResponseAmino): CodeInfoResponse;
        fromAminoMsg(object: CodeInfoResponseAminoMsg): CodeInfoResponse;
        fromPartial(object: {
            codeId?: bigint;
            creator?: string;
            dataHash?: Uint8Array;
            instantiatePermission?: {
                address?: string;
                addresses?: string[];
                permission?: AccessType;
            };
        }): CodeInfoResponse;
        fromProtoMsg(message: CodeInfoResponseProtoMsg): CodeInfoResponse;
        toAmino(message: CodeInfoResponse): CodeInfoResponseAmino;
        toAminoMsg(message: CodeInfoResponse): CodeInfoResponseAminoMsg;
        toProto(message: CodeInfoResponse): Uint8Array;
        toProtoMsg(message: CodeInfoResponse): CodeInfoResponseProtoMsg;
    };
    CombinedLimit: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): CombinedLimit;
        encode(message: CombinedLimit, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: CombinedLimitAmino): CombinedLimit;
        fromAminoMsg(object: CombinedLimitAminoMsg): CombinedLimit;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.CombinedLimit";
            amounts?: {
                amount?: string;
                denom?: string;
            }[];
            callsRemaining?: bigint;
        }): CombinedLimit;
        fromProtoMsg(message: CombinedLimitProtoMsg): CombinedLimit;
        toAmino(message: CombinedLimit): CombinedLimitAmino;
        toAminoMsg(message: CombinedLimit): CombinedLimitAminoMsg;
        toProto(message: CombinedLimit): Uint8Array;
        toProtoMsg(message: CombinedLimit): CombinedLimitProtoMsg;
    };
    Contract: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Contract;
        encode(message: Contract, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ContractAmino): Contract;
        fromAminoMsg(object: ContractAminoMsg): Contract;
        fromPartial(object: {
            contractAddress?: string;
            contractCodeHistory?: {
                codeId?: bigint;
                msg?: Uint8Array;
                operation?: ContractCodeHistoryOperationType;
                updated?: {
                    blockHeight?: bigint;
                    txIndex?: bigint;
                };
            }[];
            contractInfo?: {
                admin?: string;
                codeId?: bigint;
                created?: {
                    blockHeight?: bigint;
                    txIndex?: bigint;
                };
                creator?: string;
                extension?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
                ibcPortId?: string;
                label?: string;
            };
            contractState?: {
                key?: Uint8Array;
                value?: Uint8Array;
            }[];
        }): Contract;
        fromProtoMsg(message: ContractProtoMsg): Contract;
        toAmino(message: Contract): ContractAmino;
        toAminoMsg(message: Contract): ContractAminoMsg;
        toProto(message: Contract): Uint8Array;
        toProtoMsg(message: Contract): ContractProtoMsg;
    };
    ContractAuthzFilterX_FromAmino: ((content: AnyAmino) => Any);
    ContractAuthzFilterX_InterfaceDecoder: ((input: Uint8Array | BinaryReader) =>
        | Any
        | AllowAllMessagesFilter
        | AcceptedMessageKeysFilter
        | AcceptedMessagesFilter);
    ContractAuthzFilterX_ToAmino: ((content: Any) => AnyAmino);
    ContractAuthzLimitX_FromAmino: ((content: AnyAmino) => Any);
    ContractAuthzLimitX_InterfaceDecoder: ((input: Uint8Array | BinaryReader) =>
        | Any
        | MaxCallsLimit
        | MaxFundsLimit
        | CombinedLimit);
    ContractAuthzLimitX_ToAmino: ((content: Any) => AnyAmino);
    ContractCodeHistoryEntry: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ContractCodeHistoryEntry;
        encode(message: ContractCodeHistoryEntry, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ContractCodeHistoryEntryAmino): ContractCodeHistoryEntry;
        fromAminoMsg(object: ContractCodeHistoryEntryAminoMsg): ContractCodeHistoryEntry;
        fromPartial(object: {
            codeId?: bigint;
            msg?: Uint8Array;
            operation?: ContractCodeHistoryOperationType;
            updated?: {
                blockHeight?: bigint;
                txIndex?: bigint;
            };
        }): ContractCodeHistoryEntry;
        fromProtoMsg(message: ContractCodeHistoryEntryProtoMsg): ContractCodeHistoryEntry;
        toAmino(message: ContractCodeHistoryEntry): ContractCodeHistoryEntryAmino;
        toAminoMsg(message: ContractCodeHistoryEntry): ContractCodeHistoryEntryAminoMsg;
        toProto(message: ContractCodeHistoryEntry): Uint8Array;
        toProtoMsg(message: ContractCodeHistoryEntry): ContractCodeHistoryEntryProtoMsg;
    };
    ContractCodeHistoryOperationTypeAmino: typeof ContractCodeHistoryOperationType;
    ContractCodeHistoryOperationTypeSDKType: typeof ContractCodeHistoryOperationType;
    ContractExecutionAuthorization: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ContractExecutionAuthorization;
        encode(message: ContractExecutionAuthorization, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ContractExecutionAuthorizationAmino): ContractExecutionAuthorization;
        fromAminoMsg(object: ContractExecutionAuthorizationAminoMsg): ContractExecutionAuthorization;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.ContractExecutionAuthorization";
            grants?: {
                contract?: string;
                filter?:
                    | {
                        $typeUrl?: string;
                        typeUrl?: string;
                        value?: Uint8Array;
                    }
                    | {
                        $typeUrl?: "/cosmwasm.wasm.v1.AllowAllMessagesFilter";
                    }
                    | {
                        $typeUrl?: "/cosmwasm.wasm.v1.AcceptedMessageKeysFilter";
                        keys?: string[];
                    }
                    | {
                        $typeUrl?: "/cosmwasm.wasm.v1.AcceptedMessagesFilter";
                        messages?: Uint8Array[];
                    };
                limit?:
                    | {
                        $typeUrl?: string;
                        typeUrl?: string;
                        value?: Uint8Array;
                    }
                    | {
                        $typeUrl?: "/cosmwasm.wasm.v1.MaxCallsLimit";
                        remaining?: bigint;
                    }
                    | {
                        $typeUrl?: "/cosmwasm.wasm.v1.MaxFundsLimit";
                        amounts?: {
                            amount?: ...;
                            denom?: ...;
                        }[];
                    }
                    | {
                        $typeUrl?: "/cosmwasm.wasm.v1.CombinedLimit";
                        amounts?: {
                            amount?: ...;
                            denom?: ...;
                        }[];
                        callsRemaining?: bigint;
                    };
            }[];
        }): ContractExecutionAuthorization;
        fromProtoMsg(message: ContractExecutionAuthorizationProtoMsg): ContractExecutionAuthorization;
        toAmino(message: ContractExecutionAuthorization): ContractExecutionAuthorizationAmino;
        toAminoMsg(message: ContractExecutionAuthorization): ContractExecutionAuthorizationAminoMsg;
        toProto(message: ContractExecutionAuthorization): Uint8Array;
        toProtoMsg(message: ContractExecutionAuthorization): ContractExecutionAuthorizationProtoMsg;
    };
    ContractGrant: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ContractGrant;
        encode(message: ContractGrant, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ContractGrantAmino): ContractGrant;
        fromAminoMsg(object: ContractGrantAminoMsg): ContractGrant;
        fromPartial(object: {
            contract?: string;
            filter?:
                | {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                }
                | {
                    $typeUrl?: "/cosmwasm.wasm.v1.AllowAllMessagesFilter";
                }
                | {
                    $typeUrl?: "/cosmwasm.wasm.v1.AcceptedMessageKeysFilter";
                    keys?: string[];
                }
                | {
                    $typeUrl?: "/cosmwasm.wasm.v1.AcceptedMessagesFilter";
                    messages?: Uint8Array[];
                };
            limit?:
                | {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                }
                | {
                    $typeUrl?: "/cosmwasm.wasm.v1.MaxCallsLimit";
                    remaining?: bigint;
                }
                | {
                    $typeUrl?: "/cosmwasm.wasm.v1.MaxFundsLimit";
                    amounts?: {
                        amount?: string;
                        denom?: string;
                    }[];
                }
                | {
                    $typeUrl?: "/cosmwasm.wasm.v1.CombinedLimit";
                    amounts?: {
                        amount?: string;
                        denom?: string;
                    }[];
                    callsRemaining?: bigint;
                };
        }): ContractGrant;
        fromProtoMsg(message: ContractGrantProtoMsg): ContractGrant;
        toAmino(message: ContractGrant): ContractGrantAmino;
        toAminoMsg(message: ContractGrant): ContractGrantAminoMsg;
        toProto(message: ContractGrant): Uint8Array;
        toProtoMsg(message: ContractGrant): ContractGrantProtoMsg;
    };
    ContractInfo: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ContractInfo;
        encode(message: ContractInfo, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ContractInfoAmino): ContractInfo;
        fromAminoMsg(object: ContractInfoAminoMsg): ContractInfo;
        fromPartial(object: {
            admin?: string;
            codeId?: bigint;
            created?: {
                blockHeight?: bigint;
                txIndex?: bigint;
            };
            creator?: string;
            extension?: {
                $typeUrl?: string;
                typeUrl?: string;
                value?: Uint8Array;
            };
            ibcPortId?: string;
            label?: string;
        }): ContractInfo;
        fromProtoMsg(message: ContractInfoProtoMsg): ContractInfo;
        toAmino(message: ContractInfo): ContractInfoAmino;
        toAminoMsg(message: ContractInfo): ContractInfoAminoMsg;
        toProto(message: ContractInfo): Uint8Array;
        toProtoMsg(message: ContractInfo): ContractInfoProtoMsg;
    };
    ContractInfoExtension_FromAmino: ((content: AnyAmino) => Any);
    ContractInfoExtension_InterfaceDecoder: ((input: Uint8Array | BinaryReader) => Any);
    ContractInfoExtension_ToAmino: ((content: Any) => AnyAmino);
    ContractMigrationAuthorization: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ContractMigrationAuthorization;
        encode(message: ContractMigrationAuthorization, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ContractMigrationAuthorizationAmino): ContractMigrationAuthorization;
        fromAminoMsg(object: ContractMigrationAuthorizationAminoMsg): ContractMigrationAuthorization;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.ContractMigrationAuthorization";
            grants?: {
                contract?: string;
                filter?:
                    | {
                        $typeUrl?: string;
                        typeUrl?: string;
                        value?: Uint8Array;
                    }
                    | {
                        $typeUrl?: "/cosmwasm.wasm.v1.AllowAllMessagesFilter";
                    }
                    | {
                        $typeUrl?: "/cosmwasm.wasm.v1.AcceptedMessageKeysFilter";
                        keys?: string[];
                    }
                    | {
                        $typeUrl?: "/cosmwasm.wasm.v1.AcceptedMessagesFilter";
                        messages?: Uint8Array[];
                    };
                limit?:
                    | {
                        $typeUrl?: string;
                        typeUrl?: string;
                        value?: Uint8Array;
                    }
                    | {
                        $typeUrl?: "/cosmwasm.wasm.v1.MaxCallsLimit";
                        remaining?: bigint;
                    }
                    | {
                        $typeUrl?: "/cosmwasm.wasm.v1.MaxFundsLimit";
                        amounts?: {
                            amount?: ...;
                            denom?: ...;
                        }[];
                    }
                    | {
                        $typeUrl?: "/cosmwasm.wasm.v1.CombinedLimit";
                        amounts?: {
                            amount?: ...;
                            denom?: ...;
                        }[];
                        callsRemaining?: bigint;
                    };
            }[];
        }): ContractMigrationAuthorization;
        fromProtoMsg(message: ContractMigrationAuthorizationProtoMsg): ContractMigrationAuthorization;
        toAmino(message: ContractMigrationAuthorization): ContractMigrationAuthorizationAmino;
        toAminoMsg(message: ContractMigrationAuthorization): ContractMigrationAuthorizationAminoMsg;
        toProto(message: ContractMigrationAuthorization): Uint8Array;
        toProtoMsg(message: ContractMigrationAuthorization): ContractMigrationAuthorizationProtoMsg;
    };
    ExecuteContractProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): ExecuteContractProposal;
        encode(message: ExecuteContractProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ExecuteContractProposalAmino): ExecuteContractProposal;
        fromAminoMsg(object: ExecuteContractProposalAminoMsg): ExecuteContractProposal;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.ExecuteContractProposal";
            contract?: string;
            description?: string;
            funds?: {
                amount?: string;
                denom?: string;
            }[];
            msg?: Uint8Array;
            runAs?: string;
            title?: string;
        }): ExecuteContractProposal;
        fromProtoMsg(message: ExecuteContractProposalProtoMsg): ExecuteContractProposal;
        toAmino(message: ExecuteContractProposal): ExecuteContractProposalAmino;
        toAminoMsg(message: ExecuteContractProposal): ExecuteContractProposalAminoMsg;
        toProto(message: ExecuteContractProposal): Uint8Array;
        toProtoMsg(message: ExecuteContractProposal): ExecuteContractProposalProtoMsg;
    };
    GenesisState: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): GenesisState;
        encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: GenesisStateAmino): GenesisState;
        fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
        fromPartial(object: {
            codes?: {
                codeBytes?: Uint8Array;
                codeId?: bigint;
                codeInfo?: {
                    codeHash?: Uint8Array;
                    creator?: string;
                    instantiateConfig?: {
                        address?: (...) | (...);
                        addresses?: (...) | (...);
                        permission?: (...) | (...);
                    };
                };
                pinned?: boolean;
            }[];
            contracts?: {
                contractAddress?: string;
                contractCodeHistory?: {
                    codeId?: bigint;
                    msg?: Uint8Array;
                    operation?: ContractCodeHistoryOperationType;
                    updated?: {
                        blockHeight?: ...;
                        txIndex?: ...;
                    };
                }[];
                contractInfo?: {
                    admin?: string;
                    codeId?: bigint;
                    created?: {
                        blockHeight?: (...) | (...);
                        txIndex?: (...) | (...);
                    };
                    creator?: string;
                    extension?: {
                        $typeUrl?: (...) | (...);
                        typeUrl?: (...) | (...);
                        value?: (...) | (...);
                    };
                    ibcPortId?: string;
                    label?: string;
                };
                contractState?: {
                    key?: Uint8Array;
                    value?: Uint8Array;
                }[];
            }[];
            params?: {
                codeUploadAccess?: {
                    address?: string;
                    addresses?: string[];
                    permission?: AccessType;
                };
                instantiateDefaultPermission?: AccessType;
            };
            sequences?: {
                idKey?: Uint8Array;
                value?: bigint;
            }[];
        }): GenesisState;
        fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
        toAmino(message: GenesisState): GenesisStateAmino;
        toAminoMsg(message: GenesisState): GenesisStateAminoMsg;
        toProto(message: GenesisState): Uint8Array;
        toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
    };
    InstantiateContract2Proposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): InstantiateContract2Proposal;
        encode(message: InstantiateContract2Proposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: InstantiateContract2ProposalAmino): InstantiateContract2Proposal;
        fromAminoMsg(object: InstantiateContract2ProposalAminoMsg): InstantiateContract2Proposal;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.InstantiateContract2Proposal";
            admin?: string;
            codeId?: bigint;
            description?: string;
            fixMsg?: boolean;
            funds?: {
                amount?: string;
                denom?: string;
            }[];
            label?: string;
            msg?: Uint8Array;
            runAs?: string;
            salt?: Uint8Array;
            title?: string;
        }): InstantiateContract2Proposal;
        fromProtoMsg(message: InstantiateContract2ProposalProtoMsg): InstantiateContract2Proposal;
        toAmino(message: InstantiateContract2Proposal): InstantiateContract2ProposalAmino;
        toAminoMsg(message: InstantiateContract2Proposal): InstantiateContract2ProposalAminoMsg;
        toProto(message: InstantiateContract2Proposal): Uint8Array;
        toProtoMsg(message: InstantiateContract2Proposal): InstantiateContract2ProposalProtoMsg;
    };
    InstantiateContractProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): InstantiateContractProposal;
        encode(message: InstantiateContractProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: InstantiateContractProposalAmino): InstantiateContractProposal;
        fromAminoMsg(object: InstantiateContractProposalAminoMsg): InstantiateContractProposal;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.InstantiateContractProposal";
            admin?: string;
            codeId?: bigint;
            description?: string;
            funds?: {
                amount?: string;
                denom?: string;
            }[];
            label?: string;
            msg?: Uint8Array;
            runAs?: string;
            title?: string;
        }): InstantiateContractProposal;
        fromProtoMsg(message: InstantiateContractProposalProtoMsg): InstantiateContractProposal;
        toAmino(message: InstantiateContractProposal): InstantiateContractProposalAmino;
        toAminoMsg(message: InstantiateContractProposal): InstantiateContractProposalAminoMsg;
        toProto(message: InstantiateContractProposal): Uint8Array;
        toProtoMsg(message: InstantiateContractProposal): InstantiateContractProposalProtoMsg;
    };
    MaxCallsLimit: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MaxCallsLimit;
        encode(message: MaxCallsLimit, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MaxCallsLimitAmino): MaxCallsLimit;
        fromAminoMsg(object: MaxCallsLimitAminoMsg): MaxCallsLimit;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.MaxCallsLimit";
            remaining?: bigint;
        }): MaxCallsLimit;
        fromProtoMsg(message: MaxCallsLimitProtoMsg): MaxCallsLimit;
        toAmino(message: MaxCallsLimit): MaxCallsLimitAmino;
        toAminoMsg(message: MaxCallsLimit): MaxCallsLimitAminoMsg;
        toProto(message: MaxCallsLimit): Uint8Array;
        toProtoMsg(message: MaxCallsLimit): MaxCallsLimitProtoMsg;
    };
    MaxFundsLimit: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MaxFundsLimit;
        encode(message: MaxFundsLimit, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MaxFundsLimitAmino): MaxFundsLimit;
        fromAminoMsg(object: MaxFundsLimitAminoMsg): MaxFundsLimit;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.MaxFundsLimit";
            amounts?: {
                amount?: string;
                denom?: string;
            }[];
        }): MaxFundsLimit;
        fromProtoMsg(message: MaxFundsLimitProtoMsg): MaxFundsLimit;
        toAmino(message: MaxFundsLimit): MaxFundsLimitAmino;
        toAminoMsg(message: MaxFundsLimit): MaxFundsLimitAminoMsg;
        toProto(message: MaxFundsLimit): Uint8Array;
        toProtoMsg(message: MaxFundsLimit): MaxFundsLimitProtoMsg;
    };
    MessageComposer: {
        encoded: {
            clearAdmin(value: MsgClearAdmin): {
                typeUrl: string;
                value: Uint8Array;
            };
            executeContract(value: MsgExecuteContract): {
                typeUrl: string;
                value: Uint8Array;
            };
            instantiateContract(value: MsgInstantiateContract): {
                typeUrl: string;
                value: Uint8Array;
            };
            instantiateContract2(value: MsgInstantiateContract2): {
                typeUrl: string;
                value: Uint8Array;
            };
            migrateContract(value: MsgMigrateContract): {
                typeUrl: string;
                value: Uint8Array;
            };
            storeCode(value: MsgStoreCode): {
                typeUrl: string;
                value: Uint8Array;
            };
            updateAdmin(value: MsgUpdateAdmin): {
                typeUrl: string;
                value: Uint8Array;
            };
        };
        fromPartial: {
            clearAdmin(value: MsgClearAdmin): {
                typeUrl: string;
                value: MsgClearAdmin;
            };
            executeContract(value: MsgExecuteContract): {
                typeUrl: string;
                value: MsgExecuteContract;
            };
            instantiateContract(value: MsgInstantiateContract): {
                typeUrl: string;
                value: MsgInstantiateContract;
            };
            instantiateContract2(value: MsgInstantiateContract2): {
                typeUrl: string;
                value: MsgInstantiateContract2;
            };
            migrateContract(value: MsgMigrateContract): {
                typeUrl: string;
                value: MsgMigrateContract;
            };
            storeCode(value: MsgStoreCode): {
                typeUrl: string;
                value: MsgStoreCode;
            };
            updateAdmin(value: MsgUpdateAdmin): {
                typeUrl: string;
                value: MsgUpdateAdmin;
            };
        };
        withTypeUrl: {
            clearAdmin(value: MsgClearAdmin): {
                typeUrl: string;
                value: MsgClearAdmin;
            };
            executeContract(value: MsgExecuteContract): {
                typeUrl: string;
                value: MsgExecuteContract;
            };
            instantiateContract(value: MsgInstantiateContract): {
                typeUrl: string;
                value: MsgInstantiateContract;
            };
            instantiateContract2(value: MsgInstantiateContract2): {
                typeUrl: string;
                value: MsgInstantiateContract2;
            };
            migrateContract(value: MsgMigrateContract): {
                typeUrl: string;
                value: MsgMigrateContract;
            };
            storeCode(value: MsgStoreCode): {
                typeUrl: string;
                value: MsgStoreCode;
            };
            updateAdmin(value: MsgUpdateAdmin): {
                typeUrl: string;
                value: MsgUpdateAdmin;
            };
        };
    };
    MigrateContractProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MigrateContractProposal;
        encode(message: MigrateContractProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MigrateContractProposalAmino): MigrateContractProposal;
        fromAminoMsg(object: MigrateContractProposalAminoMsg): MigrateContractProposal;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.MigrateContractProposal";
            codeId?: bigint;
            contract?: string;
            description?: string;
            msg?: Uint8Array;
            title?: string;
        }): MigrateContractProposal;
        fromProtoMsg(message: MigrateContractProposalProtoMsg): MigrateContractProposal;
        toAmino(message: MigrateContractProposal): MigrateContractProposalAmino;
        toAminoMsg(message: MigrateContractProposal): MigrateContractProposalAminoMsg;
        toProto(message: MigrateContractProposal): Uint8Array;
        toProtoMsg(message: MigrateContractProposal): MigrateContractProposalProtoMsg;
    };
    Model: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Model;
        encode(message: Model, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ModelAmino): Model;
        fromAminoMsg(object: ModelAminoMsg): Model;
        fromPartial(object: {
            key?: Uint8Array;
            value?: Uint8Array;
        }): Model;
        fromProtoMsg(message: ModelProtoMsg): Model;
        toAmino(message: Model): ModelAmino;
        toAminoMsg(message: Model): ModelAminoMsg;
        toProto(message: Model): Uint8Array;
        toProtoMsg(message: Model): ModelProtoMsg;
    };
    MsgClearAdmin: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgClearAdmin;
        encode(message: MsgClearAdmin, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgClearAdminAmino): MsgClearAdmin;
        fromAminoMsg(object: MsgClearAdminAminoMsg): MsgClearAdmin;
        fromPartial(object: {
            contract?: string;
            sender?: string;
        }): MsgClearAdmin;
        fromProtoMsg(message: MsgClearAdminProtoMsg): MsgClearAdmin;
        toAmino(message: MsgClearAdmin): MsgClearAdminAmino;
        toAminoMsg(message: MsgClearAdmin): MsgClearAdminAminoMsg;
        toProto(message: MsgClearAdmin): Uint8Array;
        toProtoMsg(message: MsgClearAdmin): MsgClearAdminProtoMsg;
    };
    MsgClearAdminResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgClearAdminResponse;
        encode(_: MsgClearAdminResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgClearAdminResponseAmino): MsgClearAdminResponse;
        fromAminoMsg(object: MsgClearAdminResponseAminoMsg): MsgClearAdminResponse;
        fromPartial(_: {}): MsgClearAdminResponse;
        fromProtoMsg(message: MsgClearAdminResponseProtoMsg): MsgClearAdminResponse;
        toAmino(_: MsgClearAdminResponse): MsgClearAdminResponseAmino;
        toAminoMsg(message: MsgClearAdminResponse): MsgClearAdminResponseAminoMsg;
        toProto(message: MsgClearAdminResponse): Uint8Array;
        toProtoMsg(message: MsgClearAdminResponse): MsgClearAdminResponseProtoMsg;
    };
    MsgExecuteContract: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgExecuteContract;
        encode(message: MsgExecuteContract, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgExecuteContractAmino): MsgExecuteContract;
        fromAminoMsg(object: MsgExecuteContractAminoMsg): MsgExecuteContract;
        fromPartial(object: {
            contract?: string;
            funds?: {
                amount?: string;
                denom?: string;
            }[];
            msg?: Uint8Array;
            sender?: string;
        }): MsgExecuteContract;
        fromProtoMsg(message: MsgExecuteContractProtoMsg): MsgExecuteContract;
        toAmino(message: MsgExecuteContract): MsgExecuteContractAmino;
        toAminoMsg(message: MsgExecuteContract): MsgExecuteContractAminoMsg;
        toProto(message: MsgExecuteContract): Uint8Array;
        toProtoMsg(message: MsgExecuteContract): MsgExecuteContractProtoMsg;
    };
    MsgExecuteContractResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgExecuteContractResponse;
        encode(message: MsgExecuteContractResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgExecuteContractResponseAmino): MsgExecuteContractResponse;
        fromAminoMsg(object: MsgExecuteContractResponseAminoMsg): MsgExecuteContractResponse;
        fromPartial(object: {
            data?: Uint8Array;
        }): MsgExecuteContractResponse;
        fromProtoMsg(message: MsgExecuteContractResponseProtoMsg): MsgExecuteContractResponse;
        toAmino(message: MsgExecuteContractResponse): MsgExecuteContractResponseAmino;
        toAminoMsg(message: MsgExecuteContractResponse): MsgExecuteContractResponseAminoMsg;
        toProto(message: MsgExecuteContractResponse): Uint8Array;
        toProtoMsg(message: MsgExecuteContractResponse): MsgExecuteContractResponseProtoMsg;
    };
    MsgIBCCloseChannel: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgIBCCloseChannel;
        encode(message: MsgIBCCloseChannel, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgIBCCloseChannelAmino): MsgIBCCloseChannel;
        fromAminoMsg(object: MsgIBCCloseChannelAminoMsg): MsgIBCCloseChannel;
        fromPartial(object: {
            channel?: string;
        }): MsgIBCCloseChannel;
        fromProtoMsg(message: MsgIBCCloseChannelProtoMsg): MsgIBCCloseChannel;
        toAmino(message: MsgIBCCloseChannel): MsgIBCCloseChannelAmino;
        toAminoMsg(message: MsgIBCCloseChannel): MsgIBCCloseChannelAminoMsg;
        toProto(message: MsgIBCCloseChannel): Uint8Array;
        toProtoMsg(message: MsgIBCCloseChannel): MsgIBCCloseChannelProtoMsg;
    };
    MsgIBCSend: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgIBCSend;
        encode(message: MsgIBCSend, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgIBCSendAmino): MsgIBCSend;
        fromAminoMsg(object: MsgIBCSendAminoMsg): MsgIBCSend;
        fromPartial(object: {
            channel?: string;
            data?: Uint8Array;
            timeoutHeight?: bigint;
            timeoutTimestamp?: bigint;
        }): MsgIBCSend;
        fromProtoMsg(message: MsgIBCSendProtoMsg): MsgIBCSend;
        toAmino(message: MsgIBCSend): MsgIBCSendAmino;
        toAminoMsg(message: MsgIBCSend): MsgIBCSendAminoMsg;
        toProto(message: MsgIBCSend): Uint8Array;
        toProtoMsg(message: MsgIBCSend): MsgIBCSendProtoMsg;
    };
    MsgInstantiateContract: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgInstantiateContract;
        encode(message: MsgInstantiateContract, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgInstantiateContractAmino): MsgInstantiateContract;
        fromAminoMsg(object: MsgInstantiateContractAminoMsg): MsgInstantiateContract;
        fromPartial(object: {
            admin?: string;
            codeId?: bigint;
            funds?: {
                amount?: string;
                denom?: string;
            }[];
            label?: string;
            msg?: Uint8Array;
            sender?: string;
        }): MsgInstantiateContract;
        fromProtoMsg(message: MsgInstantiateContractProtoMsg): MsgInstantiateContract;
        toAmino(message: MsgInstantiateContract): MsgInstantiateContractAmino;
        toAminoMsg(message: MsgInstantiateContract): MsgInstantiateContractAminoMsg;
        toProto(message: MsgInstantiateContract): Uint8Array;
        toProtoMsg(message: MsgInstantiateContract): MsgInstantiateContractProtoMsg;
    };
    MsgInstantiateContract2: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgInstantiateContract2;
        encode(message: MsgInstantiateContract2, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgInstantiateContract2Amino): MsgInstantiateContract2;
        fromAminoMsg(object: MsgInstantiateContract2AminoMsg): MsgInstantiateContract2;
        fromPartial(object: {
            admin?: string;
            codeId?: bigint;
            fixMsg?: boolean;
            funds?: {
                amount?: string;
                denom?: string;
            }[];
            label?: string;
            msg?: Uint8Array;
            salt?: Uint8Array;
            sender?: string;
        }): MsgInstantiateContract2;
        fromProtoMsg(message: MsgInstantiateContract2ProtoMsg): MsgInstantiateContract2;
        toAmino(message: MsgInstantiateContract2): MsgInstantiateContract2Amino;
        toAminoMsg(message: MsgInstantiateContract2): MsgInstantiateContract2AminoMsg;
        toProto(message: MsgInstantiateContract2): Uint8Array;
        toProtoMsg(message: MsgInstantiateContract2): MsgInstantiateContract2ProtoMsg;
    };
    MsgInstantiateContract2Response: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgInstantiateContract2Response;
        encode(message: MsgInstantiateContract2Response, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgInstantiateContract2ResponseAmino): MsgInstantiateContract2Response;
        fromAminoMsg(object: MsgInstantiateContract2ResponseAminoMsg): MsgInstantiateContract2Response;
        fromPartial(object: {
            address?: string;
            data?: Uint8Array;
        }): MsgInstantiateContract2Response;
        fromProtoMsg(message: MsgInstantiateContract2ResponseProtoMsg): MsgInstantiateContract2Response;
        toAmino(message: MsgInstantiateContract2Response): MsgInstantiateContract2ResponseAmino;
        toAminoMsg(message: MsgInstantiateContract2Response): MsgInstantiateContract2ResponseAminoMsg;
        toProto(message: MsgInstantiateContract2Response): Uint8Array;
        toProtoMsg(message: MsgInstantiateContract2Response): MsgInstantiateContract2ResponseProtoMsg;
    };
    MsgInstantiateContractResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgInstantiateContractResponse;
        encode(message: MsgInstantiateContractResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgInstantiateContractResponseAmino): MsgInstantiateContractResponse;
        fromAminoMsg(object: MsgInstantiateContractResponseAminoMsg): MsgInstantiateContractResponse;
        fromPartial(object: {
            address?: string;
            data?: Uint8Array;
        }): MsgInstantiateContractResponse;
        fromProtoMsg(message: MsgInstantiateContractResponseProtoMsg): MsgInstantiateContractResponse;
        toAmino(message: MsgInstantiateContractResponse): MsgInstantiateContractResponseAmino;
        toAminoMsg(message: MsgInstantiateContractResponse): MsgInstantiateContractResponseAminoMsg;
        toProto(message: MsgInstantiateContractResponse): Uint8Array;
        toProtoMsg(message: MsgInstantiateContractResponse): MsgInstantiateContractResponseProtoMsg;
    };
    MsgMigrateContract: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgMigrateContract;
        encode(message: MsgMigrateContract, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgMigrateContractAmino): MsgMigrateContract;
        fromAminoMsg(object: MsgMigrateContractAminoMsg): MsgMigrateContract;
        fromPartial(object: {
            codeId?: bigint;
            contract?: string;
            msg?: Uint8Array;
            sender?: string;
        }): MsgMigrateContract;
        fromProtoMsg(message: MsgMigrateContractProtoMsg): MsgMigrateContract;
        toAmino(message: MsgMigrateContract): MsgMigrateContractAmino;
        toAminoMsg(message: MsgMigrateContract): MsgMigrateContractAminoMsg;
        toProto(message: MsgMigrateContract): Uint8Array;
        toProtoMsg(message: MsgMigrateContract): MsgMigrateContractProtoMsg;
    };
    MsgMigrateContractResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgMigrateContractResponse;
        encode(message: MsgMigrateContractResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgMigrateContractResponseAmino): MsgMigrateContractResponse;
        fromAminoMsg(object: MsgMigrateContractResponseAminoMsg): MsgMigrateContractResponse;
        fromPartial(object: {
            data?: Uint8Array;
        }): MsgMigrateContractResponse;
        fromProtoMsg(message: MsgMigrateContractResponseProtoMsg): MsgMigrateContractResponse;
        toAmino(message: MsgMigrateContractResponse): MsgMigrateContractResponseAmino;
        toAminoMsg(message: MsgMigrateContractResponse): MsgMigrateContractResponseAminoMsg;
        toProto(message: MsgMigrateContractResponse): Uint8Array;
        toProtoMsg(message: MsgMigrateContractResponse): MsgMigrateContractResponseProtoMsg;
    };
    MsgStoreCode: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgStoreCode;
        encode(message: MsgStoreCode, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgStoreCodeAmino): MsgStoreCode;
        fromAminoMsg(object: MsgStoreCodeAminoMsg): MsgStoreCode;
        fromPartial(object: {
            instantiatePermission?: {
                address?: string;
                addresses?: string[];
                permission?: AccessType;
            };
            sender?: string;
            wasmByteCode?: Uint8Array;
        }): MsgStoreCode;
        fromProtoMsg(message: MsgStoreCodeProtoMsg): MsgStoreCode;
        toAmino(message: MsgStoreCode): MsgStoreCodeAmino;
        toAminoMsg(message: MsgStoreCode): MsgStoreCodeAminoMsg;
        toProto(message: MsgStoreCode): Uint8Array;
        toProtoMsg(message: MsgStoreCode): MsgStoreCodeProtoMsg;
    };
    MsgStoreCodeResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgStoreCodeResponse;
        encode(message: MsgStoreCodeResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgStoreCodeResponseAmino): MsgStoreCodeResponse;
        fromAminoMsg(object: MsgStoreCodeResponseAminoMsg): MsgStoreCodeResponse;
        fromPartial(object: {
            checksum?: Uint8Array;
            codeId?: bigint;
        }): MsgStoreCodeResponse;
        fromProtoMsg(message: MsgStoreCodeResponseProtoMsg): MsgStoreCodeResponse;
        toAmino(message: MsgStoreCodeResponse): MsgStoreCodeResponseAmino;
        toAminoMsg(message: MsgStoreCodeResponse): MsgStoreCodeResponseAminoMsg;
        toProto(message: MsgStoreCodeResponse): Uint8Array;
        toProtoMsg(message: MsgStoreCodeResponse): MsgStoreCodeResponseProtoMsg;
    };
    MsgUpdateAdmin: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUpdateAdmin;
        encode(message: MsgUpdateAdmin, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: MsgUpdateAdminAmino): MsgUpdateAdmin;
        fromAminoMsg(object: MsgUpdateAdminAminoMsg): MsgUpdateAdmin;
        fromPartial(object: {
            contract?: string;
            newAdmin?: string;
            sender?: string;
        }): MsgUpdateAdmin;
        fromProtoMsg(message: MsgUpdateAdminProtoMsg): MsgUpdateAdmin;
        toAmino(message: MsgUpdateAdmin): MsgUpdateAdminAmino;
        toAminoMsg(message: MsgUpdateAdmin): MsgUpdateAdminAminoMsg;
        toProto(message: MsgUpdateAdmin): Uint8Array;
        toProtoMsg(message: MsgUpdateAdmin): MsgUpdateAdminProtoMsg;
    };
    MsgUpdateAdminResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): MsgUpdateAdminResponse;
        encode(_: MsgUpdateAdminResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: MsgUpdateAdminResponseAmino): MsgUpdateAdminResponse;
        fromAminoMsg(object: MsgUpdateAdminResponseAminoMsg): MsgUpdateAdminResponse;
        fromPartial(_: {}): MsgUpdateAdminResponse;
        fromProtoMsg(message: MsgUpdateAdminResponseProtoMsg): MsgUpdateAdminResponse;
        toAmino(_: MsgUpdateAdminResponse): MsgUpdateAdminResponseAmino;
        toAminoMsg(message: MsgUpdateAdminResponse): MsgUpdateAdminResponseAminoMsg;
        toProto(message: MsgUpdateAdminResponse): Uint8Array;
        toProtoMsg(message: MsgUpdateAdminResponse): MsgUpdateAdminResponseProtoMsg;
    };
    Params: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Params;
        encode(message: Params, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: ParamsAmino): Params;
        fromAminoMsg(object: ParamsAminoMsg): Params;
        fromPartial(object: {
            codeUploadAccess?: {
                address?: string;
                addresses?: string[];
                permission?: AccessType;
            };
            instantiateDefaultPermission?: AccessType;
        }): Params;
        fromProtoMsg(message: ParamsProtoMsg): Params;
        toAmino(message: Params): ParamsAmino;
        toAminoMsg(message: Params): ParamsAminoMsg;
        toProto(message: Params): Uint8Array;
        toProtoMsg(message: Params): ParamsProtoMsg;
    };
    PinCodesProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): PinCodesProposal;
        encode(message: PinCodesProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: PinCodesProposalAmino): PinCodesProposal;
        fromAminoMsg(object: PinCodesProposalAminoMsg): PinCodesProposal;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.PinCodesProposal";
            codeIds?: bigint[];
            description?: string;
            title?: string;
        }): PinCodesProposal;
        fromProtoMsg(message: PinCodesProposalProtoMsg): PinCodesProposal;
        toAmino(message: PinCodesProposal): PinCodesProposalAmino;
        toAminoMsg(message: PinCodesProposal): PinCodesProposalAminoMsg;
        toProto(message: PinCodesProposal): Uint8Array;
        toProtoMsg(message: PinCodesProposal): PinCodesProposalProtoMsg;
    };
    QueryAllContractStateRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryAllContractStateRequest;
        encode(message: QueryAllContractStateRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryAllContractStateRequestAmino): QueryAllContractStateRequest;
        fromAminoMsg(object: QueryAllContractStateRequestAminoMsg): QueryAllContractStateRequest;
        fromPartial(object: {
            address?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }): QueryAllContractStateRequest;
        fromProtoMsg(message: QueryAllContractStateRequestProtoMsg): QueryAllContractStateRequest;
        toAmino(message: QueryAllContractStateRequest): QueryAllContractStateRequestAmino;
        toAminoMsg(message: QueryAllContractStateRequest): QueryAllContractStateRequestAminoMsg;
        toProto(message: QueryAllContractStateRequest): Uint8Array;
        toProtoMsg(message: QueryAllContractStateRequest): QueryAllContractStateRequestProtoMsg;
    };
    QueryAllContractStateResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryAllContractStateResponse;
        encode(message: QueryAllContractStateResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryAllContractStateResponseAmino): QueryAllContractStateResponse;
        fromAminoMsg(object: QueryAllContractStateResponseAminoMsg): QueryAllContractStateResponse;
        fromPartial(object: {
            models?: {
                key?: Uint8Array;
                value?: Uint8Array;
            }[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryAllContractStateResponse;
        fromProtoMsg(message: QueryAllContractStateResponseProtoMsg): QueryAllContractStateResponse;
        toAmino(message: QueryAllContractStateResponse): QueryAllContractStateResponseAmino;
        toAminoMsg(message: QueryAllContractStateResponse): QueryAllContractStateResponseAminoMsg;
        toProto(message: QueryAllContractStateResponse): Uint8Array;
        toProtoMsg(message: QueryAllContractStateResponse): QueryAllContractStateResponseProtoMsg;
    };
    QueryCodeRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryCodeRequest;
        encode(message: QueryCodeRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryCodeRequestAmino): QueryCodeRequest;
        fromAminoMsg(object: QueryCodeRequestAminoMsg): QueryCodeRequest;
        fromPartial(object: {
            codeId?: bigint;
        }): QueryCodeRequest;
        fromProtoMsg(message: QueryCodeRequestProtoMsg): QueryCodeRequest;
        toAmino(message: QueryCodeRequest): QueryCodeRequestAmino;
        toAminoMsg(message: QueryCodeRequest): QueryCodeRequestAminoMsg;
        toProto(message: QueryCodeRequest): Uint8Array;
        toProtoMsg(message: QueryCodeRequest): QueryCodeRequestProtoMsg;
    };
    QueryCodeResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryCodeResponse;
        encode(message: QueryCodeResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryCodeResponseAmino): QueryCodeResponse;
        fromAminoMsg(object: QueryCodeResponseAminoMsg): QueryCodeResponse;
        fromPartial(object: {
            codeInfo?: {
                codeId?: bigint;
                creator?: string;
                dataHash?: Uint8Array;
                instantiatePermission?: {
                    address?: string;
                    addresses?: string[];
                    permission?: AccessType;
                };
            };
            data?: Uint8Array;
        }): QueryCodeResponse;
        fromProtoMsg(message: QueryCodeResponseProtoMsg): QueryCodeResponse;
        toAmino(message: QueryCodeResponse): QueryCodeResponseAmino;
        toAminoMsg(message: QueryCodeResponse): QueryCodeResponseAminoMsg;
        toProto(message: QueryCodeResponse): Uint8Array;
        toProtoMsg(message: QueryCodeResponse): QueryCodeResponseProtoMsg;
    };
    QueryCodesRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryCodesRequest;
        encode(message: QueryCodesRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryCodesRequestAmino): QueryCodesRequest;
        fromAminoMsg(object: QueryCodesRequestAminoMsg): QueryCodesRequest;
        fromPartial(object: {
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }): QueryCodesRequest;
        fromProtoMsg(message: QueryCodesRequestProtoMsg): QueryCodesRequest;
        toAmino(message: QueryCodesRequest): QueryCodesRequestAmino;
        toAminoMsg(message: QueryCodesRequest): QueryCodesRequestAminoMsg;
        toProto(message: QueryCodesRequest): Uint8Array;
        toProtoMsg(message: QueryCodesRequest): QueryCodesRequestProtoMsg;
    };
    QueryCodesResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryCodesResponse;
        encode(message: QueryCodesResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryCodesResponseAmino): QueryCodesResponse;
        fromAminoMsg(object: QueryCodesResponseAminoMsg): QueryCodesResponse;
        fromPartial(object: {
            codeInfos?: {
                codeId?: bigint;
                creator?: string;
                dataHash?: Uint8Array;
                instantiatePermission?: {
                    address?: string;
                    addresses?: string[];
                    permission?: AccessType;
                };
            }[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryCodesResponse;
        fromProtoMsg(message: QueryCodesResponseProtoMsg): QueryCodesResponse;
        toAmino(message: QueryCodesResponse): QueryCodesResponseAmino;
        toAminoMsg(message: QueryCodesResponse): QueryCodesResponseAminoMsg;
        toProto(message: QueryCodesResponse): Uint8Array;
        toProtoMsg(message: QueryCodesResponse): QueryCodesResponseProtoMsg;
    };
    QueryContractHistoryRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryContractHistoryRequest;
        encode(message: QueryContractHistoryRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryContractHistoryRequestAmino): QueryContractHistoryRequest;
        fromAminoMsg(object: QueryContractHistoryRequestAminoMsg): QueryContractHistoryRequest;
        fromPartial(object: {
            address?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }): QueryContractHistoryRequest;
        fromProtoMsg(message: QueryContractHistoryRequestProtoMsg): QueryContractHistoryRequest;
        toAmino(message: QueryContractHistoryRequest): QueryContractHistoryRequestAmino;
        toAminoMsg(message: QueryContractHistoryRequest): QueryContractHistoryRequestAminoMsg;
        toProto(message: QueryContractHistoryRequest): Uint8Array;
        toProtoMsg(message: QueryContractHistoryRequest): QueryContractHistoryRequestProtoMsg;
    };
    QueryContractHistoryResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryContractHistoryResponse;
        encode(message: QueryContractHistoryResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryContractHistoryResponseAmino): QueryContractHistoryResponse;
        fromAminoMsg(object: QueryContractHistoryResponseAminoMsg): QueryContractHistoryResponse;
        fromPartial(object: {
            entries?: {
                codeId?: bigint;
                msg?: Uint8Array;
                operation?: ContractCodeHistoryOperationType;
                updated?: {
                    blockHeight?: bigint;
                    txIndex?: bigint;
                };
            }[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryContractHistoryResponse;
        fromProtoMsg(message: QueryContractHistoryResponseProtoMsg): QueryContractHistoryResponse;
        toAmino(message: QueryContractHistoryResponse): QueryContractHistoryResponseAmino;
        toAminoMsg(message: QueryContractHistoryResponse): QueryContractHistoryResponseAminoMsg;
        toProto(message: QueryContractHistoryResponse): Uint8Array;
        toProtoMsg(message: QueryContractHistoryResponse): QueryContractHistoryResponseProtoMsg;
    };
    QueryContractInfoRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryContractInfoRequest;
        encode(message: QueryContractInfoRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryContractInfoRequestAmino): QueryContractInfoRequest;
        fromAminoMsg(object: QueryContractInfoRequestAminoMsg): QueryContractInfoRequest;
        fromPartial(object: {
            address?: string;
        }): QueryContractInfoRequest;
        fromProtoMsg(message: QueryContractInfoRequestProtoMsg): QueryContractInfoRequest;
        toAmino(message: QueryContractInfoRequest): QueryContractInfoRequestAmino;
        toAminoMsg(message: QueryContractInfoRequest): QueryContractInfoRequestAminoMsg;
        toProto(message: QueryContractInfoRequest): Uint8Array;
        toProtoMsg(message: QueryContractInfoRequest): QueryContractInfoRequestProtoMsg;
    };
    QueryContractInfoResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryContractInfoResponse;
        encode(message: QueryContractInfoResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryContractInfoResponseAmino): QueryContractInfoResponse;
        fromAminoMsg(object: QueryContractInfoResponseAminoMsg): QueryContractInfoResponse;
        fromPartial(object: {
            address?: string;
            contractInfo?: {
                admin?: string;
                codeId?: bigint;
                created?: {
                    blockHeight?: bigint;
                    txIndex?: bigint;
                };
                creator?: string;
                extension?: {
                    $typeUrl?: string;
                    typeUrl?: string;
                    value?: Uint8Array;
                };
                ibcPortId?: string;
                label?: string;
            };
        }): QueryContractInfoResponse;
        fromProtoMsg(message: QueryContractInfoResponseProtoMsg): QueryContractInfoResponse;
        toAmino(message: QueryContractInfoResponse): QueryContractInfoResponseAmino;
        toAminoMsg(message: QueryContractInfoResponse): QueryContractInfoResponseAminoMsg;
        toProto(message: QueryContractInfoResponse): Uint8Array;
        toProtoMsg(message: QueryContractInfoResponse): QueryContractInfoResponseProtoMsg;
    };
    QueryContractsByCodeRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryContractsByCodeRequest;
        encode(message: QueryContractsByCodeRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryContractsByCodeRequestAmino): QueryContractsByCodeRequest;
        fromAminoMsg(object: QueryContractsByCodeRequestAminoMsg): QueryContractsByCodeRequest;
        fromPartial(object: {
            codeId?: bigint;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }): QueryContractsByCodeRequest;
        fromProtoMsg(message: QueryContractsByCodeRequestProtoMsg): QueryContractsByCodeRequest;
        toAmino(message: QueryContractsByCodeRequest): QueryContractsByCodeRequestAmino;
        toAminoMsg(message: QueryContractsByCodeRequest): QueryContractsByCodeRequestAminoMsg;
        toProto(message: QueryContractsByCodeRequest): Uint8Array;
        toProtoMsg(message: QueryContractsByCodeRequest): QueryContractsByCodeRequestProtoMsg;
    };
    QueryContractsByCodeResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryContractsByCodeResponse;
        encode(message: QueryContractsByCodeResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryContractsByCodeResponseAmino): QueryContractsByCodeResponse;
        fromAminoMsg(object: QueryContractsByCodeResponseAminoMsg): QueryContractsByCodeResponse;
        fromPartial(object: {
            contracts?: string[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryContractsByCodeResponse;
        fromProtoMsg(message: QueryContractsByCodeResponseProtoMsg): QueryContractsByCodeResponse;
        toAmino(message: QueryContractsByCodeResponse): QueryContractsByCodeResponseAmino;
        toAminoMsg(message: QueryContractsByCodeResponse): QueryContractsByCodeResponseAminoMsg;
        toProto(message: QueryContractsByCodeResponse): Uint8Array;
        toProtoMsg(message: QueryContractsByCodeResponse): QueryContractsByCodeResponseProtoMsg;
    };
    QueryContractsByCreatorRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryContractsByCreatorRequest;
        encode(message: QueryContractsByCreatorRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryContractsByCreatorRequestAmino): QueryContractsByCreatorRequest;
        fromAminoMsg(object: QueryContractsByCreatorRequestAminoMsg): QueryContractsByCreatorRequest;
        fromPartial(object: {
            creatorAddress?: string;
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }): QueryContractsByCreatorRequest;
        fromProtoMsg(message: QueryContractsByCreatorRequestProtoMsg): QueryContractsByCreatorRequest;
        toAmino(message: QueryContractsByCreatorRequest): QueryContractsByCreatorRequestAmino;
        toAminoMsg(message: QueryContractsByCreatorRequest): QueryContractsByCreatorRequestAminoMsg;
        toProto(message: QueryContractsByCreatorRequest): Uint8Array;
        toProtoMsg(message: QueryContractsByCreatorRequest): QueryContractsByCreatorRequestProtoMsg;
    };
    QueryContractsByCreatorResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryContractsByCreatorResponse;
        encode(message: QueryContractsByCreatorResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryContractsByCreatorResponseAmino): QueryContractsByCreatorResponse;
        fromAminoMsg(object: QueryContractsByCreatorResponseAminoMsg): QueryContractsByCreatorResponse;
        fromPartial(object: {
            contractAddresses?: string[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryContractsByCreatorResponse;
        fromProtoMsg(message: QueryContractsByCreatorResponseProtoMsg): QueryContractsByCreatorResponse;
        toAmino(message: QueryContractsByCreatorResponse): QueryContractsByCreatorResponseAmino;
        toAminoMsg(message: QueryContractsByCreatorResponse): QueryContractsByCreatorResponseAminoMsg;
        toProto(message: QueryContractsByCreatorResponse): Uint8Array;
        toProtoMsg(message: QueryContractsByCreatorResponse): QueryContractsByCreatorResponseProtoMsg;
    };
    QueryParamsRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryParamsRequest;
        encode(_: QueryParamsRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest;
        fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest;
        fromPartial(_: {}): QueryParamsRequest;
        fromProtoMsg(message: QueryParamsRequestProtoMsg): QueryParamsRequest;
        toAmino(_: QueryParamsRequest): QueryParamsRequestAmino;
        toAminoMsg(message: QueryParamsRequest): QueryParamsRequestAminoMsg;
        toProto(message: QueryParamsRequest): Uint8Array;
        toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg;
    };
    QueryParamsResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryParamsResponse;
        encode(message: QueryParamsResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse;
        fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse;
        fromPartial(object: {
            params?: {
                codeUploadAccess?: {
                    address?: string;
                    addresses?: string[];
                    permission?: AccessType;
                };
                instantiateDefaultPermission?: AccessType;
            };
        }): QueryParamsResponse;
        fromProtoMsg(message: QueryParamsResponseProtoMsg): QueryParamsResponse;
        toAmino(message: QueryParamsResponse): QueryParamsResponseAmino;
        toAminoMsg(message: QueryParamsResponse): QueryParamsResponseAminoMsg;
        toProto(message: QueryParamsResponse): Uint8Array;
        toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg;
    };
    QueryPinnedCodesRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryPinnedCodesRequest;
        encode(message: QueryPinnedCodesRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryPinnedCodesRequestAmino): QueryPinnedCodesRequest;
        fromAminoMsg(object: QueryPinnedCodesRequestAminoMsg): QueryPinnedCodesRequest;
        fromPartial(object: {
            pagination?: {
                countTotal?: boolean;
                key?: Uint8Array;
                limit?: bigint;
                offset?: bigint;
                reverse?: boolean;
            };
        }): QueryPinnedCodesRequest;
        fromProtoMsg(message: QueryPinnedCodesRequestProtoMsg): QueryPinnedCodesRequest;
        toAmino(message: QueryPinnedCodesRequest): QueryPinnedCodesRequestAmino;
        toAminoMsg(message: QueryPinnedCodesRequest): QueryPinnedCodesRequestAminoMsg;
        toProto(message: QueryPinnedCodesRequest): Uint8Array;
        toProtoMsg(message: QueryPinnedCodesRequest): QueryPinnedCodesRequestProtoMsg;
    };
    QueryPinnedCodesResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryPinnedCodesResponse;
        encode(message: QueryPinnedCodesResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryPinnedCodesResponseAmino): QueryPinnedCodesResponse;
        fromAminoMsg(object: QueryPinnedCodesResponseAminoMsg): QueryPinnedCodesResponse;
        fromPartial(object: {
            codeIds?: bigint[];
            pagination?: {
                nextKey?: Uint8Array;
                total?: bigint;
            };
        }): QueryPinnedCodesResponse;
        fromProtoMsg(message: QueryPinnedCodesResponseProtoMsg): QueryPinnedCodesResponse;
        toAmino(message: QueryPinnedCodesResponse): QueryPinnedCodesResponseAmino;
        toAminoMsg(message: QueryPinnedCodesResponse): QueryPinnedCodesResponseAminoMsg;
        toProto(message: QueryPinnedCodesResponse): Uint8Array;
        toProtoMsg(message: QueryPinnedCodesResponse): QueryPinnedCodesResponseProtoMsg;
    };
    QueryRawContractStateRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryRawContractStateRequest;
        encode(message: QueryRawContractStateRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryRawContractStateRequestAmino): QueryRawContractStateRequest;
        fromAminoMsg(object: QueryRawContractStateRequestAminoMsg): QueryRawContractStateRequest;
        fromPartial(object: {
            address?: string;
            queryData?: Uint8Array;
        }): QueryRawContractStateRequest;
        fromProtoMsg(message: QueryRawContractStateRequestProtoMsg): QueryRawContractStateRequest;
        toAmino(message: QueryRawContractStateRequest): QueryRawContractStateRequestAmino;
        toAminoMsg(message: QueryRawContractStateRequest): QueryRawContractStateRequestAminoMsg;
        toProto(message: QueryRawContractStateRequest): Uint8Array;
        toProtoMsg(message: QueryRawContractStateRequest): QueryRawContractStateRequestProtoMsg;
    };
    QueryRawContractStateResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QueryRawContractStateResponse;
        encode(message: QueryRawContractStateResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QueryRawContractStateResponseAmino): QueryRawContractStateResponse;
        fromAminoMsg(object: QueryRawContractStateResponseAminoMsg): QueryRawContractStateResponse;
        fromPartial(object: {
            data?: Uint8Array;
        }): QueryRawContractStateResponse;
        fromProtoMsg(message: QueryRawContractStateResponseProtoMsg): QueryRawContractStateResponse;
        toAmino(message: QueryRawContractStateResponse): QueryRawContractStateResponseAmino;
        toAminoMsg(message: QueryRawContractStateResponse): QueryRawContractStateResponseAminoMsg;
        toProto(message: QueryRawContractStateResponse): Uint8Array;
        toProtoMsg(message: QueryRawContractStateResponse): QueryRawContractStateResponseProtoMsg;
    };
    QuerySmartContractStateRequest: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QuerySmartContractStateRequest;
        encode(message: QuerySmartContractStateRequest, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QuerySmartContractStateRequestAmino): QuerySmartContractStateRequest;
        fromAminoMsg(object: QuerySmartContractStateRequestAminoMsg): QuerySmartContractStateRequest;
        fromPartial(object: {
            address?: string;
            queryData?: Uint8Array;
        }): QuerySmartContractStateRequest;
        fromProtoMsg(message: QuerySmartContractStateRequestProtoMsg): QuerySmartContractStateRequest;
        toAmino(message: QuerySmartContractStateRequest): QuerySmartContractStateRequestAmino;
        toAminoMsg(message: QuerySmartContractStateRequest): QuerySmartContractStateRequestAminoMsg;
        toProto(message: QuerySmartContractStateRequest): Uint8Array;
        toProtoMsg(message: QuerySmartContractStateRequest): QuerySmartContractStateRequestProtoMsg;
    };
    QuerySmartContractStateResponse: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): QuerySmartContractStateResponse;
        encode(message: QuerySmartContractStateResponse, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: QuerySmartContractStateResponseAmino): QuerySmartContractStateResponse;
        fromAminoMsg(object: QuerySmartContractStateResponseAminoMsg): QuerySmartContractStateResponse;
        fromPartial(object: {
            data?: Uint8Array;
        }): QuerySmartContractStateResponse;
        fromProtoMsg(message: QuerySmartContractStateResponseProtoMsg): QuerySmartContractStateResponse;
        toAmino(message: QuerySmartContractStateResponse): QuerySmartContractStateResponseAmino;
        toAminoMsg(message: QuerySmartContractStateResponse): QuerySmartContractStateResponseAminoMsg;
        toProto(message: QuerySmartContractStateResponse): Uint8Array;
        toProtoMsg(message: QuerySmartContractStateResponse): QuerySmartContractStateResponseProtoMsg;
    };
    Sequence: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): Sequence;
        encode(message: Sequence, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: SequenceAmino): Sequence;
        fromAminoMsg(object: SequenceAminoMsg): Sequence;
        fromPartial(object: {
            idKey?: Uint8Array;
            value?: bigint;
        }): Sequence;
        fromProtoMsg(message: SequenceProtoMsg): Sequence;
        toAmino(message: Sequence): SequenceAmino;
        toAminoMsg(message: Sequence): SequenceAminoMsg;
        toProto(message: Sequence): Uint8Array;
        toProtoMsg(message: Sequence): SequenceProtoMsg;
    };
    StoreAndInstantiateContractProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): StoreAndInstantiateContractProposal;
        encode(message: StoreAndInstantiateContractProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: StoreAndInstantiateContractProposalAmino): StoreAndInstantiateContractProposal;
        fromAminoMsg(object: StoreAndInstantiateContractProposalAminoMsg): StoreAndInstantiateContractProposal;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.StoreAndInstantiateContractProposal";
            admin?: string;
            builder?: string;
            codeHash?: Uint8Array;
            description?: string;
            funds?: {
                amount?: string;
                denom?: string;
            }[];
            instantiatePermission?: {
                address?: string;
                addresses?: string[];
                permission?: AccessType;
            };
            label?: string;
            msg?: Uint8Array;
            runAs?: string;
            source?: string;
            title?: string;
            unpinCode?: boolean;
            wasmByteCode?: Uint8Array;
        }): StoreAndInstantiateContractProposal;
        fromProtoMsg(message: StoreAndInstantiateContractProposalProtoMsg): StoreAndInstantiateContractProposal;
        toAmino(message: StoreAndInstantiateContractProposal): StoreAndInstantiateContractProposalAmino;
        toAminoMsg(message: StoreAndInstantiateContractProposal): StoreAndInstantiateContractProposalAminoMsg;
        toProto(message: StoreAndInstantiateContractProposal): Uint8Array;
        toProtoMsg(message: StoreAndInstantiateContractProposal): StoreAndInstantiateContractProposalProtoMsg;
    };
    StoreCodeProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): StoreCodeProposal;
        encode(message: StoreCodeProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: StoreCodeProposalAmino): StoreCodeProposal;
        fromAminoMsg(object: StoreCodeProposalAminoMsg): StoreCodeProposal;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.StoreCodeProposal";
            builder?: string;
            codeHash?: Uint8Array;
            description?: string;
            instantiatePermission?: {
                address?: string;
                addresses?: string[];
                permission?: AccessType;
            };
            runAs?: string;
            source?: string;
            title?: string;
            unpinCode?: boolean;
            wasmByteCode?: Uint8Array;
        }): StoreCodeProposal;
        fromProtoMsg(message: StoreCodeProposalProtoMsg): StoreCodeProposal;
        toAmino(message: StoreCodeProposal): StoreCodeProposalAmino;
        toAminoMsg(message: StoreCodeProposal): StoreCodeProposalAminoMsg;
        toProto(message: StoreCodeProposal): Uint8Array;
        toProtoMsg(message: StoreCodeProposal): StoreCodeProposalProtoMsg;
    };
    SudoContractProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): SudoContractProposal;
        encode(message: SudoContractProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: SudoContractProposalAmino): SudoContractProposal;
        fromAminoMsg(object: SudoContractProposalAminoMsg): SudoContractProposal;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.SudoContractProposal";
            contract?: string;
            description?: string;
            msg?: Uint8Array;
            title?: string;
        }): SudoContractProposal;
        fromProtoMsg(message: SudoContractProposalProtoMsg): SudoContractProposal;
        toAmino(message: SudoContractProposal): SudoContractProposalAmino;
        toAminoMsg(message: SudoContractProposal): SudoContractProposalAminoMsg;
        toProto(message: SudoContractProposal): Uint8Array;
        toProtoMsg(message: SudoContractProposal): SudoContractProposalProtoMsg;
    };
    UnpinCodesProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): UnpinCodesProposal;
        encode(message: UnpinCodesProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: UnpinCodesProposalAmino): UnpinCodesProposal;
        fromAminoMsg(object: UnpinCodesProposalAminoMsg): UnpinCodesProposal;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.UnpinCodesProposal";
            codeIds?: bigint[];
            description?: string;
            title?: string;
        }): UnpinCodesProposal;
        fromProtoMsg(message: UnpinCodesProposalProtoMsg): UnpinCodesProposal;
        toAmino(message: UnpinCodesProposal): UnpinCodesProposalAmino;
        toAminoMsg(message: UnpinCodesProposal): UnpinCodesProposalAminoMsg;
        toProto(message: UnpinCodesProposal): Uint8Array;
        toProtoMsg(message: UnpinCodesProposal): UnpinCodesProposalProtoMsg;
    };
    UpdateAdminProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): UpdateAdminProposal;
        encode(message: UpdateAdminProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: UpdateAdminProposalAmino): UpdateAdminProposal;
        fromAminoMsg(object: UpdateAdminProposalAminoMsg): UpdateAdminProposal;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.UpdateAdminProposal";
            contract?: string;
            description?: string;
            newAdmin?: string;
            title?: string;
        }): UpdateAdminProposal;
        fromProtoMsg(message: UpdateAdminProposalProtoMsg): UpdateAdminProposal;
        toAmino(message: UpdateAdminProposal): UpdateAdminProposalAmino;
        toAminoMsg(message: UpdateAdminProposal): UpdateAdminProposalAminoMsg;
        toProto(message: UpdateAdminProposal): Uint8Array;
        toProtoMsg(message: UpdateAdminProposal): UpdateAdminProposalProtoMsg;
    };
    UpdateInstantiateConfigProposal: {
        typeUrl: string;
        decode(input: Uint8Array | BinaryReader, length?: number): UpdateInstantiateConfigProposal;
        encode(message: UpdateInstantiateConfigProposal, writer?: BinaryWriter): BinaryWriter;
        fromAmino(object: UpdateInstantiateConfigProposalAmino): UpdateInstantiateConfigProposal;
        fromAminoMsg(object: UpdateInstantiateConfigProposalAminoMsg): UpdateInstantiateConfigProposal;
        fromPartial(object: {
            $typeUrl?: "/cosmwasm.wasm.v1.UpdateInstantiateConfigProposal";
            accessConfigUpdates?: {
                codeId?: bigint;
                instantiatePermission?: {
                    address?: string;
                    addresses?: string[];
                    permission?: AccessType;
                };
            }[];
            description?: string;
            title?: string;
        }): UpdateInstantiateConfigProposal;
        fromProtoMsg(message: UpdateInstantiateConfigProposalProtoMsg): UpdateInstantiateConfigProposal;
        toAmino(message: UpdateInstantiateConfigProposal): UpdateInstantiateConfigProposalAmino;
        toAminoMsg(message: UpdateInstantiateConfigProposal): UpdateInstantiateConfigProposalAminoMsg;
        toProto(message: UpdateInstantiateConfigProposal): Uint8Array;
        toProtoMsg(message: UpdateInstantiateConfigProposal): UpdateInstantiateConfigProposalProtoMsg;
    };
    createRpcQueryExtension: ((base: QueryClient) => {
        allContractState(request: QueryAllContractStateRequest): Promise<QueryAllContractStateResponse>;
        code(request: QueryCodeRequest): Promise<QueryCodeResponse>;
        codes(request?: QueryCodesRequest): Promise<QueryCodesResponse>;
        contractHistory(request: QueryContractHistoryRequest): Promise<QueryContractHistoryResponse>;
        contractInfo(request: QueryContractInfoRequest): Promise<QueryContractInfoResponse>;
        contractsByCode(request: QueryContractsByCodeRequest): Promise<QueryContractsByCodeResponse>;
        contractsByCreator(request: QueryContractsByCreatorRequest): Promise<QueryContractsByCreatorResponse>;
        params(request?: QueryParamsRequest): Promise<QueryParamsResponse>;
        pinnedCodes(request?: QueryPinnedCodesRequest): Promise<QueryPinnedCodesResponse>;
        rawContractState(request: QueryRawContractStateRequest): Promise<QueryRawContractStateResponse>;
        smartContractState(request: QuerySmartContractStateRequest): Promise<QuerySmartContractStateResponse>;
    });
    load: ((protoRegistry: Registry) => void);
    registry: readonly [string, TelescopeGeneratedType<any, any, any>][];
    accessTypeFromJSON(object: any): AccessType;
    accessTypeToJSON(object: AccessType): string;
    contractCodeHistoryOperationTypeFromJSON(object: any): ContractCodeHistoryOperationType;
    contractCodeHistoryOperationTypeToJSON(object: ContractCodeHistoryOperationType): string;
} = ...