injectivejs 0.1.0 → 0.2.0

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

@@ -0,0 +1,1248 @@
+import * as _94 from "./wasm/v1/genesis";
+import * as _95 from "./wasm/v1/ibc";
+import * as _96 from "./wasm/v1/proposal";
+import * as _97 from "./wasm/v1/query";
+import * as _98 from "./wasm/v1/tx";
+import * as _99 from "./wasm/v1/types";
+import * as _267 from "./wasm/v1/query.lcd";
+import * as _268 from "./wasm/v1/query.rpc.query";
+import * as _269 from "./wasm/v1/tx.rpc.msg";
+export declare namespace cosmwasm {
+    namespace wasm {
+        const v1: {
+            MsgClientImpl: typeof _269.MsgClientImpl;
+            QueryClientImpl: typeof _268.QueryClientImpl;
+            createRpcQueryExtension: (base: import("@cosmjs/stargate").QueryClient) => {
+                contractInfo(request: _97.QueryContractInfoRequest): Promise<_97.QueryContractInfoResponse>;
+                contractHistory(request: _97.QueryContractHistoryRequest): Promise<_97.QueryContractHistoryResponse>;
+                contractsByCode(request: _97.QueryContractsByCodeRequest): Promise<_97.QueryContractsByCodeResponse>;
+                allContractState(request: _97.QueryAllContractStateRequest): Promise<_97.QueryAllContractStateResponse>;
+                rawContractState(request: _97.QueryRawContractStateRequest): Promise<_97.QueryRawContractStateResponse>;
+                smartContractState(request: _97.QuerySmartContractStateRequest): Promise<_97.QuerySmartContractStateResponse>;
+                code(request: _97.QueryCodeRequest): Promise<_97.QueryCodeResponse>;
+                codes(request?: _97.QueryCodesRequest): Promise<_97.QueryCodesResponse>;
+                pinnedCodes(request?: _97.QueryPinnedCodesRequest): Promise<_97.QueryPinnedCodesResponse>;
+            };
+            LCDQueryClient: typeof _267.LCDQueryClient;
+            registry: readonly [string, import("@cosmjs/proto-signing").GeneratedType][];
+            load: (protoRegistry: import("@cosmjs/proto-signing").Registry) => void;
+            MessageComposer: {
+                encoded: {
+                    storeCode(value: _98.MsgStoreCode): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    instantiateContract(value: _98.MsgInstantiateContract): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    executeContract(value: _98.MsgExecuteContract): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    migrateContract(value: _98.MsgMigrateContract): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    updateAdmin(value: _98.MsgUpdateAdmin): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                    clearAdmin(value: _98.MsgClearAdmin): {
+                        typeUrl: string;
+                        value: Uint8Array;
+                    };
+                };
+                withTypeUrl: {
+                    storeCode(value: _98.MsgStoreCode): {
+                        typeUrl: string;
+                        value: _98.MsgStoreCode;
+                    };
+                    instantiateContract(value: _98.MsgInstantiateContract): {
+                        typeUrl: string;
+                        value: _98.MsgInstantiateContract;
+                    };
+                    executeContract(value: _98.MsgExecuteContract): {
+                        typeUrl: string;
+                        value: _98.MsgExecuteContract;
+                    };
+                    migrateContract(value: _98.MsgMigrateContract): {
+                        typeUrl: string;
+                        value: _98.MsgMigrateContract;
+                    };
+                    updateAdmin(value: _98.MsgUpdateAdmin): {
+                        typeUrl: string;
+                        value: _98.MsgUpdateAdmin;
+                    };
+                    clearAdmin(value: _98.MsgClearAdmin): {
+                        typeUrl: string;
+                        value: _98.MsgClearAdmin;
+                    };
+                };
+                fromPartial: {
+                    storeCode(value: _98.MsgStoreCode): {
+                        typeUrl: string;
+                        value: _98.MsgStoreCode;
+                    };
+                    instantiateContract(value: _98.MsgInstantiateContract): {
+                        typeUrl: string;
+                        value: _98.MsgInstantiateContract;
+                    };
+                    executeContract(value: _98.MsgExecuteContract): {
+                        typeUrl: string;
+                        value: _98.MsgExecuteContract;
+                    };
+                    migrateContract(value: _98.MsgMigrateContract): {
+                        typeUrl: string;
+                        value: _98.MsgMigrateContract;
+                    };
+                    updateAdmin(value: _98.MsgUpdateAdmin): {
+                        typeUrl: string;
+                        value: _98.MsgUpdateAdmin;
+                    };
+                    clearAdmin(value: _98.MsgClearAdmin): {
+                        typeUrl: string;
+                        value: _98.MsgClearAdmin;
+                    };
+                };
+            };
+            AminoConverter: {
+                "/cosmwasm.wasm.v1.MsgStoreCode": {
+                    aminoType: string;
+                    toAmino: ({ sender, wasmByteCode, instantiatePermission }: _98.MsgStoreCode) => {
+                        sender: string;
+                        wasm_byte_code: string;
+                        instantiate_permission: {
+                            permission: number;
+                            address: string;
+                        };
+                    };
+                    fromAmino: ({ sender, wasm_byte_code, instantiate_permission }: {
+                        sender: string;
+                        wasm_byte_code: string;
+                        instantiate_permission: {
+                            permission: number;
+                            address: string;
+                        };
+                    }) => _98.MsgStoreCode;
+                };
+                "/cosmwasm.wasm.v1.MsgInstantiateContract": {
+                    aminoType: string;
+                    toAmino: ({ sender, admin, codeId, label, msg, funds }: _98.MsgInstantiateContract) => {
+                        sender: string;
+                        admin: string;
+                        code_id: string;
+                        label: string;
+                        msg: Uint8Array;
+                        funds: {
+                            denom: string;
+                            amount: string;
+                        }[];
+                    };
+                    fromAmino: ({ sender, admin, code_id, label, msg, funds }: {
+                        sender: string;
+                        admin: string;
+                        code_id: string;
+                        label: string;
+                        msg: Uint8Array;
+                        funds: {
+                            denom: string;
+                            amount: string;
+                        }[];
+                    }) => _98.MsgInstantiateContract;
+                };
+                "/cosmwasm.wasm.v1.MsgExecuteContract": {
+                    aminoType: string;
+                    toAmino: ({ sender, contract, msg, funds }: _98.MsgExecuteContract) => {
+                        sender: string;
+                        contract: string;
+                        msg: Uint8Array;
+                        funds: {
+                            denom: string;
+                            amount: string;
+                        }[];
+                    };
+                    fromAmino: ({ sender, contract, msg, funds }: {
+                        sender: string;
+                        contract: string;
+                        msg: Uint8Array;
+                        funds: {
+                            denom: string;
+                            amount: string;
+                        }[];
+                    }) => _98.MsgExecuteContract;
+                };
+                "/cosmwasm.wasm.v1.MsgMigrateContract": {
+                    aminoType: string;
+                    toAmino: ({ sender, contract, codeId, msg }: _98.MsgMigrateContract) => {
+                        sender: string;
+                        contract: string;
+                        code_id: string;
+                        msg: Uint8Array;
+                    };
+                    fromAmino: ({ sender, contract, code_id, msg }: {
+                        sender: string;
+                        contract: string;
+                        code_id: string;
+                        msg: Uint8Array;
+                    }) => _98.MsgMigrateContract;
+                };
+                "/cosmwasm.wasm.v1.MsgUpdateAdmin": {
+                    aminoType: string;
+                    toAmino: ({ sender, newAdmin, contract }: _98.MsgUpdateAdmin) => {
+                        sender: string;
+                        new_admin: string;
+                        contract: string;
+                    };
+                    fromAmino: ({ sender, new_admin, contract }: {
+                        sender: string;
+                        new_admin: string;
+                        contract: string;
+                    }) => _98.MsgUpdateAdmin;
+                };
+                "/cosmwasm.wasm.v1.MsgClearAdmin": {
+                    aminoType: string;
+                    toAmino: ({ sender, contract }: _98.MsgClearAdmin) => {
+                        sender: string;
+                        contract: string;
+                    };
+                    fromAmino: ({ sender, contract }: {
+                        sender: string;
+                        contract: string;
+                    }) => _98.MsgClearAdmin;
+                };
+            };
+            accessTypeFromJSON(object: any): _99.AccessType;
+            accessTypeToJSON(object: _99.AccessType): string;
+            contractCodeHistoryOperationTypeFromJSON(object: any): _99.ContractCodeHistoryOperationType;
+            contractCodeHistoryOperationTypeToJSON(object: _99.ContractCodeHistoryOperationType): string;
+            AccessType: typeof _99.AccessType;
+            AccessTypeSDKType: typeof _99.AccessTypeSDKType;
+            ContractCodeHistoryOperationType: typeof _99.ContractCodeHistoryOperationType;
+            ContractCodeHistoryOperationTypeSDKType: typeof _99.ContractCodeHistoryOperationTypeSDKType;
+            AccessTypeParam: {
+                encode(message: _99.AccessTypeParam, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _99.AccessTypeParam;
+                fromPartial(object: {
+                    value?: _99.AccessType;
+                }): _99.AccessTypeParam;
+            };
+            AccessConfig: {
+                encode(message: _99.AccessConfig, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _99.AccessConfig;
+                fromPartial(object: {
+                    permission?: _99.AccessType;
+                    address?: string;
+                }): _99.AccessConfig;
+            };
+            Params: {
+                encode(message: _99.Params, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _99.Params;
+                fromPartial(object: {
+                    codeUploadAccess?: {
+                        permission?: _99.AccessType;
+                        address?: string;
+                    };
+                    instantiateDefaultPermission?: _99.AccessType;
+                    maxWasmCodeSize?: any;
+                }): _99.Params;
+            };
+            CodeInfo: {
+                encode(message: _99.CodeInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _99.CodeInfo;
+                fromPartial(object: {
+                    codeHash?: Uint8Array;
+                    creator?: string;
+                    instantiateConfig?: {
+                        permission?: _99.AccessType;
+                        address?: string;
+                    };
+                }): _99.CodeInfo;
+            };
+            ContractInfo: {
+                encode(message: _99.ContractInfo, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _99.ContractInfo;
+                fromPartial(object: {
+                    codeId?: any;
+                    creator?: string;
+                    admin?: string;
+                    label?: string;
+                    created?: {
+                        blockHeight?: any;
+                        txIndex?: any;
+                    };
+                    ibcPortId?: string;
+                    extension?: {
+                        typeUrl?: string;
+                        value?: Uint8Array;
+                    };
+                }): _99.ContractInfo;
+            };
+            ContractCodeHistoryEntry: {
+                encode(message: _99.ContractCodeHistoryEntry, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _99.ContractCodeHistoryEntry;
+                fromPartial(object: {
+                    operation?: _99.ContractCodeHistoryOperationType;
+                    codeId?: any;
+                    updated?: {
+                        blockHeight?: any;
+                        txIndex?: any;
+                    };
+                    msg?: Uint8Array;
+                }): _99.ContractCodeHistoryEntry;
+            };
+            AbsoluteTxPosition: {
+                encode(message: _99.AbsoluteTxPosition, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _99.AbsoluteTxPosition;
+                fromPartial(object: {
+                    blockHeight?: any;
+                    txIndex?: any;
+                }): _99.AbsoluteTxPosition;
+            };
+            Model: {
+                encode(message: _99.Model, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _99.Model;
+                fromPartial(object: {
+                    key?: Uint8Array;
+                    value?: Uint8Array;
+                }): _99.Model;
+            };
+            MsgStoreCode: {
+                encode(message: _98.MsgStoreCode, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _98.MsgStoreCode;
+                fromPartial(object: {
+                    sender?: string;
+                    wasmByteCode?: Uint8Array;
+                    instantiatePermission?: {
+                        permission?: _99.AccessType;
+                        address?: string;
+                    };
+                }): _98.MsgStoreCode;
+            };
+            MsgStoreCodeResponse: {
+                encode(message: _98.MsgStoreCodeResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _98.MsgStoreCodeResponse;
+                fromPartial(object: {
+                    codeId?: any;
+                }): _98.MsgStoreCodeResponse;
+            };
+            MsgInstantiateContract: {
+                encode(message: _98.MsgInstantiateContract, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _98.MsgInstantiateContract;
+                fromPartial(object: {
+                    sender?: string;
+                    admin?: string;
+                    codeId?: any;
+                    label?: string;
+                    msg?: Uint8Array;
+                    funds?: {
+                        denom?: string;
+                        amount?: string;
+                    }[];
+                }): _98.MsgInstantiateContract;
+            };
+            MsgInstantiateContractResponse: {
+                encode(message: _98.MsgInstantiateContractResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _98.MsgInstantiateContractResponse;
+                fromPartial(object: {
+                    address?: string;
+                    data?: Uint8Array;
+                }): _98.MsgInstantiateContractResponse;
+            };
+            MsgExecuteContract: {
+                encode(message: _98.MsgExecuteContract, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _98.MsgExecuteContract;
+                fromPartial(object: {
+                    sender?: string;
+                    contract?: string;
+                    msg?: Uint8Array;
+                    funds?: {
+                        denom?: string;
+                        amount?: string;
+                    }[];
+                }): _98.MsgExecuteContract;
+            };
+            MsgExecuteContractResponse: {
+                encode(message: _98.MsgExecuteContractResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _98.MsgExecuteContractResponse;
+                fromPartial(object: {
+                    data?: Uint8Array;
+                }): _98.MsgExecuteContractResponse;
+            };
+            MsgMigrateContract: {
+                encode(message: _98.MsgMigrateContract, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _98.MsgMigrateContract;
+                fromPartial(object: {
+                    sender?: string;
+                    contract?: string;
+                    codeId?: any;
+                    msg?: Uint8Array;
+                }): _98.MsgMigrateContract;
+            };
+            MsgMigrateContractResponse: {
+                encode(message: _98.MsgMigrateContractResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _98.MsgMigrateContractResponse;
+                fromPartial(object: {
+                    data?: Uint8Array;
+                }): _98.MsgMigrateContractResponse;
+            };
+            MsgUpdateAdmin: {
+                encode(message: _98.MsgUpdateAdmin, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _98.MsgUpdateAdmin;
+                fromPartial(object: {
+                    sender?: string;
+                    newAdmin?: string;
+                    contract?: string;
+                }): _98.MsgUpdateAdmin;
+            };
+            MsgUpdateAdminResponse: {
+                encode(_: _98.MsgUpdateAdminResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _98.MsgUpdateAdminResponse;
+                fromPartial(_: {}): _98.MsgUpdateAdminResponse;
+            };
+            MsgClearAdmin: {
+                encode(message: _98.MsgClearAdmin, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _98.MsgClearAdmin;
+                fromPartial(object: {
+                    sender?: string;
+                    contract?: string;
+                }): _98.MsgClearAdmin;
+            };
+            MsgClearAdminResponse: {
+                encode(_: _98.MsgClearAdminResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _98.MsgClearAdminResponse;
+                fromPartial(_: {}): _98.MsgClearAdminResponse;
+            };
+            QueryContractInfoRequest: {
+                encode(message: _97.QueryContractInfoRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryContractInfoRequest;
+                fromPartial(object: {
+                    address?: string;
+                }): _97.QueryContractInfoRequest;
+            };
+            QueryContractInfoResponse: {
+                encode(message: _97.QueryContractInfoResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryContractInfoResponse;
+                fromPartial(object: {
+                    address?: string;
+                    contractInfo?: {
+                        codeId?: any;
+                        creator?: string;
+                        admin?: string;
+                        label?: string;
+                        created?: {
+                            blockHeight?: any;
+                            txIndex?: any;
+                        };
+                        ibcPortId?: string;
+                        extension?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                    };
+                }): _97.QueryContractInfoResponse;
+            };
+            QueryContractHistoryRequest: {
+                encode(message: _97.QueryContractHistoryRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryContractHistoryRequest;
+                fromPartial(object: {
+                    address?: string;
+                    pagination?: {
+                        key?: Uint8Array;
+                        offset?: any;
+                        limit?: any;
+                        countTotal?: boolean;
+                        reverse?: boolean;
+                    };
+                }): _97.QueryContractHistoryRequest;
+            };
+            QueryContractHistoryResponse: {
+                encode(message: _97.QueryContractHistoryResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryContractHistoryResponse;
+                fromPartial(object: {
+                    entries?: {
+                        operation?: _99.ContractCodeHistoryOperationType;
+                        codeId?: any;
+                        updated?: {
+                            blockHeight?: any;
+                            txIndex?: any;
+                        };
+                        msg?: Uint8Array;
+                    }[];
+                    pagination?: {
+                        nextKey?: Uint8Array;
+                        total?: any;
+                    };
+                }): _97.QueryContractHistoryResponse;
+            };
+            QueryContractsByCodeRequest: {
+                encode(message: _97.QueryContractsByCodeRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryContractsByCodeRequest;
+                fromPartial(object: {
+                    codeId?: any;
+                    pagination?: {
+                        key?: Uint8Array;
+                        offset?: any;
+                        limit?: any;
+                        countTotal?: boolean;
+                        reverse?: boolean;
+                    };
+                }): _97.QueryContractsByCodeRequest;
+            };
+            QueryContractsByCodeResponse: {
+                encode(message: _97.QueryContractsByCodeResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryContractsByCodeResponse;
+                fromPartial(object: {
+                    contracts?: string[];
+                    pagination?: {
+                        nextKey?: Uint8Array;
+                        total?: any;
+                    };
+                }): _97.QueryContractsByCodeResponse;
+            };
+            QueryAllContractStateRequest: {
+                encode(message: _97.QueryAllContractStateRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryAllContractStateRequest;
+                fromPartial(object: {
+                    address?: string;
+                    pagination?: {
+                        key?: Uint8Array;
+                        offset?: any;
+                        limit?: any;
+                        countTotal?: boolean;
+                        reverse?: boolean;
+                    };
+                }): _97.QueryAllContractStateRequest;
+            };
+            QueryAllContractStateResponse: {
+                encode(message: _97.QueryAllContractStateResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryAllContractStateResponse;
+                fromPartial(object: {
+                    models?: {
+                        key?: Uint8Array;
+                        value?: Uint8Array;
+                    }[];
+                    pagination?: {
+                        nextKey?: Uint8Array;
+                        total?: any;
+                    };
+                }): _97.QueryAllContractStateResponse;
+            };
+            QueryRawContractStateRequest: {
+                encode(message: _97.QueryRawContractStateRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryRawContractStateRequest;
+                fromPartial(object: {
+                    address?: string;
+                    queryData?: Uint8Array;
+                }): _97.QueryRawContractStateRequest;
+            };
+            QueryRawContractStateResponse: {
+                encode(message: _97.QueryRawContractStateResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryRawContractStateResponse;
+                fromPartial(object: {
+                    data?: Uint8Array;
+                }): _97.QueryRawContractStateResponse;
+            };
+            QuerySmartContractStateRequest: {
+                encode(message: _97.QuerySmartContractStateRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QuerySmartContractStateRequest;
+                fromPartial(object: {
+                    address?: string;
+                    queryData?: Uint8Array;
+                }): _97.QuerySmartContractStateRequest;
+            };
+            QuerySmartContractStateResponse: {
+                encode(message: _97.QuerySmartContractStateResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QuerySmartContractStateResponse;
+                fromPartial(object: {
+                    data?: Uint8Array;
+                }): _97.QuerySmartContractStateResponse;
+            };
+            QueryCodeRequest: {
+                encode(message: _97.QueryCodeRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryCodeRequest;
+                fromPartial(object: {
+                    codeId?: any;
+                }): _97.QueryCodeRequest;
+            };
+            CodeInfoResponse: {
+                encode(message: _97.CodeInfoResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.CodeInfoResponse;
+                fromPartial(object: {
+                    codeId?: any;
+                    creator?: string;
+                    dataHash?: Uint8Array;
+                }): _97.CodeInfoResponse;
+            };
+            QueryCodeResponse: {
+                encode(message: _97.QueryCodeResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryCodeResponse;
+                fromPartial(object: {
+                    codeInfo?: {
+                        codeId?: any;
+                        creator?: string;
+                        dataHash?: Uint8Array;
+                    };
+                    data?: Uint8Array;
+                }): _97.QueryCodeResponse;
+            };
+            QueryCodesRequest: {
+                encode(message: _97.QueryCodesRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryCodesRequest;
+                fromPartial(object: {
+                    pagination?: {
+                        key?: Uint8Array;
+                        offset?: any;
+                        limit?: any;
+                        countTotal?: boolean;
+                        reverse?: boolean;
+                    };
+                }): _97.QueryCodesRequest;
+            };
+            QueryCodesResponse: {
+                encode(message: _97.QueryCodesResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryCodesResponse;
+                fromPartial(object: {
+                    codeInfos?: {
+                        codeId?: any;
+                        creator?: string;
+                        dataHash?: Uint8Array;
+                    }[];
+                    pagination?: {
+                        nextKey?: Uint8Array;
+                        total?: any;
+                    };
+                }): _97.QueryCodesResponse;
+            };
+            QueryPinnedCodesRequest: {
+                encode(message: _97.QueryPinnedCodesRequest, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryPinnedCodesRequest;
+                fromPartial(object: {
+                    pagination?: {
+                        key?: Uint8Array;
+                        offset?: any;
+                        limit?: any;
+                        countTotal?: boolean;
+                        reverse?: boolean;
+                    };
+                }): _97.QueryPinnedCodesRequest;
+            };
+            QueryPinnedCodesResponse: {
+                encode(message: _97.QueryPinnedCodesResponse, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _97.QueryPinnedCodesResponse;
+                fromPartial(object: {
+                    codeIds?: any[];
+                    pagination?: {
+                        nextKey?: Uint8Array;
+                        total?: any;
+                    };
+                }): _97.QueryPinnedCodesResponse;
+            };
+            StoreCodeProposal: {
+                encode(message: _96.StoreCodeProposal, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _96.StoreCodeProposal;
+                fromPartial(object: {
+                    title?: string;
+                    description?: string;
+                    runAs?: string;
+                    wasmByteCode?: Uint8Array;
+                    instantiatePermission?: {
+                        permission?: _99.AccessType;
+                        address?: string;
+                    };
+                }): _96.StoreCodeProposal;
+            };
+            InstantiateContractProposal: {
+                encode(message: _96.InstantiateContractProposal, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _96.InstantiateContractProposal;
+                fromPartial(object: {
+                    title?: string;
+                    description?: string;
+                    runAs?: string;
+                    admin?: string;
+                    codeId?: any;
+                    label?: string;
+                    msg?: Uint8Array;
+                    funds?: {
+                        denom?: string;
+                        amount?: string;
+                    }[];
+                }): _96.InstantiateContractProposal;
+            };
+            MigrateContractProposal: {
+                encode(message: _96.MigrateContractProposal, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _96.MigrateContractProposal;
+                fromPartial(object: {
+                    title?: string;
+                    description?: string;
+                    contract?: string;
+                    codeId?: any;
+                    msg?: Uint8Array;
+                }): _96.MigrateContractProposal;
+            };
+            SudoContractProposal: {
+                encode(message: _96.SudoContractProposal, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _96.SudoContractProposal;
+                fromPartial(object: {
+                    title?: string;
+                    description?: string;
+                    contract?: string;
+                    msg?: Uint8Array;
+                }): _96.SudoContractProposal;
+            };
+            ExecuteContractProposal: {
+                encode(message: _96.ExecuteContractProposal, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _96.ExecuteContractProposal;
+                fromPartial(object: {
+                    title?: string;
+                    description?: string;
+                    runAs?: string;
+                    contract?: string;
+                    msg?: Uint8Array;
+                    funds?: {
+                        denom?: string;
+                        amount?: string;
+                    }[];
+                }): _96.ExecuteContractProposal;
+            };
+            UpdateAdminProposal: {
+                encode(message: _96.UpdateAdminProposal, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _96.UpdateAdminProposal;
+                fromPartial(object: {
+                    title?: string;
+                    description?: string;
+                    newAdmin?: string;
+                    contract?: string;
+                }): _96.UpdateAdminProposal;
+            };
+            ClearAdminProposal: {
+                encode(message: _96.ClearAdminProposal, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _96.ClearAdminProposal;
+                fromPartial(object: {
+                    title?: string;
+                    description?: string;
+                    contract?: string;
+                }): _96.ClearAdminProposal;
+            };
+            PinCodesProposal: {
+                encode(message: _96.PinCodesProposal, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _96.PinCodesProposal;
+                fromPartial(object: {
+                    title?: string;
+                    description?: string;
+                    codeIds?: any[];
+                }): _96.PinCodesProposal;
+            };
+            UnpinCodesProposal: {
+                encode(message: _96.UnpinCodesProposal, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _96.UnpinCodesProposal;
+                fromPartial(object: {
+                    title?: string;
+                    description?: string;
+                    codeIds?: any[];
+                }): _96.UnpinCodesProposal;
+            };
+            MsgIBCSend: {
+                encode(message: _95.MsgIBCSend, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _95.MsgIBCSend;
+                fromPartial(object: {
+                    channel?: string;
+                    timeoutHeight?: any;
+                    timeoutTimestamp?: any;
+                    data?: Uint8Array;
+                }): _95.MsgIBCSend;
+            };
+            MsgIBCCloseChannel: {
+                encode(message: _95.MsgIBCCloseChannel, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _95.MsgIBCCloseChannel;
+                fromPartial(object: {
+                    channel?: string;
+                }): _95.MsgIBCCloseChannel;
+            };
+            GenesisState: {
+                encode(message: _94.GenesisState, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _94.GenesisState;
+                fromPartial(object: {
+                    params?: {
+                        codeUploadAccess?: {
+                            permission?: _99.AccessType;
+                            address?: string;
+                        };
+                        instantiateDefaultPermission?: _99.AccessType;
+                        maxWasmCodeSize?: any;
+                    };
+                    codes?: {
+                        codeId?: any;
+                        codeInfo?: {
+                            codeHash?: Uint8Array;
+                            creator?: string;
+                            instantiateConfig?: {
+                                permission?: _99.AccessType;
+                                address?: string;
+                            };
+                        };
+                        codeBytes?: Uint8Array;
+                        pinned?: boolean;
+                    }[];
+                    contracts?: {
+                        contractAddress?: string;
+                        contractInfo?: {
+                            codeId?: any;
+                            creator?: string;
+                            admin?: string;
+                            label?: string;
+                            created?: {
+                                blockHeight?: any;
+                                txIndex?: any;
+                            };
+                            ibcPortId?: string;
+                            extension?: {
+                                typeUrl?: string;
+                                value?: Uint8Array;
+                            };
+                        };
+                        contractState?: {
+                            key?: Uint8Array;
+                            value?: Uint8Array;
+                        }[];
+                    }[];
+                    sequences?: {
+                        idKey?: Uint8Array;
+                        value?: any;
+                    }[];
+                    genMsgs?: {
+                        storeCode?: {
+                            sender?: string;
+                            wasmByteCode?: Uint8Array;
+                            instantiatePermission?: {
+                                permission?: _99.AccessType;
+                                address?: string;
+                            };
+                        };
+                        instantiateContract?: {
+                            sender?: string;
+                            admin?: string;
+                            codeId?: any;
+                            label?: string;
+                            msg?: Uint8Array;
+                            funds?: {
+                                denom?: string;
+                                amount?: string;
+                            }[];
+                        };
+                        executeContract?: {
+                            sender?: string;
+                            contract?: string;
+                            msg?: Uint8Array;
+                            funds?: {
+                                denom?: string;
+                                amount?: string;
+                            }[];
+                        };
+                    }[];
+                }): _94.GenesisState;
+            };
+            GenesisState_GenMsgs: {
+                encode(message: _94.GenesisState_GenMsgs, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _94.GenesisState_GenMsgs;
+                fromPartial(object: {
+                    storeCode?: {
+                        sender?: string;
+                        wasmByteCode?: Uint8Array;
+                        instantiatePermission?: {
+                            permission?: _99.AccessType;
+                            address?: string;
+                        };
+                    };
+                    instantiateContract?: {
+                        sender?: string;
+                        admin?: string;
+                        codeId?: any;
+                        label?: string;
+                        msg?: Uint8Array;
+                        funds?: {
+                            denom?: string;
+                            amount?: string;
+                        }[];
+                    };
+                    executeContract?: {
+                        sender?: string;
+                        contract?: string;
+                        msg?: Uint8Array;
+                        funds?: {
+                            denom?: string;
+                            amount?: string;
+                        }[];
+                    };
+                }): _94.GenesisState_GenMsgs;
+            };
+            Code: {
+                encode(message: _94.Code, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _94.Code;
+                fromPartial(object: {
+                    codeId?: any;
+                    codeInfo?: {
+                        codeHash?: Uint8Array;
+                        creator?: string;
+                        instantiateConfig?: {
+                            permission?: _99.AccessType;
+                            address?: string;
+                        };
+                    };
+                    codeBytes?: Uint8Array;
+                    pinned?: boolean;
+                }): _94.Code;
+            };
+            Contract: {
+                encode(message: _94.Contract, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _94.Contract;
+                fromPartial(object: {
+                    contractAddress?: string;
+                    contractInfo?: {
+                        codeId?: any;
+                        creator?: string;
+                        admin?: string;
+                        label?: string;
+                        created?: {
+                            blockHeight?: any;
+                            txIndex?: any;
+                        };
+                        ibcPortId?: string;
+                        extension?: {
+                            typeUrl?: string;
+                            value?: Uint8Array;
+                        };
+                    };
+                    contractState?: {
+                        key?: Uint8Array;
+                        value?: Uint8Array;
+                    }[];
+                }): _94.Contract;
+            };
+            Sequence: {
+                encode(message: _94.Sequence, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+                decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _94.Sequence;
+                fromPartial(object: {
+                    idKey?: Uint8Array;
+                    value?: any;
+                }): _94.Sequence;
+            };
+        };
+    }
+    const ClientFactory: {
+        createRPCMsgClient: ({ rpc }: {
+            rpc: import("@osmonauts/helpers").Rpc;
+        }) => Promise<{
+            cosmos: {
+                authz: {
+                    v1beta1: import("../cosmos/authz/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                bank: {
+                    v1beta1: import("../cosmos/bank/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                crisis: {
+                    v1beta1: import("../cosmos/crisis/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                distribution: {
+                    v1beta1: import("../cosmos/distribution/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                evidence: {
+                    v1beta1: import("../cosmos/evidence/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;
+                };
+                nft: {
+                    v1beta1: import("../cosmos/nft/v1beta1/tx.rpc.msg").MsgClientImpl;
+                };
+                slashing: {
+                    v1beta1: import("../cosmos/slashing/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: _269.MsgClientImpl;
+                };
+            };
+        }>;
+        createRPCQueryClient: ({ rpcEndpoint }: {
+            rpcEndpoint: string;
+        }) => Promise<{
+            cosmos: {
+                app: {
+                    v1alpha1: {
+                        config(request?: import("../cosmos/app/v1alpha1/query").QueryConfigRequest): Promise<import("../cosmos/app/v1alpha1/query").QueryConfigResponse>;
+                    };
+                };
+                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>;
+                        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>;
+                        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>;
+                    };
+                };
+                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>;
+                        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>;
+                        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>;
+                    };
+                };
+                base: {
+                    tendermint: {
+                        v1beta1: {
+                            getNodeInfo(request?: import("../cosmos/base/tendermint/v1beta1/query").GetNodeInfoRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetNodeInfoResponse>;
+                            getSyncing(request?: import("../cosmos/base/tendermint/v1beta1/query").GetSyncingRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetSyncingResponse>;
+                            getLatestBlock(request?: import("../cosmos/base/tendermint/v1beta1/query").GetLatestBlockRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetLatestBlockResponse>;
+                            getBlockByHeight(request: import("../cosmos/base/tendermint/v1beta1/query").GetBlockByHeightRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetBlockByHeightResponse>;
+                            getLatestValidatorSet(request?: import("../cosmos/base/tendermint/v1beta1/query").GetLatestValidatorSetRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetLatestValidatorSetResponse>;
+                            getValidatorSetByHeight(request: import("../cosmos/base/tendermint/v1beta1/query").GetValidatorSetByHeightRequest): Promise<import("../cosmos/base/tendermint/v1beta1/query").GetValidatorSetByHeightResponse>;
+                        };
+                    };
+                };
+                distribution: {
+                    v1beta1: {
+                        params(request?: import("../cosmos/distribution/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/distribution/v1beta1/query").QueryParamsResponse>;
+                        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>;
+                    };
+                };
+                evidence: {
+                    v1beta1: {
+                        evidence(request: import("../cosmos/evidence/v1beta1/query").QueryEvidenceRequest): Promise<import("../cosmos/evidence/v1beta1/query").QueryEvidenceResponse>;
+                        allEvidence(request?: import("../cosmos/evidence/v1beta1/query").QueryAllEvidenceRequest): Promise<import("../cosmos/evidence/v1beta1/query").QueryAllEvidenceResponse>;
+                    };
+                };
+                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: {
+                        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>;
+                    };
+                };
+                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>;
+                    };
+                };
+                nft: {
+                    v1beta1: {
+                        balance(request: import("../cosmos/nft/v1beta1/query").QueryBalanceRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryBalanceResponse>;
+                        owner(request: import("../cosmos/nft/v1beta1/query").QueryOwnerRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryOwnerResponse>;
+                        supply(request: import("../cosmos/nft/v1beta1/query").QuerySupplyRequest): Promise<import("../cosmos/nft/v1beta1/query").QuerySupplyResponse>;
+                        nFTs(request: import("../cosmos/nft/v1beta1/query").QueryNFTsRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryNFTsResponse>;
+                        nFT(request: import("../cosmos/nft/v1beta1/query").QueryNFTRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryNFTResponse>;
+                        class(request: import("../cosmos/nft/v1beta1/query").QueryClassRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryClassResponse>;
+                        classes(request?: import("../cosmos/nft/v1beta1/query").QueryClassesRequest): Promise<import("../cosmos/nft/v1beta1/query").QueryClassesResponse>;
+                    };
+                };
+                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>;
+                    };
+                };
+                slashing: {
+                    v1beta1: {
+                        params(request?: import("../cosmos/slashing/v1beta1/query").QueryParamsRequest): Promise<import("../cosmos/slashing/v1beta1/query").QueryParamsResponse>;
+                        signingInfo(request: import("../cosmos/slashing/v1beta1/query").QuerySigningInfoRequest): Promise<import("../cosmos/slashing/v1beta1/query").QuerySigningInfoResponse>;
+                        signingInfos(request?: import("../cosmos/slashing/v1beta1/query").QuerySigningInfosRequest): Promise<import("../cosmos/slashing/v1beta1/query").QuerySigningInfosResponse>;
+                    };
+                };
+                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>;
+                    };
+                };
+                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: _97.QueryContractInfoRequest): Promise<_97.QueryContractInfoResponse>;
+                        contractHistory(request: _97.QueryContractHistoryRequest): Promise<_97.QueryContractHistoryResponse>;
+                        contractsByCode(request: _97.QueryContractsByCodeRequest): Promise<_97.QueryContractsByCodeResponse>;
+                        allContractState(request: _97.QueryAllContractStateRequest): Promise<_97.QueryAllContractStateResponse>;
+                        rawContractState(request: _97.QueryRawContractStateRequest): Promise<_97.QueryRawContractStateResponse>;
+                        smartContractState(request: _97.QuerySmartContractStateRequest): Promise<_97.QuerySmartContractStateResponse>;
+                        code(request: _97.QueryCodeRequest): Promise<_97.QueryCodeResponse>;
+                        codes(request?: _97.QueryCodesRequest): Promise<_97.QueryCodesResponse>;
+                        pinnedCodes(request?: _97.QueryPinnedCodesRequest): Promise<_97.QueryPinnedCodesResponse>;
+                    };
+                };
+            };
+        }>;
+        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: {
+                    tendermint: {
+                        v1beta1: import("../cosmos/base/tendermint/v1beta1/query.lcd").LCDQueryClient;
+                    };
+                };
+                distribution: {
+                    v1beta1: import("../cosmos/distribution/v1beta1/query.lcd").LCDQueryClient;
+                };
+                evidence: {
+                    v1beta1: import("../cosmos/evidence/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;
+                };
+                nft: {
+                    v1beta1: import("../cosmos/nft/v1beta1/query.lcd").LCDQueryClient;
+                };
+                params: {
+                    v1beta1: import("../cosmos/params/v1beta1/query.lcd").LCDQueryClient;
+                };
+                slashing: {
+                    v1beta1: import("../cosmos/slashing/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: _267.LCDQueryClient;
+                };
+            };
+        }>;
+    };
+}