@manifest-network/manifestjs 2.1.0

package/dist/codegen/cosmwasm/bundle.d.ts

@@ -0,0 +1,2926 @@
+import * as _84 from "./wasm/v1/authz";
+import * as _85 from "./wasm/v1/genesis";
+import * as _86 from "./wasm/v1/ibc";
+import * as _87 from "./wasm/v1/proposal_legacy";
+import * as _88 from "./wasm/v1/query";
+import * as _89 from "./wasm/v1/tx";
+import * as _90 from "./wasm/v1/types";
+import * as _220 from "./wasm/v1/query.lcd";
+import * as _221 from "./wasm/v1/query.rpc.Query";
+import * as _222 from "./wasm/v1/tx.rpc.msg";
+export declare namespace cosmwasm {
+    namespace wasm {
+        const v1: {
+            MsgClientImpl: typeof _222.MsgClientImpl;
+            createClientImpl: (rpc: import("..").TxRpc) => _222.MsgClientImpl;
+            QueryClientImpl: typeof _221.QueryClientImpl;
+            createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                contractInfo(request: _88.QueryContractInfoRequest): Promise<_88.QueryContractInfoResponse>;
+                contractHistory(request: _88.QueryContractHistoryRequest): Promise<_88.QueryContractHistoryResponse>;
+                contractsByCode(request: _88.QueryContractsByCodeRequest): Promise<_88.QueryContractsByCodeResponse>;
+                allContractState(request: _88.QueryAllContractStateRequest): Promise<_88.QueryAllContractStateResponse>;
+                rawContractState(request: _88.QueryRawContractStateRequest): Promise<_88.QueryRawContractStateResponse>;
+                smartContractState(request: _88.QuerySmartContractStateRequest): Promise<_88.QuerySmartContractStateResponse>;
+                code(request: _88.QueryCodeRequest): Promise<_88.QueryCodeResponse>;
+                codes(request?: _88.QueryCodesRequest): Promise<_88.QueryCodesResponse>;
+                codeInfo(request: _88.QueryCodeInfoRequest): Promise<_88.QueryCodeInfoResponse>;
+                pinnedCodes(request?: _88.QueryPinnedCodesRequest): Promise<_88.QueryPinnedCodesResponse>;
+                params(request?: _88.QueryParamsRequest): Promise<_88.QueryParamsResponse>;
+                contractsByCreator(request: _88.QueryContractsByCreatorRequest): Promise<_88.QueryContractsByCreatorResponse>;
+                wasmLimitsConfig(request?: _88.QueryWasmLimitsConfigRequest): Promise<_88.QueryWasmLimitsConfigResponse>;
+                buildAddress(request: _88.QueryBuildAddressRequest): Promise<_88.QueryBuildAddressResponse>;
+            };
+            LCDQueryClient: typeof _220.LCDQueryClient;
+            registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
+            load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
+            MessageComposer: {
+                encoded: {
+                    storeCode(value: _89.MsgStoreCode): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    instantiateContract(value: _89.MsgInstantiateContract): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    instantiateContract2(value: _89.MsgInstantiateContract2): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    executeContract(value: _89.MsgExecuteContract): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    migrateContract(value: _89.MsgMigrateContract): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    updateAdmin(value: _89.MsgUpdateAdmin): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    clearAdmin(value: _89.MsgClearAdmin): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    updateInstantiateConfig(value: _89.MsgUpdateInstantiateConfig): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    updateParams(value: _89.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    sudoContract(value: _89.MsgSudoContract): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    pinCodes(value: _89.MsgPinCodes): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    unpinCodes(value: _89.MsgUnpinCodes): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    storeAndInstantiateContract(value: _89.MsgStoreAndInstantiateContract): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    removeCodeUploadParamsAddresses(value: _89.MsgRemoveCodeUploadParamsAddresses): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    addCodeUploadParamsAddresses(value: _89.MsgAddCodeUploadParamsAddresses): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    storeAndMigrateContract(value: _89.MsgStoreAndMigrateContract): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    updateContractLabel(value: _89.MsgUpdateContractLabel): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                };
+                withTypeUrl: {
+                    storeCode(value: _89.MsgStoreCode): {
+                        typeUrl: string;
+                        value: _89.MsgStoreCode;
+                    };
+                    instantiateContract(value: _89.MsgInstantiateContract): {
+                        typeUrl: string;
+                        value: _89.MsgInstantiateContract;
+                    };
+                    instantiateContract2(value: _89.MsgInstantiateContract2): {
+                        typeUrl: string;
+                        value: _89.MsgInstantiateContract2;
+                    };
+                    executeContract(value: _89.MsgExecuteContract): {
+                        typeUrl: string;
+                        value: _89.MsgExecuteContract;
+                    };
+                    migrateContract(value: _89.MsgMigrateContract): {
+                        typeUrl: string;
+                        value: _89.MsgMigrateContract;
+                    };
+                    updateAdmin(value: _89.MsgUpdateAdmin): {
+                        typeUrl: string;
+                        value: _89.MsgUpdateAdmin;
+                    };
+                    clearAdmin(value: _89.MsgClearAdmin): {
+                        typeUrl: string;
+                        value: _89.MsgClearAdmin;
+                    };
+                    updateInstantiateConfig(value: _89.MsgUpdateInstantiateConfig): {
+                        typeUrl: string;
+                        value: _89.MsgUpdateInstantiateConfig;
+                    };
+                    updateParams(value: _89.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: _89.MsgUpdateParams;
+                    };
+                    sudoContract(value: _89.MsgSudoContract): {
+                        typeUrl: string;
+                        value: _89.MsgSudoContract;
+                    };
+                    pinCodes(value: _89.MsgPinCodes): {
+                        typeUrl: string;
+                        value: _89.MsgPinCodes;
+                    };
+                    unpinCodes(value: _89.MsgUnpinCodes): {
+                        typeUrl: string;
+                        value: _89.MsgUnpinCodes;
+                    };
+                    storeAndInstantiateContract(value: _89.MsgStoreAndInstantiateContract): {
+                        typeUrl: string;
+                        value: _89.MsgStoreAndInstantiateContract;
+                    };
+                    removeCodeUploadParamsAddresses(value: _89.MsgRemoveCodeUploadParamsAddresses): {
+                        typeUrl: string;
+                        value: _89.MsgRemoveCodeUploadParamsAddresses;
+                    };
+                    addCodeUploadParamsAddresses(value: _89.MsgAddCodeUploadParamsAddresses): {
+                        typeUrl: string;
+                        value: _89.MsgAddCodeUploadParamsAddresses;
+                    };
+                    storeAndMigrateContract(value: _89.MsgStoreAndMigrateContract): {
+                        typeUrl: string;
+                        value: _89.MsgStoreAndMigrateContract;
+                    };
+                    updateContractLabel(value: _89.MsgUpdateContractLabel): {
+                        typeUrl: string;
+                        value: _89.MsgUpdateContractLabel;
+                    };
+                };
+                toJSON: {
+                    storeCode(value: _89.MsgStoreCode): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            wasmByteCode: string;
+                            instantiatePermission?: {
+                                permission: _90.AccessType;
+                                addresses: string[];
+                            };
+                        };
+                    };
+                    instantiateContract(value: _89.MsgInstantiateContract): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            admin: string;
+                            codeId: string;
+                            label: string;
+                            msg: string;
+                            funds: {
+                                denom: string;
+                                amount: string;
+                            }[];
+                        };
+                    };
+                    instantiateContract2(value: _89.MsgInstantiateContract2): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            admin: string;
+                            codeId: string;
+                            label: string;
+                            msg: string;
+                            funds: {
+                                denom: string;
+                                amount: string;
+                            }[];
+                            salt: string;
+                            fixMsg: boolean;
+                        };
+                    };
+                    executeContract(value: _89.MsgExecuteContract): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            contract: string;
+                            msg: string;
+                            funds: {
+                                denom: string;
+                                amount: string;
+                            }[];
+                        };
+                    };
+                    migrateContract(value: _89.MsgMigrateContract): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            contract: string;
+                            codeId: string;
+                            msg: string;
+                        };
+                    };
+                    updateAdmin(value: _89.MsgUpdateAdmin): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            newAdmin: string;
+                            contract: string;
+                        };
+                    };
+                    clearAdmin(value: _89.MsgClearAdmin): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            contract: string;
+                        };
+                    };
+                    updateInstantiateConfig(value: _89.MsgUpdateInstantiateConfig): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            codeId: string;
+                            newInstantiatePermission?: {
+                                permission: _90.AccessType;
+                                addresses: string[];
+                            };
+                        };
+                    };
+                    updateParams(value: _89.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: {
+                            authority: string;
+                            params: {
+                                codeUploadAccess: {
+                                    permission: _90.AccessType;
+                                    addresses: string[];
+                                };
+                                instantiateDefaultPermission: _90.AccessType;
+                            };
+                        };
+                    };
+                    sudoContract(value: _89.MsgSudoContract): {
+                        typeUrl: string;
+                        value: {
+                            authority: string;
+                            contract: string;
+                            msg: string;
+                        };
+                    };
+                    pinCodes(value: _89.MsgPinCodes): {
+                        typeUrl: string;
+                        value: {
+                            authority: string;
+                            codeIds: string[];
+                        };
+                    };
+                    unpinCodes(value: _89.MsgUnpinCodes): {
+                        typeUrl: string;
+                        value: {
+                            authority: string;
+                            codeIds: string[];
+                        };
+                    };
+                    storeAndInstantiateContract(value: _89.MsgStoreAndInstantiateContract): {
+                        typeUrl: string;
+                        value: {
+                            authority: string;
+                            wasmByteCode: string;
+                            instantiatePermission?: {
+                                permission: _90.AccessType;
+                                addresses: string[];
+                            };
+                            unpinCode: boolean;
+                            admin: string;
+                            label: string;
+                            msg: string;
+                            funds: {
+                                denom: string;
+                                amount: string;
+                            }[];
+                            source: string;
+                            builder: string;
+                            codeHash: string;
+                        };
+                    };
+                    removeCodeUploadParamsAddresses(value: _89.MsgRemoveCodeUploadParamsAddresses): {
+                        typeUrl: string;
+                        value: {
+                            authority: string;
+                            addresses: string[];
+                        };
+                    };
+                    addCodeUploadParamsAddresses(value: _89.MsgAddCodeUploadParamsAddresses): {
+                        typeUrl: string;
+                        value: {
+                            authority: string;
+                            addresses: string[];
+                        };
+                    };
+                    storeAndMigrateContract(value: _89.MsgStoreAndMigrateContract): {
+                        typeUrl: string;
+                        value: {
+                            authority: string;
+                            wasmByteCode: string;
+                            instantiatePermission?: {
+                                permission: _90.AccessType;
+                                addresses: string[];
+                            };
+                            contract: string;
+                            msg: string;
+                        };
+                    };
+                    updateContractLabel(value: _89.MsgUpdateContractLabel): {
+                        typeUrl: string;
+                        value: {
+                            sender: string;
+                            newLabel: string;
+                            contract: string;
+                        };
+                    };
+                };
+                fromJSON: {
+                    storeCode(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgStoreCode;
+                    };
+                    instantiateContract(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgInstantiateContract;
+                    };
+                    instantiateContract2(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgInstantiateContract2;
+                    };
+                    executeContract(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgExecuteContract;
+                    };
+                    migrateContract(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgMigrateContract;
+                    };
+                    updateAdmin(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgUpdateAdmin;
+                    };
+                    clearAdmin(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgClearAdmin;
+                    };
+                    updateInstantiateConfig(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgUpdateInstantiateConfig;
+                    };
+                    updateParams(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgUpdateParams;
+                    };
+                    sudoContract(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgSudoContract;
+                    };
+                    pinCodes(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgPinCodes;
+                    };
+                    unpinCodes(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgUnpinCodes;
+                    };
+                    storeAndInstantiateContract(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgStoreAndInstantiateContract;
+                    };
+                    removeCodeUploadParamsAddresses(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgRemoveCodeUploadParamsAddresses;
+                    };
+                    addCodeUploadParamsAddresses(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgAddCodeUploadParamsAddresses;
+                    };
+                    storeAndMigrateContract(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgStoreAndMigrateContract;
+                    };
+                    updateContractLabel(value: any): {
+                        typeUrl: string;
+                        value: _89.MsgUpdateContractLabel;
+                    };
+                };
+                fromPartial: {
+                    storeCode(value: _89.MsgStoreCode): {
+                        typeUrl: string;
+                        value: _89.MsgStoreCode;
+                    };
+                    instantiateContract(value: _89.MsgInstantiateContract): {
+                        typeUrl: string;
+                        value: _89.MsgInstantiateContract;
+                    };
+                    instantiateContract2(value: _89.MsgInstantiateContract2): {
+                        typeUrl: string;
+                        value: _89.MsgInstantiateContract2;
+                    };
+                    executeContract(value: _89.MsgExecuteContract): {
+                        typeUrl: string;
+                        value: _89.MsgExecuteContract;
+                    };
+                    migrateContract(value: _89.MsgMigrateContract): {
+                        typeUrl: string;
+                        value: _89.MsgMigrateContract;
+                    };
+                    updateAdmin(value: _89.MsgUpdateAdmin): {
+                        typeUrl: string;
+                        value: _89.MsgUpdateAdmin;
+                    };
+                    clearAdmin(value: _89.MsgClearAdmin): {
+                        typeUrl: string;
+                        value: _89.MsgClearAdmin;
+                    };
+                    updateInstantiateConfig(value: _89.MsgUpdateInstantiateConfig): {
+                        typeUrl: string;
+                        value: _89.MsgUpdateInstantiateConfig;
+                    };
+                    updateParams(value: _89.MsgUpdateParams): {
+                        typeUrl: string;
+                        value: _89.MsgUpdateParams;
+                    };
+                    sudoContract(value: _89.MsgSudoContract): {
+                        typeUrl: string;
+                        value: _89.MsgSudoContract;
+                    };
+                    pinCodes(value: _89.MsgPinCodes): {
+                        typeUrl: string;
+                        value: _89.MsgPinCodes;
+                    };
+                    unpinCodes(value: _89.MsgUnpinCodes): {
+                        typeUrl: string;
+                        value: _89.MsgUnpinCodes;
+                    };
+                    storeAndInstantiateContract(value: _89.MsgStoreAndInstantiateContract): {
+                        typeUrl: string;
+                        value: _89.MsgStoreAndInstantiateContract;
+                    };
+                    removeCodeUploadParamsAddresses(value: _89.MsgRemoveCodeUploadParamsAddresses): {
+                        typeUrl: string;
+                        value: _89.MsgRemoveCodeUploadParamsAddresses;
+                    };
+                    addCodeUploadParamsAddresses(value: _89.MsgAddCodeUploadParamsAddresses): {
+                        typeUrl: string;
+                        value: _89.MsgAddCodeUploadParamsAddresses;
+                    };
+                    storeAndMigrateContract(value: _89.MsgStoreAndMigrateContract): {
+                        typeUrl: string;
+                        value: _89.MsgStoreAndMigrateContract;
+                    };
+                    updateContractLabel(value: _89.MsgUpdateContractLabel): {
+                        typeUrl: string;
+                        value: _89.MsgUpdateContractLabel;
+                    };
+                };
+            };
+            AminoConverter: {
+                "/cosmwasm.wasm.v1.MsgStoreCode": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgStoreCode) => _89.MsgStoreCodeAmino;
+                    fromAmino: (object: _89.MsgStoreCodeAmino) => _89.MsgStoreCode;
+                };
+                "/cosmwasm.wasm.v1.MsgInstantiateContract": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgInstantiateContract) => _89.MsgInstantiateContractAmino;
+                    fromAmino: (object: _89.MsgInstantiateContractAmino) => _89.MsgInstantiateContract;
+                };
+                "/cosmwasm.wasm.v1.MsgInstantiateContract2": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgInstantiateContract2) => _89.MsgInstantiateContract2Amino;
+                    fromAmino: (object: _89.MsgInstantiateContract2Amino) => _89.MsgInstantiateContract2;
+                };
+                "/cosmwasm.wasm.v1.MsgExecuteContract": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgExecuteContract) => _89.MsgExecuteContractAmino;
+                    fromAmino: (object: _89.MsgExecuteContractAmino) => _89.MsgExecuteContract;
+                };
+                "/cosmwasm.wasm.v1.MsgMigrateContract": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgMigrateContract) => _89.MsgMigrateContractAmino;
+                    fromAmino: (object: _89.MsgMigrateContractAmino) => _89.MsgMigrateContract;
+                };
+                "/cosmwasm.wasm.v1.MsgUpdateAdmin": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgUpdateAdmin) => _89.MsgUpdateAdminAmino;
+                    fromAmino: (object: _89.MsgUpdateAdminAmino) => _89.MsgUpdateAdmin;
+                };
+                "/cosmwasm.wasm.v1.MsgClearAdmin": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgClearAdmin) => _89.MsgClearAdminAmino;
+                    fromAmino: (object: _89.MsgClearAdminAmino) => _89.MsgClearAdmin;
+                };
+                "/cosmwasm.wasm.v1.MsgUpdateInstantiateConfig": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgUpdateInstantiateConfig) => _89.MsgUpdateInstantiateConfigAmino;
+                    fromAmino: (object: _89.MsgUpdateInstantiateConfigAmino) => _89.MsgUpdateInstantiateConfig;
+                };
+                "/cosmwasm.wasm.v1.MsgUpdateParams": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgUpdateParams) => _89.MsgUpdateParamsAmino;
+                    fromAmino: (object: _89.MsgUpdateParamsAmino) => _89.MsgUpdateParams;
+                };
+                "/cosmwasm.wasm.v1.MsgSudoContract": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgSudoContract) => _89.MsgSudoContractAmino;
+                    fromAmino: (object: _89.MsgSudoContractAmino) => _89.MsgSudoContract;
+                };
+                "/cosmwasm.wasm.v1.MsgPinCodes": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgPinCodes) => _89.MsgPinCodesAmino;
+                    fromAmino: (object: _89.MsgPinCodesAmino) => _89.MsgPinCodes;
+                };
+                "/cosmwasm.wasm.v1.MsgUnpinCodes": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgUnpinCodes) => _89.MsgUnpinCodesAmino;
+                    fromAmino: (object: _89.MsgUnpinCodesAmino) => _89.MsgUnpinCodes;
+                };
+                "/cosmwasm.wasm.v1.MsgStoreAndInstantiateContract": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgStoreAndInstantiateContract) => _89.MsgStoreAndInstantiateContractAmino;
+                    fromAmino: (object: _89.MsgStoreAndInstantiateContractAmino) => _89.MsgStoreAndInstantiateContract;
+                };
+                "/cosmwasm.wasm.v1.MsgRemoveCodeUploadParamsAddresses": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgRemoveCodeUploadParamsAddresses) => _89.MsgRemoveCodeUploadParamsAddressesAmino;
+                    fromAmino: (object: _89.MsgRemoveCodeUploadParamsAddressesAmino) => _89.MsgRemoveCodeUploadParamsAddresses;
+                };
+                "/cosmwasm.wasm.v1.MsgAddCodeUploadParamsAddresses": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgAddCodeUploadParamsAddresses) => _89.MsgAddCodeUploadParamsAddressesAmino;
+                    fromAmino: (object: _89.MsgAddCodeUploadParamsAddressesAmino) => _89.MsgAddCodeUploadParamsAddresses;
+                };
+                "/cosmwasm.wasm.v1.MsgStoreAndMigrateContract": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgStoreAndMigrateContract) => _89.MsgStoreAndMigrateContractAmino;
+                    fromAmino: (object: _89.MsgStoreAndMigrateContractAmino) => _89.MsgStoreAndMigrateContract;
+                };
+                "/cosmwasm.wasm.v1.MsgUpdateContractLabel": {
+                    aminoType: string;
+                    toAmino: (message: _89.MsgUpdateContractLabel) => _89.MsgUpdateContractLabelAmino;
+                    fromAmino: (object: _89.MsgUpdateContractLabelAmino) => _89.MsgUpdateContractLabel;
+                };
+            };
+            accessTypeFromJSON(object: any): _90.AccessType;
+            accessTypeToJSON(object: _90.AccessType): string;
+            contractCodeHistoryOperationTypeFromJSON(object: any): _90.ContractCodeHistoryOperationType;
+            contractCodeHistoryOperationTypeToJSON(object: _90.ContractCodeHistoryOperationType): string;
+            AccessType: typeof _90.AccessType;
+            AccessTypeSDKType: typeof _90.AccessType;
+            AccessTypeAmino: typeof _90.AccessType;
+            ContractCodeHistoryOperationType: typeof _90.ContractCodeHistoryOperationType;
+            ContractCodeHistoryOperationTypeSDKType: typeof _90.ContractCodeHistoryOperationType;
+            ContractCodeHistoryOperationTypeAmino: typeof _90.ContractCodeHistoryOperationType;
+            AccessTypeParam: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _90.AccessTypeParam;
+                isSDK(o: any): o is _90.AccessTypeParamSDKType;
+                isAmino(o: any): o is _90.AccessTypeParamAmino;
+                encode(message: _90.AccessTypeParam, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _90.AccessTypeParam;
+                fromJSON(object: any): _90.AccessTypeParam;
+                toJSON(message: _90.AccessTypeParam): import("..").JsonSafe<_90.AccessTypeParam>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_90.AccessTypeParam>, I>>(object: I): _90.AccessTypeParam;
+                fromAmino(object: _90.AccessTypeParamAmino): _90.AccessTypeParam;
+                toAmino(message: _90.AccessTypeParam): _90.AccessTypeParamAmino;
+                fromAminoMsg(object: _90.AccessTypeParamAminoMsg): _90.AccessTypeParam;
+                toAminoMsg(message: _90.AccessTypeParam): _90.AccessTypeParamAminoMsg;
+                fromProtoMsg(message: _90.AccessTypeParamProtoMsg): _90.AccessTypeParam;
+                toProto(message: _90.AccessTypeParam): Uint8Array;
+                toProtoMsg(message: _90.AccessTypeParam): _90.AccessTypeParamProtoMsg;
+            };
+            AccessConfig: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _90.AccessConfig;
+                isSDK(o: any): o is _90.AccessConfigSDKType;
+                isAmino(o: any): o is _90.AccessConfigAmino;
+                encode(message: _90.AccessConfig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _90.AccessConfig;
+                fromJSON(object: any): _90.AccessConfig;
+                toJSON(message: _90.AccessConfig): import("..").JsonSafe<_90.AccessConfig>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_90.AccessConfig>, I>>(object: I): _90.AccessConfig;
+                fromAmino(object: _90.AccessConfigAmino): _90.AccessConfig;
+                toAmino(message: _90.AccessConfig): _90.AccessConfigAmino;
+                fromAminoMsg(object: _90.AccessConfigAminoMsg): _90.AccessConfig;
+                toAminoMsg(message: _90.AccessConfig): _90.AccessConfigAminoMsg;
+                fromProtoMsg(message: _90.AccessConfigProtoMsg): _90.AccessConfig;
+                toProto(message: _90.AccessConfig): Uint8Array;
+                toProtoMsg(message: _90.AccessConfig): _90.AccessConfigProtoMsg;
+            };
+            Params: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _90.Params;
+                isSDK(o: any): o is _90.ParamsSDKType;
+                isAmino(o: any): o is _90.ParamsAmino;
+                encode(message: _90.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _90.Params;
+                fromJSON(object: any): _90.Params;
+                toJSON(message: _90.Params): import("..").JsonSafe<_90.Params>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_90.Params>, I>>(object: I): _90.Params;
+                fromAmino(object: _90.ParamsAmino): _90.Params;
+                toAmino(message: _90.Params): _90.ParamsAmino;
+                fromAminoMsg(object: _90.ParamsAminoMsg): _90.Params;
+                toAminoMsg(message: _90.Params): _90.ParamsAminoMsg;
+                fromProtoMsg(message: _90.ParamsProtoMsg): _90.Params;
+                toProto(message: _90.Params): Uint8Array;
+                toProtoMsg(message: _90.Params): _90.ParamsProtoMsg;
+            };
+            CodeInfo: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _90.CodeInfo;
+                isSDK(o: any): o is _90.CodeInfoSDKType;
+                isAmino(o: any): o is _90.CodeInfoAmino;
+                encode(message: _90.CodeInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _90.CodeInfo;
+                fromJSON(object: any): _90.CodeInfo;
+                toJSON(message: _90.CodeInfo): import("..").JsonSafe<_90.CodeInfo>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_90.CodeInfo>, I>>(object: I): _90.CodeInfo;
+                fromAmino(object: _90.CodeInfoAmino): _90.CodeInfo;
+                toAmino(message: _90.CodeInfo): _90.CodeInfoAmino;
+                fromAminoMsg(object: _90.CodeInfoAminoMsg): _90.CodeInfo;
+                toAminoMsg(message: _90.CodeInfo): _90.CodeInfoAminoMsg;
+                fromProtoMsg(message: _90.CodeInfoProtoMsg): _90.CodeInfo;
+                toProto(message: _90.CodeInfo): Uint8Array;
+                toProtoMsg(message: _90.CodeInfo): _90.CodeInfoProtoMsg;
+            };
+            ContractInfo: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _90.ContractInfo;
+                isSDK(o: any): o is _90.ContractInfoSDKType;
+                isAmino(o: any): o is _90.ContractInfoAmino;
+                encode(message: _90.ContractInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _90.ContractInfo;
+                fromJSON(object: any): _90.ContractInfo;
+                toJSON(message: _90.ContractInfo): import("..").JsonSafe<_90.ContractInfo>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_90.ContractInfo>, I>>(object: I): _90.ContractInfo;
+                fromAmino(object: _90.ContractInfoAmino): _90.ContractInfo;
+                toAmino(message: _90.ContractInfo): _90.ContractInfoAmino;
+                fromAminoMsg(object: _90.ContractInfoAminoMsg): _90.ContractInfo;
+                toAminoMsg(message: _90.ContractInfo): _90.ContractInfoAminoMsg;
+                fromProtoMsg(message: _90.ContractInfoProtoMsg): _90.ContractInfo;
+                toProto(message: _90.ContractInfo): Uint8Array;
+                toProtoMsg(message: _90.ContractInfo): _90.ContractInfoProtoMsg;
+            };
+            ContractCodeHistoryEntry: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _90.ContractCodeHistoryEntry;
+                isSDK(o: any): o is _90.ContractCodeHistoryEntrySDKType;
+                isAmino(o: any): o is _90.ContractCodeHistoryEntryAmino;
+                encode(message: _90.ContractCodeHistoryEntry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _90.ContractCodeHistoryEntry;
+                fromJSON(object: any): _90.ContractCodeHistoryEntry;
+                toJSON(message: _90.ContractCodeHistoryEntry): import("..").JsonSafe<_90.ContractCodeHistoryEntry>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_90.ContractCodeHistoryEntry>, I>>(object: I): _90.ContractCodeHistoryEntry;
+                fromAmino(object: _90.ContractCodeHistoryEntryAmino): _90.ContractCodeHistoryEntry;
+                toAmino(message: _90.ContractCodeHistoryEntry): _90.ContractCodeHistoryEntryAmino;
+                fromAminoMsg(object: _90.ContractCodeHistoryEntryAminoMsg): _90.ContractCodeHistoryEntry;
+                toAminoMsg(message: _90.ContractCodeHistoryEntry): _90.ContractCodeHistoryEntryAminoMsg;
+                fromProtoMsg(message: _90.ContractCodeHistoryEntryProtoMsg): _90.ContractCodeHistoryEntry;
+                toProto(message: _90.ContractCodeHistoryEntry): Uint8Array;
+                toProtoMsg(message: _90.ContractCodeHistoryEntry): _90.ContractCodeHistoryEntryProtoMsg;
+            };
+            AbsoluteTxPosition: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _90.AbsoluteTxPosition;
+                isSDK(o: any): o is _90.AbsoluteTxPositionSDKType;
+                isAmino(o: any): o is _90.AbsoluteTxPositionAmino;
+                encode(message: _90.AbsoluteTxPosition, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _90.AbsoluteTxPosition;
+                fromJSON(object: any): _90.AbsoluteTxPosition;
+                toJSON(message: _90.AbsoluteTxPosition): import("..").JsonSafe<_90.AbsoluteTxPosition>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_90.AbsoluteTxPosition>, I>>(object: I): _90.AbsoluteTxPosition;
+                fromAmino(object: _90.AbsoluteTxPositionAmino): _90.AbsoluteTxPosition;
+                toAmino(message: _90.AbsoluteTxPosition): _90.AbsoluteTxPositionAmino;
+                fromAminoMsg(object: _90.AbsoluteTxPositionAminoMsg): _90.AbsoluteTxPosition;
+                toAminoMsg(message: _90.AbsoluteTxPosition): _90.AbsoluteTxPositionAminoMsg;
+                fromProtoMsg(message: _90.AbsoluteTxPositionProtoMsg): _90.AbsoluteTxPosition;
+                toProto(message: _90.AbsoluteTxPosition): Uint8Array;
+                toProtoMsg(message: _90.AbsoluteTxPosition): _90.AbsoluteTxPositionProtoMsg;
+            };
+            Model: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _90.Model;
+                isSDK(o: any): o is _90.ModelSDKType;
+                isAmino(o: any): o is _90.ModelAmino;
+                encode(message: _90.Model, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _90.Model;
+                fromJSON(object: any): _90.Model;
+                toJSON(message: _90.Model): import("..").JsonSafe<_90.Model>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_90.Model>, I>>(object: I): _90.Model;
+                fromAmino(object: _90.ModelAmino): _90.Model;
+                toAmino(message: _90.Model): _90.ModelAmino;
+                fromAminoMsg(object: _90.ModelAminoMsg): _90.Model;
+                toAminoMsg(message: _90.Model): _90.ModelAminoMsg;
+                fromProtoMsg(message: _90.ModelProtoMsg): _90.Model;
+                toProto(message: _90.Model): Uint8Array;
+                toProtoMsg(message: _90.Model): _90.ModelProtoMsg;
+            };
+            MsgStoreCode: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgStoreCode;
+                isSDK(o: any): o is _89.MsgStoreCodeSDKType;
+                isAmino(o: any): o is _89.MsgStoreCodeAmino;
+                encode(message: _89.MsgStoreCode, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgStoreCode;
+                fromJSON(object: any): _89.MsgStoreCode;
+                toJSON(message: _89.MsgStoreCode): import("..").JsonSafe<_89.MsgStoreCode>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgStoreCode>, I>>(object: I): _89.MsgStoreCode;
+                fromAmino(object: _89.MsgStoreCodeAmino): _89.MsgStoreCode;
+                toAmino(message: _89.MsgStoreCode): _89.MsgStoreCodeAmino;
+                fromAminoMsg(object: _89.MsgStoreCodeAminoMsg): _89.MsgStoreCode;
+                toAminoMsg(message: _89.MsgStoreCode): _89.MsgStoreCodeAminoMsg;
+                fromProtoMsg(message: _89.MsgStoreCodeProtoMsg): _89.MsgStoreCode;
+                toProto(message: _89.MsgStoreCode): Uint8Array;
+                toProtoMsg(message: _89.MsgStoreCode): _89.MsgStoreCodeProtoMsg;
+            };
+            MsgStoreCodeResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgStoreCodeResponse;
+                isSDK(o: any): o is _89.MsgStoreCodeResponseSDKType;
+                isAmino(o: any): o is _89.MsgStoreCodeResponseAmino;
+                encode(message: _89.MsgStoreCodeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgStoreCodeResponse;
+                fromJSON(object: any): _89.MsgStoreCodeResponse;
+                toJSON(message: _89.MsgStoreCodeResponse): import("..").JsonSafe<_89.MsgStoreCodeResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgStoreCodeResponse>, I>>(object: I): _89.MsgStoreCodeResponse;
+                fromAmino(object: _89.MsgStoreCodeResponseAmino): _89.MsgStoreCodeResponse;
+                toAmino(message: _89.MsgStoreCodeResponse): _89.MsgStoreCodeResponseAmino;
+                fromAminoMsg(object: _89.MsgStoreCodeResponseAminoMsg): _89.MsgStoreCodeResponse;
+                toAminoMsg(message: _89.MsgStoreCodeResponse): _89.MsgStoreCodeResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgStoreCodeResponseProtoMsg): _89.MsgStoreCodeResponse;
+                toProto(message: _89.MsgStoreCodeResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgStoreCodeResponse): _89.MsgStoreCodeResponseProtoMsg;
+            };
+            MsgInstantiateContract: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgInstantiateContract;
+                isSDK(o: any): o is _89.MsgInstantiateContractSDKType;
+                isAmino(o: any): o is _89.MsgInstantiateContractAmino;
+                encode(message: _89.MsgInstantiateContract, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgInstantiateContract;
+                fromJSON(object: any): _89.MsgInstantiateContract;
+                toJSON(message: _89.MsgInstantiateContract): import("..").JsonSafe<_89.MsgInstantiateContract>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgInstantiateContract>, I>>(object: I): _89.MsgInstantiateContract;
+                fromAmino(object: _89.MsgInstantiateContractAmino): _89.MsgInstantiateContract;
+                toAmino(message: _89.MsgInstantiateContract): _89.MsgInstantiateContractAmino;
+                fromAminoMsg(object: _89.MsgInstantiateContractAminoMsg): _89.MsgInstantiateContract;
+                toAminoMsg(message: _89.MsgInstantiateContract): _89.MsgInstantiateContractAminoMsg;
+                fromProtoMsg(message: _89.MsgInstantiateContractProtoMsg): _89.MsgInstantiateContract;
+                toProto(message: _89.MsgInstantiateContract): Uint8Array;
+                toProtoMsg(message: _89.MsgInstantiateContract): _89.MsgInstantiateContractProtoMsg;
+            };
+            MsgInstantiateContractResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgInstantiateContractResponse;
+                isSDK(o: any): o is _89.MsgInstantiateContractResponseSDKType;
+                isAmino(o: any): o is _89.MsgInstantiateContractResponseAmino;
+                encode(message: _89.MsgInstantiateContractResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgInstantiateContractResponse;
+                fromJSON(object: any): _89.MsgInstantiateContractResponse;
+                toJSON(message: _89.MsgInstantiateContractResponse): import("..").JsonSafe<_89.MsgInstantiateContractResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgInstantiateContractResponse>, I>>(object: I): _89.MsgInstantiateContractResponse;
+                fromAmino(object: _89.MsgInstantiateContractResponseAmino): _89.MsgInstantiateContractResponse;
+                toAmino(message: _89.MsgInstantiateContractResponse): _89.MsgInstantiateContractResponseAmino;
+                fromAminoMsg(object: _89.MsgInstantiateContractResponseAminoMsg): _89.MsgInstantiateContractResponse;
+                toAminoMsg(message: _89.MsgInstantiateContractResponse): _89.MsgInstantiateContractResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgInstantiateContractResponseProtoMsg): _89.MsgInstantiateContractResponse;
+                toProto(message: _89.MsgInstantiateContractResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgInstantiateContractResponse): _89.MsgInstantiateContractResponseProtoMsg;
+            };
+            MsgInstantiateContract2: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgInstantiateContract2;
+                isSDK(o: any): o is _89.MsgInstantiateContract2SDKType;
+                isAmino(o: any): o is _89.MsgInstantiateContract2Amino;
+                encode(message: _89.MsgInstantiateContract2, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgInstantiateContract2;
+                fromJSON(object: any): _89.MsgInstantiateContract2;
+                toJSON(message: _89.MsgInstantiateContract2): import("..").JsonSafe<_89.MsgInstantiateContract2>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgInstantiateContract2>, I>>(object: I): _89.MsgInstantiateContract2;
+                fromAmino(object: _89.MsgInstantiateContract2Amino): _89.MsgInstantiateContract2;
+                toAmino(message: _89.MsgInstantiateContract2): _89.MsgInstantiateContract2Amino;
+                fromAminoMsg(object: _89.MsgInstantiateContract2AminoMsg): _89.MsgInstantiateContract2;
+                toAminoMsg(message: _89.MsgInstantiateContract2): _89.MsgInstantiateContract2AminoMsg;
+                fromProtoMsg(message: _89.MsgInstantiateContract2ProtoMsg): _89.MsgInstantiateContract2;
+                toProto(message: _89.MsgInstantiateContract2): Uint8Array;
+                toProtoMsg(message: _89.MsgInstantiateContract2): _89.MsgInstantiateContract2ProtoMsg;
+            };
+            MsgInstantiateContract2Response: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgInstantiateContract2Response;
+                isSDK(o: any): o is _89.MsgInstantiateContract2ResponseSDKType;
+                isAmino(o: any): o is _89.MsgInstantiateContract2ResponseAmino;
+                encode(message: _89.MsgInstantiateContract2Response, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgInstantiateContract2Response;
+                fromJSON(object: any): _89.MsgInstantiateContract2Response;
+                toJSON(message: _89.MsgInstantiateContract2Response): import("..").JsonSafe<_89.MsgInstantiateContract2Response>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgInstantiateContract2Response>, I>>(object: I): _89.MsgInstantiateContract2Response;
+                fromAmino(object: _89.MsgInstantiateContract2ResponseAmino): _89.MsgInstantiateContract2Response;
+                toAmino(message: _89.MsgInstantiateContract2Response): _89.MsgInstantiateContract2ResponseAmino;
+                fromAminoMsg(object: _89.MsgInstantiateContract2ResponseAminoMsg): _89.MsgInstantiateContract2Response;
+                toAminoMsg(message: _89.MsgInstantiateContract2Response): _89.MsgInstantiateContract2ResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgInstantiateContract2ResponseProtoMsg): _89.MsgInstantiateContract2Response;
+                toProto(message: _89.MsgInstantiateContract2Response): Uint8Array;
+                toProtoMsg(message: _89.MsgInstantiateContract2Response): _89.MsgInstantiateContract2ResponseProtoMsg;
+            };
+            MsgExecuteContract: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgExecuteContract;
+                isSDK(o: any): o is _89.MsgExecuteContractSDKType;
+                isAmino(o: any): o is _89.MsgExecuteContractAmino;
+                encode(message: _89.MsgExecuteContract, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgExecuteContract;
+                fromJSON(object: any): _89.MsgExecuteContract;
+                toJSON(message: _89.MsgExecuteContract): import("..").JsonSafe<_89.MsgExecuteContract>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgExecuteContract>, I>>(object: I): _89.MsgExecuteContract;
+                fromAmino(object: _89.MsgExecuteContractAmino): _89.MsgExecuteContract;
+                toAmino(message: _89.MsgExecuteContract): _89.MsgExecuteContractAmino;
+                fromAminoMsg(object: _89.MsgExecuteContractAminoMsg): _89.MsgExecuteContract;
+                toAminoMsg(message: _89.MsgExecuteContract): _89.MsgExecuteContractAminoMsg;
+                fromProtoMsg(message: _89.MsgExecuteContractProtoMsg): _89.MsgExecuteContract;
+                toProto(message: _89.MsgExecuteContract): Uint8Array;
+                toProtoMsg(message: _89.MsgExecuteContract): _89.MsgExecuteContractProtoMsg;
+            };
+            MsgExecuteContractResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgExecuteContractResponse;
+                isSDK(o: any): o is _89.MsgExecuteContractResponseSDKType;
+                isAmino(o: any): o is _89.MsgExecuteContractResponseAmino;
+                encode(message: _89.MsgExecuteContractResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgExecuteContractResponse;
+                fromJSON(object: any): _89.MsgExecuteContractResponse;
+                toJSON(message: _89.MsgExecuteContractResponse): import("..").JsonSafe<_89.MsgExecuteContractResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgExecuteContractResponse>, I>>(object: I): _89.MsgExecuteContractResponse;
+                fromAmino(object: _89.MsgExecuteContractResponseAmino): _89.MsgExecuteContractResponse;
+                toAmino(message: _89.MsgExecuteContractResponse): _89.MsgExecuteContractResponseAmino;
+                fromAminoMsg(object: _89.MsgExecuteContractResponseAminoMsg): _89.MsgExecuteContractResponse;
+                toAminoMsg(message: _89.MsgExecuteContractResponse): _89.MsgExecuteContractResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgExecuteContractResponseProtoMsg): _89.MsgExecuteContractResponse;
+                toProto(message: _89.MsgExecuteContractResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgExecuteContractResponse): _89.MsgExecuteContractResponseProtoMsg;
+            };
+            MsgMigrateContract: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgMigrateContract;
+                isSDK(o: any): o is _89.MsgMigrateContractSDKType;
+                isAmino(o: any): o is _89.MsgMigrateContractAmino;
+                encode(message: _89.MsgMigrateContract, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgMigrateContract;
+                fromJSON(object: any): _89.MsgMigrateContract;
+                toJSON(message: _89.MsgMigrateContract): import("..").JsonSafe<_89.MsgMigrateContract>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgMigrateContract>, I>>(object: I): _89.MsgMigrateContract;
+                fromAmino(object: _89.MsgMigrateContractAmino): _89.MsgMigrateContract;
+                toAmino(message: _89.MsgMigrateContract): _89.MsgMigrateContractAmino;
+                fromAminoMsg(object: _89.MsgMigrateContractAminoMsg): _89.MsgMigrateContract;
+                toAminoMsg(message: _89.MsgMigrateContract): _89.MsgMigrateContractAminoMsg;
+                fromProtoMsg(message: _89.MsgMigrateContractProtoMsg): _89.MsgMigrateContract;
+                toProto(message: _89.MsgMigrateContract): Uint8Array;
+                toProtoMsg(message: _89.MsgMigrateContract): _89.MsgMigrateContractProtoMsg;
+            };
+            MsgMigrateContractResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgMigrateContractResponse;
+                isSDK(o: any): o is _89.MsgMigrateContractResponseSDKType;
+                isAmino(o: any): o is _89.MsgMigrateContractResponseAmino;
+                encode(message: _89.MsgMigrateContractResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgMigrateContractResponse;
+                fromJSON(object: any): _89.MsgMigrateContractResponse;
+                toJSON(message: _89.MsgMigrateContractResponse): import("..").JsonSafe<_89.MsgMigrateContractResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgMigrateContractResponse>, I>>(object: I): _89.MsgMigrateContractResponse;
+                fromAmino(object: _89.MsgMigrateContractResponseAmino): _89.MsgMigrateContractResponse;
+                toAmino(message: _89.MsgMigrateContractResponse): _89.MsgMigrateContractResponseAmino;
+                fromAminoMsg(object: _89.MsgMigrateContractResponseAminoMsg): _89.MsgMigrateContractResponse;
+                toAminoMsg(message: _89.MsgMigrateContractResponse): _89.MsgMigrateContractResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgMigrateContractResponseProtoMsg): _89.MsgMigrateContractResponse;
+                toProto(message: _89.MsgMigrateContractResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgMigrateContractResponse): _89.MsgMigrateContractResponseProtoMsg;
+            };
+            MsgUpdateAdmin: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgUpdateAdmin;
+                isSDK(o: any): o is _89.MsgUpdateAdminSDKType;
+                isAmino(o: any): o is _89.MsgUpdateAdminAmino;
+                encode(message: _89.MsgUpdateAdmin, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgUpdateAdmin;
+                fromJSON(object: any): _89.MsgUpdateAdmin;
+                toJSON(message: _89.MsgUpdateAdmin): import("..").JsonSafe<_89.MsgUpdateAdmin>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgUpdateAdmin>, I>>(object: I): _89.MsgUpdateAdmin;
+                fromAmino(object: _89.MsgUpdateAdminAmino): _89.MsgUpdateAdmin;
+                toAmino(message: _89.MsgUpdateAdmin): _89.MsgUpdateAdminAmino;
+                fromAminoMsg(object: _89.MsgUpdateAdminAminoMsg): _89.MsgUpdateAdmin;
+                toAminoMsg(message: _89.MsgUpdateAdmin): _89.MsgUpdateAdminAminoMsg;
+                fromProtoMsg(message: _89.MsgUpdateAdminProtoMsg): _89.MsgUpdateAdmin;
+                toProto(message: _89.MsgUpdateAdmin): Uint8Array;
+                toProtoMsg(message: _89.MsgUpdateAdmin): _89.MsgUpdateAdminProtoMsg;
+            };
+            MsgUpdateAdminResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgUpdateAdminResponse;
+                isSDK(o: any): o is _89.MsgUpdateAdminResponseSDKType;
+                isAmino(o: any): o is _89.MsgUpdateAdminResponseAmino;
+                encode(_: _89.MsgUpdateAdminResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgUpdateAdminResponse;
+                fromJSON(_: any): _89.MsgUpdateAdminResponse;
+                toJSON(_: _89.MsgUpdateAdminResponse): import("..").JsonSafe<_89.MsgUpdateAdminResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgUpdateAdminResponse>, I>>(_: I): _89.MsgUpdateAdminResponse;
+                fromAmino(_: _89.MsgUpdateAdminResponseAmino): _89.MsgUpdateAdminResponse;
+                toAmino(_: _89.MsgUpdateAdminResponse): _89.MsgUpdateAdminResponseAmino;
+                fromAminoMsg(object: _89.MsgUpdateAdminResponseAminoMsg): _89.MsgUpdateAdminResponse;
+                toAminoMsg(message: _89.MsgUpdateAdminResponse): _89.MsgUpdateAdminResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgUpdateAdminResponseProtoMsg): _89.MsgUpdateAdminResponse;
+                toProto(message: _89.MsgUpdateAdminResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgUpdateAdminResponse): _89.MsgUpdateAdminResponseProtoMsg;
+            };
+            MsgClearAdmin: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgClearAdmin;
+                isSDK(o: any): o is _89.MsgClearAdminSDKType;
+                isAmino(o: any): o is _89.MsgClearAdminAmino;
+                encode(message: _89.MsgClearAdmin, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgClearAdmin;
+                fromJSON(object: any): _89.MsgClearAdmin;
+                toJSON(message: _89.MsgClearAdmin): import("..").JsonSafe<_89.MsgClearAdmin>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgClearAdmin>, I>>(object: I): _89.MsgClearAdmin;
+                fromAmino(object: _89.MsgClearAdminAmino): _89.MsgClearAdmin;
+                toAmino(message: _89.MsgClearAdmin): _89.MsgClearAdminAmino;
+                fromAminoMsg(object: _89.MsgClearAdminAminoMsg): _89.MsgClearAdmin;
+                toAminoMsg(message: _89.MsgClearAdmin): _89.MsgClearAdminAminoMsg;
+                fromProtoMsg(message: _89.MsgClearAdminProtoMsg): _89.MsgClearAdmin;
+                toProto(message: _89.MsgClearAdmin): Uint8Array;
+                toProtoMsg(message: _89.MsgClearAdmin): _89.MsgClearAdminProtoMsg;
+            };
+            MsgClearAdminResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgClearAdminResponse;
+                isSDK(o: any): o is _89.MsgClearAdminResponseSDKType;
+                isAmino(o: any): o is _89.MsgClearAdminResponseAmino;
+                encode(_: _89.MsgClearAdminResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgClearAdminResponse;
+                fromJSON(_: any): _89.MsgClearAdminResponse;
+                toJSON(_: _89.MsgClearAdminResponse): import("..").JsonSafe<_89.MsgClearAdminResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgClearAdminResponse>, I>>(_: I): _89.MsgClearAdminResponse;
+                fromAmino(_: _89.MsgClearAdminResponseAmino): _89.MsgClearAdminResponse;
+                toAmino(_: _89.MsgClearAdminResponse): _89.MsgClearAdminResponseAmino;
+                fromAminoMsg(object: _89.MsgClearAdminResponseAminoMsg): _89.MsgClearAdminResponse;
+                toAminoMsg(message: _89.MsgClearAdminResponse): _89.MsgClearAdminResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgClearAdminResponseProtoMsg): _89.MsgClearAdminResponse;
+                toProto(message: _89.MsgClearAdminResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgClearAdminResponse): _89.MsgClearAdminResponseProtoMsg;
+            };
+            MsgUpdateInstantiateConfig: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgUpdateInstantiateConfig;
+                isSDK(o: any): o is _89.MsgUpdateInstantiateConfigSDKType;
+                isAmino(o: any): o is _89.MsgUpdateInstantiateConfigAmino;
+                encode(message: _89.MsgUpdateInstantiateConfig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgUpdateInstantiateConfig;
+                fromJSON(object: any): _89.MsgUpdateInstantiateConfig;
+                toJSON(message: _89.MsgUpdateInstantiateConfig): import("..").JsonSafe<_89.MsgUpdateInstantiateConfig>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgUpdateInstantiateConfig>, I>>(object: I): _89.MsgUpdateInstantiateConfig;
+                fromAmino(object: _89.MsgUpdateInstantiateConfigAmino): _89.MsgUpdateInstantiateConfig;
+                toAmino(message: _89.MsgUpdateInstantiateConfig): _89.MsgUpdateInstantiateConfigAmino;
+                fromAminoMsg(object: _89.MsgUpdateInstantiateConfigAminoMsg): _89.MsgUpdateInstantiateConfig;
+                toAminoMsg(message: _89.MsgUpdateInstantiateConfig): _89.MsgUpdateInstantiateConfigAminoMsg;
+                fromProtoMsg(message: _89.MsgUpdateInstantiateConfigProtoMsg): _89.MsgUpdateInstantiateConfig;
+                toProto(message: _89.MsgUpdateInstantiateConfig): Uint8Array;
+                toProtoMsg(message: _89.MsgUpdateInstantiateConfig): _89.MsgUpdateInstantiateConfigProtoMsg;
+            };
+            MsgUpdateInstantiateConfigResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgUpdateInstantiateConfigResponse;
+                isSDK(o: any): o is _89.MsgUpdateInstantiateConfigResponseSDKType;
+                isAmino(o: any): o is _89.MsgUpdateInstantiateConfigResponseAmino;
+                encode(_: _89.MsgUpdateInstantiateConfigResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgUpdateInstantiateConfigResponse;
+                fromJSON(_: any): _89.MsgUpdateInstantiateConfigResponse;
+                toJSON(_: _89.MsgUpdateInstantiateConfigResponse): import("..").JsonSafe<_89.MsgUpdateInstantiateConfigResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgUpdateInstantiateConfigResponse>, I>>(_: I): _89.MsgUpdateInstantiateConfigResponse;
+                fromAmino(_: _89.MsgUpdateInstantiateConfigResponseAmino): _89.MsgUpdateInstantiateConfigResponse;
+                toAmino(_: _89.MsgUpdateInstantiateConfigResponse): _89.MsgUpdateInstantiateConfigResponseAmino;
+                fromAminoMsg(object: _89.MsgUpdateInstantiateConfigResponseAminoMsg): _89.MsgUpdateInstantiateConfigResponse;
+                toAminoMsg(message: _89.MsgUpdateInstantiateConfigResponse): _89.MsgUpdateInstantiateConfigResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgUpdateInstantiateConfigResponseProtoMsg): _89.MsgUpdateInstantiateConfigResponse;
+                toProto(message: _89.MsgUpdateInstantiateConfigResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgUpdateInstantiateConfigResponse): _89.MsgUpdateInstantiateConfigResponseProtoMsg;
+            };
+            MsgUpdateParams: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgUpdateParams;
+                isSDK(o: any): o is _89.MsgUpdateParamsSDKType;
+                isAmino(o: any): o is _89.MsgUpdateParamsAmino;
+                encode(message: _89.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgUpdateParams;
+                fromJSON(object: any): _89.MsgUpdateParams;
+                toJSON(message: _89.MsgUpdateParams): import("..").JsonSafe<_89.MsgUpdateParams>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgUpdateParams>, I>>(object: I): _89.MsgUpdateParams;
+                fromAmino(object: _89.MsgUpdateParamsAmino): _89.MsgUpdateParams;
+                toAmino(message: _89.MsgUpdateParams): _89.MsgUpdateParamsAmino;
+                fromAminoMsg(object: _89.MsgUpdateParamsAminoMsg): _89.MsgUpdateParams;
+                toAminoMsg(message: _89.MsgUpdateParams): _89.MsgUpdateParamsAminoMsg;
+                fromProtoMsg(message: _89.MsgUpdateParamsProtoMsg): _89.MsgUpdateParams;
+                toProto(message: _89.MsgUpdateParams): Uint8Array;
+                toProtoMsg(message: _89.MsgUpdateParams): _89.MsgUpdateParamsProtoMsg;
+            };
+            MsgUpdateParamsResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgUpdateParamsResponse;
+                isSDK(o: any): o is _89.MsgUpdateParamsResponseSDKType;
+                isAmino(o: any): o is _89.MsgUpdateParamsResponseAmino;
+                encode(_: _89.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgUpdateParamsResponse;
+                fromJSON(_: any): _89.MsgUpdateParamsResponse;
+                toJSON(_: _89.MsgUpdateParamsResponse): import("..").JsonSafe<_89.MsgUpdateParamsResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgUpdateParamsResponse>, I>>(_: I): _89.MsgUpdateParamsResponse;
+                fromAmino(_: _89.MsgUpdateParamsResponseAmino): _89.MsgUpdateParamsResponse;
+                toAmino(_: _89.MsgUpdateParamsResponse): _89.MsgUpdateParamsResponseAmino;
+                fromAminoMsg(object: _89.MsgUpdateParamsResponseAminoMsg): _89.MsgUpdateParamsResponse;
+                toAminoMsg(message: _89.MsgUpdateParamsResponse): _89.MsgUpdateParamsResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgUpdateParamsResponseProtoMsg): _89.MsgUpdateParamsResponse;
+                toProto(message: _89.MsgUpdateParamsResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgUpdateParamsResponse): _89.MsgUpdateParamsResponseProtoMsg;
+            };
+            MsgSudoContract: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgSudoContract;
+                isSDK(o: any): o is _89.MsgSudoContractSDKType;
+                isAmino(o: any): o is _89.MsgSudoContractAmino;
+                encode(message: _89.MsgSudoContract, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgSudoContract;
+                fromJSON(object: any): _89.MsgSudoContract;
+                toJSON(message: _89.MsgSudoContract): import("..").JsonSafe<_89.MsgSudoContract>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgSudoContract>, I>>(object: I): _89.MsgSudoContract;
+                fromAmino(object: _89.MsgSudoContractAmino): _89.MsgSudoContract;
+                toAmino(message: _89.MsgSudoContract): _89.MsgSudoContractAmino;
+                fromAminoMsg(object: _89.MsgSudoContractAminoMsg): _89.MsgSudoContract;
+                toAminoMsg(message: _89.MsgSudoContract): _89.MsgSudoContractAminoMsg;
+                fromProtoMsg(message: _89.MsgSudoContractProtoMsg): _89.MsgSudoContract;
+                toProto(message: _89.MsgSudoContract): Uint8Array;
+                toProtoMsg(message: _89.MsgSudoContract): _89.MsgSudoContractProtoMsg;
+            };
+            MsgSudoContractResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgSudoContractResponse;
+                isSDK(o: any): o is _89.MsgSudoContractResponseSDKType;
+                isAmino(o: any): o is _89.MsgSudoContractResponseAmino;
+                encode(message: _89.MsgSudoContractResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgSudoContractResponse;
+                fromJSON(object: any): _89.MsgSudoContractResponse;
+                toJSON(message: _89.MsgSudoContractResponse): import("..").JsonSafe<_89.MsgSudoContractResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgSudoContractResponse>, I>>(object: I): _89.MsgSudoContractResponse;
+                fromAmino(object: _89.MsgSudoContractResponseAmino): _89.MsgSudoContractResponse;
+                toAmino(message: _89.MsgSudoContractResponse): _89.MsgSudoContractResponseAmino;
+                fromAminoMsg(object: _89.MsgSudoContractResponseAminoMsg): _89.MsgSudoContractResponse;
+                toAminoMsg(message: _89.MsgSudoContractResponse): _89.MsgSudoContractResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgSudoContractResponseProtoMsg): _89.MsgSudoContractResponse;
+                toProto(message: _89.MsgSudoContractResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgSudoContractResponse): _89.MsgSudoContractResponseProtoMsg;
+            };
+            MsgPinCodes: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgPinCodes;
+                isSDK(o: any): o is _89.MsgPinCodesSDKType;
+                isAmino(o: any): o is _89.MsgPinCodesAmino;
+                encode(message: _89.MsgPinCodes, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgPinCodes;
+                fromJSON(object: any): _89.MsgPinCodes;
+                toJSON(message: _89.MsgPinCodes): import("..").JsonSafe<_89.MsgPinCodes>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgPinCodes>, I>>(object: I): _89.MsgPinCodes;
+                fromAmino(object: _89.MsgPinCodesAmino): _89.MsgPinCodes;
+                toAmino(message: _89.MsgPinCodes): _89.MsgPinCodesAmino;
+                fromAminoMsg(object: _89.MsgPinCodesAminoMsg): _89.MsgPinCodes;
+                toAminoMsg(message: _89.MsgPinCodes): _89.MsgPinCodesAminoMsg;
+                fromProtoMsg(message: _89.MsgPinCodesProtoMsg): _89.MsgPinCodes;
+                toProto(message: _89.MsgPinCodes): Uint8Array;
+                toProtoMsg(message: _89.MsgPinCodes): _89.MsgPinCodesProtoMsg;
+            };
+            MsgPinCodesResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgPinCodesResponse;
+                isSDK(o: any): o is _89.MsgPinCodesResponseSDKType;
+                isAmino(o: any): o is _89.MsgPinCodesResponseAmino;
+                encode(_: _89.MsgPinCodesResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgPinCodesResponse;
+                fromJSON(_: any): _89.MsgPinCodesResponse;
+                toJSON(_: _89.MsgPinCodesResponse): import("..").JsonSafe<_89.MsgPinCodesResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgPinCodesResponse>, I>>(_: I): _89.MsgPinCodesResponse;
+                fromAmino(_: _89.MsgPinCodesResponseAmino): _89.MsgPinCodesResponse;
+                toAmino(_: _89.MsgPinCodesResponse): _89.MsgPinCodesResponseAmino;
+                fromAminoMsg(object: _89.MsgPinCodesResponseAminoMsg): _89.MsgPinCodesResponse;
+                toAminoMsg(message: _89.MsgPinCodesResponse): _89.MsgPinCodesResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgPinCodesResponseProtoMsg): _89.MsgPinCodesResponse;
+                toProto(message: _89.MsgPinCodesResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgPinCodesResponse): _89.MsgPinCodesResponseProtoMsg;
+            };
+            MsgUnpinCodes: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgUnpinCodes;
+                isSDK(o: any): o is _89.MsgUnpinCodesSDKType;
+                isAmino(o: any): o is _89.MsgUnpinCodesAmino;
+                encode(message: _89.MsgUnpinCodes, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgUnpinCodes;
+                fromJSON(object: any): _89.MsgUnpinCodes;
+                toJSON(message: _89.MsgUnpinCodes): import("..").JsonSafe<_89.MsgUnpinCodes>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgUnpinCodes>, I>>(object: I): _89.MsgUnpinCodes;
+                fromAmino(object: _89.MsgUnpinCodesAmino): _89.MsgUnpinCodes;
+                toAmino(message: _89.MsgUnpinCodes): _89.MsgUnpinCodesAmino;
+                fromAminoMsg(object: _89.MsgUnpinCodesAminoMsg): _89.MsgUnpinCodes;
+                toAminoMsg(message: _89.MsgUnpinCodes): _89.MsgUnpinCodesAminoMsg;
+                fromProtoMsg(message: _89.MsgUnpinCodesProtoMsg): _89.MsgUnpinCodes;
+                toProto(message: _89.MsgUnpinCodes): Uint8Array;
+                toProtoMsg(message: _89.MsgUnpinCodes): _89.MsgUnpinCodesProtoMsg;
+            };
+            MsgUnpinCodesResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgUnpinCodesResponse;
+                isSDK(o: any): o is _89.MsgUnpinCodesResponseSDKType;
+                isAmino(o: any): o is _89.MsgUnpinCodesResponseAmino;
+                encode(_: _89.MsgUnpinCodesResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgUnpinCodesResponse;
+                fromJSON(_: any): _89.MsgUnpinCodesResponse;
+                toJSON(_: _89.MsgUnpinCodesResponse): import("..").JsonSafe<_89.MsgUnpinCodesResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgUnpinCodesResponse>, I>>(_: I): _89.MsgUnpinCodesResponse;
+                fromAmino(_: _89.MsgUnpinCodesResponseAmino): _89.MsgUnpinCodesResponse;
+                toAmino(_: _89.MsgUnpinCodesResponse): _89.MsgUnpinCodesResponseAmino;
+                fromAminoMsg(object: _89.MsgUnpinCodesResponseAminoMsg): _89.MsgUnpinCodesResponse;
+                toAminoMsg(message: _89.MsgUnpinCodesResponse): _89.MsgUnpinCodesResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgUnpinCodesResponseProtoMsg): _89.MsgUnpinCodesResponse;
+                toProto(message: _89.MsgUnpinCodesResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgUnpinCodesResponse): _89.MsgUnpinCodesResponseProtoMsg;
+            };
+            MsgStoreAndInstantiateContract: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgStoreAndInstantiateContract;
+                isSDK(o: any): o is _89.MsgStoreAndInstantiateContractSDKType;
+                isAmino(o: any): o is _89.MsgStoreAndInstantiateContractAmino;
+                encode(message: _89.MsgStoreAndInstantiateContract, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgStoreAndInstantiateContract;
+                fromJSON(object: any): _89.MsgStoreAndInstantiateContract;
+                toJSON(message: _89.MsgStoreAndInstantiateContract): import("..").JsonSafe<_89.MsgStoreAndInstantiateContract>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgStoreAndInstantiateContract>, I>>(object: I): _89.MsgStoreAndInstantiateContract;
+                fromAmino(object: _89.MsgStoreAndInstantiateContractAmino): _89.MsgStoreAndInstantiateContract;
+                toAmino(message: _89.MsgStoreAndInstantiateContract): _89.MsgStoreAndInstantiateContractAmino;
+                fromAminoMsg(object: _89.MsgStoreAndInstantiateContractAminoMsg): _89.MsgStoreAndInstantiateContract;
+                toAminoMsg(message: _89.MsgStoreAndInstantiateContract): _89.MsgStoreAndInstantiateContractAminoMsg;
+                fromProtoMsg(message: _89.MsgStoreAndInstantiateContractProtoMsg): _89.MsgStoreAndInstantiateContract;
+                toProto(message: _89.MsgStoreAndInstantiateContract): Uint8Array;
+                toProtoMsg(message: _89.MsgStoreAndInstantiateContract): _89.MsgStoreAndInstantiateContractProtoMsg;
+            };
+            MsgStoreAndInstantiateContractResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgStoreAndInstantiateContractResponse;
+                isSDK(o: any): o is _89.MsgStoreAndInstantiateContractResponseSDKType;
+                isAmino(o: any): o is _89.MsgStoreAndInstantiateContractResponseAmino;
+                encode(message: _89.MsgStoreAndInstantiateContractResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgStoreAndInstantiateContractResponse;
+                fromJSON(object: any): _89.MsgStoreAndInstantiateContractResponse;
+                toJSON(message: _89.MsgStoreAndInstantiateContractResponse): import("..").JsonSafe<_89.MsgStoreAndInstantiateContractResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgStoreAndInstantiateContractResponse>, I>>(object: I): _89.MsgStoreAndInstantiateContractResponse;
+                fromAmino(object: _89.MsgStoreAndInstantiateContractResponseAmino): _89.MsgStoreAndInstantiateContractResponse;
+                toAmino(message: _89.MsgStoreAndInstantiateContractResponse): _89.MsgStoreAndInstantiateContractResponseAmino;
+                fromAminoMsg(object: _89.MsgStoreAndInstantiateContractResponseAminoMsg): _89.MsgStoreAndInstantiateContractResponse;
+                toAminoMsg(message: _89.MsgStoreAndInstantiateContractResponse): _89.MsgStoreAndInstantiateContractResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgStoreAndInstantiateContractResponseProtoMsg): _89.MsgStoreAndInstantiateContractResponse;
+                toProto(message: _89.MsgStoreAndInstantiateContractResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgStoreAndInstantiateContractResponse): _89.MsgStoreAndInstantiateContractResponseProtoMsg;
+            };
+            MsgAddCodeUploadParamsAddresses: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgAddCodeUploadParamsAddresses;
+                isSDK(o: any): o is _89.MsgAddCodeUploadParamsAddressesSDKType;
+                isAmino(o: any): o is _89.MsgAddCodeUploadParamsAddressesAmino;
+                encode(message: _89.MsgAddCodeUploadParamsAddresses, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgAddCodeUploadParamsAddresses;
+                fromJSON(object: any): _89.MsgAddCodeUploadParamsAddresses;
+                toJSON(message: _89.MsgAddCodeUploadParamsAddresses): import("..").JsonSafe<_89.MsgAddCodeUploadParamsAddresses>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgAddCodeUploadParamsAddresses>, I>>(object: I): _89.MsgAddCodeUploadParamsAddresses;
+                fromAmino(object: _89.MsgAddCodeUploadParamsAddressesAmino): _89.MsgAddCodeUploadParamsAddresses;
+                toAmino(message: _89.MsgAddCodeUploadParamsAddresses): _89.MsgAddCodeUploadParamsAddressesAmino;
+                fromAminoMsg(object: _89.MsgAddCodeUploadParamsAddressesAminoMsg): _89.MsgAddCodeUploadParamsAddresses;
+                toAminoMsg(message: _89.MsgAddCodeUploadParamsAddresses): _89.MsgAddCodeUploadParamsAddressesAminoMsg;
+                fromProtoMsg(message: _89.MsgAddCodeUploadParamsAddressesProtoMsg): _89.MsgAddCodeUploadParamsAddresses;
+                toProto(message: _89.MsgAddCodeUploadParamsAddresses): Uint8Array;
+                toProtoMsg(message: _89.MsgAddCodeUploadParamsAddresses): _89.MsgAddCodeUploadParamsAddressesProtoMsg;
+            };
+            MsgAddCodeUploadParamsAddressesResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgAddCodeUploadParamsAddressesResponse;
+                isSDK(o: any): o is _89.MsgAddCodeUploadParamsAddressesResponseSDKType;
+                isAmino(o: any): o is _89.MsgAddCodeUploadParamsAddressesResponseAmino;
+                encode(_: _89.MsgAddCodeUploadParamsAddressesResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgAddCodeUploadParamsAddressesResponse;
+                fromJSON(_: any): _89.MsgAddCodeUploadParamsAddressesResponse;
+                toJSON(_: _89.MsgAddCodeUploadParamsAddressesResponse): import("..").JsonSafe<_89.MsgAddCodeUploadParamsAddressesResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgAddCodeUploadParamsAddressesResponse>, I>>(_: I): _89.MsgAddCodeUploadParamsAddressesResponse;
+                fromAmino(_: _89.MsgAddCodeUploadParamsAddressesResponseAmino): _89.MsgAddCodeUploadParamsAddressesResponse;
+                toAmino(_: _89.MsgAddCodeUploadParamsAddressesResponse): _89.MsgAddCodeUploadParamsAddressesResponseAmino;
+                fromAminoMsg(object: _89.MsgAddCodeUploadParamsAddressesResponseAminoMsg): _89.MsgAddCodeUploadParamsAddressesResponse;
+                toAminoMsg(message: _89.MsgAddCodeUploadParamsAddressesResponse): _89.MsgAddCodeUploadParamsAddressesResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgAddCodeUploadParamsAddressesResponseProtoMsg): _89.MsgAddCodeUploadParamsAddressesResponse;
+                toProto(message: _89.MsgAddCodeUploadParamsAddressesResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgAddCodeUploadParamsAddressesResponse): _89.MsgAddCodeUploadParamsAddressesResponseProtoMsg;
+            };
+            MsgRemoveCodeUploadParamsAddresses: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgRemoveCodeUploadParamsAddresses;
+                isSDK(o: any): o is _89.MsgRemoveCodeUploadParamsAddressesSDKType;
+                isAmino(o: any): o is _89.MsgRemoveCodeUploadParamsAddressesAmino;
+                encode(message: _89.MsgRemoveCodeUploadParamsAddresses, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgRemoveCodeUploadParamsAddresses;
+                fromJSON(object: any): _89.MsgRemoveCodeUploadParamsAddresses;
+                toJSON(message: _89.MsgRemoveCodeUploadParamsAddresses): import("..").JsonSafe<_89.MsgRemoveCodeUploadParamsAddresses>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgRemoveCodeUploadParamsAddresses>, I>>(object: I): _89.MsgRemoveCodeUploadParamsAddresses;
+                fromAmino(object: _89.MsgRemoveCodeUploadParamsAddressesAmino): _89.MsgRemoveCodeUploadParamsAddresses;
+                toAmino(message: _89.MsgRemoveCodeUploadParamsAddresses): _89.MsgRemoveCodeUploadParamsAddressesAmino;
+                fromAminoMsg(object: _89.MsgRemoveCodeUploadParamsAddressesAminoMsg): _89.MsgRemoveCodeUploadParamsAddresses;
+                toAminoMsg(message: _89.MsgRemoveCodeUploadParamsAddresses): _89.MsgRemoveCodeUploadParamsAddressesAminoMsg;
+                fromProtoMsg(message: _89.MsgRemoveCodeUploadParamsAddressesProtoMsg): _89.MsgRemoveCodeUploadParamsAddresses;
+                toProto(message: _89.MsgRemoveCodeUploadParamsAddresses): Uint8Array;
+                toProtoMsg(message: _89.MsgRemoveCodeUploadParamsAddresses): _89.MsgRemoveCodeUploadParamsAddressesProtoMsg;
+            };
+            MsgRemoveCodeUploadParamsAddressesResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgRemoveCodeUploadParamsAddressesResponse;
+                isSDK(o: any): o is _89.MsgRemoveCodeUploadParamsAddressesResponseSDKType;
+                isAmino(o: any): o is _89.MsgRemoveCodeUploadParamsAddressesResponseAmino;
+                encode(_: _89.MsgRemoveCodeUploadParamsAddressesResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgRemoveCodeUploadParamsAddressesResponse;
+                fromJSON(_: any): _89.MsgRemoveCodeUploadParamsAddressesResponse;
+                toJSON(_: _89.MsgRemoveCodeUploadParamsAddressesResponse): import("..").JsonSafe<_89.MsgRemoveCodeUploadParamsAddressesResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgRemoveCodeUploadParamsAddressesResponse>, I>>(_: I): _89.MsgRemoveCodeUploadParamsAddressesResponse;
+                fromAmino(_: _89.MsgRemoveCodeUploadParamsAddressesResponseAmino): _89.MsgRemoveCodeUploadParamsAddressesResponse;
+                toAmino(_: _89.MsgRemoveCodeUploadParamsAddressesResponse): _89.MsgRemoveCodeUploadParamsAddressesResponseAmino;
+                fromAminoMsg(object: _89.MsgRemoveCodeUploadParamsAddressesResponseAminoMsg): _89.MsgRemoveCodeUploadParamsAddressesResponse;
+                toAminoMsg(message: _89.MsgRemoveCodeUploadParamsAddressesResponse): _89.MsgRemoveCodeUploadParamsAddressesResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgRemoveCodeUploadParamsAddressesResponseProtoMsg): _89.MsgRemoveCodeUploadParamsAddressesResponse;
+                toProto(message: _89.MsgRemoveCodeUploadParamsAddressesResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgRemoveCodeUploadParamsAddressesResponse): _89.MsgRemoveCodeUploadParamsAddressesResponseProtoMsg;
+            };
+            MsgStoreAndMigrateContract: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgStoreAndMigrateContract;
+                isSDK(o: any): o is _89.MsgStoreAndMigrateContractSDKType;
+                isAmino(o: any): o is _89.MsgStoreAndMigrateContractAmino;
+                encode(message: _89.MsgStoreAndMigrateContract, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgStoreAndMigrateContract;
+                fromJSON(object: any): _89.MsgStoreAndMigrateContract;
+                toJSON(message: _89.MsgStoreAndMigrateContract): import("..").JsonSafe<_89.MsgStoreAndMigrateContract>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgStoreAndMigrateContract>, I>>(object: I): _89.MsgStoreAndMigrateContract;
+                fromAmino(object: _89.MsgStoreAndMigrateContractAmino): _89.MsgStoreAndMigrateContract;
+                toAmino(message: _89.MsgStoreAndMigrateContract): _89.MsgStoreAndMigrateContractAmino;
+                fromAminoMsg(object: _89.MsgStoreAndMigrateContractAminoMsg): _89.MsgStoreAndMigrateContract;
+                toAminoMsg(message: _89.MsgStoreAndMigrateContract): _89.MsgStoreAndMigrateContractAminoMsg;
+                fromProtoMsg(message: _89.MsgStoreAndMigrateContractProtoMsg): _89.MsgStoreAndMigrateContract;
+                toProto(message: _89.MsgStoreAndMigrateContract): Uint8Array;
+                toProtoMsg(message: _89.MsgStoreAndMigrateContract): _89.MsgStoreAndMigrateContractProtoMsg;
+            };
+            MsgStoreAndMigrateContractResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgStoreAndMigrateContractResponse;
+                isSDK(o: any): o is _89.MsgStoreAndMigrateContractResponseSDKType;
+                isAmino(o: any): o is _89.MsgStoreAndMigrateContractResponseAmino;
+                encode(message: _89.MsgStoreAndMigrateContractResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgStoreAndMigrateContractResponse;
+                fromJSON(object: any): _89.MsgStoreAndMigrateContractResponse;
+                toJSON(message: _89.MsgStoreAndMigrateContractResponse): import("..").JsonSafe<_89.MsgStoreAndMigrateContractResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgStoreAndMigrateContractResponse>, I>>(object: I): _89.MsgStoreAndMigrateContractResponse;
+                fromAmino(object: _89.MsgStoreAndMigrateContractResponseAmino): _89.MsgStoreAndMigrateContractResponse;
+                toAmino(message: _89.MsgStoreAndMigrateContractResponse): _89.MsgStoreAndMigrateContractResponseAmino;
+                fromAminoMsg(object: _89.MsgStoreAndMigrateContractResponseAminoMsg): _89.MsgStoreAndMigrateContractResponse;
+                toAminoMsg(message: _89.MsgStoreAndMigrateContractResponse): _89.MsgStoreAndMigrateContractResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgStoreAndMigrateContractResponseProtoMsg): _89.MsgStoreAndMigrateContractResponse;
+                toProto(message: _89.MsgStoreAndMigrateContractResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgStoreAndMigrateContractResponse): _89.MsgStoreAndMigrateContractResponseProtoMsg;
+            };
+            MsgUpdateContractLabel: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgUpdateContractLabel;
+                isSDK(o: any): o is _89.MsgUpdateContractLabelSDKType;
+                isAmino(o: any): o is _89.MsgUpdateContractLabelAmino;
+                encode(message: _89.MsgUpdateContractLabel, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgUpdateContractLabel;
+                fromJSON(object: any): _89.MsgUpdateContractLabel;
+                toJSON(message: _89.MsgUpdateContractLabel): import("..").JsonSafe<_89.MsgUpdateContractLabel>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgUpdateContractLabel>, I>>(object: I): _89.MsgUpdateContractLabel;
+                fromAmino(object: _89.MsgUpdateContractLabelAmino): _89.MsgUpdateContractLabel;
+                toAmino(message: _89.MsgUpdateContractLabel): _89.MsgUpdateContractLabelAmino;
+                fromAminoMsg(object: _89.MsgUpdateContractLabelAminoMsg): _89.MsgUpdateContractLabel;
+                toAminoMsg(message: _89.MsgUpdateContractLabel): _89.MsgUpdateContractLabelAminoMsg;
+                fromProtoMsg(message: _89.MsgUpdateContractLabelProtoMsg): _89.MsgUpdateContractLabel;
+                toProto(message: _89.MsgUpdateContractLabel): Uint8Array;
+                toProtoMsg(message: _89.MsgUpdateContractLabel): _89.MsgUpdateContractLabelProtoMsg;
+            };
+            MsgUpdateContractLabelResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _89.MsgUpdateContractLabelResponse;
+                isSDK(o: any): o is _89.MsgUpdateContractLabelResponseSDKType;
+                isAmino(o: any): o is _89.MsgUpdateContractLabelResponseAmino;
+                encode(_: _89.MsgUpdateContractLabelResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _89.MsgUpdateContractLabelResponse;
+                fromJSON(_: any): _89.MsgUpdateContractLabelResponse;
+                toJSON(_: _89.MsgUpdateContractLabelResponse): import("..").JsonSafe<_89.MsgUpdateContractLabelResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_89.MsgUpdateContractLabelResponse>, I>>(_: I): _89.MsgUpdateContractLabelResponse;
+                fromAmino(_: _89.MsgUpdateContractLabelResponseAmino): _89.MsgUpdateContractLabelResponse;
+                toAmino(_: _89.MsgUpdateContractLabelResponse): _89.MsgUpdateContractLabelResponseAmino;
+                fromAminoMsg(object: _89.MsgUpdateContractLabelResponseAminoMsg): _89.MsgUpdateContractLabelResponse;
+                toAminoMsg(message: _89.MsgUpdateContractLabelResponse): _89.MsgUpdateContractLabelResponseAminoMsg;
+                fromProtoMsg(message: _89.MsgUpdateContractLabelResponseProtoMsg): _89.MsgUpdateContractLabelResponse;
+                toProto(message: _89.MsgUpdateContractLabelResponse): Uint8Array;
+                toProtoMsg(message: _89.MsgUpdateContractLabelResponse): _89.MsgUpdateContractLabelResponseProtoMsg;
+            };
+            QueryContractInfoRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryContractInfoRequest;
+                isSDK(o: any): o is _88.QueryContractInfoRequestSDKType;
+                isAmino(o: any): o is _88.QueryContractInfoRequestAmino;
+                encode(message: _88.QueryContractInfoRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryContractInfoRequest;
+                fromJSON(object: any): _88.QueryContractInfoRequest;
+                toJSON(message: _88.QueryContractInfoRequest): import("..").JsonSafe<_88.QueryContractInfoRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryContractInfoRequest>, I>>(object: I): _88.QueryContractInfoRequest;
+                fromAmino(object: _88.QueryContractInfoRequestAmino): _88.QueryContractInfoRequest;
+                toAmino(message: _88.QueryContractInfoRequest): _88.QueryContractInfoRequestAmino;
+                fromAminoMsg(object: _88.QueryContractInfoRequestAminoMsg): _88.QueryContractInfoRequest;
+                toAminoMsg(message: _88.QueryContractInfoRequest): _88.QueryContractInfoRequestAminoMsg;
+                fromProtoMsg(message: _88.QueryContractInfoRequestProtoMsg): _88.QueryContractInfoRequest;
+                toProto(message: _88.QueryContractInfoRequest): Uint8Array;
+                toProtoMsg(message: _88.QueryContractInfoRequest): _88.QueryContractInfoRequestProtoMsg;
+            };
+            QueryContractInfoResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryContractInfoResponse;
+                isSDK(o: any): o is _88.QueryContractInfoResponseSDKType;
+                isAmino(o: any): o is _88.QueryContractInfoResponseAmino;
+                encode(message: _88.QueryContractInfoResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryContractInfoResponse;
+                fromJSON(object: any): _88.QueryContractInfoResponse;
+                toJSON(message: _88.QueryContractInfoResponse): import("..").JsonSafe<_88.QueryContractInfoResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryContractInfoResponse>, I>>(object: I): _88.QueryContractInfoResponse;
+                fromAmino(object: _88.QueryContractInfoResponseAmino): _88.QueryContractInfoResponse;
+                toAmino(message: _88.QueryContractInfoResponse): _88.QueryContractInfoResponseAmino;
+                fromAminoMsg(object: _88.QueryContractInfoResponseAminoMsg): _88.QueryContractInfoResponse;
+                toAminoMsg(message: _88.QueryContractInfoResponse): _88.QueryContractInfoResponseAminoMsg;
+                fromProtoMsg(message: _88.QueryContractInfoResponseProtoMsg): _88.QueryContractInfoResponse;
+                toProto(message: _88.QueryContractInfoResponse): Uint8Array;
+                toProtoMsg(message: _88.QueryContractInfoResponse): _88.QueryContractInfoResponseProtoMsg;
+            };
+            QueryContractHistoryRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryContractHistoryRequest;
+                isSDK(o: any): o is _88.QueryContractHistoryRequestSDKType;
+                isAmino(o: any): o is _88.QueryContractHistoryRequestAmino;
+                encode(message: _88.QueryContractHistoryRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryContractHistoryRequest;
+                fromJSON(object: any): _88.QueryContractHistoryRequest;
+                toJSON(message: _88.QueryContractHistoryRequest): import("..").JsonSafe<_88.QueryContractHistoryRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryContractHistoryRequest>, I>>(object: I): _88.QueryContractHistoryRequest;
+                fromAmino(object: _88.QueryContractHistoryRequestAmino): _88.QueryContractHistoryRequest;
+                toAmino(message: _88.QueryContractHistoryRequest): _88.QueryContractHistoryRequestAmino;
+                fromAminoMsg(object: _88.QueryContractHistoryRequestAminoMsg): _88.QueryContractHistoryRequest;
+                toAminoMsg(message: _88.QueryContractHistoryRequest): _88.QueryContractHistoryRequestAminoMsg;
+                fromProtoMsg(message: _88.QueryContractHistoryRequestProtoMsg): _88.QueryContractHistoryRequest;
+                toProto(message: _88.QueryContractHistoryRequest): Uint8Array;
+                toProtoMsg(message: _88.QueryContractHistoryRequest): _88.QueryContractHistoryRequestProtoMsg;
+            };
+            QueryContractHistoryResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryContractHistoryResponse;
+                isSDK(o: any): o is _88.QueryContractHistoryResponseSDKType;
+                isAmino(o: any): o is _88.QueryContractHistoryResponseAmino;
+                encode(message: _88.QueryContractHistoryResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryContractHistoryResponse;
+                fromJSON(object: any): _88.QueryContractHistoryResponse;
+                toJSON(message: _88.QueryContractHistoryResponse): import("..").JsonSafe<_88.QueryContractHistoryResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryContractHistoryResponse>, I>>(object: I): _88.QueryContractHistoryResponse;
+                fromAmino(object: _88.QueryContractHistoryResponseAmino): _88.QueryContractHistoryResponse;
+                toAmino(message: _88.QueryContractHistoryResponse): _88.QueryContractHistoryResponseAmino;
+                fromAminoMsg(object: _88.QueryContractHistoryResponseAminoMsg): _88.QueryContractHistoryResponse;
+                toAminoMsg(message: _88.QueryContractHistoryResponse): _88.QueryContractHistoryResponseAminoMsg;
+                fromProtoMsg(message: _88.QueryContractHistoryResponseProtoMsg): _88.QueryContractHistoryResponse;
+                toProto(message: _88.QueryContractHistoryResponse): Uint8Array;
+                toProtoMsg(message: _88.QueryContractHistoryResponse): _88.QueryContractHistoryResponseProtoMsg;
+            };
+            QueryContractsByCodeRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryContractsByCodeRequest;
+                isSDK(o: any): o is _88.QueryContractsByCodeRequestSDKType;
+                isAmino(o: any): o is _88.QueryContractsByCodeRequestAmino;
+                encode(message: _88.QueryContractsByCodeRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryContractsByCodeRequest;
+                fromJSON(object: any): _88.QueryContractsByCodeRequest;
+                toJSON(message: _88.QueryContractsByCodeRequest): import("..").JsonSafe<_88.QueryContractsByCodeRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryContractsByCodeRequest>, I>>(object: I): _88.QueryContractsByCodeRequest;
+                fromAmino(object: _88.QueryContractsByCodeRequestAmino): _88.QueryContractsByCodeRequest;
+                toAmino(message: _88.QueryContractsByCodeRequest): _88.QueryContractsByCodeRequestAmino;
+                fromAminoMsg(object: _88.QueryContractsByCodeRequestAminoMsg): _88.QueryContractsByCodeRequest;
+                toAminoMsg(message: _88.QueryContractsByCodeRequest): _88.QueryContractsByCodeRequestAminoMsg;
+                fromProtoMsg(message: _88.QueryContractsByCodeRequestProtoMsg): _88.QueryContractsByCodeRequest;
+                toProto(message: _88.QueryContractsByCodeRequest): Uint8Array;
+                toProtoMsg(message: _88.QueryContractsByCodeRequest): _88.QueryContractsByCodeRequestProtoMsg;
+            };
+            QueryContractsByCodeResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryContractsByCodeResponse;
+                isSDK(o: any): o is _88.QueryContractsByCodeResponseSDKType;
+                isAmino(o: any): o is _88.QueryContractsByCodeResponseAmino;
+                encode(message: _88.QueryContractsByCodeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryContractsByCodeResponse;
+                fromJSON(object: any): _88.QueryContractsByCodeResponse;
+                toJSON(message: _88.QueryContractsByCodeResponse): import("..").JsonSafe<_88.QueryContractsByCodeResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryContractsByCodeResponse>, I>>(object: I): _88.QueryContractsByCodeResponse;
+                fromAmino(object: _88.QueryContractsByCodeResponseAmino): _88.QueryContractsByCodeResponse;
+                toAmino(message: _88.QueryContractsByCodeResponse): _88.QueryContractsByCodeResponseAmino;
+                fromAminoMsg(object: _88.QueryContractsByCodeResponseAminoMsg): _88.QueryContractsByCodeResponse;
+                toAminoMsg(message: _88.QueryContractsByCodeResponse): _88.QueryContractsByCodeResponseAminoMsg;
+                fromProtoMsg(message: _88.QueryContractsByCodeResponseProtoMsg): _88.QueryContractsByCodeResponse;
+                toProto(message: _88.QueryContractsByCodeResponse): Uint8Array;
+                toProtoMsg(message: _88.QueryContractsByCodeResponse): _88.QueryContractsByCodeResponseProtoMsg;
+            };
+            QueryAllContractStateRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryAllContractStateRequest;
+                isSDK(o: any): o is _88.QueryAllContractStateRequestSDKType;
+                isAmino(o: any): o is _88.QueryAllContractStateRequestAmino;
+                encode(message: _88.QueryAllContractStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryAllContractStateRequest;
+                fromJSON(object: any): _88.QueryAllContractStateRequest;
+                toJSON(message: _88.QueryAllContractStateRequest): import("..").JsonSafe<_88.QueryAllContractStateRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryAllContractStateRequest>, I>>(object: I): _88.QueryAllContractStateRequest;
+                fromAmino(object: _88.QueryAllContractStateRequestAmino): _88.QueryAllContractStateRequest;
+                toAmino(message: _88.QueryAllContractStateRequest): _88.QueryAllContractStateRequestAmino;
+                fromAminoMsg(object: _88.QueryAllContractStateRequestAminoMsg): _88.QueryAllContractStateRequest;
+                toAminoMsg(message: _88.QueryAllContractStateRequest): _88.QueryAllContractStateRequestAminoMsg;
+                fromProtoMsg(message: _88.QueryAllContractStateRequestProtoMsg): _88.QueryAllContractStateRequest;
+                toProto(message: _88.QueryAllContractStateRequest): Uint8Array;
+                toProtoMsg(message: _88.QueryAllContractStateRequest): _88.QueryAllContractStateRequestProtoMsg;
+            };
+            QueryAllContractStateResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryAllContractStateResponse;
+                isSDK(o: any): o is _88.QueryAllContractStateResponseSDKType;
+                isAmino(o: any): o is _88.QueryAllContractStateResponseAmino;
+                encode(message: _88.QueryAllContractStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryAllContractStateResponse;
+                fromJSON(object: any): _88.QueryAllContractStateResponse;
+                toJSON(message: _88.QueryAllContractStateResponse): import("..").JsonSafe<_88.QueryAllContractStateResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryAllContractStateResponse>, I>>(object: I): _88.QueryAllContractStateResponse;
+                fromAmino(object: _88.QueryAllContractStateResponseAmino): _88.QueryAllContractStateResponse;
+                toAmino(message: _88.QueryAllContractStateResponse): _88.QueryAllContractStateResponseAmino;
+                fromAminoMsg(object: _88.QueryAllContractStateResponseAminoMsg): _88.QueryAllContractStateResponse;
+                toAminoMsg(message: _88.QueryAllContractStateResponse): _88.QueryAllContractStateResponseAminoMsg;
+                fromProtoMsg(message: _88.QueryAllContractStateResponseProtoMsg): _88.QueryAllContractStateResponse;
+                toProto(message: _88.QueryAllContractStateResponse): Uint8Array;
+                toProtoMsg(message: _88.QueryAllContractStateResponse): _88.QueryAllContractStateResponseProtoMsg;
+            };
+            QueryRawContractStateRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryRawContractStateRequest;
+                isSDK(o: any): o is _88.QueryRawContractStateRequestSDKType;
+                isAmino(o: any): o is _88.QueryRawContractStateRequestAmino;
+                encode(message: _88.QueryRawContractStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryRawContractStateRequest;
+                fromJSON(object: any): _88.QueryRawContractStateRequest;
+                toJSON(message: _88.QueryRawContractStateRequest): import("..").JsonSafe<_88.QueryRawContractStateRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryRawContractStateRequest>, I>>(object: I): _88.QueryRawContractStateRequest;
+                fromAmino(object: _88.QueryRawContractStateRequestAmino): _88.QueryRawContractStateRequest;
+                toAmino(message: _88.QueryRawContractStateRequest): _88.QueryRawContractStateRequestAmino;
+                fromAminoMsg(object: _88.QueryRawContractStateRequestAminoMsg): _88.QueryRawContractStateRequest;
+                toAminoMsg(message: _88.QueryRawContractStateRequest): _88.QueryRawContractStateRequestAminoMsg;
+                fromProtoMsg(message: _88.QueryRawContractStateRequestProtoMsg): _88.QueryRawContractStateRequest;
+                toProto(message: _88.QueryRawContractStateRequest): Uint8Array;
+                toProtoMsg(message: _88.QueryRawContractStateRequest): _88.QueryRawContractStateRequestProtoMsg;
+            };
+            QueryRawContractStateResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryRawContractStateResponse;
+                isSDK(o: any): o is _88.QueryRawContractStateResponseSDKType;
+                isAmino(o: any): o is _88.QueryRawContractStateResponseAmino;
+                encode(message: _88.QueryRawContractStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryRawContractStateResponse;
+                fromJSON(object: any): _88.QueryRawContractStateResponse;
+                toJSON(message: _88.QueryRawContractStateResponse): import("..").JsonSafe<_88.QueryRawContractStateResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryRawContractStateResponse>, I>>(object: I): _88.QueryRawContractStateResponse;
+                fromAmino(object: _88.QueryRawContractStateResponseAmino): _88.QueryRawContractStateResponse;
+                toAmino(message: _88.QueryRawContractStateResponse): _88.QueryRawContractStateResponseAmino;
+                fromAminoMsg(object: _88.QueryRawContractStateResponseAminoMsg): _88.QueryRawContractStateResponse;
+                toAminoMsg(message: _88.QueryRawContractStateResponse): _88.QueryRawContractStateResponseAminoMsg;
+                fromProtoMsg(message: _88.QueryRawContractStateResponseProtoMsg): _88.QueryRawContractStateResponse;
+                toProto(message: _88.QueryRawContractStateResponse): Uint8Array;
+                toProtoMsg(message: _88.QueryRawContractStateResponse): _88.QueryRawContractStateResponseProtoMsg;
+            };
+            QuerySmartContractStateRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QuerySmartContractStateRequest;
+                isSDK(o: any): o is _88.QuerySmartContractStateRequestSDKType;
+                isAmino(o: any): o is _88.QuerySmartContractStateRequestAmino;
+                encode(message: _88.QuerySmartContractStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QuerySmartContractStateRequest;
+                fromJSON(object: any): _88.QuerySmartContractStateRequest;
+                toJSON(message: _88.QuerySmartContractStateRequest): import("..").JsonSafe<_88.QuerySmartContractStateRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QuerySmartContractStateRequest>, I>>(object: I): _88.QuerySmartContractStateRequest;
+                fromAmino(object: _88.QuerySmartContractStateRequestAmino): _88.QuerySmartContractStateRequest;
+                toAmino(message: _88.QuerySmartContractStateRequest): _88.QuerySmartContractStateRequestAmino;
+                fromAminoMsg(object: _88.QuerySmartContractStateRequestAminoMsg): _88.QuerySmartContractStateRequest;
+                toAminoMsg(message: _88.QuerySmartContractStateRequest): _88.QuerySmartContractStateRequestAminoMsg;
+                fromProtoMsg(message: _88.QuerySmartContractStateRequestProtoMsg): _88.QuerySmartContractStateRequest;
+                toProto(message: _88.QuerySmartContractStateRequest): Uint8Array;
+                toProtoMsg(message: _88.QuerySmartContractStateRequest): _88.QuerySmartContractStateRequestProtoMsg;
+            };
+            QuerySmartContractStateResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QuerySmartContractStateResponse;
+                isSDK(o: any): o is _88.QuerySmartContractStateResponseSDKType;
+                isAmino(o: any): o is _88.QuerySmartContractStateResponseAmino;
+                encode(message: _88.QuerySmartContractStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QuerySmartContractStateResponse;
+                fromJSON(object: any): _88.QuerySmartContractStateResponse;
+                toJSON(message: _88.QuerySmartContractStateResponse): import("..").JsonSafe<_88.QuerySmartContractStateResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QuerySmartContractStateResponse>, I>>(object: I): _88.QuerySmartContractStateResponse;
+                fromAmino(object: _88.QuerySmartContractStateResponseAmino): _88.QuerySmartContractStateResponse;
+                toAmino(message: _88.QuerySmartContractStateResponse): _88.QuerySmartContractStateResponseAmino;
+                fromAminoMsg(object: _88.QuerySmartContractStateResponseAminoMsg): _88.QuerySmartContractStateResponse;
+                toAminoMsg(message: _88.QuerySmartContractStateResponse): _88.QuerySmartContractStateResponseAminoMsg;
+                fromProtoMsg(message: _88.QuerySmartContractStateResponseProtoMsg): _88.QuerySmartContractStateResponse;
+                toProto(message: _88.QuerySmartContractStateResponse): Uint8Array;
+                toProtoMsg(message: _88.QuerySmartContractStateResponse): _88.QuerySmartContractStateResponseProtoMsg;
+            };
+            QueryCodeRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryCodeRequest;
+                isSDK(o: any): o is _88.QueryCodeRequestSDKType;
+                isAmino(o: any): o is _88.QueryCodeRequestAmino;
+                encode(message: _88.QueryCodeRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryCodeRequest;
+                fromJSON(object: any): _88.QueryCodeRequest;
+                toJSON(message: _88.QueryCodeRequest): import("..").JsonSafe<_88.QueryCodeRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryCodeRequest>, I>>(object: I): _88.QueryCodeRequest;
+                fromAmino(object: _88.QueryCodeRequestAmino): _88.QueryCodeRequest;
+                toAmino(message: _88.QueryCodeRequest): _88.QueryCodeRequestAmino;
+                fromAminoMsg(object: _88.QueryCodeRequestAminoMsg): _88.QueryCodeRequest;
+                toAminoMsg(message: _88.QueryCodeRequest): _88.QueryCodeRequestAminoMsg;
+                fromProtoMsg(message: _88.QueryCodeRequestProtoMsg): _88.QueryCodeRequest;
+                toProto(message: _88.QueryCodeRequest): Uint8Array;
+                toProtoMsg(message: _88.QueryCodeRequest): _88.QueryCodeRequestProtoMsg;
+            };
+            QueryCodeInfoRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryCodeInfoRequest;
+                isSDK(o: any): o is _88.QueryCodeInfoRequestSDKType;
+                isAmino(o: any): o is _88.QueryCodeInfoRequestAmino;
+                encode(message: _88.QueryCodeInfoRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryCodeInfoRequest;
+                fromJSON(object: any): _88.QueryCodeInfoRequest;
+                toJSON(message: _88.QueryCodeInfoRequest): import("..").JsonSafe<_88.QueryCodeInfoRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryCodeInfoRequest>, I>>(object: I): _88.QueryCodeInfoRequest;
+                fromAmino(object: _88.QueryCodeInfoRequestAmino): _88.QueryCodeInfoRequest;
+                toAmino(message: _88.QueryCodeInfoRequest): _88.QueryCodeInfoRequestAmino;
+                fromAminoMsg(object: _88.QueryCodeInfoRequestAminoMsg): _88.QueryCodeInfoRequest;
+                toAminoMsg(message: _88.QueryCodeInfoRequest): _88.QueryCodeInfoRequestAminoMsg;
+                fromProtoMsg(message: _88.QueryCodeInfoRequestProtoMsg): _88.QueryCodeInfoRequest;
+                toProto(message: _88.QueryCodeInfoRequest): Uint8Array;
+                toProtoMsg(message: _88.QueryCodeInfoRequest): _88.QueryCodeInfoRequestProtoMsg;
+            };
+            QueryCodeInfoResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryCodeInfoResponse;
+                isSDK(o: any): o is _88.QueryCodeInfoResponseSDKType;
+                isAmino(o: any): o is _88.QueryCodeInfoResponseAmino;
+                encode(message: _88.QueryCodeInfoResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryCodeInfoResponse;
+                fromJSON(object: any): _88.QueryCodeInfoResponse;
+                toJSON(message: _88.QueryCodeInfoResponse): import("..").JsonSafe<_88.QueryCodeInfoResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryCodeInfoResponse>, I>>(object: I): _88.QueryCodeInfoResponse;
+                fromAmino(object: _88.QueryCodeInfoResponseAmino): _88.QueryCodeInfoResponse;
+                toAmino(message: _88.QueryCodeInfoResponse): _88.QueryCodeInfoResponseAmino;
+                fromAminoMsg(object: _88.QueryCodeInfoResponseAminoMsg): _88.QueryCodeInfoResponse;
+                toAminoMsg(message: _88.QueryCodeInfoResponse): _88.QueryCodeInfoResponseAminoMsg;
+                fromProtoMsg(message: _88.QueryCodeInfoResponseProtoMsg): _88.QueryCodeInfoResponse;
+                toProto(message: _88.QueryCodeInfoResponse): Uint8Array;
+                toProtoMsg(message: _88.QueryCodeInfoResponse): _88.QueryCodeInfoResponseProtoMsg;
+            };
+            CodeInfoResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.CodeInfoResponse;
+                isSDK(o: any): o is _88.CodeInfoResponseSDKType;
+                isAmino(o: any): o is _88.CodeInfoResponseAmino;
+                encode(message: _88.CodeInfoResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.CodeInfoResponse;
+                fromJSON(object: any): _88.CodeInfoResponse;
+                toJSON(message: _88.CodeInfoResponse): import("..").JsonSafe<_88.CodeInfoResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.CodeInfoResponse>, I>>(object: I): _88.CodeInfoResponse;
+                fromAmino(object: _88.CodeInfoResponseAmino): _88.CodeInfoResponse;
+                toAmino(message: _88.CodeInfoResponse): _88.CodeInfoResponseAmino;
+                fromAminoMsg(object: _88.CodeInfoResponseAminoMsg): _88.CodeInfoResponse;
+                toAminoMsg(message: _88.CodeInfoResponse): _88.CodeInfoResponseAminoMsg;
+                fromProtoMsg(message: _88.CodeInfoResponseProtoMsg): _88.CodeInfoResponse;
+                toProto(message: _88.CodeInfoResponse): Uint8Array;
+                toProtoMsg(message: _88.CodeInfoResponse): _88.CodeInfoResponseProtoMsg;
+            };
+            QueryCodeResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryCodeResponse;
+                isSDK(o: any): o is _88.QueryCodeResponseSDKType;
+                isAmino(o: any): o is _88.QueryCodeResponseAmino;
+                encode(message: _88.QueryCodeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryCodeResponse;
+                fromJSON(object: any): _88.QueryCodeResponse;
+                toJSON(message: _88.QueryCodeResponse): import("..").JsonSafe<_88.QueryCodeResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryCodeResponse>, I>>(object: I): _88.QueryCodeResponse;
+                fromAmino(object: _88.QueryCodeResponseAmino): _88.QueryCodeResponse;
+                toAmino(message: _88.QueryCodeResponse): _88.QueryCodeResponseAmino;
+                fromAminoMsg(object: _88.QueryCodeResponseAminoMsg): _88.QueryCodeResponse;
+                toAminoMsg(message: _88.QueryCodeResponse): _88.QueryCodeResponseAminoMsg;
+                fromProtoMsg(message: _88.QueryCodeResponseProtoMsg): _88.QueryCodeResponse;
+                toProto(message: _88.QueryCodeResponse): Uint8Array;
+                toProtoMsg(message: _88.QueryCodeResponse): _88.QueryCodeResponseProtoMsg;
+            };
+            QueryCodesRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryCodesRequest;
+                isSDK(o: any): o is _88.QueryCodesRequestSDKType;
+                isAmino(o: any): o is _88.QueryCodesRequestAmino;
+                encode(message: _88.QueryCodesRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryCodesRequest;
+                fromJSON(object: any): _88.QueryCodesRequest;
+                toJSON(message: _88.QueryCodesRequest): import("..").JsonSafe<_88.QueryCodesRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryCodesRequest>, I>>(object: I): _88.QueryCodesRequest;
+                fromAmino(object: _88.QueryCodesRequestAmino): _88.QueryCodesRequest;
+                toAmino(message: _88.QueryCodesRequest): _88.QueryCodesRequestAmino;
+                fromAminoMsg(object: _88.QueryCodesRequestAminoMsg): _88.QueryCodesRequest;
+                toAminoMsg(message: _88.QueryCodesRequest): _88.QueryCodesRequestAminoMsg;
+                fromProtoMsg(message: _88.QueryCodesRequestProtoMsg): _88.QueryCodesRequest;
+                toProto(message: _88.QueryCodesRequest): Uint8Array;
+                toProtoMsg(message: _88.QueryCodesRequest): _88.QueryCodesRequestProtoMsg;
+            };
+            QueryCodesResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryCodesResponse;
+                isSDK(o: any): o is _88.QueryCodesResponseSDKType;
+                isAmino(o: any): o is _88.QueryCodesResponseAmino;
+                encode(message: _88.QueryCodesResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryCodesResponse;
+                fromJSON(object: any): _88.QueryCodesResponse;
+                toJSON(message: _88.QueryCodesResponse): import("..").JsonSafe<_88.QueryCodesResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryCodesResponse>, I>>(object: I): _88.QueryCodesResponse;
+                fromAmino(object: _88.QueryCodesResponseAmino): _88.QueryCodesResponse;
+                toAmino(message: _88.QueryCodesResponse): _88.QueryCodesResponseAmino;
+                fromAminoMsg(object: _88.QueryCodesResponseAminoMsg): _88.QueryCodesResponse;
+                toAminoMsg(message: _88.QueryCodesResponse): _88.QueryCodesResponseAminoMsg;
+                fromProtoMsg(message: _88.QueryCodesResponseProtoMsg): _88.QueryCodesResponse;
+                toProto(message: _88.QueryCodesResponse): Uint8Array;
+                toProtoMsg(message: _88.QueryCodesResponse): _88.QueryCodesResponseProtoMsg;
+            };
+            QueryPinnedCodesRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryPinnedCodesRequest;
+                isSDK(o: any): o is _88.QueryPinnedCodesRequestSDKType;
+                isAmino(o: any): o is _88.QueryPinnedCodesRequestAmino;
+                encode(message: _88.QueryPinnedCodesRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryPinnedCodesRequest;
+                fromJSON(object: any): _88.QueryPinnedCodesRequest;
+                toJSON(message: _88.QueryPinnedCodesRequest): import("..").JsonSafe<_88.QueryPinnedCodesRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryPinnedCodesRequest>, I>>(object: I): _88.QueryPinnedCodesRequest;
+                fromAmino(object: _88.QueryPinnedCodesRequestAmino): _88.QueryPinnedCodesRequest;
+                toAmino(message: _88.QueryPinnedCodesRequest): _88.QueryPinnedCodesRequestAmino;
+                fromAminoMsg(object: _88.QueryPinnedCodesRequestAminoMsg): _88.QueryPinnedCodesRequest;
+                toAminoMsg(message: _88.QueryPinnedCodesRequest): _88.QueryPinnedCodesRequestAminoMsg;
+                fromProtoMsg(message: _88.QueryPinnedCodesRequestProtoMsg): _88.QueryPinnedCodesRequest;
+                toProto(message: _88.QueryPinnedCodesRequest): Uint8Array;
+                toProtoMsg(message: _88.QueryPinnedCodesRequest): _88.QueryPinnedCodesRequestProtoMsg;
+            };
+            QueryPinnedCodesResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryPinnedCodesResponse;
+                isSDK(o: any): o is _88.QueryPinnedCodesResponseSDKType;
+                isAmino(o: any): o is _88.QueryPinnedCodesResponseAmino;
+                encode(message: _88.QueryPinnedCodesResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryPinnedCodesResponse;
+                fromJSON(object: any): _88.QueryPinnedCodesResponse;
+                toJSON(message: _88.QueryPinnedCodesResponse): import("..").JsonSafe<_88.QueryPinnedCodesResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryPinnedCodesResponse>, I>>(object: I): _88.QueryPinnedCodesResponse;
+                fromAmino(object: _88.QueryPinnedCodesResponseAmino): _88.QueryPinnedCodesResponse;
+                toAmino(message: _88.QueryPinnedCodesResponse): _88.QueryPinnedCodesResponseAmino;
+                fromAminoMsg(object: _88.QueryPinnedCodesResponseAminoMsg): _88.QueryPinnedCodesResponse;
+                toAminoMsg(message: _88.QueryPinnedCodesResponse): _88.QueryPinnedCodesResponseAminoMsg;
+                fromProtoMsg(message: _88.QueryPinnedCodesResponseProtoMsg): _88.QueryPinnedCodesResponse;
+                toProto(message: _88.QueryPinnedCodesResponse): Uint8Array;
+                toProtoMsg(message: _88.QueryPinnedCodesResponse): _88.QueryPinnedCodesResponseProtoMsg;
+            };
+            QueryParamsRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryParamsRequest;
+                isSDK(o: any): o is _88.QueryParamsRequestSDKType;
+                isAmino(o: any): o is _88.QueryParamsRequestAmino;
+                encode(_: _88.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryParamsRequest;
+                fromJSON(_: any): _88.QueryParamsRequest;
+                toJSON(_: _88.QueryParamsRequest): import("..").JsonSafe<_88.QueryParamsRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryParamsRequest>, I>>(_: I): _88.QueryParamsRequest;
+                fromAmino(_: _88.QueryParamsRequestAmino): _88.QueryParamsRequest;
+                toAmino(_: _88.QueryParamsRequest): _88.QueryParamsRequestAmino;
+                fromAminoMsg(object: _88.QueryParamsRequestAminoMsg): _88.QueryParamsRequest;
+                toAminoMsg(message: _88.QueryParamsRequest): _88.QueryParamsRequestAminoMsg;
+                fromProtoMsg(message: _88.QueryParamsRequestProtoMsg): _88.QueryParamsRequest;
+                toProto(message: _88.QueryParamsRequest): Uint8Array;
+                toProtoMsg(message: _88.QueryParamsRequest): _88.QueryParamsRequestProtoMsg;
+            };
+            QueryParamsResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryParamsResponse;
+                isSDK(o: any): o is _88.QueryParamsResponseSDKType;
+                isAmino(o: any): o is _88.QueryParamsResponseAmino;
+                encode(message: _88.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryParamsResponse;
+                fromJSON(object: any): _88.QueryParamsResponse;
+                toJSON(message: _88.QueryParamsResponse): import("..").JsonSafe<_88.QueryParamsResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryParamsResponse>, I>>(object: I): _88.QueryParamsResponse;
+                fromAmino(object: _88.QueryParamsResponseAmino): _88.QueryParamsResponse;
+                toAmino(message: _88.QueryParamsResponse): _88.QueryParamsResponseAmino;
+                fromAminoMsg(object: _88.QueryParamsResponseAminoMsg): _88.QueryParamsResponse;
+                toAminoMsg(message: _88.QueryParamsResponse): _88.QueryParamsResponseAminoMsg;
+                fromProtoMsg(message: _88.QueryParamsResponseProtoMsg): _88.QueryParamsResponse;
+                toProto(message: _88.QueryParamsResponse): Uint8Array;
+                toProtoMsg(message: _88.QueryParamsResponse): _88.QueryParamsResponseProtoMsg;
+            };
+            QueryContractsByCreatorRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryContractsByCreatorRequest;
+                isSDK(o: any): o is _88.QueryContractsByCreatorRequestSDKType;
+                isAmino(o: any): o is _88.QueryContractsByCreatorRequestAmino;
+                encode(message: _88.QueryContractsByCreatorRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryContractsByCreatorRequest;
+                fromJSON(object: any): _88.QueryContractsByCreatorRequest;
+                toJSON(message: _88.QueryContractsByCreatorRequest): import("..").JsonSafe<_88.QueryContractsByCreatorRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryContractsByCreatorRequest>, I>>(object: I): _88.QueryContractsByCreatorRequest;
+                fromAmino(object: _88.QueryContractsByCreatorRequestAmino): _88.QueryContractsByCreatorRequest;
+                toAmino(message: _88.QueryContractsByCreatorRequest): _88.QueryContractsByCreatorRequestAmino;
+                fromAminoMsg(object: _88.QueryContractsByCreatorRequestAminoMsg): _88.QueryContractsByCreatorRequest;
+                toAminoMsg(message: _88.QueryContractsByCreatorRequest): _88.QueryContractsByCreatorRequestAminoMsg;
+                fromProtoMsg(message: _88.QueryContractsByCreatorRequestProtoMsg): _88.QueryContractsByCreatorRequest;
+                toProto(message: _88.QueryContractsByCreatorRequest): Uint8Array;
+                toProtoMsg(message: _88.QueryContractsByCreatorRequest): _88.QueryContractsByCreatorRequestProtoMsg;
+            };
+            QueryContractsByCreatorResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryContractsByCreatorResponse;
+                isSDK(o: any): o is _88.QueryContractsByCreatorResponseSDKType;
+                isAmino(o: any): o is _88.QueryContractsByCreatorResponseAmino;
+                encode(message: _88.QueryContractsByCreatorResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryContractsByCreatorResponse;
+                fromJSON(object: any): _88.QueryContractsByCreatorResponse;
+                toJSON(message: _88.QueryContractsByCreatorResponse): import("..").JsonSafe<_88.QueryContractsByCreatorResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryContractsByCreatorResponse>, I>>(object: I): _88.QueryContractsByCreatorResponse;
+                fromAmino(object: _88.QueryContractsByCreatorResponseAmino): _88.QueryContractsByCreatorResponse;
+                toAmino(message: _88.QueryContractsByCreatorResponse): _88.QueryContractsByCreatorResponseAmino;
+                fromAminoMsg(object: _88.QueryContractsByCreatorResponseAminoMsg): _88.QueryContractsByCreatorResponse;
+                toAminoMsg(message: _88.QueryContractsByCreatorResponse): _88.QueryContractsByCreatorResponseAminoMsg;
+                fromProtoMsg(message: _88.QueryContractsByCreatorResponseProtoMsg): _88.QueryContractsByCreatorResponse;
+                toProto(message: _88.QueryContractsByCreatorResponse): Uint8Array;
+                toProtoMsg(message: _88.QueryContractsByCreatorResponse): _88.QueryContractsByCreatorResponseProtoMsg;
+            };
+            QueryWasmLimitsConfigRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryWasmLimitsConfigRequest;
+                isSDK(o: any): o is _88.QueryWasmLimitsConfigRequestSDKType;
+                isAmino(o: any): o is _88.QueryWasmLimitsConfigRequestAmino;
+                encode(_: _88.QueryWasmLimitsConfigRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryWasmLimitsConfigRequest;
+                fromJSON(_: any): _88.QueryWasmLimitsConfigRequest;
+                toJSON(_: _88.QueryWasmLimitsConfigRequest): import("..").JsonSafe<_88.QueryWasmLimitsConfigRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryWasmLimitsConfigRequest>, I>>(_: I): _88.QueryWasmLimitsConfigRequest;
+                fromAmino(_: _88.QueryWasmLimitsConfigRequestAmino): _88.QueryWasmLimitsConfigRequest;
+                toAmino(_: _88.QueryWasmLimitsConfigRequest): _88.QueryWasmLimitsConfigRequestAmino;
+                fromAminoMsg(object: _88.QueryWasmLimitsConfigRequestAminoMsg): _88.QueryWasmLimitsConfigRequest;
+                toAminoMsg(message: _88.QueryWasmLimitsConfigRequest): _88.QueryWasmLimitsConfigRequestAminoMsg;
+                fromProtoMsg(message: _88.QueryWasmLimitsConfigRequestProtoMsg): _88.QueryWasmLimitsConfigRequest;
+                toProto(message: _88.QueryWasmLimitsConfigRequest): Uint8Array;
+                toProtoMsg(message: _88.QueryWasmLimitsConfigRequest): _88.QueryWasmLimitsConfigRequestProtoMsg;
+            };
+            QueryWasmLimitsConfigResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryWasmLimitsConfigResponse;
+                isSDK(o: any): o is _88.QueryWasmLimitsConfigResponseSDKType;
+                isAmino(o: any): o is _88.QueryWasmLimitsConfigResponseAmino;
+                encode(message: _88.QueryWasmLimitsConfigResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryWasmLimitsConfigResponse;
+                fromJSON(object: any): _88.QueryWasmLimitsConfigResponse;
+                toJSON(message: _88.QueryWasmLimitsConfigResponse): import("..").JsonSafe<_88.QueryWasmLimitsConfigResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryWasmLimitsConfigResponse>, I>>(object: I): _88.QueryWasmLimitsConfigResponse;
+                fromAmino(object: _88.QueryWasmLimitsConfigResponseAmino): _88.QueryWasmLimitsConfigResponse;
+                toAmino(message: _88.QueryWasmLimitsConfigResponse): _88.QueryWasmLimitsConfigResponseAmino;
+                fromAminoMsg(object: _88.QueryWasmLimitsConfigResponseAminoMsg): _88.QueryWasmLimitsConfigResponse;
+                toAminoMsg(message: _88.QueryWasmLimitsConfigResponse): _88.QueryWasmLimitsConfigResponseAminoMsg;
+                fromProtoMsg(message: _88.QueryWasmLimitsConfigResponseProtoMsg): _88.QueryWasmLimitsConfigResponse;
+                toProto(message: _88.QueryWasmLimitsConfigResponse): Uint8Array;
+                toProtoMsg(message: _88.QueryWasmLimitsConfigResponse): _88.QueryWasmLimitsConfigResponseProtoMsg;
+            };
+            QueryBuildAddressRequest: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryBuildAddressRequest;
+                isSDK(o: any): o is _88.QueryBuildAddressRequestSDKType;
+                isAmino(o: any): o is _88.QueryBuildAddressRequestAmino;
+                encode(message: _88.QueryBuildAddressRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryBuildAddressRequest;
+                fromJSON(object: any): _88.QueryBuildAddressRequest;
+                toJSON(message: _88.QueryBuildAddressRequest): import("..").JsonSafe<_88.QueryBuildAddressRequest>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryBuildAddressRequest>, I>>(object: I): _88.QueryBuildAddressRequest;
+                fromAmino(object: _88.QueryBuildAddressRequestAmino): _88.QueryBuildAddressRequest;
+                toAmino(message: _88.QueryBuildAddressRequest): _88.QueryBuildAddressRequestAmino;
+                fromAminoMsg(object: _88.QueryBuildAddressRequestAminoMsg): _88.QueryBuildAddressRequest;
+                toAminoMsg(message: _88.QueryBuildAddressRequest): _88.QueryBuildAddressRequestAminoMsg;
+                fromProtoMsg(message: _88.QueryBuildAddressRequestProtoMsg): _88.QueryBuildAddressRequest;
+                toProto(message: _88.QueryBuildAddressRequest): Uint8Array;
+                toProtoMsg(message: _88.QueryBuildAddressRequest): _88.QueryBuildAddressRequestProtoMsg;
+            };
+            QueryBuildAddressResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _88.QueryBuildAddressResponse;
+                isSDK(o: any): o is _88.QueryBuildAddressResponseSDKType;
+                isAmino(o: any): o is _88.QueryBuildAddressResponseAmino;
+                encode(message: _88.QueryBuildAddressResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _88.QueryBuildAddressResponse;
+                fromJSON(object: any): _88.QueryBuildAddressResponse;
+                toJSON(message: _88.QueryBuildAddressResponse): import("..").JsonSafe<_88.QueryBuildAddressResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_88.QueryBuildAddressResponse>, I>>(object: I): _88.QueryBuildAddressResponse;
+                fromAmino(object: _88.QueryBuildAddressResponseAmino): _88.QueryBuildAddressResponse;
+                toAmino(message: _88.QueryBuildAddressResponse): _88.QueryBuildAddressResponseAmino;
+                fromAminoMsg(object: _88.QueryBuildAddressResponseAminoMsg): _88.QueryBuildAddressResponse;
+                toAminoMsg(message: _88.QueryBuildAddressResponse): _88.QueryBuildAddressResponseAminoMsg;
+                fromProtoMsg(message: _88.QueryBuildAddressResponseProtoMsg): _88.QueryBuildAddressResponse;
+                toProto(message: _88.QueryBuildAddressResponse): Uint8Array;
+                toProtoMsg(message: _88.QueryBuildAddressResponse): _88.QueryBuildAddressResponseProtoMsg;
+            };
+            StoreCodeProposal: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _87.StoreCodeProposal;
+                isSDK(o: any): o is _87.StoreCodeProposalSDKType;
+                isAmino(o: any): o is _87.StoreCodeProposalAmino;
+                encode(message: _87.StoreCodeProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _87.StoreCodeProposal;
+                fromJSON(object: any): _87.StoreCodeProposal;
+                toJSON(message: _87.StoreCodeProposal): import("..").JsonSafe<_87.StoreCodeProposal>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_87.StoreCodeProposal>, I>>(object: I): _87.StoreCodeProposal;
+                fromAmino(object: _87.StoreCodeProposalAmino): _87.StoreCodeProposal;
+                toAmino(message: _87.StoreCodeProposal): _87.StoreCodeProposalAmino;
+                fromAminoMsg(object: _87.StoreCodeProposalAminoMsg): _87.StoreCodeProposal;
+                toAminoMsg(message: _87.StoreCodeProposal): _87.StoreCodeProposalAminoMsg;
+                fromProtoMsg(message: _87.StoreCodeProposalProtoMsg): _87.StoreCodeProposal;
+                toProto(message: _87.StoreCodeProposal): Uint8Array;
+                toProtoMsg(message: _87.StoreCodeProposal): _87.StoreCodeProposalProtoMsg;
+            };
+            InstantiateContractProposal: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _87.InstantiateContractProposal;
+                isSDK(o: any): o is _87.InstantiateContractProposalSDKType;
+                isAmino(o: any): o is _87.InstantiateContractProposalAmino;
+                encode(message: _87.InstantiateContractProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _87.InstantiateContractProposal;
+                fromJSON(object: any): _87.InstantiateContractProposal;
+                toJSON(message: _87.InstantiateContractProposal): import("..").JsonSafe<_87.InstantiateContractProposal>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_87.InstantiateContractProposal>, I>>(object: I): _87.InstantiateContractProposal;
+                fromAmino(object: _87.InstantiateContractProposalAmino): _87.InstantiateContractProposal;
+                toAmino(message: _87.InstantiateContractProposal): _87.InstantiateContractProposalAmino;
+                fromAminoMsg(object: _87.InstantiateContractProposalAminoMsg): _87.InstantiateContractProposal;
+                toAminoMsg(message: _87.InstantiateContractProposal): _87.InstantiateContractProposalAminoMsg;
+                fromProtoMsg(message: _87.InstantiateContractProposalProtoMsg): _87.InstantiateContractProposal;
+                toProto(message: _87.InstantiateContractProposal): Uint8Array;
+                toProtoMsg(message: _87.InstantiateContractProposal): _87.InstantiateContractProposalProtoMsg;
+            };
+            InstantiateContract2Proposal: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _87.InstantiateContract2Proposal;
+                isSDK(o: any): o is _87.InstantiateContract2ProposalSDKType;
+                isAmino(o: any): o is _87.InstantiateContract2ProposalAmino;
+                encode(message: _87.InstantiateContract2Proposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _87.InstantiateContract2Proposal;
+                fromJSON(object: any): _87.InstantiateContract2Proposal;
+                toJSON(message: _87.InstantiateContract2Proposal): import("..").JsonSafe<_87.InstantiateContract2Proposal>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_87.InstantiateContract2Proposal>, I>>(object: I): _87.InstantiateContract2Proposal;
+                fromAmino(object: _87.InstantiateContract2ProposalAmino): _87.InstantiateContract2Proposal;
+                toAmino(message: _87.InstantiateContract2Proposal): _87.InstantiateContract2ProposalAmino;
+                fromAminoMsg(object: _87.InstantiateContract2ProposalAminoMsg): _87.InstantiateContract2Proposal;
+                toAminoMsg(message: _87.InstantiateContract2Proposal): _87.InstantiateContract2ProposalAminoMsg;
+                fromProtoMsg(message: _87.InstantiateContract2ProposalProtoMsg): _87.InstantiateContract2Proposal;
+                toProto(message: _87.InstantiateContract2Proposal): Uint8Array;
+                toProtoMsg(message: _87.InstantiateContract2Proposal): _87.InstantiateContract2ProposalProtoMsg;
+            };
+            MigrateContractProposal: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _87.MigrateContractProposal;
+                isSDK(o: any): o is _87.MigrateContractProposalSDKType;
+                isAmino(o: any): o is _87.MigrateContractProposalAmino;
+                encode(message: _87.MigrateContractProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _87.MigrateContractProposal;
+                fromJSON(object: any): _87.MigrateContractProposal;
+                toJSON(message: _87.MigrateContractProposal): import("..").JsonSafe<_87.MigrateContractProposal>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_87.MigrateContractProposal>, I>>(object: I): _87.MigrateContractProposal;
+                fromAmino(object: _87.MigrateContractProposalAmino): _87.MigrateContractProposal;
+                toAmino(message: _87.MigrateContractProposal): _87.MigrateContractProposalAmino;
+                fromAminoMsg(object: _87.MigrateContractProposalAminoMsg): _87.MigrateContractProposal;
+                toAminoMsg(message: _87.MigrateContractProposal): _87.MigrateContractProposalAminoMsg;
+                fromProtoMsg(message: _87.MigrateContractProposalProtoMsg): _87.MigrateContractProposal;
+                toProto(message: _87.MigrateContractProposal): Uint8Array;
+                toProtoMsg(message: _87.MigrateContractProposal): _87.MigrateContractProposalProtoMsg;
+            };
+            SudoContractProposal: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _87.SudoContractProposal;
+                isSDK(o: any): o is _87.SudoContractProposalSDKType;
+                isAmino(o: any): o is _87.SudoContractProposalAmino;
+                encode(message: _87.SudoContractProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _87.SudoContractProposal;
+                fromJSON(object: any): _87.SudoContractProposal;
+                toJSON(message: _87.SudoContractProposal): import("..").JsonSafe<_87.SudoContractProposal>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_87.SudoContractProposal>, I>>(object: I): _87.SudoContractProposal;
+                fromAmino(object: _87.SudoContractProposalAmino): _87.SudoContractProposal;
+                toAmino(message: _87.SudoContractProposal): _87.SudoContractProposalAmino;
+                fromAminoMsg(object: _87.SudoContractProposalAminoMsg): _87.SudoContractProposal;
+                toAminoMsg(message: _87.SudoContractProposal): _87.SudoContractProposalAminoMsg;
+                fromProtoMsg(message: _87.SudoContractProposalProtoMsg): _87.SudoContractProposal;
+                toProto(message: _87.SudoContractProposal): Uint8Array;
+                toProtoMsg(message: _87.SudoContractProposal): _87.SudoContractProposalProtoMsg;
+            };
+            ExecuteContractProposal: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _87.ExecuteContractProposal;
+                isSDK(o: any): o is _87.ExecuteContractProposalSDKType;
+                isAmino(o: any): o is _87.ExecuteContractProposalAmino;
+                encode(message: _87.ExecuteContractProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _87.ExecuteContractProposal;
+                fromJSON(object: any): _87.ExecuteContractProposal;
+                toJSON(message: _87.ExecuteContractProposal): import("..").JsonSafe<_87.ExecuteContractProposal>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_87.ExecuteContractProposal>, I>>(object: I): _87.ExecuteContractProposal;
+                fromAmino(object: _87.ExecuteContractProposalAmino): _87.ExecuteContractProposal;
+                toAmino(message: _87.ExecuteContractProposal): _87.ExecuteContractProposalAmino;
+                fromAminoMsg(object: _87.ExecuteContractProposalAminoMsg): _87.ExecuteContractProposal;
+                toAminoMsg(message: _87.ExecuteContractProposal): _87.ExecuteContractProposalAminoMsg;
+                fromProtoMsg(message: _87.ExecuteContractProposalProtoMsg): _87.ExecuteContractProposal;
+                toProto(message: _87.ExecuteContractProposal): Uint8Array;
+                toProtoMsg(message: _87.ExecuteContractProposal): _87.ExecuteContractProposalProtoMsg;
+            };
+            UpdateAdminProposal: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _87.UpdateAdminProposal;
+                isSDK(o: any): o is _87.UpdateAdminProposalSDKType;
+                isAmino(o: any): o is _87.UpdateAdminProposalAmino;
+                encode(message: _87.UpdateAdminProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _87.UpdateAdminProposal;
+                fromJSON(object: any): _87.UpdateAdminProposal;
+                toJSON(message: _87.UpdateAdminProposal): import("..").JsonSafe<_87.UpdateAdminProposal>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_87.UpdateAdminProposal>, I>>(object: I): _87.UpdateAdminProposal;
+                fromAmino(object: _87.UpdateAdminProposalAmino): _87.UpdateAdminProposal;
+                toAmino(message: _87.UpdateAdminProposal): _87.UpdateAdminProposalAmino;
+                fromAminoMsg(object: _87.UpdateAdminProposalAminoMsg): _87.UpdateAdminProposal;
+                toAminoMsg(message: _87.UpdateAdminProposal): _87.UpdateAdminProposalAminoMsg;
+                fromProtoMsg(message: _87.UpdateAdminProposalProtoMsg): _87.UpdateAdminProposal;
+                toProto(message: _87.UpdateAdminProposal): Uint8Array;
+                toProtoMsg(message: _87.UpdateAdminProposal): _87.UpdateAdminProposalProtoMsg;
+            };
+            ClearAdminProposal: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _87.ClearAdminProposal;
+                isSDK(o: any): o is _87.ClearAdminProposalSDKType;
+                isAmino(o: any): o is _87.ClearAdminProposalAmino;
+                encode(message: _87.ClearAdminProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _87.ClearAdminProposal;
+                fromJSON(object: any): _87.ClearAdminProposal;
+                toJSON(message: _87.ClearAdminProposal): import("..").JsonSafe<_87.ClearAdminProposal>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_87.ClearAdminProposal>, I>>(object: I): _87.ClearAdminProposal;
+                fromAmino(object: _87.ClearAdminProposalAmino): _87.ClearAdminProposal;
+                toAmino(message: _87.ClearAdminProposal): _87.ClearAdminProposalAmino;
+                fromAminoMsg(object: _87.ClearAdminProposalAminoMsg): _87.ClearAdminProposal;
+                toAminoMsg(message: _87.ClearAdminProposal): _87.ClearAdminProposalAminoMsg;
+                fromProtoMsg(message: _87.ClearAdminProposalProtoMsg): _87.ClearAdminProposal;
+                toProto(message: _87.ClearAdminProposal): Uint8Array;
+                toProtoMsg(message: _87.ClearAdminProposal): _87.ClearAdminProposalProtoMsg;
+            };
+            PinCodesProposal: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _87.PinCodesProposal;
+                isSDK(o: any): o is _87.PinCodesProposalSDKType;
+                isAmino(o: any): o is _87.PinCodesProposalAmino;
+                encode(message: _87.PinCodesProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _87.PinCodesProposal;
+                fromJSON(object: any): _87.PinCodesProposal;
+                toJSON(message: _87.PinCodesProposal): import("..").JsonSafe<_87.PinCodesProposal>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_87.PinCodesProposal>, I>>(object: I): _87.PinCodesProposal;
+                fromAmino(object: _87.PinCodesProposalAmino): _87.PinCodesProposal;
+                toAmino(message: _87.PinCodesProposal): _87.PinCodesProposalAmino;
+                fromAminoMsg(object: _87.PinCodesProposalAminoMsg): _87.PinCodesProposal;
+                toAminoMsg(message: _87.PinCodesProposal): _87.PinCodesProposalAminoMsg;
+                fromProtoMsg(message: _87.PinCodesProposalProtoMsg): _87.PinCodesProposal;
+                toProto(message: _87.PinCodesProposal): Uint8Array;
+                toProtoMsg(message: _87.PinCodesProposal): _87.PinCodesProposalProtoMsg;
+            };
+            UnpinCodesProposal: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _87.UnpinCodesProposal;
+                isSDK(o: any): o is _87.UnpinCodesProposalSDKType;
+                isAmino(o: any): o is _87.UnpinCodesProposalAmino;
+                encode(message: _87.UnpinCodesProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _87.UnpinCodesProposal;
+                fromJSON(object: any): _87.UnpinCodesProposal;
+                toJSON(message: _87.UnpinCodesProposal): import("..").JsonSafe<_87.UnpinCodesProposal>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_87.UnpinCodesProposal>, I>>(object: I): _87.UnpinCodesProposal;
+                fromAmino(object: _87.UnpinCodesProposalAmino): _87.UnpinCodesProposal;
+                toAmino(message: _87.UnpinCodesProposal): _87.UnpinCodesProposalAmino;
+                fromAminoMsg(object: _87.UnpinCodesProposalAminoMsg): _87.UnpinCodesProposal;
+                toAminoMsg(message: _87.UnpinCodesProposal): _87.UnpinCodesProposalAminoMsg;
+                fromProtoMsg(message: _87.UnpinCodesProposalProtoMsg): _87.UnpinCodesProposal;
+                toProto(message: _87.UnpinCodesProposal): Uint8Array;
+                toProtoMsg(message: _87.UnpinCodesProposal): _87.UnpinCodesProposalProtoMsg;
+            };
+            AccessConfigUpdate: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _87.AccessConfigUpdate;
+                isSDK(o: any): o is _87.AccessConfigUpdateSDKType;
+                isAmino(o: any): o is _87.AccessConfigUpdateAmino;
+                encode(message: _87.AccessConfigUpdate, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _87.AccessConfigUpdate;
+                fromJSON(object: any): _87.AccessConfigUpdate;
+                toJSON(message: _87.AccessConfigUpdate): import("..").JsonSafe<_87.AccessConfigUpdate>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_87.AccessConfigUpdate>, I>>(object: I): _87.AccessConfigUpdate;
+                fromAmino(object: _87.AccessConfigUpdateAmino): _87.AccessConfigUpdate;
+                toAmino(message: _87.AccessConfigUpdate): _87.AccessConfigUpdateAmino;
+                fromAminoMsg(object: _87.AccessConfigUpdateAminoMsg): _87.AccessConfigUpdate;
+                toAminoMsg(message: _87.AccessConfigUpdate): _87.AccessConfigUpdateAminoMsg;
+                fromProtoMsg(message: _87.AccessConfigUpdateProtoMsg): _87.AccessConfigUpdate;
+                toProto(message: _87.AccessConfigUpdate): Uint8Array;
+                toProtoMsg(message: _87.AccessConfigUpdate): _87.AccessConfigUpdateProtoMsg;
+            };
+            UpdateInstantiateConfigProposal: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _87.UpdateInstantiateConfigProposal;
+                isSDK(o: any): o is _87.UpdateInstantiateConfigProposalSDKType;
+                isAmino(o: any): o is _87.UpdateInstantiateConfigProposalAmino;
+                encode(message: _87.UpdateInstantiateConfigProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _87.UpdateInstantiateConfigProposal;
+                fromJSON(object: any): _87.UpdateInstantiateConfigProposal;
+                toJSON(message: _87.UpdateInstantiateConfigProposal): import("..").JsonSafe<_87.UpdateInstantiateConfigProposal>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_87.UpdateInstantiateConfigProposal>, I>>(object: I): _87.UpdateInstantiateConfigProposal;
+                fromAmino(object: _87.UpdateInstantiateConfigProposalAmino): _87.UpdateInstantiateConfigProposal;
+                toAmino(message: _87.UpdateInstantiateConfigProposal): _87.UpdateInstantiateConfigProposalAmino;
+                fromAminoMsg(object: _87.UpdateInstantiateConfigProposalAminoMsg): _87.UpdateInstantiateConfigProposal;
+                toAminoMsg(message: _87.UpdateInstantiateConfigProposal): _87.UpdateInstantiateConfigProposalAminoMsg;
+                fromProtoMsg(message: _87.UpdateInstantiateConfigProposalProtoMsg): _87.UpdateInstantiateConfigProposal;
+                toProto(message: _87.UpdateInstantiateConfigProposal): Uint8Array;
+                toProtoMsg(message: _87.UpdateInstantiateConfigProposal): _87.UpdateInstantiateConfigProposalProtoMsg;
+            };
+            StoreAndInstantiateContractProposal: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _87.StoreAndInstantiateContractProposal;
+                isSDK(o: any): o is _87.StoreAndInstantiateContractProposalSDKType;
+                isAmino(o: any): o is _87.StoreAndInstantiateContractProposalAmino;
+                encode(message: _87.StoreAndInstantiateContractProposal, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _87.StoreAndInstantiateContractProposal;
+                fromJSON(object: any): _87.StoreAndInstantiateContractProposal;
+                toJSON(message: _87.StoreAndInstantiateContractProposal): import("..").JsonSafe<_87.StoreAndInstantiateContractProposal>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_87.StoreAndInstantiateContractProposal>, I>>(object: I): _87.StoreAndInstantiateContractProposal;
+                fromAmino(object: _87.StoreAndInstantiateContractProposalAmino): _87.StoreAndInstantiateContractProposal;
+                toAmino(message: _87.StoreAndInstantiateContractProposal): _87.StoreAndInstantiateContractProposalAmino;
+                fromAminoMsg(object: _87.StoreAndInstantiateContractProposalAminoMsg): _87.StoreAndInstantiateContractProposal;
+                toAminoMsg(message: _87.StoreAndInstantiateContractProposal): _87.StoreAndInstantiateContractProposalAminoMsg;
+                fromProtoMsg(message: _87.StoreAndInstantiateContractProposalProtoMsg): _87.StoreAndInstantiateContractProposal;
+                toProto(message: _87.StoreAndInstantiateContractProposal): Uint8Array;
+                toProtoMsg(message: _87.StoreAndInstantiateContractProposal): _87.StoreAndInstantiateContractProposalProtoMsg;
+            };
+            MsgIBCSend: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _86.MsgIBCSend;
+                isSDK(o: any): o is _86.MsgIBCSendSDKType;
+                isAmino(o: any): o is _86.MsgIBCSendAmino;
+                encode(message: _86.MsgIBCSend, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _86.MsgIBCSend;
+                fromJSON(object: any): _86.MsgIBCSend;
+                toJSON(message: _86.MsgIBCSend): import("..").JsonSafe<_86.MsgIBCSend>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_86.MsgIBCSend>, I>>(object: I): _86.MsgIBCSend;
+                fromAmino(object: _86.MsgIBCSendAmino): _86.MsgIBCSend;
+                toAmino(message: _86.MsgIBCSend): _86.MsgIBCSendAmino;
+                fromAminoMsg(object: _86.MsgIBCSendAminoMsg): _86.MsgIBCSend;
+                toAminoMsg(message: _86.MsgIBCSend): _86.MsgIBCSendAminoMsg;
+                fromProtoMsg(message: _86.MsgIBCSendProtoMsg): _86.MsgIBCSend;
+                toProto(message: _86.MsgIBCSend): Uint8Array;
+                toProtoMsg(message: _86.MsgIBCSend): _86.MsgIBCSendProtoMsg;
+            };
+            MsgIBCSendResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _86.MsgIBCSendResponse;
+                isSDK(o: any): o is _86.MsgIBCSendResponseSDKType;
+                isAmino(o: any): o is _86.MsgIBCSendResponseAmino;
+                encode(message: _86.MsgIBCSendResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _86.MsgIBCSendResponse;
+                fromJSON(object: any): _86.MsgIBCSendResponse;
+                toJSON(message: _86.MsgIBCSendResponse): import("..").JsonSafe<_86.MsgIBCSendResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_86.MsgIBCSendResponse>, I>>(object: I): _86.MsgIBCSendResponse;
+                fromAmino(object: _86.MsgIBCSendResponseAmino): _86.MsgIBCSendResponse;
+                toAmino(message: _86.MsgIBCSendResponse): _86.MsgIBCSendResponseAmino;
+                fromAminoMsg(object: _86.MsgIBCSendResponseAminoMsg): _86.MsgIBCSendResponse;
+                toAminoMsg(message: _86.MsgIBCSendResponse): _86.MsgIBCSendResponseAminoMsg;
+                fromProtoMsg(message: _86.MsgIBCSendResponseProtoMsg): _86.MsgIBCSendResponse;
+                toProto(message: _86.MsgIBCSendResponse): Uint8Array;
+                toProtoMsg(message: _86.MsgIBCSendResponse): _86.MsgIBCSendResponseProtoMsg;
+            };
+            MsgIBCWriteAcknowledgementResponse: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _86.MsgIBCWriteAcknowledgementResponse;
+                isSDK(o: any): o is _86.MsgIBCWriteAcknowledgementResponseSDKType;
+                isAmino(o: any): o is _86.MsgIBCWriteAcknowledgementResponseAmino;
+                encode(_: _86.MsgIBCWriteAcknowledgementResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _86.MsgIBCWriteAcknowledgementResponse;
+                fromJSON(_: any): _86.MsgIBCWriteAcknowledgementResponse;
+                toJSON(_: _86.MsgIBCWriteAcknowledgementResponse): import("..").JsonSafe<_86.MsgIBCWriteAcknowledgementResponse>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_86.MsgIBCWriteAcknowledgementResponse>, I>>(_: I): _86.MsgIBCWriteAcknowledgementResponse;
+                fromAmino(_: _86.MsgIBCWriteAcknowledgementResponseAmino): _86.MsgIBCWriteAcknowledgementResponse;
+                toAmino(_: _86.MsgIBCWriteAcknowledgementResponse): _86.MsgIBCWriteAcknowledgementResponseAmino;
+                fromAminoMsg(object: _86.MsgIBCWriteAcknowledgementResponseAminoMsg): _86.MsgIBCWriteAcknowledgementResponse;
+                toAminoMsg(message: _86.MsgIBCWriteAcknowledgementResponse): _86.MsgIBCWriteAcknowledgementResponseAminoMsg;
+                fromProtoMsg(message: _86.MsgIBCWriteAcknowledgementResponseProtoMsg): _86.MsgIBCWriteAcknowledgementResponse;
+                toProto(message: _86.MsgIBCWriteAcknowledgementResponse): Uint8Array;
+                toProtoMsg(message: _86.MsgIBCWriteAcknowledgementResponse): _86.MsgIBCWriteAcknowledgementResponseProtoMsg;
+            };
+            MsgIBCCloseChannel: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _86.MsgIBCCloseChannel;
+                isSDK(o: any): o is _86.MsgIBCCloseChannelSDKType;
+                isAmino(o: any): o is _86.MsgIBCCloseChannelAmino;
+                encode(message: _86.MsgIBCCloseChannel, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _86.MsgIBCCloseChannel;
+                fromJSON(object: any): _86.MsgIBCCloseChannel;
+                toJSON(message: _86.MsgIBCCloseChannel): import("..").JsonSafe<_86.MsgIBCCloseChannel>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_86.MsgIBCCloseChannel>, I>>(object: I): _86.MsgIBCCloseChannel;
+                fromAmino(object: _86.MsgIBCCloseChannelAmino): _86.MsgIBCCloseChannel;
+                toAmino(message: _86.MsgIBCCloseChannel): _86.MsgIBCCloseChannelAmino;
+                fromAminoMsg(object: _86.MsgIBCCloseChannelAminoMsg): _86.MsgIBCCloseChannel;
+                toAminoMsg(message: _86.MsgIBCCloseChannel): _86.MsgIBCCloseChannelAminoMsg;
+                fromProtoMsg(message: _86.MsgIBCCloseChannelProtoMsg): _86.MsgIBCCloseChannel;
+                toProto(message: _86.MsgIBCCloseChannel): Uint8Array;
+                toProtoMsg(message: _86.MsgIBCCloseChannel): _86.MsgIBCCloseChannelProtoMsg;
+            };
+            GenesisState: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _85.GenesisState;
+                isSDK(o: any): o is _85.GenesisStateSDKType;
+                isAmino(o: any): o is _85.GenesisStateAmino;
+                encode(message: _85.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _85.GenesisState;
+                fromJSON(object: any): _85.GenesisState;
+                toJSON(message: _85.GenesisState): import("..").JsonSafe<_85.GenesisState>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_85.GenesisState>, I>>(object: I): _85.GenesisState;
+                fromAmino(object: _85.GenesisStateAmino): _85.GenesisState;
+                toAmino(message: _85.GenesisState): _85.GenesisStateAmino;
+                fromAminoMsg(object: _85.GenesisStateAminoMsg): _85.GenesisState;
+                toAminoMsg(message: _85.GenesisState): _85.GenesisStateAminoMsg;
+                fromProtoMsg(message: _85.GenesisStateProtoMsg): _85.GenesisState;
+                toProto(message: _85.GenesisState): Uint8Array;
+                toProtoMsg(message: _85.GenesisState): _85.GenesisStateProtoMsg;
+            };
+            Code: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _85.Code;
+                isSDK(o: any): o is _85.CodeSDKType;
+                isAmino(o: any): o is _85.CodeAmino;
+                encode(message: _85.Code, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _85.Code;
+                fromJSON(object: any): _85.Code;
+                toJSON(message: _85.Code): import("..").JsonSafe<_85.Code>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_85.Code>, I>>(object: I): _85.Code;
+                fromAmino(object: _85.CodeAmino): _85.Code;
+                toAmino(message: _85.Code): _85.CodeAmino;
+                fromAminoMsg(object: _85.CodeAminoMsg): _85.Code;
+                toAminoMsg(message: _85.Code): _85.CodeAminoMsg;
+                fromProtoMsg(message: _85.CodeProtoMsg): _85.Code;
+                toProto(message: _85.Code): Uint8Array;
+                toProtoMsg(message: _85.Code): _85.CodeProtoMsg;
+            };
+            Contract: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _85.Contract;
+                isSDK(o: any): o is _85.ContractSDKType;
+                isAmino(o: any): o is _85.ContractAmino;
+                encode(message: _85.Contract, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _85.Contract;
+                fromJSON(object: any): _85.Contract;
+                toJSON(message: _85.Contract): import("..").JsonSafe<_85.Contract>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_85.Contract>, I>>(object: I): _85.Contract;
+                fromAmino(object: _85.ContractAmino): _85.Contract;
+                toAmino(message: _85.Contract): _85.ContractAmino;
+                fromAminoMsg(object: _85.ContractAminoMsg): _85.Contract;
+                toAminoMsg(message: _85.Contract): _85.ContractAminoMsg;
+                fromProtoMsg(message: _85.ContractProtoMsg): _85.Contract;
+                toProto(message: _85.Contract): Uint8Array;
+                toProtoMsg(message: _85.Contract): _85.ContractProtoMsg;
+            };
+            Sequence: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _85.Sequence;
+                isSDK(o: any): o is _85.SequenceSDKType;
+                isAmino(o: any): o is _85.SequenceAmino;
+                encode(message: _85.Sequence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _85.Sequence;
+                fromJSON(object: any): _85.Sequence;
+                toJSON(message: _85.Sequence): import("..").JsonSafe<_85.Sequence>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_85.Sequence>, I>>(object: I): _85.Sequence;
+                fromAmino(object: _85.SequenceAmino): _85.Sequence;
+                toAmino(message: _85.Sequence): _85.SequenceAmino;
+                fromAminoMsg(object: _85.SequenceAminoMsg): _85.Sequence;
+                toAminoMsg(message: _85.Sequence): _85.SequenceAminoMsg;
+                fromProtoMsg(message: _85.SequenceProtoMsg): _85.Sequence;
+                toProto(message: _85.Sequence): Uint8Array;
+                toProtoMsg(message: _85.Sequence): _85.SequenceProtoMsg;
+            };
+            StoreCodeAuthorization: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _84.StoreCodeAuthorization;
+                isSDK(o: any): o is _84.StoreCodeAuthorizationSDKType;
+                isAmino(o: any): o is _84.StoreCodeAuthorizationAmino;
+                encode(message: _84.StoreCodeAuthorization, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.StoreCodeAuthorization;
+                fromJSON(object: any): _84.StoreCodeAuthorization;
+                toJSON(message: _84.StoreCodeAuthorization): import("..").JsonSafe<_84.StoreCodeAuthorization>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_84.StoreCodeAuthorization>, I>>(object: I): _84.StoreCodeAuthorization;
+                fromAmino(object: _84.StoreCodeAuthorizationAmino): _84.StoreCodeAuthorization;
+                toAmino(message: _84.StoreCodeAuthorization): _84.StoreCodeAuthorizationAmino;
+                fromAminoMsg(object: _84.StoreCodeAuthorizationAminoMsg): _84.StoreCodeAuthorization;
+                toAminoMsg(message: _84.StoreCodeAuthorization): _84.StoreCodeAuthorizationAminoMsg;
+                fromProtoMsg(message: _84.StoreCodeAuthorizationProtoMsg): _84.StoreCodeAuthorization;
+                toProto(message: _84.StoreCodeAuthorization): Uint8Array;
+                toProtoMsg(message: _84.StoreCodeAuthorization): _84.StoreCodeAuthorizationProtoMsg;
+            };
+            ContractExecutionAuthorization: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _84.ContractExecutionAuthorization;
+                isSDK(o: any): o is _84.ContractExecutionAuthorizationSDKType;
+                isAmino(o: any): o is _84.ContractExecutionAuthorizationAmino;
+                encode(message: _84.ContractExecutionAuthorization, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.ContractExecutionAuthorization;
+                fromJSON(object: any): _84.ContractExecutionAuthorization;
+                toJSON(message: _84.ContractExecutionAuthorization): import("..").JsonSafe<_84.ContractExecutionAuthorization>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_84.ContractExecutionAuthorization>, I>>(object: I): _84.ContractExecutionAuthorization;
+                fromAmino(object: _84.ContractExecutionAuthorizationAmino): _84.ContractExecutionAuthorization;
+                toAmino(message: _84.ContractExecutionAuthorization): _84.ContractExecutionAuthorizationAmino;
+                fromAminoMsg(object: _84.ContractExecutionAuthorizationAminoMsg): _84.ContractExecutionAuthorization;
+                toAminoMsg(message: _84.ContractExecutionAuthorization): _84.ContractExecutionAuthorizationAminoMsg;
+                fromProtoMsg(message: _84.ContractExecutionAuthorizationProtoMsg): _84.ContractExecutionAuthorization;
+                toProto(message: _84.ContractExecutionAuthorization): Uint8Array;
+                toProtoMsg(message: _84.ContractExecutionAuthorization): _84.ContractExecutionAuthorizationProtoMsg;
+            };
+            ContractMigrationAuthorization: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _84.ContractMigrationAuthorization;
+                isSDK(o: any): o is _84.ContractMigrationAuthorizationSDKType;
+                isAmino(o: any): o is _84.ContractMigrationAuthorizationAmino;
+                encode(message: _84.ContractMigrationAuthorization, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.ContractMigrationAuthorization;
+                fromJSON(object: any): _84.ContractMigrationAuthorization;
+                toJSON(message: _84.ContractMigrationAuthorization): import("..").JsonSafe<_84.ContractMigrationAuthorization>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_84.ContractMigrationAuthorization>, I>>(object: I): _84.ContractMigrationAuthorization;
+                fromAmino(object: _84.ContractMigrationAuthorizationAmino): _84.ContractMigrationAuthorization;
+                toAmino(message: _84.ContractMigrationAuthorization): _84.ContractMigrationAuthorizationAmino;
+                fromAminoMsg(object: _84.ContractMigrationAuthorizationAminoMsg): _84.ContractMigrationAuthorization;
+                toAminoMsg(message: _84.ContractMigrationAuthorization): _84.ContractMigrationAuthorizationAminoMsg;
+                fromProtoMsg(message: _84.ContractMigrationAuthorizationProtoMsg): _84.ContractMigrationAuthorization;
+                toProto(message: _84.ContractMigrationAuthorization): Uint8Array;
+                toProtoMsg(message: _84.ContractMigrationAuthorization): _84.ContractMigrationAuthorizationProtoMsg;
+            };
+            CodeGrant: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _84.CodeGrant;
+                isSDK(o: any): o is _84.CodeGrantSDKType;
+                isAmino(o: any): o is _84.CodeGrantAmino;
+                encode(message: _84.CodeGrant, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.CodeGrant;
+                fromJSON(object: any): _84.CodeGrant;
+                toJSON(message: _84.CodeGrant): import("..").JsonSafe<_84.CodeGrant>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_84.CodeGrant>, I>>(object: I): _84.CodeGrant;
+                fromAmino(object: _84.CodeGrantAmino): _84.CodeGrant;
+                toAmino(message: _84.CodeGrant): _84.CodeGrantAmino;
+                fromAminoMsg(object: _84.CodeGrantAminoMsg): _84.CodeGrant;
+                toAminoMsg(message: _84.CodeGrant): _84.CodeGrantAminoMsg;
+                fromProtoMsg(message: _84.CodeGrantProtoMsg): _84.CodeGrant;
+                toProto(message: _84.CodeGrant): Uint8Array;
+                toProtoMsg(message: _84.CodeGrant): _84.CodeGrantProtoMsg;
+            };
+            ContractGrant: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _84.ContractGrant;
+                isSDK(o: any): o is _84.ContractGrantSDKType;
+                isAmino(o: any): o is _84.ContractGrantAmino;
+                encode(message: _84.ContractGrant, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.ContractGrant;
+                fromJSON(object: any): _84.ContractGrant;
+                toJSON(message: _84.ContractGrant): import("..").JsonSafe<_84.ContractGrant>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_84.ContractGrant>, I>>(object: I): _84.ContractGrant;
+                fromAmino(object: _84.ContractGrantAmino): _84.ContractGrant;
+                toAmino(message: _84.ContractGrant): _84.ContractGrantAmino;
+                fromAminoMsg(object: _84.ContractGrantAminoMsg): _84.ContractGrant;
+                toAminoMsg(message: _84.ContractGrant): _84.ContractGrantAminoMsg;
+                fromProtoMsg(message: _84.ContractGrantProtoMsg): _84.ContractGrant;
+                toProto(message: _84.ContractGrant): Uint8Array;
+                toProtoMsg(message: _84.ContractGrant): _84.ContractGrantProtoMsg;
+            };
+            MaxCallsLimit: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _84.MaxCallsLimit;
+                isSDK(o: any): o is _84.MaxCallsLimitSDKType;
+                isAmino(o: any): o is _84.MaxCallsLimitAmino;
+                encode(message: _84.MaxCallsLimit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.MaxCallsLimit;
+                fromJSON(object: any): _84.MaxCallsLimit;
+                toJSON(message: _84.MaxCallsLimit): import("..").JsonSafe<_84.MaxCallsLimit>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_84.MaxCallsLimit>, I>>(object: I): _84.MaxCallsLimit;
+                fromAmino(object: _84.MaxCallsLimitAmino): _84.MaxCallsLimit;
+                toAmino(message: _84.MaxCallsLimit): _84.MaxCallsLimitAmino;
+                fromAminoMsg(object: _84.MaxCallsLimitAminoMsg): _84.MaxCallsLimit;
+                toAminoMsg(message: _84.MaxCallsLimit): _84.MaxCallsLimitAminoMsg;
+                fromProtoMsg(message: _84.MaxCallsLimitProtoMsg): _84.MaxCallsLimit;
+                toProto(message: _84.MaxCallsLimit): Uint8Array;
+                toProtoMsg(message: _84.MaxCallsLimit): _84.MaxCallsLimitProtoMsg;
+            };
+            MaxFundsLimit: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _84.MaxFundsLimit;
+                isSDK(o: any): o is _84.MaxFundsLimitSDKType;
+                isAmino(o: any): o is _84.MaxFundsLimitAmino;
+                encode(message: _84.MaxFundsLimit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.MaxFundsLimit;
+                fromJSON(object: any): _84.MaxFundsLimit;
+                toJSON(message: _84.MaxFundsLimit): import("..").JsonSafe<_84.MaxFundsLimit>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_84.MaxFundsLimit>, I>>(object: I): _84.MaxFundsLimit;
+                fromAmino(object: _84.MaxFundsLimitAmino): _84.MaxFundsLimit;
+                toAmino(message: _84.MaxFundsLimit): _84.MaxFundsLimitAmino;
+                fromAminoMsg(object: _84.MaxFundsLimitAminoMsg): _84.MaxFundsLimit;
+                toAminoMsg(message: _84.MaxFundsLimit): _84.MaxFundsLimitAminoMsg;
+                fromProtoMsg(message: _84.MaxFundsLimitProtoMsg): _84.MaxFundsLimit;
+                toProto(message: _84.MaxFundsLimit): Uint8Array;
+                toProtoMsg(message: _84.MaxFundsLimit): _84.MaxFundsLimitProtoMsg;
+            };
+            CombinedLimit: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _84.CombinedLimit;
+                isSDK(o: any): o is _84.CombinedLimitSDKType;
+                isAmino(o: any): o is _84.CombinedLimitAmino;
+                encode(message: _84.CombinedLimit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.CombinedLimit;
+                fromJSON(object: any): _84.CombinedLimit;
+                toJSON(message: _84.CombinedLimit): import("..").JsonSafe<_84.CombinedLimit>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_84.CombinedLimit>, I>>(object: I): _84.CombinedLimit;
+                fromAmino(object: _84.CombinedLimitAmino): _84.CombinedLimit;
+                toAmino(message: _84.CombinedLimit): _84.CombinedLimitAmino;
+                fromAminoMsg(object: _84.CombinedLimitAminoMsg): _84.CombinedLimit;
+                toAminoMsg(message: _84.CombinedLimit): _84.CombinedLimitAminoMsg;
+                fromProtoMsg(message: _84.CombinedLimitProtoMsg): _84.CombinedLimit;
+                toProto(message: _84.CombinedLimit): Uint8Array;
+                toProtoMsg(message: _84.CombinedLimit): _84.CombinedLimitProtoMsg;
+            };
+            AllowAllMessagesFilter: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _84.AllowAllMessagesFilter;
+                isSDK(o: any): o is _84.AllowAllMessagesFilterSDKType;
+                isAmino(o: any): o is _84.AllowAllMessagesFilterAmino;
+                encode(_: _84.AllowAllMessagesFilter, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.AllowAllMessagesFilter;
+                fromJSON(_: any): _84.AllowAllMessagesFilter;
+                toJSON(_: _84.AllowAllMessagesFilter): import("..").JsonSafe<_84.AllowAllMessagesFilter>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_84.AllowAllMessagesFilter>, I>>(_: I): _84.AllowAllMessagesFilter;
+                fromAmino(_: _84.AllowAllMessagesFilterAmino): _84.AllowAllMessagesFilter;
+                toAmino(_: _84.AllowAllMessagesFilter): _84.AllowAllMessagesFilterAmino;
+                fromAminoMsg(object: _84.AllowAllMessagesFilterAminoMsg): _84.AllowAllMessagesFilter;
+                toAminoMsg(message: _84.AllowAllMessagesFilter): _84.AllowAllMessagesFilterAminoMsg;
+                fromProtoMsg(message: _84.AllowAllMessagesFilterProtoMsg): _84.AllowAllMessagesFilter;
+                toProto(message: _84.AllowAllMessagesFilter): Uint8Array;
+                toProtoMsg(message: _84.AllowAllMessagesFilter): _84.AllowAllMessagesFilterProtoMsg;
+            };
+            AcceptedMessageKeysFilter: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _84.AcceptedMessageKeysFilter;
+                isSDK(o: any): o is _84.AcceptedMessageKeysFilterSDKType;
+                isAmino(o: any): o is _84.AcceptedMessageKeysFilterAmino;
+                encode(message: _84.AcceptedMessageKeysFilter, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.AcceptedMessageKeysFilter;
+                fromJSON(object: any): _84.AcceptedMessageKeysFilter;
+                toJSON(message: _84.AcceptedMessageKeysFilter): import("..").JsonSafe<_84.AcceptedMessageKeysFilter>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_84.AcceptedMessageKeysFilter>, I>>(object: I): _84.AcceptedMessageKeysFilter;
+                fromAmino(object: _84.AcceptedMessageKeysFilterAmino): _84.AcceptedMessageKeysFilter;
+                toAmino(message: _84.AcceptedMessageKeysFilter): _84.AcceptedMessageKeysFilterAmino;
+                fromAminoMsg(object: _84.AcceptedMessageKeysFilterAminoMsg): _84.AcceptedMessageKeysFilter;
+                toAminoMsg(message: _84.AcceptedMessageKeysFilter): _84.AcceptedMessageKeysFilterAminoMsg;
+                fromProtoMsg(message: _84.AcceptedMessageKeysFilterProtoMsg): _84.AcceptedMessageKeysFilter;
+                toProto(message: _84.AcceptedMessageKeysFilter): Uint8Array;
+                toProtoMsg(message: _84.AcceptedMessageKeysFilter): _84.AcceptedMessageKeysFilterProtoMsg;
+            };
+            AcceptedMessagesFilter: {
+                typeUrl: string;
+                aminoType: string;
+                is(o: any): o is _84.AcceptedMessagesFilter;
+                isSDK(o: any): o is _84.AcceptedMessagesFilterSDKType;
+                isAmino(o: any): o is _84.AcceptedMessagesFilterAmino;
+                encode(message: _84.AcceptedMessagesFilter, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
+                decode(input: import("..").BinaryReader | Uint8Array, length?: number): _84.AcceptedMessagesFilter;
+                fromJSON(object: any): _84.AcceptedMessagesFilter;
+                toJSON(message: _84.AcceptedMessagesFilter): import("..").JsonSafe<_84.AcceptedMessagesFilter>;
+                fromPartial<I extends import("../helpers").Exact<import("../helpers").DeepPartial<_84.AcceptedMessagesFilter>, I>>(object: I): _84.AcceptedMessagesFilter;
+                fromAmino(object: _84.AcceptedMessagesFilterAmino): _84.AcceptedMessagesFilter;
+                toAmino(message: _84.AcceptedMessagesFilter): _84.AcceptedMessagesFilterAmino;
+                fromAminoMsg(object: _84.AcceptedMessagesFilterAminoMsg): _84.AcceptedMessagesFilter;
+                toAminoMsg(message: _84.AcceptedMessagesFilter): _84.AcceptedMessagesFilterAminoMsg;
+                fromProtoMsg(message: _84.AcceptedMessagesFilterProtoMsg): _84.AcceptedMessagesFilter;
+                toProto(message: _84.AcceptedMessagesFilter): Uint8Array;
+                toProtoMsg(message: _84.AcceptedMessagesFilter): _84.AcceptedMessagesFilterProtoMsg;
+            };
+        };
+    }
+    const ClientFactory: {
+        createRPCMsgClient: ({ rpc }: {
+            rpc: import("../helpers").Rpc;
+        }) => Promise<{
+            cosmos: {
+                auth: {
+                    v1beta1: import("../cosmos/auth/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                authz: {
+                    v1beta1: import("../cosmos/authz/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                bank: {
+                    v1beta1: import("../cosmos/bank/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                circuit: {
+                    v1: import("../cosmos/circuit/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                consensus: {
+                    v1: import("../cosmos/consensus/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                distribution: {
+                    v1beta1: import("../cosmos/distribution/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                feegrant: {
+                    v1beta1: import("../cosmos/feegrant/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                gov: {
+                    v1: import("../cosmos/gov/v1/tx.rpc.msg").MsgClientImpl;
+                    v1beta1: import("../cosmos/gov/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                group: {
+                    v1: import("../cosmos/group/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                mint: {
+                    v1beta1: import("../cosmos/mint/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                staking: {
+                    v1beta1: import("../cosmos/staking/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                upgrade: {
+                    v1beta1: import("../cosmos/upgrade/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                vesting: {
+                    v1beta1: import("../cosmos/vesting/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+            };
+            cosmwasm: {
+                wasm: {
+                    v1: _222.MsgClientImpl;
+                };
+            };
+        }>;
+        createRPCMsgExtensions: ({ rpcEndpoint, signer }: {
+            rpcEndpoint: string | import("@cosmjs/tendermint-rpc").HttpEndpoint;
+            signer: import("@cosmjs/proto-signing").OfflineSigner;
+        }) => Promise<{
+            cosmos: {
+                auth: {
+                    v1beta1: import("../cosmos/auth/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                authz: {
+                    v1beta1: import("../cosmos/authz/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                bank: {
+                    v1beta1: import("../cosmos/bank/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                circuit: {
+                    v1: import("../cosmos/circuit/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                consensus: {
+                    v1: import("../cosmos/consensus/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                distribution: {
+                    v1beta1: import("../cosmos/distribution/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                feegrant: {
+                    v1beta1: import("../cosmos/feegrant/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                gov: {
+                    v1: import("../cosmos/gov/v1/tx.rpc.msg").MsgClientImpl;
+                    v1beta1: import("../cosmos/gov/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                group: {
+                    v1: import("../cosmos/group/v1/tx.rpc.msg").MsgClientImpl;
+                };
+                mint: {
+                    v1beta1: import("../cosmos/mint/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                staking: {
+                    v1beta1: import("../cosmos/staking/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                upgrade: {
+                    v1beta1: import("../cosmos/upgrade/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                vesting: {
+                    v1beta1: import("../cosmos/vesting/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+            };
+            cosmwasm: {
+                wasm: {
+                    v1: _222.MsgClientImpl;
+                };
+            };
+        }>;
+        createRPCQueryClient: ({ rpcEndpoint }: {
+            rpcEndpoint: string | import("@cosmjs/tendermint-rpc").HttpEndpoint;
+        }) => Promise<{
+            cosmos: {
+                auth: {
+                    v1beta1: {
+                        accounts(request?: import("../cosmos/auth/v1beta1/query").QueryAccountsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountsResponse>;
+                        account(request: import("../cosmos/auth/v1beta1/query").QueryAccountRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountResponse>;
+                        accountAddressByID(request: import("../cosmos/auth/v1beta1/query").QueryAccountAddressByIDRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountAddressByIDResponse>;
+                        params(request?: import("../cosmos/auth/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryParamsResponse>;
+                        moduleAccounts(request?: import("../cosmos/auth/v1beta1/query").QueryModuleAccountsRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryModuleAccountsResponse>;
+                        moduleAccountByName(request: import("../cosmos/auth/v1beta1/query").QueryModuleAccountByNameRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryModuleAccountByNameResponse>;
+                        bech32Prefix(request?: import("../cosmos/auth/v1beta1/query").Bech32PrefixRequest): Promise<import("../cosmos/auth/v1beta1/query").Bech32PrefixResponse>;
+                        addressBytesToString(request: import("../cosmos/auth/v1beta1/query").AddressBytesToStringRequest): Promise<import("../cosmos/auth/v1beta1/query").AddressBytesToStringResponse>;
+                        addressStringToBytes(request: import("../cosmos/auth/v1beta1/query").AddressStringToBytesRequest): Promise<import("../cosmos/auth/v1beta1/query").AddressStringToBytesResponse>;
+                        accountInfo(request: import("../cosmos/auth/v1beta1/query").QueryAccountInfoRequest): Promise<import("../cosmos/auth/v1beta1/query").QueryAccountInfoResponse>;
+                    };
+                };
+                authz: {
+                    v1beta1: {
+                        grants(request: import("../cosmos/authz/v1beta1/query").QueryGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGrantsResponse>;
+                        granterGrants(request: import("../cosmos/authz/v1beta1/query").QueryGranterGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGranterGrantsResponse>;
+                        granteeGrants(request: import("../cosmos/authz/v1beta1/query").QueryGranteeGrantsRequest): Promise<import("../cosmos/authz/v1beta1/query").QueryGranteeGrantsResponse>;
+                    };
+                };
+                bank: {
+                    v1beta1: {
+                        balance(request: import("../cosmos/bank/v1beta1/query").QueryBalanceRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryBalanceResponse>;
+                        allBalances(request: import("../cosmos/bank/v1beta1/query").QueryAllBalancesRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryAllBalancesResponse>;
+                        spendableBalances(request: import("../cosmos/bank/v1beta1/query").QuerySpendableBalancesRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySpendableBalancesResponse>;
+                        spendableBalanceByDenom(request: import("../cosmos/bank/v1beta1/query").QuerySpendableBalanceByDenomRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySpendableBalanceByDenomResponse>;
+                        totalSupply(request?: import("../cosmos/bank/v1beta1/query").QueryTotalSupplyRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryTotalSupplyResponse>;
+                        supplyOf(request: import("../cosmos/bank/v1beta1/query").QuerySupplyOfRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySupplyOfResponse>;
+                        params(request?: import("../cosmos/bank/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryParamsResponse>;
+                        denomMetadata(request: import("../cosmos/bank/v1beta1/query").QueryDenomMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomMetadataResponse>;
+                        denomMetadataByQueryString(request: import("../cosmos/bank/v1beta1/query").QueryDenomMetadataByQueryStringRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomMetadataByQueryStringResponse>;
+                        denomsMetadata(request?: import("../cosmos/bank/v1beta1/query").QueryDenomsMetadataRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomsMetadataResponse>;
+                        denomOwners(request: import("../cosmos/bank/v1beta1/query").QueryDenomOwnersRequest): Promise<import("../cosmos/bank/v1beta1/query").QueryDenomOwnersResponse>;
+                        sendEnabled(request: import("../cosmos/bank/v1beta1/query").QuerySendEnabledRequest): Promise<import("../cosmos/bank/v1beta1/query").QuerySendEnabledResponse>;
+                    };
+                };
+                base: {
+                    node: {
+                        v1beta1: {
+                            config(request?: import("../cosmos/base/node/v1beta1/query").ConfigRequest): Promise<import("../cosmos/base/node/v1beta1/query").ConfigResponse>;
+                            status(request?: import("../cosmos/base/node/v1beta1/query").StatusRequest): Promise<import("../cosmos/base/node/v1beta1/query").StatusResponse>;
+                        };
+                    };
+                };
+                circuit: {
+                    v1: {
+                        account(request: import("../cosmos/circuit/v1/query").QueryAccountRequest): Promise<import("../cosmos/circuit/v1/query").AccountResponse>;
+                        accounts(request?: import("../cosmos/circuit/v1/query").QueryAccountsRequest): Promise<import("../cosmos/circuit/v1/query").AccountsResponse>;
+                        disabledList(request?: import("../cosmos/circuit/v1/query").QueryDisabledListRequest): Promise<import("../cosmos/circuit/v1/query").DisabledListResponse>;
+                    };
+                };
+                consensus: {
+                    v1: {
+                        params(request?: import("../cosmos/consensus/v1/query").QueryParamsRequest): Promise<import("../cosmos/consensus/v1/query").QueryParamsResponse>;
+                    };
+                };
+                distribution: {
+                    v1beta1: {
+                        params(request?: import("../cosmos/distribution/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryParamsResponse>;
+                        validatorDistributionInfo(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorDistributionInfoRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorDistributionInfoResponse>;
+                        validatorOutstandingRewards(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorOutstandingRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorOutstandingRewardsResponse>;
+                        validatorCommission(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorCommissionRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorCommissionResponse>;
+                        validatorSlashes(request: import("../cosmos/distribution/v1beta1/query").QueryValidatorSlashesRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryValidatorSlashesResponse>;
+                        delegationRewards(request: import("../cosmos/distribution/v1beta1/query").QueryDelegationRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegationRewardsResponse>;
+                        delegationTotalRewards(request: import("../cosmos/distribution/v1beta1/query").QueryDelegationTotalRewardsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegationTotalRewardsResponse>;
+                        delegatorValidators(request: import("../cosmos/distribution/v1beta1/query").QueryDelegatorValidatorsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegatorValidatorsResponse>;
+                        delegatorWithdrawAddress(request: import("../cosmos/distribution/v1beta1/query").QueryDelegatorWithdrawAddressRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryDelegatorWithdrawAddressResponse>;
+                        communityPool(request?: import("../cosmos/distribution/v1beta1/query").QueryCommunityPoolRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryCommunityPoolResponse>;
+                    };
+                };
+                feegrant: {
+                    v1beta1: {
+                        allowance(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowanceRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowanceResponse>;
+                        allowances(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowancesRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowancesResponse>;
+                        allowancesByGranter(request: import("../cosmos/feegrant/v1beta1/query").QueryAllowancesByGranterRequest): Promise<import("../cosmos/feegrant/v1beta1/query").QueryAllowancesByGranterResponse>;
+                    };
+                };
+                gov: {
+                    v1: {
+                        constitution(request?: import("../cosmos/gov/v1/query").QueryConstitutionRequest): Promise<import("../cosmos/gov/v1/query").QueryConstitutionResponse>;
+                        proposal(request: import("../cosmos/gov/v1/query").QueryProposalRequest): Promise<import("../cosmos/gov/v1/query").QueryProposalResponse>;
+                        proposals(request: import("../cosmos/gov/v1/query").QueryProposalsRequest): Promise<import("../cosmos/gov/v1/query").QueryProposalsResponse>;
+                        vote(request: import("../cosmos/gov/v1/query").QueryVoteRequest): Promise<import("../cosmos/gov/v1/query").QueryVoteResponse>;
+                        votes(request: import("../cosmos/gov/v1/query").QueryVotesRequest): Promise<import("../cosmos/gov/v1/query").QueryVotesResponse>;
+                        params(request: import("../cosmos/gov/v1/query").QueryParamsRequest): Promise<import("../cosmos/gov/v1/query").QueryParamsResponse>;
+                        deposit(request: import("../cosmos/gov/v1/query").QueryDepositRequest): Promise<import("../cosmos/gov/v1/query").QueryDepositResponse>;
+                        deposits(request: import("../cosmos/gov/v1/query").QueryDepositsRequest): Promise<import("../cosmos/gov/v1/query").QueryDepositsResponse>;
+                        tallyResult(request: import("../cosmos/gov/v1/query").QueryTallyResultRequest): Promise<import("../cosmos/gov/v1/query").QueryTallyResultResponse>;
+                    };
+                    v1beta1: {
+                        proposal(request: import("../cosmos/gov/v1beta1/query").QueryProposalRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryProposalResponse>;
+                        proposals(request: import("../cosmos/gov/v1beta1/query").QueryProposalsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryProposalsResponse>;
+                        vote(request: import("../cosmos/gov/v1beta1/query").QueryVoteRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryVoteResponse>;
+                        votes(request: import("../cosmos/gov/v1beta1/query").QueryVotesRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryVotesResponse>;
+                        params(request: import("../cosmos/gov/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryParamsResponse>;
+                        deposit(request: import("../cosmos/gov/v1beta1/query").QueryDepositRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryDepositResponse>;
+                        deposits(request: import("../cosmos/gov/v1beta1/query").QueryDepositsRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryDepositsResponse>;
+                        tallyResult(request: import("../cosmos/gov/v1beta1/query").QueryTallyResultRequest): Promise<import("../cosmos/gov/v1beta1/query").QueryTallyResultResponse>;
+                    };
+                };
+                group: {
+                    v1: {
+                        groupInfo(request: import("../cosmos/group/v1/query").QueryGroupInfoRequest): Promise<import("../cosmos/group/v1/query").QueryGroupInfoResponse>;
+                        groupPolicyInfo(request: import("../cosmos/group/v1/query").QueryGroupPolicyInfoRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPolicyInfoResponse>;
+                        groupMembers(request: import("../cosmos/group/v1/query").QueryGroupMembersRequest): Promise<import("../cosmos/group/v1/query").QueryGroupMembersResponse>;
+                        groupsByAdmin(request: import("../cosmos/group/v1/query").QueryGroupsByAdminRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsByAdminResponse>;
+                        groupPoliciesByGroup(request: import("../cosmos/group/v1/query").QueryGroupPoliciesByGroupRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPoliciesByGroupResponse>;
+                        groupPoliciesByAdmin(request: import("../cosmos/group/v1/query").QueryGroupPoliciesByAdminRequest): Promise<import("../cosmos/group/v1/query").QueryGroupPoliciesByAdminResponse>;
+                        proposal(request: import("../cosmos/group/v1/query").QueryProposalRequest): Promise<import("../cosmos/group/v1/query").QueryProposalResponse>;
+                        proposalsByGroupPolicy(request: import("../cosmos/group/v1/query").QueryProposalsByGroupPolicyRequest): Promise<import("../cosmos/group/v1/query").QueryProposalsByGroupPolicyResponse>;
+                        voteByProposalVoter(request: import("../cosmos/group/v1/query").QueryVoteByProposalVoterRequest): Promise<import("../cosmos/group/v1/query").QueryVoteByProposalVoterResponse>;
+                        votesByProposal(request: import("../cosmos/group/v1/query").QueryVotesByProposalRequest): Promise<import("../cosmos/group/v1/query").QueryVotesByProposalResponse>;
+                        votesByVoter(request: import("../cosmos/group/v1/query").QueryVotesByVoterRequest): Promise<import("../cosmos/group/v1/query").QueryVotesByVoterResponse>;
+                        groupsByMember(request: import("../cosmos/group/v1/query").QueryGroupsByMemberRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsByMemberResponse>;
+                        tallyResult(request: import("../cosmos/group/v1/query").QueryTallyResultRequest): Promise<import("../cosmos/group/v1/query").QueryTallyResultResponse>;
+                        groups(request?: import("../cosmos/group/v1/query").QueryGroupsRequest): Promise<import("../cosmos/group/v1/query").QueryGroupsResponse>;
+                    };
+                };
+                mint: {
+                    v1beta1: {
+                        params(request?: import("../cosmos/mint/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryParamsResponse>;
+                        inflation(request?: import("../cosmos/mint/v1beta1/query").QueryInflationRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryInflationResponse>;
+                        annualProvisions(request?: import("../cosmos/mint/v1beta1/query").QueryAnnualProvisionsRequest): Promise<import("../cosmos/mint/v1beta1/query").QueryAnnualProvisionsResponse>;
+                    };
+                };
+                orm: {
+                    query: {
+                        v1alpha1: {
+                            get(request: import("../cosmos/orm/query/v1alpha1/query").GetRequest): Promise<import("../cosmos/orm/query/v1alpha1/query").GetResponse>;
+                            list(request: import("../cosmos/orm/query/v1alpha1/query").ListRequest): Promise<import("../cosmos/orm/query/v1alpha1/query").ListResponse>;
+                        };
+                    };
+                };
+                params: {
+                    v1beta1: {
+                        params(request: import("../cosmos/params/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/params/v1beta1/query").QueryParamsResponse>;
+                        subspaces(request?: import("../cosmos/params/v1beta1/query").QuerySubspacesRequest): Promise<import("../cosmos/params/v1beta1/query").QuerySubspacesResponse>;
+                    };
+                };
+                staking: {
+                    v1beta1: {
+                        validators(request: import("../cosmos/staking/v1beta1/query").QueryValidatorsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorsResponse>;
+                        validator(request: import("../cosmos/staking/v1beta1/query").QueryValidatorRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorResponse>;
+                        validatorDelegations(request: import("../cosmos/staking/v1beta1/query").QueryValidatorDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorDelegationsResponse>;
+                        validatorUnbondingDelegations(request: import("../cosmos/staking/v1beta1/query").QueryValidatorUnbondingDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryValidatorUnbondingDelegationsResponse>;
+                        delegation(request: import("../cosmos/staking/v1beta1/query").QueryDelegationRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegationResponse>;
+                        unbondingDelegation(request: import("../cosmos/staking/v1beta1/query").QueryUnbondingDelegationRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryUnbondingDelegationResponse>;
+                        delegatorDelegations(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorDelegationsResponse>;
+                        delegatorUnbondingDelegations(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorUnbondingDelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorUnbondingDelegationsResponse>;
+                        redelegations(request: import("../cosmos/staking/v1beta1/query").QueryRedelegationsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryRedelegationsResponse>;
+                        delegatorValidators(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorsResponse>;
+                        delegatorValidator(request: import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryDelegatorValidatorResponse>;
+                        historicalInfo(request: import("../cosmos/staking/v1beta1/query").QueryHistoricalInfoRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryHistoricalInfoResponse>;
+                        pool(request?: import("../cosmos/staking/v1beta1/query").QueryPoolRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryPoolResponse>;
+                        params(request?: import("../cosmos/staking/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/staking/v1beta1/query").QueryParamsResponse>;
+                    };
+                };
+                tx: {
+                    v1beta1: {
+                        simulate(request: import("../cosmos/tx/v1beta1/service").SimulateRequest): Promise<import("../cosmos/tx/v1beta1/service").SimulateResponse>;
+                        getTx(request: import("../cosmos/tx/v1beta1/service").GetTxRequest): Promise<import("../cosmos/tx/v1beta1/service").GetTxResponse>;
+                        broadcastTx(request: import("../cosmos/tx/v1beta1/service").BroadcastTxRequest): Promise<import("../cosmos/tx/v1beta1/service").BroadcastTxResponse>;
+                        getTxsEvent(request: import("../cosmos/tx/v1beta1/service").GetTxsEventRequest): Promise<import("../cosmos/tx/v1beta1/service").GetTxsEventResponse>;
+                        getBlockWithTxs(request: import("../cosmos/tx/v1beta1/service").GetBlockWithTxsRequest): Promise<import("../cosmos/tx/v1beta1/service").GetBlockWithTxsResponse>;
+                        txDecode(request: import("../cosmos/tx/v1beta1/service").TxDecodeRequest): Promise<import("../cosmos/tx/v1beta1/service").TxDecodeResponse>;
+                        txEncode(request: import("../cosmos/tx/v1beta1/service").TxEncodeRequest): Promise<import("../cosmos/tx/v1beta1/service").TxEncodeResponse>;
+                        txEncodeAmino(request: import("../cosmos/tx/v1beta1/service").TxEncodeAminoRequest): Promise<import("../cosmos/tx/v1beta1/service").TxEncodeAminoResponse>;
+                        txDecodeAmino(request: import("../cosmos/tx/v1beta1/service").TxDecodeAminoRequest): Promise<import("../cosmos/tx/v1beta1/service").TxDecodeAminoResponse>;
+                    };
+                };
+                upgrade: {
+                    v1beta1: {
+                        currentPlan(request?: import("../cosmos/upgrade/v1beta1/query").QueryCurrentPlanRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryCurrentPlanResponse>;
+                        appliedPlan(request: import("../cosmos/upgrade/v1beta1/query").QueryAppliedPlanRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryAppliedPlanResponse>;
+                        upgradedConsensusState(request: import("../cosmos/upgrade/v1beta1/query").QueryUpgradedConsensusStateRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryUpgradedConsensusStateResponse>;
+                        moduleVersions(request: import("../cosmos/upgrade/v1beta1/query").QueryModuleVersionsRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryModuleVersionsResponse>;
+                        authority(request?: import("../cosmos/upgrade/v1beta1/query").QueryAuthorityRequest): Promise<import("../cosmos/upgrade/v1beta1/query").QueryAuthorityResponse>;
+                    };
+                };
+            };
+            cosmwasm: {
+                wasm: {
+                    v1: {
+                        contractInfo(request: _88.QueryContractInfoRequest): Promise<_88.QueryContractInfoResponse>;
+                        contractHistory(request: _88.QueryContractHistoryRequest): Promise<_88.QueryContractHistoryResponse>;
+                        contractsByCode(request: _88.QueryContractsByCodeRequest): Promise<_88.QueryContractsByCodeResponse>;
+                        allContractState(request: _88.QueryAllContractStateRequest): Promise<_88.QueryAllContractStateResponse>;
+                        rawContractState(request: _88.QueryRawContractStateRequest): Promise<_88.QueryRawContractStateResponse>;
+                        smartContractState(request: _88.QuerySmartContractStateRequest): Promise<_88.QuerySmartContractStateResponse>;
+                        code(request: _88.QueryCodeRequest): Promise<_88.QueryCodeResponse>;
+                        codes(request?: _88.QueryCodesRequest): Promise<_88.QueryCodesResponse>;
+                        codeInfo(request: _88.QueryCodeInfoRequest): Promise<_88.QueryCodeInfoResponse>;
+                        pinnedCodes(request?: _88.QueryPinnedCodesRequest): Promise<_88.QueryPinnedCodesResponse>;
+                        params(request?: _88.QueryParamsRequest): Promise<_88.QueryParamsResponse>;
+                        contractsByCreator(request: _88.QueryContractsByCreatorRequest): Promise<_88.QueryContractsByCreatorResponse>;
+                        wasmLimitsConfig(request?: _88.QueryWasmLimitsConfigRequest): Promise<_88.QueryWasmLimitsConfigResponse>;
+                        buildAddress(request: _88.QueryBuildAddressRequest): Promise<_88.QueryBuildAddressResponse>;
+                    };
+                };
+            };
+        }>;
+        createLCDClient: ({ restEndpoint }: {
+            restEndpoint: string;
+        }) => Promise<{
+            cosmos: {
+                auth: {
+                    v1beta1: import("../cosmos/auth/v1beta1/query.lcd").LCDQueryClient;
+                };
+                authz: {
+                    v1beta1: import("../cosmos/authz/v1beta1/query.lcd").LCDQueryClient;
+                };
+                bank: {
+                    v1beta1: import("../cosmos/bank/v1beta1/query.lcd").LCDQueryClient;
+                };
+                base: {
+                    node: {
+                        v1beta1: import("../cosmos/base/node/v1beta1/query.lcd").LCDQueryClient;
+                    };
+                };
+                circuit: {
+                    v1: import("../cosmos/circuit/v1/query.lcd").LCDQueryClient;
+                };
+                consensus: {
+                    v1: import("../cosmos/consensus/v1/query.lcd").LCDQueryClient;
+                };
+                distribution: {
+                    v1beta1: import("../cosmos/distribution/v1beta1/query.lcd").LCDQueryClient;
+                };
+                feegrant: {
+                    v1beta1: import("../cosmos/feegrant/v1beta1/query.lcd").LCDQueryClient;
+                };
+                gov: {
+                    v1: import("../cosmos/gov/v1/query.lcd").LCDQueryClient;
+                    v1beta1: import("../cosmos/gov/v1beta1/query.lcd").LCDQueryClient;
+                };
+                group: {
+                    v1: import("../cosmos/group/v1/query.lcd").LCDQueryClient;
+                };
+                mint: {
+                    v1beta1: import("../cosmos/mint/v1beta1/query.lcd").LCDQueryClient;
+                };
+                params: {
+                    v1beta1: import("../cosmos/params/v1beta1/query.lcd").LCDQueryClient;
+                };
+                staking: {
+                    v1beta1: import("../cosmos/staking/v1beta1/query.lcd").LCDQueryClient;
+                };
+                tx: {
+                    v1beta1: import("../cosmos/tx/v1beta1/service.lcd").LCDQueryClient;
+                };
+                upgrade: {
+                    v1beta1: import("../cosmos/upgrade/v1beta1/query.lcd").LCDQueryClient;
+                };
+            };
+            cosmwasm: {
+                wasm: {
+                    v1: _220.LCDQueryClient;
+                };
+            };
+        }>;
+    };
+}