@sparkdreamnft/sparkdreamjs 0.0.2 → 0.0.4

package/ibc/bundle.d.ts

@@ -80,58 +80,14 @@ export declare namespace ibc {
             namespace controller {
                 const v1: {
                     MsgClientImpl: typeof _317.MsgClientImpl;
+                    createClientImpl: (rpc: import("..").TxRpc) => _317.MsgClientImpl;
                     QueryClientImpl: typeof _308.QueryClientImpl;
                     createRpcQueryExtension: (base: QueryClient) => {
                         interchainAccount(request: _125.QueryInterchainAccountRequest): Promise<_125.QueryInterchainAccountResponse>;
                         params(request?: _125.QueryParamsRequest): Promise<_125.QueryParamsResponse>;
                     };
                     LCDQueryClient: typeof _299.LCDQueryClient;
-                    registry: ReadonlyArray<[string, GeneratedType]>;
-                    load: (protoRegistry: Registry) => void;
-                    MessageComposer: {
-                        encoded: {
-                            registerInterchainAccount(value: _126.MsgRegisterInterchainAccount): {
-                                typeUrl: string;
-                                value: Uint8Array<ArrayBufferLike>;
-                            };
-                            sendTx(value: _126.MsgSendTx): {
-                                typeUrl: string;
-                                value: Uint8Array<ArrayBufferLike>;
-                            };
-                            updateParams(value: _126.MsgUpdateParams): {
-                                typeUrl: string;
-                                value: Uint8Array<ArrayBufferLike>;
-                            };
-                        };
-                        withTypeUrl: {
-                            registerInterchainAccount(value: _126.MsgRegisterInterchainAccount): {
-                                typeUrl: string;
-                                value: _126.MsgRegisterInterchainAccount;
-                            };
-                            sendTx(value: _126.MsgSendTx): {
-                                typeUrl: string;
-                                value: _126.MsgSendTx;
-                            };
-                            updateParams(value: _126.MsgUpdateParams): {
-                                typeUrl: string;
-                                value: _126.MsgUpdateParams;
-                            };
-                        };
-                        fromPartial: {
-                            registerInterchainAccount(value: _126.MsgRegisterInterchainAccount): {
-                                typeUrl: string;
-                                value: _126.MsgRegisterInterchainAccount;
-                            };
-                            sendTx(value: _126.MsgSendTx): {
-                                typeUrl: string;
-                                value: _126.MsgSendTx;
-                            };
-                            updateParams(value: _126.MsgUpdateParams): {
-                                typeUrl: string;
-                                value: _126.MsgUpdateParams;
-                            };
-                        };
-                    };
+                    registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
                     AminoConverter: {
                         "/ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount": {
                             aminoType: string;
@@ -151,9 +107,10 @@ export declare namespace ibc {
                     };
                     MsgRegisterInterchainAccount: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _126.MsgRegisterInterchainAccount, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgRegisterInterchainAccount;
-                        fromPartial(object: Partial<_126.MsgRegisterInterchainAccount>): _126.MsgRegisterInterchainAccount;
+                        fromPartial(object: import("../helpers").DeepPartial<_126.MsgRegisterInterchainAccount>): _126.MsgRegisterInterchainAccount;
                         fromAmino(object: _126.MsgRegisterInterchainAccountAmino): _126.MsgRegisterInterchainAccount;
                         toAmino(message: _126.MsgRegisterInterchainAccount): _126.MsgRegisterInterchainAccountAmino;
                         fromAminoMsg(object: _126.MsgRegisterInterchainAccountAminoMsg): _126.MsgRegisterInterchainAccount;
@@ -164,9 +121,10 @@ export declare namespace ibc {
                     };
                     MsgRegisterInterchainAccountResponse: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _126.MsgRegisterInterchainAccountResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgRegisterInterchainAccountResponse;
-                        fromPartial(object: Partial<_126.MsgRegisterInterchainAccountResponse>): _126.MsgRegisterInterchainAccountResponse;
+                        fromPartial(object: import("../helpers").DeepPartial<_126.MsgRegisterInterchainAccountResponse>): _126.MsgRegisterInterchainAccountResponse;
                         fromAmino(object: _126.MsgRegisterInterchainAccountResponseAmino): _126.MsgRegisterInterchainAccountResponse;
                         toAmino(message: _126.MsgRegisterInterchainAccountResponse): _126.MsgRegisterInterchainAccountResponseAmino;
                         fromAminoMsg(object: _126.MsgRegisterInterchainAccountResponseAminoMsg): _126.MsgRegisterInterchainAccountResponse;
@@ -177,9 +135,10 @@ export declare namespace ibc {
                     };
                     MsgSendTx: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _126.MsgSendTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgSendTx;
-                        fromPartial(object: Partial<_126.MsgSendTx>): _126.MsgSendTx;
+                        fromPartial(object: import("../helpers").DeepPartial<_126.MsgSendTx>): _126.MsgSendTx;
                         fromAmino(object: _126.MsgSendTxAmino): _126.MsgSendTx;
                         toAmino(message: _126.MsgSendTx): _126.MsgSendTxAmino;
                         fromAminoMsg(object: _126.MsgSendTxAminoMsg): _126.MsgSendTx;
@@ -190,9 +149,10 @@ export declare namespace ibc {
                     };
                     MsgSendTxResponse: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _126.MsgSendTxResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgSendTxResponse;
-                        fromPartial(object: Partial<_126.MsgSendTxResponse>): _126.MsgSendTxResponse;
+                        fromPartial(object: import("../helpers").DeepPartial<_126.MsgSendTxResponse>): _126.MsgSendTxResponse;
                         fromAmino(object: _126.MsgSendTxResponseAmino): _126.MsgSendTxResponse;
                         toAmino(message: _126.MsgSendTxResponse): _126.MsgSendTxResponseAmino;
                         fromAminoMsg(object: _126.MsgSendTxResponseAminoMsg): _126.MsgSendTxResponse;
@@ -203,9 +163,10 @@ export declare namespace ibc {
                     };
                     MsgUpdateParams: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _126.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgUpdateParams;
-                        fromPartial(object: Partial<_126.MsgUpdateParams>): _126.MsgUpdateParams;
+                        fromPartial(object: import("../helpers").DeepPartial<_126.MsgUpdateParams>): _126.MsgUpdateParams;
                         fromAmino(object: _126.MsgUpdateParamsAmino): _126.MsgUpdateParams;
                         toAmino(message: _126.MsgUpdateParams): _126.MsgUpdateParamsAmino;
                         fromAminoMsg(object: _126.MsgUpdateParamsAminoMsg): _126.MsgUpdateParams;
@@ -216,9 +177,10 @@ export declare namespace ibc {
                     };
                     MsgUpdateParamsResponse: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(_: _126.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _126.MsgUpdateParamsResponse;
-                        fromPartial(_: Partial<_126.MsgUpdateParamsResponse>): _126.MsgUpdateParamsResponse;
+                        fromPartial(_: import("../helpers").DeepPartial<_126.MsgUpdateParamsResponse>): _126.MsgUpdateParamsResponse;
                         fromAmino(_: _126.MsgUpdateParamsResponseAmino): _126.MsgUpdateParamsResponse;
                         toAmino(_: _126.MsgUpdateParamsResponse): _126.MsgUpdateParamsResponseAmino;
                         fromAminoMsg(object: _126.MsgUpdateParamsResponseAminoMsg): _126.MsgUpdateParamsResponse;
@@ -229,9 +191,10 @@ export declare namespace ibc {
                     };
                     QueryInterchainAccountRequest: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _125.QueryInterchainAccountRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.QueryInterchainAccountRequest;
-                        fromPartial(object: Partial<_125.QueryInterchainAccountRequest>): _125.QueryInterchainAccountRequest;
+                        fromPartial(object: import("../helpers").DeepPartial<_125.QueryInterchainAccountRequest>): _125.QueryInterchainAccountRequest;
                         fromAmino(object: _125.QueryInterchainAccountRequestAmino): _125.QueryInterchainAccountRequest;
                         toAmino(message: _125.QueryInterchainAccountRequest): _125.QueryInterchainAccountRequestAmino;
                         fromAminoMsg(object: _125.QueryInterchainAccountRequestAminoMsg): _125.QueryInterchainAccountRequest;
@@ -242,9 +205,10 @@ export declare namespace ibc {
                     };
                     QueryInterchainAccountResponse: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _125.QueryInterchainAccountResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.QueryInterchainAccountResponse;
-                        fromPartial(object: Partial<_125.QueryInterchainAccountResponse>): _125.QueryInterchainAccountResponse;
+                        fromPartial(object: import("../helpers").DeepPartial<_125.QueryInterchainAccountResponse>): _125.QueryInterchainAccountResponse;
                         fromAmino(object: _125.QueryInterchainAccountResponseAmino): _125.QueryInterchainAccountResponse;
                         toAmino(message: _125.QueryInterchainAccountResponse): _125.QueryInterchainAccountResponseAmino;
                         fromAminoMsg(object: _125.QueryInterchainAccountResponseAminoMsg): _125.QueryInterchainAccountResponse;
@@ -255,9 +219,10 @@ export declare namespace ibc {
                     };
                     QueryParamsRequest: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(_: _125.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.QueryParamsRequest;
-                        fromPartial(_: Partial<_125.QueryParamsRequest>): _125.QueryParamsRequest;
+                        fromPartial(_: import("../helpers").DeepPartial<_125.QueryParamsRequest>): _125.QueryParamsRequest;
                         fromAmino(_: _125.QueryParamsRequestAmino): _125.QueryParamsRequest;
                         toAmino(_: _125.QueryParamsRequest): _125.QueryParamsRequestAmino;
                         fromAminoMsg(object: _125.QueryParamsRequestAminoMsg): _125.QueryParamsRequest;
@@ -268,9 +233,10 @@ export declare namespace ibc {
                     };
                     QueryParamsResponse: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _125.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _125.QueryParamsResponse;
-                        fromPartial(object: Partial<_125.QueryParamsResponse>): _125.QueryParamsResponse;
+                        fromPartial(object: import("../helpers").DeepPartial<_125.QueryParamsResponse>): _125.QueryParamsResponse;
                         fromAmino(object: _125.QueryParamsResponseAmino): _125.QueryParamsResponse;
                         toAmino(message: _125.QueryParamsResponse): _125.QueryParamsResponseAmino;
                         fromAminoMsg(object: _125.QueryParamsResponseAminoMsg): _125.QueryParamsResponse;
@@ -281,9 +247,10 @@ export declare namespace ibc {
                     };
                     Params: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _124.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _124.Params;
-                        fromPartial(object: Partial<_124.Params>): _124.Params;
+                        fromPartial(object: import("../helpers").DeepPartial<_124.Params>): _124.Params;
                         fromAmino(object: _124.ParamsAmino): _124.Params;
                         toAmino(message: _124.Params): _124.ParamsAmino;
                         fromAminoMsg(object: _124.ParamsAminoMsg): _124.Params;
@@ -298,9 +265,10 @@ export declare namespace ibc {
                 const v1: {
                     GenesisState: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _127.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _127.GenesisState;
-                        fromPartial(object: Partial<_127.GenesisState>): _127.GenesisState;
+                        fromPartial(object: import("../helpers").DeepPartial<_127.GenesisState>): _127.GenesisState;
                         fromAmino(object: _127.GenesisStateAmino): _127.GenesisState;
                         toAmino(message: _127.GenesisState): _127.GenesisStateAmino;
                         fromAminoMsg(object: _127.GenesisStateAminoMsg): _127.GenesisState;
@@ -311,9 +279,10 @@ export declare namespace ibc {
                     };
                     ControllerGenesisState: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _127.ControllerGenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _127.ControllerGenesisState;
-                        fromPartial(object: Partial<_127.ControllerGenesisState>): _127.ControllerGenesisState;
+                        fromPartial(object: import("../helpers").DeepPartial<_127.ControllerGenesisState>): _127.ControllerGenesisState;
                         fromAmino(object: _127.ControllerGenesisStateAmino): _127.ControllerGenesisState;
                         toAmino(message: _127.ControllerGenesisState): _127.ControllerGenesisStateAmino;
                         fromAminoMsg(object: _127.ControllerGenesisStateAminoMsg): _127.ControllerGenesisState;
@@ -324,9 +293,10 @@ export declare namespace ibc {
                     };
                     HostGenesisState: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _127.HostGenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _127.HostGenesisState;
-                        fromPartial(object: Partial<_127.HostGenesisState>): _127.HostGenesisState;
+                        fromPartial(object: import("../helpers").DeepPartial<_127.HostGenesisState>): _127.HostGenesisState;
                         fromAmino(object: _127.HostGenesisStateAmino): _127.HostGenesisState;
                         toAmino(message: _127.HostGenesisState): _127.HostGenesisStateAmino;
                         fromAminoMsg(object: _127.HostGenesisStateAminoMsg): _127.HostGenesisState;
@@ -337,9 +307,10 @@ export declare namespace ibc {
                     };
                     ActiveChannel: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _127.ActiveChannel, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _127.ActiveChannel;
-                        fromPartial(object: Partial<_127.ActiveChannel>): _127.ActiveChannel;
+                        fromPartial(object: import("../helpers").DeepPartial<_127.ActiveChannel>): _127.ActiveChannel;
                         fromAmino(object: _127.ActiveChannelAmino): _127.ActiveChannel;
                         toAmino(message: _127.ActiveChannel): _127.ActiveChannelAmino;
                         fromAminoMsg(object: _127.ActiveChannelAminoMsg): _127.ActiveChannel;
@@ -350,9 +321,10 @@ export declare namespace ibc {
                     };
                     RegisteredInterchainAccount: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _127.RegisteredInterchainAccount, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _127.RegisteredInterchainAccount;
-                        fromPartial(object: Partial<_127.RegisteredInterchainAccount>): _127.RegisteredInterchainAccount;
+                        fromPartial(object: import("../helpers").DeepPartial<_127.RegisteredInterchainAccount>): _127.RegisteredInterchainAccount;
                         fromAmino(object: _127.RegisteredInterchainAccountAmino): _127.RegisteredInterchainAccount;
                         toAmino(message: _127.RegisteredInterchainAccount): _127.RegisteredInterchainAccountAmino;
                         fromAminoMsg(object: _127.RegisteredInterchainAccountAminoMsg): _127.RegisteredInterchainAccount;
@@ -366,45 +338,13 @@ export declare namespace ibc {
             namespace host {
                 const v1: {
                     MsgClientImpl: typeof _318.MsgClientImpl;
+                    createClientImpl: (rpc: import("..").TxRpc) => _318.MsgClientImpl;
                     QueryClientImpl: typeof _309.QueryClientImpl;
                     createRpcQueryExtension: (base: QueryClient) => {
                         params(request?: _129.QueryParamsRequest): Promise<_129.QueryParamsResponse>;
                     };
                     LCDQueryClient: typeof _300.LCDQueryClient;
-                    registry: ReadonlyArray<[string, GeneratedType]>;
-                    load: (protoRegistry: Registry) => void;
-                    MessageComposer: {
-                        encoded: {
-                            updateParams(value: _130.MsgUpdateParams): {
-                                typeUrl: string;
-                                value: Uint8Array<ArrayBufferLike>;
-                            };
-                            moduleQuerySafe(value: _130.MsgModuleQuerySafe): {
-                                typeUrl: string;
-                                value: Uint8Array<ArrayBufferLike>;
-                            };
-                        };
-                        withTypeUrl: {
-                            updateParams(value: _130.MsgUpdateParams): {
-                                typeUrl: string;
-                                value: _130.MsgUpdateParams;
-                            };
-                            moduleQuerySafe(value: _130.MsgModuleQuerySafe): {
-                                typeUrl: string;
-                                value: _130.MsgModuleQuerySafe;
-                            };
-                        };
-                        fromPartial: {
-                            updateParams(value: _130.MsgUpdateParams): {
-                                typeUrl: string;
-                                value: _130.MsgUpdateParams;
-                            };
-                            moduleQuerySafe(value: _130.MsgModuleQuerySafe): {
-                                typeUrl: string;
-                                value: _130.MsgModuleQuerySafe;
-                            };
-                        };
-                    };
+                    registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
                     AminoConverter: {
                         "/ibc.applications.interchain_accounts.host.v1.MsgUpdateParams": {
                             aminoType: string;
@@ -419,9 +359,10 @@ export declare namespace ibc {
                     };
                     MsgUpdateParams: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _130.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _130.MsgUpdateParams;
-                        fromPartial(object: Partial<_130.MsgUpdateParams>): _130.MsgUpdateParams;
+                        fromPartial(object: import("../helpers").DeepPartial<_130.MsgUpdateParams>): _130.MsgUpdateParams;
                         fromAmino(object: _130.MsgUpdateParamsAmino): _130.MsgUpdateParams;
                         toAmino(message: _130.MsgUpdateParams): _130.MsgUpdateParamsAmino;
                         fromAminoMsg(object: _130.MsgUpdateParamsAminoMsg): _130.MsgUpdateParams;
@@ -432,9 +373,10 @@ export declare namespace ibc {
                     };
                     MsgUpdateParamsResponse: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(_: _130.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _130.MsgUpdateParamsResponse;
-                        fromPartial(_: Partial<_130.MsgUpdateParamsResponse>): _130.MsgUpdateParamsResponse;
+                        fromPartial(_: import("../helpers").DeepPartial<_130.MsgUpdateParamsResponse>): _130.MsgUpdateParamsResponse;
                         fromAmino(_: _130.MsgUpdateParamsResponseAmino): _130.MsgUpdateParamsResponse;
                         toAmino(_: _130.MsgUpdateParamsResponse): _130.MsgUpdateParamsResponseAmino;
                         fromAminoMsg(object: _130.MsgUpdateParamsResponseAminoMsg): _130.MsgUpdateParamsResponse;
@@ -445,9 +387,10 @@ export declare namespace ibc {
                     };
                     MsgModuleQuerySafe: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _130.MsgModuleQuerySafe, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _130.MsgModuleQuerySafe;
-                        fromPartial(object: Partial<_130.MsgModuleQuerySafe>): _130.MsgModuleQuerySafe;
+                        fromPartial(object: import("../helpers").DeepPartial<_130.MsgModuleQuerySafe>): _130.MsgModuleQuerySafe;
                         fromAmino(object: _130.MsgModuleQuerySafeAmino): _130.MsgModuleQuerySafe;
                         toAmino(message: _130.MsgModuleQuerySafe): _130.MsgModuleQuerySafeAmino;
                         fromAminoMsg(object: _130.MsgModuleQuerySafeAminoMsg): _130.MsgModuleQuerySafe;
@@ -458,9 +401,10 @@ export declare namespace ibc {
                     };
                     MsgModuleQuerySafeResponse: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _130.MsgModuleQuerySafeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _130.MsgModuleQuerySafeResponse;
-                        fromPartial(object: Partial<_130.MsgModuleQuerySafeResponse>): _130.MsgModuleQuerySafeResponse;
+                        fromPartial(object: import("../helpers").DeepPartial<_130.MsgModuleQuerySafeResponse>): _130.MsgModuleQuerySafeResponse;
                         fromAmino(object: _130.MsgModuleQuerySafeResponseAmino): _130.MsgModuleQuerySafeResponse;
                         toAmino(message: _130.MsgModuleQuerySafeResponse): _130.MsgModuleQuerySafeResponseAmino;
                         fromAminoMsg(object: _130.MsgModuleQuerySafeResponseAminoMsg): _130.MsgModuleQuerySafeResponse;
@@ -471,9 +415,10 @@ export declare namespace ibc {
                     };
                     QueryParamsRequest: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(_: _129.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _129.QueryParamsRequest;
-                        fromPartial(_: Partial<_129.QueryParamsRequest>): _129.QueryParamsRequest;
+                        fromPartial(_: import("../helpers").DeepPartial<_129.QueryParamsRequest>): _129.QueryParamsRequest;
                         fromAmino(_: _129.QueryParamsRequestAmino): _129.QueryParamsRequest;
                         toAmino(_: _129.QueryParamsRequest): _129.QueryParamsRequestAmino;
                         fromAminoMsg(object: _129.QueryParamsRequestAminoMsg): _129.QueryParamsRequest;
@@ -484,9 +429,10 @@ export declare namespace ibc {
                     };
                     QueryParamsResponse: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _129.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _129.QueryParamsResponse;
-                        fromPartial(object: Partial<_129.QueryParamsResponse>): _129.QueryParamsResponse;
+                        fromPartial(object: import("../helpers").DeepPartial<_129.QueryParamsResponse>): _129.QueryParamsResponse;
                         fromAmino(object: _129.QueryParamsResponseAmino): _129.QueryParamsResponse;
                         toAmino(message: _129.QueryParamsResponse): _129.QueryParamsResponseAmino;
                         fromAminoMsg(object: _129.QueryParamsResponseAminoMsg): _129.QueryParamsResponse;
@@ -497,9 +443,10 @@ export declare namespace ibc {
                     };
                     Params: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _128.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _128.Params;
-                        fromPartial(object: Partial<_128.Params>): _128.Params;
+                        fromPartial(object: import("../helpers").DeepPartial<_128.Params>): _128.Params;
                         fromAmino(object: _128.ParamsAmino): _128.Params;
                         toAmino(message: _128.Params): _128.ParamsAmino;
                         fromAminoMsg(object: _128.ParamsAminoMsg): _128.Params;
@@ -510,9 +457,10 @@ export declare namespace ibc {
                     };
                     QueryRequest: {
                         typeUrl: string;
+                        aminoType: string;
                         encode(message: _128.QueryRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                         decode(input: import("..").BinaryReader | Uint8Array, length?: number): _128.QueryRequest;
-                        fromPartial(object: Partial<_128.QueryRequest>): _128.QueryRequest;
+                        fromPartial(object: import("../helpers").DeepPartial<_128.QueryRequest>): _128.QueryRequest;
                         fromAmino(object: _128.QueryRequestAmino): _128.QueryRequest;
                         toAmino(message: _128.QueryRequest): _128.QueryRequestAmino;
                         fromAminoMsg(object: _128.QueryRequestAminoMsg): _128.QueryRequest;
@@ -527,13 +475,13 @@ export declare namespace ibc {
                 typeFromJSON(object: any): _133.Type;
                 typeToJSON(object: _133.Type): string;
                 Type: typeof _133.Type;
-                TypeSDKType: typeof _133.Type;
                 TypeAmino: typeof _133.Type;
                 InterchainAccountPacketData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _133.InterchainAccountPacketData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _133.InterchainAccountPacketData;
-                    fromPartial(object: Partial<_133.InterchainAccountPacketData>): _133.InterchainAccountPacketData;
+                    fromPartial(object: import("../helpers").DeepPartial<_133.InterchainAccountPacketData>): _133.InterchainAccountPacketData;
                     fromAmino(object: _133.InterchainAccountPacketDataAmino): _133.InterchainAccountPacketData;
                     toAmino(message: _133.InterchainAccountPacketData): _133.InterchainAccountPacketDataAmino;
                     fromAminoMsg(object: _133.InterchainAccountPacketDataAminoMsg): _133.InterchainAccountPacketData;
@@ -544,9 +492,10 @@ export declare namespace ibc {
                 };
                 CosmosTx: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _133.CosmosTx, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _133.CosmosTx;
-                    fromPartial(object: Partial<_133.CosmosTx>): _133.CosmosTx;
+                    fromPartial(object: import("../helpers").DeepPartial<_133.CosmosTx>): _133.CosmosTx;
                     fromAmino(object: _133.CosmosTxAmino): _133.CosmosTx;
                     toAmino(message: _133.CosmosTx): _133.CosmosTxAmino;
                     fromAminoMsg(object: _133.CosmosTxAminoMsg): _133.CosmosTx;
@@ -557,9 +506,10 @@ export declare namespace ibc {
                 };
                 Metadata: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _132.Metadata, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _132.Metadata;
-                    fromPartial(object: Partial<_132.Metadata>): _132.Metadata;
+                    fromPartial(object: import("../helpers").DeepPartial<_132.Metadata>): _132.Metadata;
                     fromAmino(object: _132.MetadataAmino): _132.Metadata;
                     toAmino(message: _132.Metadata): _132.MetadataAmino;
                     fromAminoMsg(object: _132.MetadataAminoMsg): _132.Metadata;
@@ -570,9 +520,10 @@ export declare namespace ibc {
                 };
                 InterchainAccount: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _131.InterchainAccount, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _131.InterchainAccount;
-                    fromPartial(object: Partial<_131.InterchainAccount>): _131.InterchainAccount;
+                    fromPartial(object: import("../helpers").DeepPartial<_131.InterchainAccount>): _131.InterchainAccount;
                     fromAmino(object: _131.InterchainAccountAmino): _131.InterchainAccount;
                     toAmino(message: _131.InterchainAccount): _131.InterchainAccountAmino;
                     fromAminoMsg(object: _131.InterchainAccountAminoMsg): _131.InterchainAccount;
@@ -588,7 +539,7 @@ export declare namespace ibc {
                 GenesisState_InFlightPacketsEntry: {
                     encode(message: _134.GenesisState_InFlightPacketsEntry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _134.GenesisState_InFlightPacketsEntry;
-                    fromPartial(object: Partial<_134.GenesisState_InFlightPacketsEntry>): _134.GenesisState_InFlightPacketsEntry;
+                    fromPartial(object: import("../helpers").DeepPartial<_134.GenesisState_InFlightPacketsEntry>): _134.GenesisState_InFlightPacketsEntry;
                     fromAmino(object: _134.GenesisState_InFlightPacketsEntryAmino): _134.GenesisState_InFlightPacketsEntry;
                     toAmino(message: _134.GenesisState_InFlightPacketsEntry): _134.GenesisState_InFlightPacketsEntryAmino;
                     fromAminoMsg(object: _134.GenesisState_InFlightPacketsEntryAminoMsg): _134.GenesisState_InFlightPacketsEntry;
@@ -597,9 +548,10 @@ export declare namespace ibc {
                 };
                 GenesisState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _134.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _134.GenesisState;
-                    fromPartial(object: Partial<_134.GenesisState>): _134.GenesisState;
+                    fromPartial(object: import("../helpers").DeepPartial<_134.GenesisState>): _134.GenesisState;
                     fromAmino(object: _134.GenesisStateAmino): _134.GenesisState;
                     toAmino(message: _134.GenesisState): _134.GenesisStateAmino;
                     fromAminoMsg(object: _134.GenesisStateAminoMsg): _134.GenesisState;
@@ -610,9 +562,10 @@ export declare namespace ibc {
                 };
                 InFlightPacket: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _134.InFlightPacket, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _134.InFlightPacket;
-                    fromPartial(object: Partial<_134.InFlightPacket>): _134.InFlightPacket;
+                    fromPartial(object: import("../helpers").DeepPartial<_134.InFlightPacket>): _134.InFlightPacket;
                     fromAmino(object: _134.InFlightPacketAmino): _134.InFlightPacket;
                     toAmino(message: _134.InFlightPacket): _134.InFlightPacketAmino;
                     fromAminoMsg(object: _134.InFlightPacketAminoMsg): _134.InFlightPacket;
@@ -626,6 +579,7 @@ export declare namespace ibc {
         namespace transfer {
             const v1: {
                 MsgClientImpl: typeof _319.MsgClientImpl;
+                createClientImpl: (rpc: import("..").TxRpc) => _319.MsgClientImpl;
                 QueryClientImpl: typeof _310.QueryClientImpl;
                 createRpcQueryExtension: (base: QueryClient) => {
                     params(request?: _139.QueryParamsRequest): Promise<_139.QueryParamsResponse>;
@@ -636,40 +590,7 @@ export declare namespace ibc {
                     totalEscrowForDenom(request: _139.QueryTotalEscrowForDenomRequest): Promise<_139.QueryTotalEscrowForDenomResponse>;
                 };
                 LCDQueryClient: typeof _301.LCDQueryClient;
-                registry: ReadonlyArray<[string, GeneratedType]>;
-                load: (protoRegistry: Registry) => void;
-                MessageComposer: {
-                    encoded: {
-                        transfer(value: _142.MsgTransfer): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        updateParams(value: _142.MsgUpdateParams): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                    };
-                    withTypeUrl: {
-                        transfer(value: _142.MsgTransfer): {
-                            typeUrl: string;
-                            value: _142.MsgTransfer;
-                        };
-                        updateParams(value: _142.MsgUpdateParams): {
-                            typeUrl: string;
-                            value: _142.MsgUpdateParams;
-                        };
-                    };
-                    fromPartial: {
-                        transfer(value: _142.MsgTransfer): {
-                            typeUrl: string;
-                            value: _142.MsgTransfer;
-                        };
-                        updateParams(value: _142.MsgUpdateParams): {
-                            typeUrl: string;
-                            value: _142.MsgUpdateParams;
-                        };
-                    };
-                };
+                registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
                 AminoConverter: {
                     "/ibc.applications.transfer.v1.MsgTransfer": {
                         aminoType: string;
@@ -684,9 +605,10 @@ export declare namespace ibc {
                 };
                 MsgTransfer: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _142.MsgTransfer, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _142.MsgTransfer;
-                    fromPartial(object: Partial<_142.MsgTransfer>): _142.MsgTransfer;
+                    fromPartial(object: import("../helpers").DeepPartial<_142.MsgTransfer>): _142.MsgTransfer;
                     fromAmino(object: _142.MsgTransferAmino): _142.MsgTransfer;
                     toAmino(message: _142.MsgTransfer): _142.MsgTransferAmino;
                     fromAminoMsg(object: _142.MsgTransferAminoMsg): _142.MsgTransfer;
@@ -697,9 +619,10 @@ export declare namespace ibc {
                 };
                 MsgTransferResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _142.MsgTransferResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _142.MsgTransferResponse;
-                    fromPartial(object: Partial<_142.MsgTransferResponse>): _142.MsgTransferResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_142.MsgTransferResponse>): _142.MsgTransferResponse;
                     fromAmino(object: _142.MsgTransferResponseAmino): _142.MsgTransferResponse;
                     toAmino(message: _142.MsgTransferResponse): _142.MsgTransferResponseAmino;
                     fromAminoMsg(object: _142.MsgTransferResponseAminoMsg): _142.MsgTransferResponse;
@@ -710,9 +633,10 @@ export declare namespace ibc {
                 };
                 MsgUpdateParams: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _142.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _142.MsgUpdateParams;
-                    fromPartial(object: Partial<_142.MsgUpdateParams>): _142.MsgUpdateParams;
+                    fromPartial(object: import("../helpers").DeepPartial<_142.MsgUpdateParams>): _142.MsgUpdateParams;
                     fromAmino(object: _142.MsgUpdateParamsAmino): _142.MsgUpdateParams;
                     toAmino(message: _142.MsgUpdateParams): _142.MsgUpdateParamsAmino;
                     fromAminoMsg(object: _142.MsgUpdateParamsAminoMsg): _142.MsgUpdateParams;
@@ -723,9 +647,10 @@ export declare namespace ibc {
                 };
                 MsgUpdateParamsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _142.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _142.MsgUpdateParamsResponse;
-                    fromPartial(_: Partial<_142.MsgUpdateParamsResponse>): _142.MsgUpdateParamsResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_142.MsgUpdateParamsResponse>): _142.MsgUpdateParamsResponse;
                     fromAmino(_: _142.MsgUpdateParamsResponseAmino): _142.MsgUpdateParamsResponse;
                     toAmino(_: _142.MsgUpdateParamsResponse): _142.MsgUpdateParamsResponseAmino;
                     fromAminoMsg(object: _142.MsgUpdateParamsResponseAminoMsg): _142.MsgUpdateParamsResponse;
@@ -736,9 +661,10 @@ export declare namespace ibc {
                 };
                 Params: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _141.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _141.Params;
-                    fromPartial(object: Partial<_141.Params>): _141.Params;
+                    fromPartial(object: import("../helpers").DeepPartial<_141.Params>): _141.Params;
                     fromAmino(object: _141.ParamsAmino): _141.Params;
                     toAmino(message: _141.Params): _141.ParamsAmino;
                     fromAminoMsg(object: _141.ParamsAminoMsg): _141.Params;
@@ -749,9 +675,10 @@ export declare namespace ibc {
                 };
                 Token: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _140.Token, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.Token;
-                    fromPartial(object: Partial<_140.Token>): _140.Token;
+                    fromPartial(object: import("../helpers").DeepPartial<_140.Token>): _140.Token;
                     fromAmino(object: _140.TokenAmino): _140.Token;
                     toAmino(message: _140.Token): _140.TokenAmino;
                     fromAminoMsg(object: _140.TokenAminoMsg): _140.Token;
@@ -762,9 +689,10 @@ export declare namespace ibc {
                 };
                 Denom: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _140.Denom, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.Denom;
-                    fromPartial(object: Partial<_140.Denom>): _140.Denom;
+                    fromPartial(object: import("../helpers").DeepPartial<_140.Denom>): _140.Denom;
                     fromAmino(object: _140.DenomAmino): _140.Denom;
                     toAmino(message: _140.Denom): _140.DenomAmino;
                     fromAminoMsg(object: _140.DenomAminoMsg): _140.Denom;
@@ -775,9 +703,10 @@ export declare namespace ibc {
                 };
                 Hop: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _140.Hop, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _140.Hop;
-                    fromPartial(object: Partial<_140.Hop>): _140.Hop;
+                    fromPartial(object: import("../helpers").DeepPartial<_140.Hop>): _140.Hop;
                     fromAmino(object: _140.HopAmino): _140.Hop;
                     toAmino(message: _140.Hop): _140.HopAmino;
                     fromAminoMsg(object: _140.HopAminoMsg): _140.Hop;
@@ -788,9 +717,10 @@ export declare namespace ibc {
                 };
                 QueryParamsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _139.QueryParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.QueryParamsRequest;
-                    fromPartial(_: Partial<_139.QueryParamsRequest>): _139.QueryParamsRequest;
+                    fromPartial(_: import("../helpers").DeepPartial<_139.QueryParamsRequest>): _139.QueryParamsRequest;
                     fromAmino(_: _139.QueryParamsRequestAmino): _139.QueryParamsRequest;
                     toAmino(_: _139.QueryParamsRequest): _139.QueryParamsRequestAmino;
                     fromAminoMsg(object: _139.QueryParamsRequestAminoMsg): _139.QueryParamsRequest;
@@ -801,9 +731,10 @@ export declare namespace ibc {
                 };
                 QueryParamsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _139.QueryParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.QueryParamsResponse;
-                    fromPartial(object: Partial<_139.QueryParamsResponse>): _139.QueryParamsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_139.QueryParamsResponse>): _139.QueryParamsResponse;
                     fromAmino(object: _139.QueryParamsResponseAmino): _139.QueryParamsResponse;
                     toAmino(message: _139.QueryParamsResponse): _139.QueryParamsResponseAmino;
                     fromAminoMsg(object: _139.QueryParamsResponseAminoMsg): _139.QueryParamsResponse;
@@ -814,9 +745,10 @@ export declare namespace ibc {
                 };
                 QueryDenomRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _139.QueryDenomRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.QueryDenomRequest;
-                    fromPartial(object: Partial<_139.QueryDenomRequest>): _139.QueryDenomRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_139.QueryDenomRequest>): _139.QueryDenomRequest;
                     fromAmino(object: _139.QueryDenomRequestAmino): _139.QueryDenomRequest;
                     toAmino(message: _139.QueryDenomRequest): _139.QueryDenomRequestAmino;
                     fromAminoMsg(object: _139.QueryDenomRequestAminoMsg): _139.QueryDenomRequest;
@@ -827,9 +759,10 @@ export declare namespace ibc {
                 };
                 QueryDenomResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _139.QueryDenomResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.QueryDenomResponse;
-                    fromPartial(object: Partial<_139.QueryDenomResponse>): _139.QueryDenomResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_139.QueryDenomResponse>): _139.QueryDenomResponse;
                     fromAmino(object: _139.QueryDenomResponseAmino): _139.QueryDenomResponse;
                     toAmino(message: _139.QueryDenomResponse): _139.QueryDenomResponseAmino;
                     fromAminoMsg(object: _139.QueryDenomResponseAminoMsg): _139.QueryDenomResponse;
@@ -840,9 +773,10 @@ export declare namespace ibc {
                 };
                 QueryDenomsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _139.QueryDenomsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.QueryDenomsRequest;
-                    fromPartial(object: Partial<_139.QueryDenomsRequest>): _139.QueryDenomsRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_139.QueryDenomsRequest>): _139.QueryDenomsRequest;
                     fromAmino(object: _139.QueryDenomsRequestAmino): _139.QueryDenomsRequest;
                     toAmino(message: _139.QueryDenomsRequest): _139.QueryDenomsRequestAmino;
                     fromAminoMsg(object: _139.QueryDenomsRequestAminoMsg): _139.QueryDenomsRequest;
@@ -853,9 +787,10 @@ export declare namespace ibc {
                 };
                 QueryDenomsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _139.QueryDenomsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.QueryDenomsResponse;
-                    fromPartial(object: Partial<_139.QueryDenomsResponse>): _139.QueryDenomsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_139.QueryDenomsResponse>): _139.QueryDenomsResponse;
                     fromAmino(object: _139.QueryDenomsResponseAmino): _139.QueryDenomsResponse;
                     toAmino(message: _139.QueryDenomsResponse): _139.QueryDenomsResponseAmino;
                     fromAminoMsg(object: _139.QueryDenomsResponseAminoMsg): _139.QueryDenomsResponse;
@@ -866,9 +801,10 @@ export declare namespace ibc {
                 };
                 QueryDenomHashRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _139.QueryDenomHashRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.QueryDenomHashRequest;
-                    fromPartial(object: Partial<_139.QueryDenomHashRequest>): _139.QueryDenomHashRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_139.QueryDenomHashRequest>): _139.QueryDenomHashRequest;
                     fromAmino(object: _139.QueryDenomHashRequestAmino): _139.QueryDenomHashRequest;
                     toAmino(message: _139.QueryDenomHashRequest): _139.QueryDenomHashRequestAmino;
                     fromAminoMsg(object: _139.QueryDenomHashRequestAminoMsg): _139.QueryDenomHashRequest;
@@ -879,9 +815,10 @@ export declare namespace ibc {
                 };
                 QueryDenomHashResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _139.QueryDenomHashResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.QueryDenomHashResponse;
-                    fromPartial(object: Partial<_139.QueryDenomHashResponse>): _139.QueryDenomHashResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_139.QueryDenomHashResponse>): _139.QueryDenomHashResponse;
                     fromAmino(object: _139.QueryDenomHashResponseAmino): _139.QueryDenomHashResponse;
                     toAmino(message: _139.QueryDenomHashResponse): _139.QueryDenomHashResponseAmino;
                     fromAminoMsg(object: _139.QueryDenomHashResponseAminoMsg): _139.QueryDenomHashResponse;
@@ -892,9 +829,10 @@ export declare namespace ibc {
                 };
                 QueryEscrowAddressRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _139.QueryEscrowAddressRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.QueryEscrowAddressRequest;
-                    fromPartial(object: Partial<_139.QueryEscrowAddressRequest>): _139.QueryEscrowAddressRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_139.QueryEscrowAddressRequest>): _139.QueryEscrowAddressRequest;
                     fromAmino(object: _139.QueryEscrowAddressRequestAmino): _139.QueryEscrowAddressRequest;
                     toAmino(message: _139.QueryEscrowAddressRequest): _139.QueryEscrowAddressRequestAmino;
                     fromAminoMsg(object: _139.QueryEscrowAddressRequestAminoMsg): _139.QueryEscrowAddressRequest;
@@ -905,9 +843,10 @@ export declare namespace ibc {
                 };
                 QueryEscrowAddressResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _139.QueryEscrowAddressResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.QueryEscrowAddressResponse;
-                    fromPartial(object: Partial<_139.QueryEscrowAddressResponse>): _139.QueryEscrowAddressResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_139.QueryEscrowAddressResponse>): _139.QueryEscrowAddressResponse;
                     fromAmino(object: _139.QueryEscrowAddressResponseAmino): _139.QueryEscrowAddressResponse;
                     toAmino(message: _139.QueryEscrowAddressResponse): _139.QueryEscrowAddressResponseAmino;
                     fromAminoMsg(object: _139.QueryEscrowAddressResponseAminoMsg): _139.QueryEscrowAddressResponse;
@@ -918,9 +857,10 @@ export declare namespace ibc {
                 };
                 QueryTotalEscrowForDenomRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _139.QueryTotalEscrowForDenomRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.QueryTotalEscrowForDenomRequest;
-                    fromPartial(object: Partial<_139.QueryTotalEscrowForDenomRequest>): _139.QueryTotalEscrowForDenomRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_139.QueryTotalEscrowForDenomRequest>): _139.QueryTotalEscrowForDenomRequest;
                     fromAmino(object: _139.QueryTotalEscrowForDenomRequestAmino): _139.QueryTotalEscrowForDenomRequest;
                     toAmino(message: _139.QueryTotalEscrowForDenomRequest): _139.QueryTotalEscrowForDenomRequestAmino;
                     fromAminoMsg(object: _139.QueryTotalEscrowForDenomRequestAminoMsg): _139.QueryTotalEscrowForDenomRequest;
@@ -931,9 +871,10 @@ export declare namespace ibc {
                 };
                 QueryTotalEscrowForDenomResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _139.QueryTotalEscrowForDenomResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _139.QueryTotalEscrowForDenomResponse;
-                    fromPartial(object: Partial<_139.QueryTotalEscrowForDenomResponse>): _139.QueryTotalEscrowForDenomResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_139.QueryTotalEscrowForDenomResponse>): _139.QueryTotalEscrowForDenomResponse;
                     fromAmino(object: _139.QueryTotalEscrowForDenomResponseAmino): _139.QueryTotalEscrowForDenomResponse;
                     toAmino(message: _139.QueryTotalEscrowForDenomResponse): _139.QueryTotalEscrowForDenomResponseAmino;
                     fromAminoMsg(object: _139.QueryTotalEscrowForDenomResponseAminoMsg): _139.QueryTotalEscrowForDenomResponse;
@@ -944,9 +885,10 @@ export declare namespace ibc {
                 };
                 FungibleTokenPacketData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _138.FungibleTokenPacketData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _138.FungibleTokenPacketData;
-                    fromPartial(object: Partial<_138.FungibleTokenPacketData>): _138.FungibleTokenPacketData;
+                    fromPartial(object: import("../helpers").DeepPartial<_138.FungibleTokenPacketData>): _138.FungibleTokenPacketData;
                     fromAmino(object: _138.FungibleTokenPacketDataAmino): _138.FungibleTokenPacketData;
                     toAmino(message: _138.FungibleTokenPacketData): _138.FungibleTokenPacketDataAmino;
                     fromAminoMsg(object: _138.FungibleTokenPacketDataAminoMsg): _138.FungibleTokenPacketData;
@@ -957,9 +899,10 @@ export declare namespace ibc {
                 };
                 GenesisState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _137.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _137.GenesisState;
-                    fromPartial(object: Partial<_137.GenesisState>): _137.GenesisState;
+                    fromPartial(object: import("../helpers").DeepPartial<_137.GenesisState>): _137.GenesisState;
                     fromAmino(object: _137.GenesisStateAmino): _137.GenesisState;
                     toAmino(message: _137.GenesisState): _137.GenesisStateAmino;
                     fromAminoMsg(object: _137.GenesisStateAminoMsg): _137.GenesisState;
@@ -970,9 +913,10 @@ export declare namespace ibc {
                 };
                 DenomTrace: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _136.DenomTrace, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _136.DenomTrace;
-                    fromPartial(object: Partial<_136.DenomTrace>): _136.DenomTrace;
+                    fromPartial(object: import("../helpers").DeepPartial<_136.DenomTrace>): _136.DenomTrace;
                     fromAmino(object: _136.DenomTraceAmino): _136.DenomTrace;
                     toAmino(message: _136.DenomTrace): _136.DenomTraceAmino;
                     fromAminoMsg(object: _136.DenomTraceAminoMsg): _136.DenomTrace;
@@ -983,9 +927,10 @@ export declare namespace ibc {
                 };
                 Allocation: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _135.Allocation, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _135.Allocation;
-                    fromPartial(object: Partial<_135.Allocation>): _135.Allocation;
+                    fromPartial(object: import("../helpers").DeepPartial<_135.Allocation>): _135.Allocation;
                     fromAmino(object: _135.AllocationAmino): _135.Allocation;
                     toAmino(message: _135.Allocation): _135.AllocationAmino;
                     fromAminoMsg(object: _135.AllocationAminoMsg): _135.Allocation;
@@ -996,9 +941,10 @@ export declare namespace ibc {
                 };
                 TransferAuthorization: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _135.TransferAuthorization, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _135.TransferAuthorization;
-                    fromPartial(object: Partial<_135.TransferAuthorization>): _135.TransferAuthorization;
+                    fromPartial(object: import("../helpers").DeepPartial<_135.TransferAuthorization>): _135.TransferAuthorization;
                     fromAmino(object: _135.TransferAuthorizationAmino): _135.TransferAuthorization;
                     toAmino(message: _135.TransferAuthorization): _135.TransferAuthorizationAmino;
                     fromAminoMsg(object: _135.TransferAuthorizationAminoMsg): _135.TransferAuthorization;
@@ -1014,6 +960,7 @@ export declare namespace ibc {
         namespace channel {
             const v1: {
                 MsgClientImpl: typeof _320.MsgClientImpl;
+                createClientImpl: (rpc: import("..").TxRpc) => _320.MsgClientImpl;
                 QueryClientImpl: typeof _311.QueryClientImpl;
                 createRpcQueryExtension: (base: QueryClient) => {
                     channel(request: _145.QueryChannelRequest): Promise<_145.QueryChannelResponse>;
@@ -1032,136 +979,7 @@ export declare namespace ibc {
                     nextSequenceSend(request: _145.QueryNextSequenceSendRequest): Promise<_145.QueryNextSequenceSendResponse>;
                 };
                 LCDQueryClient: typeof _302.LCDQueryClient;
-                registry: ReadonlyArray<[string, GeneratedType]>;
-                load: (protoRegistry: Registry) => void;
-                MessageComposer: {
-                    encoded: {
-                        channelOpenInit(value: _146.MsgChannelOpenInit): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        channelOpenTry(value: _146.MsgChannelOpenTry): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        channelOpenAck(value: _146.MsgChannelOpenAck): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        channelOpenConfirm(value: _146.MsgChannelOpenConfirm): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        channelCloseInit(value: _146.MsgChannelCloseInit): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        channelCloseConfirm(value: _146.MsgChannelCloseConfirm): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        recvPacket(value: _146.MsgRecvPacket): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        timeout(value: _146.MsgTimeout): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        timeoutOnClose(value: _146.MsgTimeoutOnClose): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        acknowledgement(value: _146.MsgAcknowledgement): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                    };
-                    withTypeUrl: {
-                        channelOpenInit(value: _146.MsgChannelOpenInit): {
-                            typeUrl: string;
-                            value: _146.MsgChannelOpenInit;
-                        };
-                        channelOpenTry(value: _146.MsgChannelOpenTry): {
-                            typeUrl: string;
-                            value: _146.MsgChannelOpenTry;
-                        };
-                        channelOpenAck(value: _146.MsgChannelOpenAck): {
-                            typeUrl: string;
-                            value: _146.MsgChannelOpenAck;
-                        };
-                        channelOpenConfirm(value: _146.MsgChannelOpenConfirm): {
-                            typeUrl: string;
-                            value: _146.MsgChannelOpenConfirm;
-                        };
-                        channelCloseInit(value: _146.MsgChannelCloseInit): {
-                            typeUrl: string;
-                            value: _146.MsgChannelCloseInit;
-                        };
-                        channelCloseConfirm(value: _146.MsgChannelCloseConfirm): {
-                            typeUrl: string;
-                            value: _146.MsgChannelCloseConfirm;
-                        };
-                        recvPacket(value: _146.MsgRecvPacket): {
-                            typeUrl: string;
-                            value: _146.MsgRecvPacket;
-                        };
-                        timeout(value: _146.MsgTimeout): {
-                            typeUrl: string;
-                            value: _146.MsgTimeout;
-                        };
-                        timeoutOnClose(value: _146.MsgTimeoutOnClose): {
-                            typeUrl: string;
-                            value: _146.MsgTimeoutOnClose;
-                        };
-                        acknowledgement(value: _146.MsgAcknowledgement): {
-                            typeUrl: string;
-                            value: _146.MsgAcknowledgement;
-                        };
-                    };
-                    fromPartial: {
-                        channelOpenInit(value: _146.MsgChannelOpenInit): {
-                            typeUrl: string;
-                            value: _146.MsgChannelOpenInit;
-                        };
-                        channelOpenTry(value: _146.MsgChannelOpenTry): {
-                            typeUrl: string;
-                            value: _146.MsgChannelOpenTry;
-                        };
-                        channelOpenAck(value: _146.MsgChannelOpenAck): {
-                            typeUrl: string;
-                            value: _146.MsgChannelOpenAck;
-                        };
-                        channelOpenConfirm(value: _146.MsgChannelOpenConfirm): {
-                            typeUrl: string;
-                            value: _146.MsgChannelOpenConfirm;
-                        };
-                        channelCloseInit(value: _146.MsgChannelCloseInit): {
-                            typeUrl: string;
-                            value: _146.MsgChannelCloseInit;
-                        };
-                        channelCloseConfirm(value: _146.MsgChannelCloseConfirm): {
-                            typeUrl: string;
-                            value: _146.MsgChannelCloseConfirm;
-                        };
-                        recvPacket(value: _146.MsgRecvPacket): {
-                            typeUrl: string;
-                            value: _146.MsgRecvPacket;
-                        };
-                        timeout(value: _146.MsgTimeout): {
-                            typeUrl: string;
-                            value: _146.MsgTimeout;
-                        };
-                        timeoutOnClose(value: _146.MsgTimeoutOnClose): {
-                            typeUrl: string;
-                            value: _146.MsgTimeoutOnClose;
-                        };
-                        acknowledgement(value: _146.MsgAcknowledgement): {
-                            typeUrl: string;
-                            value: _146.MsgAcknowledgement;
-                        };
-                    };
-                };
+                registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
                 AminoConverter: {
                     "/ibc.core.channel.v1.MsgChannelOpenInit": {
                         aminoType: string;
@@ -1217,13 +1035,13 @@ export declare namespace ibc {
                 responseResultTypeFromJSON(object: any): _146.ResponseResultType;
                 responseResultTypeToJSON(object: _146.ResponseResultType): string;
                 ResponseResultType: typeof _146.ResponseResultType;
-                ResponseResultTypeSDKType: typeof _146.ResponseResultType;
                 ResponseResultTypeAmino: typeof _146.ResponseResultType;
                 MsgChannelOpenInit: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgChannelOpenInit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgChannelOpenInit;
-                    fromPartial(object: Partial<_146.MsgChannelOpenInit>): _146.MsgChannelOpenInit;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgChannelOpenInit>): _146.MsgChannelOpenInit;
                     fromAmino(object: _146.MsgChannelOpenInitAmino): _146.MsgChannelOpenInit;
                     toAmino(message: _146.MsgChannelOpenInit): _146.MsgChannelOpenInitAmino;
                     fromAminoMsg(object: _146.MsgChannelOpenInitAminoMsg): _146.MsgChannelOpenInit;
@@ -1234,9 +1052,10 @@ export declare namespace ibc {
                 };
                 MsgChannelOpenInitResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgChannelOpenInitResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgChannelOpenInitResponse;
-                    fromPartial(object: Partial<_146.MsgChannelOpenInitResponse>): _146.MsgChannelOpenInitResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgChannelOpenInitResponse>): _146.MsgChannelOpenInitResponse;
                     fromAmino(object: _146.MsgChannelOpenInitResponseAmino): _146.MsgChannelOpenInitResponse;
                     toAmino(message: _146.MsgChannelOpenInitResponse): _146.MsgChannelOpenInitResponseAmino;
                     fromAminoMsg(object: _146.MsgChannelOpenInitResponseAminoMsg): _146.MsgChannelOpenInitResponse;
@@ -1247,9 +1066,10 @@ export declare namespace ibc {
                 };
                 MsgChannelOpenTry: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgChannelOpenTry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgChannelOpenTry;
-                    fromPartial(object: Partial<_146.MsgChannelOpenTry>): _146.MsgChannelOpenTry;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgChannelOpenTry>): _146.MsgChannelOpenTry;
                     fromAmino(object: _146.MsgChannelOpenTryAmino): _146.MsgChannelOpenTry;
                     toAmino(message: _146.MsgChannelOpenTry): _146.MsgChannelOpenTryAmino;
                     fromAminoMsg(object: _146.MsgChannelOpenTryAminoMsg): _146.MsgChannelOpenTry;
@@ -1260,9 +1080,10 @@ export declare namespace ibc {
                 };
                 MsgChannelOpenTryResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgChannelOpenTryResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgChannelOpenTryResponse;
-                    fromPartial(object: Partial<_146.MsgChannelOpenTryResponse>): _146.MsgChannelOpenTryResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgChannelOpenTryResponse>): _146.MsgChannelOpenTryResponse;
                     fromAmino(object: _146.MsgChannelOpenTryResponseAmino): _146.MsgChannelOpenTryResponse;
                     toAmino(message: _146.MsgChannelOpenTryResponse): _146.MsgChannelOpenTryResponseAmino;
                     fromAminoMsg(object: _146.MsgChannelOpenTryResponseAminoMsg): _146.MsgChannelOpenTryResponse;
@@ -1273,9 +1094,10 @@ export declare namespace ibc {
                 };
                 MsgChannelOpenAck: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgChannelOpenAck, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgChannelOpenAck;
-                    fromPartial(object: Partial<_146.MsgChannelOpenAck>): _146.MsgChannelOpenAck;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgChannelOpenAck>): _146.MsgChannelOpenAck;
                     fromAmino(object: _146.MsgChannelOpenAckAmino): _146.MsgChannelOpenAck;
                     toAmino(message: _146.MsgChannelOpenAck): _146.MsgChannelOpenAckAmino;
                     fromAminoMsg(object: _146.MsgChannelOpenAckAminoMsg): _146.MsgChannelOpenAck;
@@ -1286,9 +1108,10 @@ export declare namespace ibc {
                 };
                 MsgChannelOpenAckResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _146.MsgChannelOpenAckResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgChannelOpenAckResponse;
-                    fromPartial(_: Partial<_146.MsgChannelOpenAckResponse>): _146.MsgChannelOpenAckResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_146.MsgChannelOpenAckResponse>): _146.MsgChannelOpenAckResponse;
                     fromAmino(_: _146.MsgChannelOpenAckResponseAmino): _146.MsgChannelOpenAckResponse;
                     toAmino(_: _146.MsgChannelOpenAckResponse): _146.MsgChannelOpenAckResponseAmino;
                     fromAminoMsg(object: _146.MsgChannelOpenAckResponseAminoMsg): _146.MsgChannelOpenAckResponse;
@@ -1299,9 +1122,10 @@ export declare namespace ibc {
                 };
                 MsgChannelOpenConfirm: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgChannelOpenConfirm, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgChannelOpenConfirm;
-                    fromPartial(object: Partial<_146.MsgChannelOpenConfirm>): _146.MsgChannelOpenConfirm;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgChannelOpenConfirm>): _146.MsgChannelOpenConfirm;
                     fromAmino(object: _146.MsgChannelOpenConfirmAmino): _146.MsgChannelOpenConfirm;
                     toAmino(message: _146.MsgChannelOpenConfirm): _146.MsgChannelOpenConfirmAmino;
                     fromAminoMsg(object: _146.MsgChannelOpenConfirmAminoMsg): _146.MsgChannelOpenConfirm;
@@ -1312,9 +1136,10 @@ export declare namespace ibc {
                 };
                 MsgChannelOpenConfirmResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _146.MsgChannelOpenConfirmResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgChannelOpenConfirmResponse;
-                    fromPartial(_: Partial<_146.MsgChannelOpenConfirmResponse>): _146.MsgChannelOpenConfirmResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_146.MsgChannelOpenConfirmResponse>): _146.MsgChannelOpenConfirmResponse;
                     fromAmino(_: _146.MsgChannelOpenConfirmResponseAmino): _146.MsgChannelOpenConfirmResponse;
                     toAmino(_: _146.MsgChannelOpenConfirmResponse): _146.MsgChannelOpenConfirmResponseAmino;
                     fromAminoMsg(object: _146.MsgChannelOpenConfirmResponseAminoMsg): _146.MsgChannelOpenConfirmResponse;
@@ -1325,9 +1150,10 @@ export declare namespace ibc {
                 };
                 MsgChannelCloseInit: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgChannelCloseInit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgChannelCloseInit;
-                    fromPartial(object: Partial<_146.MsgChannelCloseInit>): _146.MsgChannelCloseInit;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgChannelCloseInit>): _146.MsgChannelCloseInit;
                     fromAmino(object: _146.MsgChannelCloseInitAmino): _146.MsgChannelCloseInit;
                     toAmino(message: _146.MsgChannelCloseInit): _146.MsgChannelCloseInitAmino;
                     fromAminoMsg(object: _146.MsgChannelCloseInitAminoMsg): _146.MsgChannelCloseInit;
@@ -1338,9 +1164,10 @@ export declare namespace ibc {
                 };
                 MsgChannelCloseInitResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _146.MsgChannelCloseInitResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgChannelCloseInitResponse;
-                    fromPartial(_: Partial<_146.MsgChannelCloseInitResponse>): _146.MsgChannelCloseInitResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_146.MsgChannelCloseInitResponse>): _146.MsgChannelCloseInitResponse;
                     fromAmino(_: _146.MsgChannelCloseInitResponseAmino): _146.MsgChannelCloseInitResponse;
                     toAmino(_: _146.MsgChannelCloseInitResponse): _146.MsgChannelCloseInitResponseAmino;
                     fromAminoMsg(object: _146.MsgChannelCloseInitResponseAminoMsg): _146.MsgChannelCloseInitResponse;
@@ -1351,9 +1178,10 @@ export declare namespace ibc {
                 };
                 MsgChannelCloseConfirm: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgChannelCloseConfirm, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgChannelCloseConfirm;
-                    fromPartial(object: Partial<_146.MsgChannelCloseConfirm>): _146.MsgChannelCloseConfirm;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgChannelCloseConfirm>): _146.MsgChannelCloseConfirm;
                     fromAmino(object: _146.MsgChannelCloseConfirmAmino): _146.MsgChannelCloseConfirm;
                     toAmino(message: _146.MsgChannelCloseConfirm): _146.MsgChannelCloseConfirmAmino;
                     fromAminoMsg(object: _146.MsgChannelCloseConfirmAminoMsg): _146.MsgChannelCloseConfirm;
@@ -1364,9 +1192,10 @@ export declare namespace ibc {
                 };
                 MsgChannelCloseConfirmResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _146.MsgChannelCloseConfirmResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgChannelCloseConfirmResponse;
-                    fromPartial(_: Partial<_146.MsgChannelCloseConfirmResponse>): _146.MsgChannelCloseConfirmResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_146.MsgChannelCloseConfirmResponse>): _146.MsgChannelCloseConfirmResponse;
                     fromAmino(_: _146.MsgChannelCloseConfirmResponseAmino): _146.MsgChannelCloseConfirmResponse;
                     toAmino(_: _146.MsgChannelCloseConfirmResponse): _146.MsgChannelCloseConfirmResponseAmino;
                     fromAminoMsg(object: _146.MsgChannelCloseConfirmResponseAminoMsg): _146.MsgChannelCloseConfirmResponse;
@@ -1377,9 +1206,10 @@ export declare namespace ibc {
                 };
                 MsgRecvPacket: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgRecvPacket, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgRecvPacket;
-                    fromPartial(object: Partial<_146.MsgRecvPacket>): _146.MsgRecvPacket;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgRecvPacket>): _146.MsgRecvPacket;
                     fromAmino(object: _146.MsgRecvPacketAmino): _146.MsgRecvPacket;
                     toAmino(message: _146.MsgRecvPacket): _146.MsgRecvPacketAmino;
                     fromAminoMsg(object: _146.MsgRecvPacketAminoMsg): _146.MsgRecvPacket;
@@ -1390,9 +1220,10 @@ export declare namespace ibc {
                 };
                 MsgRecvPacketResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgRecvPacketResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgRecvPacketResponse;
-                    fromPartial(object: Partial<_146.MsgRecvPacketResponse>): _146.MsgRecvPacketResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgRecvPacketResponse>): _146.MsgRecvPacketResponse;
                     fromAmino(object: _146.MsgRecvPacketResponseAmino): _146.MsgRecvPacketResponse;
                     toAmino(message: _146.MsgRecvPacketResponse): _146.MsgRecvPacketResponseAmino;
                     fromAminoMsg(object: _146.MsgRecvPacketResponseAminoMsg): _146.MsgRecvPacketResponse;
@@ -1403,9 +1234,10 @@ export declare namespace ibc {
                 };
                 MsgTimeout: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgTimeout, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgTimeout;
-                    fromPartial(object: Partial<_146.MsgTimeout>): _146.MsgTimeout;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgTimeout>): _146.MsgTimeout;
                     fromAmino(object: _146.MsgTimeoutAmino): _146.MsgTimeout;
                     toAmino(message: _146.MsgTimeout): _146.MsgTimeoutAmino;
                     fromAminoMsg(object: _146.MsgTimeoutAminoMsg): _146.MsgTimeout;
@@ -1416,9 +1248,10 @@ export declare namespace ibc {
                 };
                 MsgTimeoutResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgTimeoutResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgTimeoutResponse;
-                    fromPartial(object: Partial<_146.MsgTimeoutResponse>): _146.MsgTimeoutResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgTimeoutResponse>): _146.MsgTimeoutResponse;
                     fromAmino(object: _146.MsgTimeoutResponseAmino): _146.MsgTimeoutResponse;
                     toAmino(message: _146.MsgTimeoutResponse): _146.MsgTimeoutResponseAmino;
                     fromAminoMsg(object: _146.MsgTimeoutResponseAminoMsg): _146.MsgTimeoutResponse;
@@ -1429,9 +1262,10 @@ export declare namespace ibc {
                 };
                 MsgTimeoutOnClose: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgTimeoutOnClose, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgTimeoutOnClose;
-                    fromPartial(object: Partial<_146.MsgTimeoutOnClose>): _146.MsgTimeoutOnClose;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgTimeoutOnClose>): _146.MsgTimeoutOnClose;
                     fromAmino(object: _146.MsgTimeoutOnCloseAmino): _146.MsgTimeoutOnClose;
                     toAmino(message: _146.MsgTimeoutOnClose): _146.MsgTimeoutOnCloseAmino;
                     fromAminoMsg(object: _146.MsgTimeoutOnCloseAminoMsg): _146.MsgTimeoutOnClose;
@@ -1442,9 +1276,10 @@ export declare namespace ibc {
                 };
                 MsgTimeoutOnCloseResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgTimeoutOnCloseResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgTimeoutOnCloseResponse;
-                    fromPartial(object: Partial<_146.MsgTimeoutOnCloseResponse>): _146.MsgTimeoutOnCloseResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgTimeoutOnCloseResponse>): _146.MsgTimeoutOnCloseResponse;
                     fromAmino(object: _146.MsgTimeoutOnCloseResponseAmino): _146.MsgTimeoutOnCloseResponse;
                     toAmino(message: _146.MsgTimeoutOnCloseResponse): _146.MsgTimeoutOnCloseResponseAmino;
                     fromAminoMsg(object: _146.MsgTimeoutOnCloseResponseAminoMsg): _146.MsgTimeoutOnCloseResponse;
@@ -1455,9 +1290,10 @@ export declare namespace ibc {
                 };
                 MsgAcknowledgement: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgAcknowledgement, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgAcknowledgement;
-                    fromPartial(object: Partial<_146.MsgAcknowledgement>): _146.MsgAcknowledgement;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgAcknowledgement>): _146.MsgAcknowledgement;
                     fromAmino(object: _146.MsgAcknowledgementAmino): _146.MsgAcknowledgement;
                     toAmino(message: _146.MsgAcknowledgement): _146.MsgAcknowledgementAmino;
                     fromAminoMsg(object: _146.MsgAcknowledgementAminoMsg): _146.MsgAcknowledgement;
@@ -1468,9 +1304,10 @@ export declare namespace ibc {
                 };
                 MsgAcknowledgementResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _146.MsgAcknowledgementResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _146.MsgAcknowledgementResponse;
-                    fromPartial(object: Partial<_146.MsgAcknowledgementResponse>): _146.MsgAcknowledgementResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_146.MsgAcknowledgementResponse>): _146.MsgAcknowledgementResponse;
                     fromAmino(object: _146.MsgAcknowledgementResponseAmino): _146.MsgAcknowledgementResponse;
                     toAmino(message: _146.MsgAcknowledgementResponse): _146.MsgAcknowledgementResponseAmino;
                     fromAminoMsg(object: _146.MsgAcknowledgementResponseAminoMsg): _146.MsgAcknowledgementResponse;
@@ -1481,9 +1318,10 @@ export declare namespace ibc {
                 };
                 QueryChannelRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryChannelRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryChannelRequest;
-                    fromPartial(object: Partial<_145.QueryChannelRequest>): _145.QueryChannelRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryChannelRequest>): _145.QueryChannelRequest;
                     fromAmino(object: _145.QueryChannelRequestAmino): _145.QueryChannelRequest;
                     toAmino(message: _145.QueryChannelRequest): _145.QueryChannelRequestAmino;
                     fromAminoMsg(object: _145.QueryChannelRequestAminoMsg): _145.QueryChannelRequest;
@@ -1494,9 +1332,10 @@ export declare namespace ibc {
                 };
                 QueryChannelResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryChannelResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryChannelResponse;
-                    fromPartial(object: Partial<_145.QueryChannelResponse>): _145.QueryChannelResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryChannelResponse>): _145.QueryChannelResponse;
                     fromAmino(object: _145.QueryChannelResponseAmino): _145.QueryChannelResponse;
                     toAmino(message: _145.QueryChannelResponse): _145.QueryChannelResponseAmino;
                     fromAminoMsg(object: _145.QueryChannelResponseAminoMsg): _145.QueryChannelResponse;
@@ -1507,9 +1346,10 @@ export declare namespace ibc {
                 };
                 QueryChannelsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryChannelsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryChannelsRequest;
-                    fromPartial(object: Partial<_145.QueryChannelsRequest>): _145.QueryChannelsRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryChannelsRequest>): _145.QueryChannelsRequest;
                     fromAmino(object: _145.QueryChannelsRequestAmino): _145.QueryChannelsRequest;
                     toAmino(message: _145.QueryChannelsRequest): _145.QueryChannelsRequestAmino;
                     fromAminoMsg(object: _145.QueryChannelsRequestAminoMsg): _145.QueryChannelsRequest;
@@ -1520,9 +1360,10 @@ export declare namespace ibc {
                 };
                 QueryChannelsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryChannelsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryChannelsResponse;
-                    fromPartial(object: Partial<_145.QueryChannelsResponse>): _145.QueryChannelsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryChannelsResponse>): _145.QueryChannelsResponse;
                     fromAmino(object: _145.QueryChannelsResponseAmino): _145.QueryChannelsResponse;
                     toAmino(message: _145.QueryChannelsResponse): _145.QueryChannelsResponseAmino;
                     fromAminoMsg(object: _145.QueryChannelsResponseAminoMsg): _145.QueryChannelsResponse;
@@ -1533,9 +1374,10 @@ export declare namespace ibc {
                 };
                 QueryConnectionChannelsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryConnectionChannelsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryConnectionChannelsRequest;
-                    fromPartial(object: Partial<_145.QueryConnectionChannelsRequest>): _145.QueryConnectionChannelsRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryConnectionChannelsRequest>): _145.QueryConnectionChannelsRequest;
                     fromAmino(object: _145.QueryConnectionChannelsRequestAmino): _145.QueryConnectionChannelsRequest;
                     toAmino(message: _145.QueryConnectionChannelsRequest): _145.QueryConnectionChannelsRequestAmino;
                     fromAminoMsg(object: _145.QueryConnectionChannelsRequestAminoMsg): _145.QueryConnectionChannelsRequest;
@@ -1546,9 +1388,10 @@ export declare namespace ibc {
                 };
                 QueryConnectionChannelsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryConnectionChannelsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryConnectionChannelsResponse;
-                    fromPartial(object: Partial<_145.QueryConnectionChannelsResponse>): _145.QueryConnectionChannelsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryConnectionChannelsResponse>): _145.QueryConnectionChannelsResponse;
                     fromAmino(object: _145.QueryConnectionChannelsResponseAmino): _145.QueryConnectionChannelsResponse;
                     toAmino(message: _145.QueryConnectionChannelsResponse): _145.QueryConnectionChannelsResponseAmino;
                     fromAminoMsg(object: _145.QueryConnectionChannelsResponseAminoMsg): _145.QueryConnectionChannelsResponse;
@@ -1559,9 +1402,10 @@ export declare namespace ibc {
                 };
                 QueryChannelClientStateRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryChannelClientStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryChannelClientStateRequest;
-                    fromPartial(object: Partial<_145.QueryChannelClientStateRequest>): _145.QueryChannelClientStateRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryChannelClientStateRequest>): _145.QueryChannelClientStateRequest;
                     fromAmino(object: _145.QueryChannelClientStateRequestAmino): _145.QueryChannelClientStateRequest;
                     toAmino(message: _145.QueryChannelClientStateRequest): _145.QueryChannelClientStateRequestAmino;
                     fromAminoMsg(object: _145.QueryChannelClientStateRequestAminoMsg): _145.QueryChannelClientStateRequest;
@@ -1572,9 +1416,10 @@ export declare namespace ibc {
                 };
                 QueryChannelClientStateResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryChannelClientStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryChannelClientStateResponse;
-                    fromPartial(object: Partial<_145.QueryChannelClientStateResponse>): _145.QueryChannelClientStateResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryChannelClientStateResponse>): _145.QueryChannelClientStateResponse;
                     fromAmino(object: _145.QueryChannelClientStateResponseAmino): _145.QueryChannelClientStateResponse;
                     toAmino(message: _145.QueryChannelClientStateResponse): _145.QueryChannelClientStateResponseAmino;
                     fromAminoMsg(object: _145.QueryChannelClientStateResponseAminoMsg): _145.QueryChannelClientStateResponse;
@@ -1585,9 +1430,10 @@ export declare namespace ibc {
                 };
                 QueryChannelConsensusStateRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryChannelConsensusStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryChannelConsensusStateRequest;
-                    fromPartial(object: Partial<_145.QueryChannelConsensusStateRequest>): _145.QueryChannelConsensusStateRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryChannelConsensusStateRequest>): _145.QueryChannelConsensusStateRequest;
                     fromAmino(object: _145.QueryChannelConsensusStateRequestAmino): _145.QueryChannelConsensusStateRequest;
                     toAmino(message: _145.QueryChannelConsensusStateRequest): _145.QueryChannelConsensusStateRequestAmino;
                     fromAminoMsg(object: _145.QueryChannelConsensusStateRequestAminoMsg): _145.QueryChannelConsensusStateRequest;
@@ -1598,9 +1444,10 @@ export declare namespace ibc {
                 };
                 QueryChannelConsensusStateResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryChannelConsensusStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryChannelConsensusStateResponse;
-                    fromPartial(object: Partial<_145.QueryChannelConsensusStateResponse>): _145.QueryChannelConsensusStateResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryChannelConsensusStateResponse>): _145.QueryChannelConsensusStateResponse;
                     fromAmino(object: _145.QueryChannelConsensusStateResponseAmino): _145.QueryChannelConsensusStateResponse;
                     toAmino(message: _145.QueryChannelConsensusStateResponse): _145.QueryChannelConsensusStateResponseAmino;
                     fromAminoMsg(object: _145.QueryChannelConsensusStateResponseAminoMsg): _145.QueryChannelConsensusStateResponse;
@@ -1611,9 +1458,10 @@ export declare namespace ibc {
                 };
                 QueryPacketCommitmentRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryPacketCommitmentRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryPacketCommitmentRequest;
-                    fromPartial(object: Partial<_145.QueryPacketCommitmentRequest>): _145.QueryPacketCommitmentRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryPacketCommitmentRequest>): _145.QueryPacketCommitmentRequest;
                     fromAmino(object: _145.QueryPacketCommitmentRequestAmino): _145.QueryPacketCommitmentRequest;
                     toAmino(message: _145.QueryPacketCommitmentRequest): _145.QueryPacketCommitmentRequestAmino;
                     fromAminoMsg(object: _145.QueryPacketCommitmentRequestAminoMsg): _145.QueryPacketCommitmentRequest;
@@ -1624,9 +1472,10 @@ export declare namespace ibc {
                 };
                 QueryPacketCommitmentResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryPacketCommitmentResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryPacketCommitmentResponse;
-                    fromPartial(object: Partial<_145.QueryPacketCommitmentResponse>): _145.QueryPacketCommitmentResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryPacketCommitmentResponse>): _145.QueryPacketCommitmentResponse;
                     fromAmino(object: _145.QueryPacketCommitmentResponseAmino): _145.QueryPacketCommitmentResponse;
                     toAmino(message: _145.QueryPacketCommitmentResponse): _145.QueryPacketCommitmentResponseAmino;
                     fromAminoMsg(object: _145.QueryPacketCommitmentResponseAminoMsg): _145.QueryPacketCommitmentResponse;
@@ -1637,9 +1486,10 @@ export declare namespace ibc {
                 };
                 QueryPacketCommitmentsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryPacketCommitmentsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryPacketCommitmentsRequest;
-                    fromPartial(object: Partial<_145.QueryPacketCommitmentsRequest>): _145.QueryPacketCommitmentsRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryPacketCommitmentsRequest>): _145.QueryPacketCommitmentsRequest;
                     fromAmino(object: _145.QueryPacketCommitmentsRequestAmino): _145.QueryPacketCommitmentsRequest;
                     toAmino(message: _145.QueryPacketCommitmentsRequest): _145.QueryPacketCommitmentsRequestAmino;
                     fromAminoMsg(object: _145.QueryPacketCommitmentsRequestAminoMsg): _145.QueryPacketCommitmentsRequest;
@@ -1650,9 +1500,10 @@ export declare namespace ibc {
                 };
                 QueryPacketCommitmentsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryPacketCommitmentsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryPacketCommitmentsResponse;
-                    fromPartial(object: Partial<_145.QueryPacketCommitmentsResponse>): _145.QueryPacketCommitmentsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryPacketCommitmentsResponse>): _145.QueryPacketCommitmentsResponse;
                     fromAmino(object: _145.QueryPacketCommitmentsResponseAmino): _145.QueryPacketCommitmentsResponse;
                     toAmino(message: _145.QueryPacketCommitmentsResponse): _145.QueryPacketCommitmentsResponseAmino;
                     fromAminoMsg(object: _145.QueryPacketCommitmentsResponseAminoMsg): _145.QueryPacketCommitmentsResponse;
@@ -1663,9 +1514,10 @@ export declare namespace ibc {
                 };
                 QueryPacketReceiptRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryPacketReceiptRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryPacketReceiptRequest;
-                    fromPartial(object: Partial<_145.QueryPacketReceiptRequest>): _145.QueryPacketReceiptRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryPacketReceiptRequest>): _145.QueryPacketReceiptRequest;
                     fromAmino(object: _145.QueryPacketReceiptRequestAmino): _145.QueryPacketReceiptRequest;
                     toAmino(message: _145.QueryPacketReceiptRequest): _145.QueryPacketReceiptRequestAmino;
                     fromAminoMsg(object: _145.QueryPacketReceiptRequestAminoMsg): _145.QueryPacketReceiptRequest;
@@ -1676,9 +1528,10 @@ export declare namespace ibc {
                 };
                 QueryPacketReceiptResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryPacketReceiptResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryPacketReceiptResponse;
-                    fromPartial(object: Partial<_145.QueryPacketReceiptResponse>): _145.QueryPacketReceiptResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryPacketReceiptResponse>): _145.QueryPacketReceiptResponse;
                     fromAmino(object: _145.QueryPacketReceiptResponseAmino): _145.QueryPacketReceiptResponse;
                     toAmino(message: _145.QueryPacketReceiptResponse): _145.QueryPacketReceiptResponseAmino;
                     fromAminoMsg(object: _145.QueryPacketReceiptResponseAminoMsg): _145.QueryPacketReceiptResponse;
@@ -1689,9 +1542,10 @@ export declare namespace ibc {
                 };
                 QueryPacketAcknowledgementRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryPacketAcknowledgementRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryPacketAcknowledgementRequest;
-                    fromPartial(object: Partial<_145.QueryPacketAcknowledgementRequest>): _145.QueryPacketAcknowledgementRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryPacketAcknowledgementRequest>): _145.QueryPacketAcknowledgementRequest;
                     fromAmino(object: _145.QueryPacketAcknowledgementRequestAmino): _145.QueryPacketAcknowledgementRequest;
                     toAmino(message: _145.QueryPacketAcknowledgementRequest): _145.QueryPacketAcknowledgementRequestAmino;
                     fromAminoMsg(object: _145.QueryPacketAcknowledgementRequestAminoMsg): _145.QueryPacketAcknowledgementRequest;
@@ -1702,9 +1556,10 @@ export declare namespace ibc {
                 };
                 QueryPacketAcknowledgementResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryPacketAcknowledgementResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryPacketAcknowledgementResponse;
-                    fromPartial(object: Partial<_145.QueryPacketAcknowledgementResponse>): _145.QueryPacketAcknowledgementResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryPacketAcknowledgementResponse>): _145.QueryPacketAcknowledgementResponse;
                     fromAmino(object: _145.QueryPacketAcknowledgementResponseAmino): _145.QueryPacketAcknowledgementResponse;
                     toAmino(message: _145.QueryPacketAcknowledgementResponse): _145.QueryPacketAcknowledgementResponseAmino;
                     fromAminoMsg(object: _145.QueryPacketAcknowledgementResponseAminoMsg): _145.QueryPacketAcknowledgementResponse;
@@ -1715,9 +1570,10 @@ export declare namespace ibc {
                 };
                 QueryPacketAcknowledgementsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryPacketAcknowledgementsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryPacketAcknowledgementsRequest;
-                    fromPartial(object: Partial<_145.QueryPacketAcknowledgementsRequest>): _145.QueryPacketAcknowledgementsRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryPacketAcknowledgementsRequest>): _145.QueryPacketAcknowledgementsRequest;
                     fromAmino(object: _145.QueryPacketAcknowledgementsRequestAmino): _145.QueryPacketAcknowledgementsRequest;
                     toAmino(message: _145.QueryPacketAcknowledgementsRequest): _145.QueryPacketAcknowledgementsRequestAmino;
                     fromAminoMsg(object: _145.QueryPacketAcknowledgementsRequestAminoMsg): _145.QueryPacketAcknowledgementsRequest;
@@ -1728,9 +1584,10 @@ export declare namespace ibc {
                 };
                 QueryPacketAcknowledgementsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryPacketAcknowledgementsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryPacketAcknowledgementsResponse;
-                    fromPartial(object: Partial<_145.QueryPacketAcknowledgementsResponse>): _145.QueryPacketAcknowledgementsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryPacketAcknowledgementsResponse>): _145.QueryPacketAcknowledgementsResponse;
                     fromAmino(object: _145.QueryPacketAcknowledgementsResponseAmino): _145.QueryPacketAcknowledgementsResponse;
                     toAmino(message: _145.QueryPacketAcknowledgementsResponse): _145.QueryPacketAcknowledgementsResponseAmino;
                     fromAminoMsg(object: _145.QueryPacketAcknowledgementsResponseAminoMsg): _145.QueryPacketAcknowledgementsResponse;
@@ -1741,9 +1598,10 @@ export declare namespace ibc {
                 };
                 QueryUnreceivedPacketsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryUnreceivedPacketsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryUnreceivedPacketsRequest;
-                    fromPartial(object: Partial<_145.QueryUnreceivedPacketsRequest>): _145.QueryUnreceivedPacketsRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryUnreceivedPacketsRequest>): _145.QueryUnreceivedPacketsRequest;
                     fromAmino(object: _145.QueryUnreceivedPacketsRequestAmino): _145.QueryUnreceivedPacketsRequest;
                     toAmino(message: _145.QueryUnreceivedPacketsRequest): _145.QueryUnreceivedPacketsRequestAmino;
                     fromAminoMsg(object: _145.QueryUnreceivedPacketsRequestAminoMsg): _145.QueryUnreceivedPacketsRequest;
@@ -1754,9 +1612,10 @@ export declare namespace ibc {
                 };
                 QueryUnreceivedPacketsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryUnreceivedPacketsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryUnreceivedPacketsResponse;
-                    fromPartial(object: Partial<_145.QueryUnreceivedPacketsResponse>): _145.QueryUnreceivedPacketsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryUnreceivedPacketsResponse>): _145.QueryUnreceivedPacketsResponse;
                     fromAmino(object: _145.QueryUnreceivedPacketsResponseAmino): _145.QueryUnreceivedPacketsResponse;
                     toAmino(message: _145.QueryUnreceivedPacketsResponse): _145.QueryUnreceivedPacketsResponseAmino;
                     fromAminoMsg(object: _145.QueryUnreceivedPacketsResponseAminoMsg): _145.QueryUnreceivedPacketsResponse;
@@ -1767,9 +1626,10 @@ export declare namespace ibc {
                 };
                 QueryUnreceivedAcksRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryUnreceivedAcksRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryUnreceivedAcksRequest;
-                    fromPartial(object: Partial<_145.QueryUnreceivedAcksRequest>): _145.QueryUnreceivedAcksRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryUnreceivedAcksRequest>): _145.QueryUnreceivedAcksRequest;
                     fromAmino(object: _145.QueryUnreceivedAcksRequestAmino): _145.QueryUnreceivedAcksRequest;
                     toAmino(message: _145.QueryUnreceivedAcksRequest): _145.QueryUnreceivedAcksRequestAmino;
                     fromAminoMsg(object: _145.QueryUnreceivedAcksRequestAminoMsg): _145.QueryUnreceivedAcksRequest;
@@ -1780,9 +1640,10 @@ export declare namespace ibc {
                 };
                 QueryUnreceivedAcksResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryUnreceivedAcksResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryUnreceivedAcksResponse;
-                    fromPartial(object: Partial<_145.QueryUnreceivedAcksResponse>): _145.QueryUnreceivedAcksResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryUnreceivedAcksResponse>): _145.QueryUnreceivedAcksResponse;
                     fromAmino(object: _145.QueryUnreceivedAcksResponseAmino): _145.QueryUnreceivedAcksResponse;
                     toAmino(message: _145.QueryUnreceivedAcksResponse): _145.QueryUnreceivedAcksResponseAmino;
                     fromAminoMsg(object: _145.QueryUnreceivedAcksResponseAminoMsg): _145.QueryUnreceivedAcksResponse;
@@ -1793,9 +1654,10 @@ export declare namespace ibc {
                 };
                 QueryNextSequenceReceiveRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryNextSequenceReceiveRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryNextSequenceReceiveRequest;
-                    fromPartial(object: Partial<_145.QueryNextSequenceReceiveRequest>): _145.QueryNextSequenceReceiveRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryNextSequenceReceiveRequest>): _145.QueryNextSequenceReceiveRequest;
                     fromAmino(object: _145.QueryNextSequenceReceiveRequestAmino): _145.QueryNextSequenceReceiveRequest;
                     toAmino(message: _145.QueryNextSequenceReceiveRequest): _145.QueryNextSequenceReceiveRequestAmino;
                     fromAminoMsg(object: _145.QueryNextSequenceReceiveRequestAminoMsg): _145.QueryNextSequenceReceiveRequest;
@@ -1806,9 +1668,10 @@ export declare namespace ibc {
                 };
                 QueryNextSequenceReceiveResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryNextSequenceReceiveResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryNextSequenceReceiveResponse;
-                    fromPartial(object: Partial<_145.QueryNextSequenceReceiveResponse>): _145.QueryNextSequenceReceiveResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryNextSequenceReceiveResponse>): _145.QueryNextSequenceReceiveResponse;
                     fromAmino(object: _145.QueryNextSequenceReceiveResponseAmino): _145.QueryNextSequenceReceiveResponse;
                     toAmino(message: _145.QueryNextSequenceReceiveResponse): _145.QueryNextSequenceReceiveResponseAmino;
                     fromAminoMsg(object: _145.QueryNextSequenceReceiveResponseAminoMsg): _145.QueryNextSequenceReceiveResponse;
@@ -1819,9 +1682,10 @@ export declare namespace ibc {
                 };
                 QueryNextSequenceSendRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryNextSequenceSendRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryNextSequenceSendRequest;
-                    fromPartial(object: Partial<_145.QueryNextSequenceSendRequest>): _145.QueryNextSequenceSendRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryNextSequenceSendRequest>): _145.QueryNextSequenceSendRequest;
                     fromAmino(object: _145.QueryNextSequenceSendRequestAmino): _145.QueryNextSequenceSendRequest;
                     toAmino(message: _145.QueryNextSequenceSendRequest): _145.QueryNextSequenceSendRequestAmino;
                     fromAminoMsg(object: _145.QueryNextSequenceSendRequestAminoMsg): _145.QueryNextSequenceSendRequest;
@@ -1832,9 +1696,10 @@ export declare namespace ibc {
                 };
                 QueryNextSequenceSendResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _145.QueryNextSequenceSendResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _145.QueryNextSequenceSendResponse;
-                    fromPartial(object: Partial<_145.QueryNextSequenceSendResponse>): _145.QueryNextSequenceSendResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_145.QueryNextSequenceSendResponse>): _145.QueryNextSequenceSendResponse;
                     fromAmino(object: _145.QueryNextSequenceSendResponseAmino): _145.QueryNextSequenceSendResponse;
                     toAmino(message: _145.QueryNextSequenceSendResponse): _145.QueryNextSequenceSendResponseAmino;
                     fromAminoMsg(object: _145.QueryNextSequenceSendResponseAminoMsg): _145.QueryNextSequenceSendResponse;
@@ -1845,9 +1710,10 @@ export declare namespace ibc {
                 };
                 GenesisState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _144.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _144.GenesisState;
-                    fromPartial(object: Partial<_144.GenesisState>): _144.GenesisState;
+                    fromPartial(object: import("../helpers").DeepPartial<_144.GenesisState>): _144.GenesisState;
                     fromAmino(object: _144.GenesisStateAmino): _144.GenesisState;
                     toAmino(message: _144.GenesisState): _144.GenesisStateAmino;
                     fromAminoMsg(object: _144.GenesisStateAminoMsg): _144.GenesisState;
@@ -1858,9 +1724,10 @@ export declare namespace ibc {
                 };
                 PacketSequence: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _144.PacketSequence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _144.PacketSequence;
-                    fromPartial(object: Partial<_144.PacketSequence>): _144.PacketSequence;
+                    fromPartial(object: import("../helpers").DeepPartial<_144.PacketSequence>): _144.PacketSequence;
                     fromAmino(object: _144.PacketSequenceAmino): _144.PacketSequence;
                     toAmino(message: _144.PacketSequence): _144.PacketSequenceAmino;
                     fromAminoMsg(object: _144.PacketSequenceAminoMsg): _144.PacketSequence;
@@ -1874,16 +1741,15 @@ export declare namespace ibc {
                 orderFromJSON(object: any): _143.Order;
                 orderToJSON(object: _143.Order): string;
                 State: typeof _143.State;
-                StateSDKType: typeof _143.State;
                 StateAmino: typeof _143.State;
                 Order: typeof _143.Order;
-                OrderSDKType: typeof _143.Order;
                 OrderAmino: typeof _143.Order;
                 Channel: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _143.Channel, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _143.Channel;
-                    fromPartial(object: Partial<_143.Channel>): _143.Channel;
+                    fromPartial(object: import("../helpers").DeepPartial<_143.Channel>): _143.Channel;
                     fromAmino(object: _143.ChannelAmino): _143.Channel;
                     toAmino(message: _143.Channel): _143.ChannelAmino;
                     fromAminoMsg(object: _143.ChannelAminoMsg): _143.Channel;
@@ -1894,9 +1760,10 @@ export declare namespace ibc {
                 };
                 IdentifiedChannel: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _143.IdentifiedChannel, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _143.IdentifiedChannel;
-                    fromPartial(object: Partial<_143.IdentifiedChannel>): _143.IdentifiedChannel;
+                    fromPartial(object: import("../helpers").DeepPartial<_143.IdentifiedChannel>): _143.IdentifiedChannel;
                     fromAmino(object: _143.IdentifiedChannelAmino): _143.IdentifiedChannel;
                     toAmino(message: _143.IdentifiedChannel): _143.IdentifiedChannelAmino;
                     fromAminoMsg(object: _143.IdentifiedChannelAminoMsg): _143.IdentifiedChannel;
@@ -1907,9 +1774,10 @@ export declare namespace ibc {
                 };
                 Counterparty: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _143.Counterparty, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _143.Counterparty;
-                    fromPartial(object: Partial<_143.Counterparty>): _143.Counterparty;
+                    fromPartial(object: import("../helpers").DeepPartial<_143.Counterparty>): _143.Counterparty;
                     fromAmino(object: _143.CounterpartyAmino): _143.Counterparty;
                     toAmino(message: _143.Counterparty): _143.CounterpartyAmino;
                     fromAminoMsg(object: _143.CounterpartyAminoMsg): _143.Counterparty;
@@ -1920,9 +1788,10 @@ export declare namespace ibc {
                 };
                 Packet: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _143.Packet, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _143.Packet;
-                    fromPartial(object: Partial<_143.Packet>): _143.Packet;
+                    fromPartial(object: import("../helpers").DeepPartial<_143.Packet>): _143.Packet;
                     fromAmino(object: _143.PacketAmino): _143.Packet;
                     toAmino(message: _143.Packet): _143.PacketAmino;
                     fromAminoMsg(object: _143.PacketAminoMsg): _143.Packet;
@@ -1933,9 +1802,10 @@ export declare namespace ibc {
                 };
                 PacketState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _143.PacketState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _143.PacketState;
-                    fromPartial(object: Partial<_143.PacketState>): _143.PacketState;
+                    fromPartial(object: import("../helpers").DeepPartial<_143.PacketState>): _143.PacketState;
                     fromAmino(object: _143.PacketStateAmino): _143.PacketState;
                     toAmino(message: _143.PacketState): _143.PacketStateAmino;
                     fromAminoMsg(object: _143.PacketStateAminoMsg): _143.PacketState;
@@ -1946,9 +1816,10 @@ export declare namespace ibc {
                 };
                 PacketId: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _143.PacketId, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _143.PacketId;
-                    fromPartial(object: Partial<_143.PacketId>): _143.PacketId;
+                    fromPartial(object: import("../helpers").DeepPartial<_143.PacketId>): _143.PacketId;
                     fromAmino(object: _143.PacketIdAmino): _143.PacketId;
                     toAmino(message: _143.PacketId): _143.PacketIdAmino;
                     fromAminoMsg(object: _143.PacketIdAminoMsg): _143.PacketId;
@@ -1959,9 +1830,10 @@ export declare namespace ibc {
                 };
                 Acknowledgement: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _143.Acknowledgement, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _143.Acknowledgement;
-                    fromPartial(object: Partial<_143.Acknowledgement>): _143.Acknowledgement;
+                    fromPartial(object: import("../helpers").DeepPartial<_143.Acknowledgement>): _143.Acknowledgement;
                     fromAmino(object: _143.AcknowledgementAmino): _143.Acknowledgement;
                     toAmino(message: _143.Acknowledgement): _143.AcknowledgementAmino;
                     fromAminoMsg(object: _143.AcknowledgementAminoMsg): _143.Acknowledgement;
@@ -1972,9 +1844,10 @@ export declare namespace ibc {
                 };
                 Timeout: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _143.Timeout, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _143.Timeout;
-                    fromPartial(object: Partial<_143.Timeout>): _143.Timeout;
+                    fromPartial(object: import("../helpers").DeepPartial<_143.Timeout>): _143.Timeout;
                     fromAmino(object: _143.TimeoutAmino): _143.Timeout;
                     toAmino(message: _143.Timeout): _143.TimeoutAmino;
                     fromAminoMsg(object: _143.TimeoutAminoMsg): _143.Timeout;
@@ -1986,6 +1859,7 @@ export declare namespace ibc {
             };
             const v2: {
                 MsgClientImpl: typeof _321.MsgClientImpl;
+                createClientImpl: (rpc: import("..").TxRpc) => _321.MsgClientImpl;
                 QueryClientImpl: typeof _312.QueryClientImpl;
                 createRpcQueryExtension: (base: QueryClient) => {
                     nextSequenceSend(request: _149.QueryNextSequenceSendRequest): Promise<_149.QueryNextSequenceSendResponse>;
@@ -1998,64 +1872,7 @@ export declare namespace ibc {
                     unreceivedAcks(request: _149.QueryUnreceivedAcksRequest): Promise<_149.QueryUnreceivedAcksResponse>;
                 };
                 LCDQueryClient: typeof _303.LCDQueryClient;
-                registry: ReadonlyArray<[string, GeneratedType]>;
-                load: (protoRegistry: Registry) => void;
-                MessageComposer: {
-                    encoded: {
-                        sendPacket(value: _150.MsgSendPacket): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        recvPacket(value: _150.MsgRecvPacket): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        timeout(value: _150.MsgTimeout): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        acknowledgement(value: _150.MsgAcknowledgement): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                    };
-                    withTypeUrl: {
-                        sendPacket(value: _150.MsgSendPacket): {
-                            typeUrl: string;
-                            value: _150.MsgSendPacket;
-                        };
-                        recvPacket(value: _150.MsgRecvPacket): {
-                            typeUrl: string;
-                            value: _150.MsgRecvPacket;
-                        };
-                        timeout(value: _150.MsgTimeout): {
-                            typeUrl: string;
-                            value: _150.MsgTimeout;
-                        };
-                        acknowledgement(value: _150.MsgAcknowledgement): {
-                            typeUrl: string;
-                            value: _150.MsgAcknowledgement;
-                        };
-                    };
-                    fromPartial: {
-                        sendPacket(value: _150.MsgSendPacket): {
-                            typeUrl: string;
-                            value: _150.MsgSendPacket;
-                        };
-                        recvPacket(value: _150.MsgRecvPacket): {
-                            typeUrl: string;
-                            value: _150.MsgRecvPacket;
-                        };
-                        timeout(value: _150.MsgTimeout): {
-                            typeUrl: string;
-                            value: _150.MsgTimeout;
-                        };
-                        acknowledgement(value: _150.MsgAcknowledgement): {
-                            typeUrl: string;
-                            value: _150.MsgAcknowledgement;
-                        };
-                    };
-                };
+                registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
                 AminoConverter: {
                     "/ibc.core.channel.v2.MsgSendPacket": {
                         aminoType: string;
@@ -2081,13 +1898,13 @@ export declare namespace ibc {
                 responseResultTypeFromJSON(object: any): _150.ResponseResultType;
                 responseResultTypeToJSON(object: _150.ResponseResultType): string;
                 ResponseResultType: typeof _150.ResponseResultType;
-                ResponseResultTypeSDKType: typeof _150.ResponseResultType;
                 ResponseResultTypeAmino: typeof _150.ResponseResultType;
                 MsgSendPacket: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _150.MsgSendPacket, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _150.MsgSendPacket;
-                    fromPartial(object: Partial<_150.MsgSendPacket>): _150.MsgSendPacket;
+                    fromPartial(object: import("../helpers").DeepPartial<_150.MsgSendPacket>): _150.MsgSendPacket;
                     fromAmino(object: _150.MsgSendPacketAmino): _150.MsgSendPacket;
                     toAmino(message: _150.MsgSendPacket): _150.MsgSendPacketAmino;
                     fromAminoMsg(object: _150.MsgSendPacketAminoMsg): _150.MsgSendPacket;
@@ -2098,9 +1915,10 @@ export declare namespace ibc {
                 };
                 MsgSendPacketResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _150.MsgSendPacketResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _150.MsgSendPacketResponse;
-                    fromPartial(object: Partial<_150.MsgSendPacketResponse>): _150.MsgSendPacketResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_150.MsgSendPacketResponse>): _150.MsgSendPacketResponse;
                     fromAmino(object: _150.MsgSendPacketResponseAmino): _150.MsgSendPacketResponse;
                     toAmino(message: _150.MsgSendPacketResponse): _150.MsgSendPacketResponseAmino;
                     fromAminoMsg(object: _150.MsgSendPacketResponseAminoMsg): _150.MsgSendPacketResponse;
@@ -2111,9 +1929,10 @@ export declare namespace ibc {
                 };
                 MsgRecvPacket: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _150.MsgRecvPacket, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _150.MsgRecvPacket;
-                    fromPartial(object: Partial<_150.MsgRecvPacket>): _150.MsgRecvPacket;
+                    fromPartial(object: import("../helpers").DeepPartial<_150.MsgRecvPacket>): _150.MsgRecvPacket;
                     fromAmino(object: _150.MsgRecvPacketAmino): _150.MsgRecvPacket;
                     toAmino(message: _150.MsgRecvPacket): _150.MsgRecvPacketAmino;
                     fromAminoMsg(object: _150.MsgRecvPacketAminoMsg): _150.MsgRecvPacket;
@@ -2124,9 +1943,10 @@ export declare namespace ibc {
                 };
                 MsgRecvPacketResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _150.MsgRecvPacketResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _150.MsgRecvPacketResponse;
-                    fromPartial(object: Partial<_150.MsgRecvPacketResponse>): _150.MsgRecvPacketResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_150.MsgRecvPacketResponse>): _150.MsgRecvPacketResponse;
                     fromAmino(object: _150.MsgRecvPacketResponseAmino): _150.MsgRecvPacketResponse;
                     toAmino(message: _150.MsgRecvPacketResponse): _150.MsgRecvPacketResponseAmino;
                     fromAminoMsg(object: _150.MsgRecvPacketResponseAminoMsg): _150.MsgRecvPacketResponse;
@@ -2137,9 +1957,10 @@ export declare namespace ibc {
                 };
                 MsgTimeout: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _150.MsgTimeout, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _150.MsgTimeout;
-                    fromPartial(object: Partial<_150.MsgTimeout>): _150.MsgTimeout;
+                    fromPartial(object: import("../helpers").DeepPartial<_150.MsgTimeout>): _150.MsgTimeout;
                     fromAmino(object: _150.MsgTimeoutAmino): _150.MsgTimeout;
                     toAmino(message: _150.MsgTimeout): _150.MsgTimeoutAmino;
                     fromAminoMsg(object: _150.MsgTimeoutAminoMsg): _150.MsgTimeout;
@@ -2150,9 +1971,10 @@ export declare namespace ibc {
                 };
                 MsgTimeoutResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _150.MsgTimeoutResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _150.MsgTimeoutResponse;
-                    fromPartial(object: Partial<_150.MsgTimeoutResponse>): _150.MsgTimeoutResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_150.MsgTimeoutResponse>): _150.MsgTimeoutResponse;
                     fromAmino(object: _150.MsgTimeoutResponseAmino): _150.MsgTimeoutResponse;
                     toAmino(message: _150.MsgTimeoutResponse): _150.MsgTimeoutResponseAmino;
                     fromAminoMsg(object: _150.MsgTimeoutResponseAminoMsg): _150.MsgTimeoutResponse;
@@ -2163,9 +1985,10 @@ export declare namespace ibc {
                 };
                 MsgAcknowledgement: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _150.MsgAcknowledgement, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _150.MsgAcknowledgement;
-                    fromPartial(object: Partial<_150.MsgAcknowledgement>): _150.MsgAcknowledgement;
+                    fromPartial(object: import("../helpers").DeepPartial<_150.MsgAcknowledgement>): _150.MsgAcknowledgement;
                     fromAmino(object: _150.MsgAcknowledgementAmino): _150.MsgAcknowledgement;
                     toAmino(message: _150.MsgAcknowledgement): _150.MsgAcknowledgementAmino;
                     fromAminoMsg(object: _150.MsgAcknowledgementAminoMsg): _150.MsgAcknowledgement;
@@ -2176,9 +1999,10 @@ export declare namespace ibc {
                 };
                 MsgAcknowledgementResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _150.MsgAcknowledgementResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _150.MsgAcknowledgementResponse;
-                    fromPartial(object: Partial<_150.MsgAcknowledgementResponse>): _150.MsgAcknowledgementResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_150.MsgAcknowledgementResponse>): _150.MsgAcknowledgementResponse;
                     fromAmino(object: _150.MsgAcknowledgementResponseAmino): _150.MsgAcknowledgementResponse;
                     toAmino(message: _150.MsgAcknowledgementResponse): _150.MsgAcknowledgementResponseAmino;
                     fromAminoMsg(object: _150.MsgAcknowledgementResponseAminoMsg): _150.MsgAcknowledgementResponse;
@@ -2189,9 +2013,10 @@ export declare namespace ibc {
                 };
                 QueryNextSequenceSendRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryNextSequenceSendRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryNextSequenceSendRequest;
-                    fromPartial(object: Partial<_149.QueryNextSequenceSendRequest>): _149.QueryNextSequenceSendRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryNextSequenceSendRequest>): _149.QueryNextSequenceSendRequest;
                     fromAmino(object: _149.QueryNextSequenceSendRequestAmino): _149.QueryNextSequenceSendRequest;
                     toAmino(message: _149.QueryNextSequenceSendRequest): _149.QueryNextSequenceSendRequestAmino;
                     fromAminoMsg(object: _149.QueryNextSequenceSendRequestAminoMsg): _149.QueryNextSequenceSendRequest;
@@ -2202,9 +2027,10 @@ export declare namespace ibc {
                 };
                 QueryNextSequenceSendResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryNextSequenceSendResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryNextSequenceSendResponse;
-                    fromPartial(object: Partial<_149.QueryNextSequenceSendResponse>): _149.QueryNextSequenceSendResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryNextSequenceSendResponse>): _149.QueryNextSequenceSendResponse;
                     fromAmino(object: _149.QueryNextSequenceSendResponseAmino): _149.QueryNextSequenceSendResponse;
                     toAmino(message: _149.QueryNextSequenceSendResponse): _149.QueryNextSequenceSendResponseAmino;
                     fromAminoMsg(object: _149.QueryNextSequenceSendResponseAminoMsg): _149.QueryNextSequenceSendResponse;
@@ -2215,9 +2041,10 @@ export declare namespace ibc {
                 };
                 QueryPacketCommitmentRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryPacketCommitmentRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryPacketCommitmentRequest;
-                    fromPartial(object: Partial<_149.QueryPacketCommitmentRequest>): _149.QueryPacketCommitmentRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryPacketCommitmentRequest>): _149.QueryPacketCommitmentRequest;
                     fromAmino(object: _149.QueryPacketCommitmentRequestAmino): _149.QueryPacketCommitmentRequest;
                     toAmino(message: _149.QueryPacketCommitmentRequest): _149.QueryPacketCommitmentRequestAmino;
                     fromAminoMsg(object: _149.QueryPacketCommitmentRequestAminoMsg): _149.QueryPacketCommitmentRequest;
@@ -2228,9 +2055,10 @@ export declare namespace ibc {
                 };
                 QueryPacketCommitmentResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryPacketCommitmentResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryPacketCommitmentResponse;
-                    fromPartial(object: Partial<_149.QueryPacketCommitmentResponse>): _149.QueryPacketCommitmentResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryPacketCommitmentResponse>): _149.QueryPacketCommitmentResponse;
                     fromAmino(object: _149.QueryPacketCommitmentResponseAmino): _149.QueryPacketCommitmentResponse;
                     toAmino(message: _149.QueryPacketCommitmentResponse): _149.QueryPacketCommitmentResponseAmino;
                     fromAminoMsg(object: _149.QueryPacketCommitmentResponseAminoMsg): _149.QueryPacketCommitmentResponse;
@@ -2241,9 +2069,10 @@ export declare namespace ibc {
                 };
                 QueryPacketCommitmentsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryPacketCommitmentsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryPacketCommitmentsRequest;
-                    fromPartial(object: Partial<_149.QueryPacketCommitmentsRequest>): _149.QueryPacketCommitmentsRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryPacketCommitmentsRequest>): _149.QueryPacketCommitmentsRequest;
                     fromAmino(object: _149.QueryPacketCommitmentsRequestAmino): _149.QueryPacketCommitmentsRequest;
                     toAmino(message: _149.QueryPacketCommitmentsRequest): _149.QueryPacketCommitmentsRequestAmino;
                     fromAminoMsg(object: _149.QueryPacketCommitmentsRequestAminoMsg): _149.QueryPacketCommitmentsRequest;
@@ -2254,9 +2083,10 @@ export declare namespace ibc {
                 };
                 QueryPacketCommitmentsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryPacketCommitmentsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryPacketCommitmentsResponse;
-                    fromPartial(object: Partial<_149.QueryPacketCommitmentsResponse>): _149.QueryPacketCommitmentsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryPacketCommitmentsResponse>): _149.QueryPacketCommitmentsResponse;
                     fromAmino(object: _149.QueryPacketCommitmentsResponseAmino): _149.QueryPacketCommitmentsResponse;
                     toAmino(message: _149.QueryPacketCommitmentsResponse): _149.QueryPacketCommitmentsResponseAmino;
                     fromAminoMsg(object: _149.QueryPacketCommitmentsResponseAminoMsg): _149.QueryPacketCommitmentsResponse;
@@ -2267,9 +2097,10 @@ export declare namespace ibc {
                 };
                 QueryPacketAcknowledgementRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryPacketAcknowledgementRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryPacketAcknowledgementRequest;
-                    fromPartial(object: Partial<_149.QueryPacketAcknowledgementRequest>): _149.QueryPacketAcknowledgementRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryPacketAcknowledgementRequest>): _149.QueryPacketAcknowledgementRequest;
                     fromAmino(object: _149.QueryPacketAcknowledgementRequestAmino): _149.QueryPacketAcknowledgementRequest;
                     toAmino(message: _149.QueryPacketAcknowledgementRequest): _149.QueryPacketAcknowledgementRequestAmino;
                     fromAminoMsg(object: _149.QueryPacketAcknowledgementRequestAminoMsg): _149.QueryPacketAcknowledgementRequest;
@@ -2280,9 +2111,10 @@ export declare namespace ibc {
                 };
                 QueryPacketAcknowledgementResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryPacketAcknowledgementResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryPacketAcknowledgementResponse;
-                    fromPartial(object: Partial<_149.QueryPacketAcknowledgementResponse>): _149.QueryPacketAcknowledgementResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryPacketAcknowledgementResponse>): _149.QueryPacketAcknowledgementResponse;
                     fromAmino(object: _149.QueryPacketAcknowledgementResponseAmino): _149.QueryPacketAcknowledgementResponse;
                     toAmino(message: _149.QueryPacketAcknowledgementResponse): _149.QueryPacketAcknowledgementResponseAmino;
                     fromAminoMsg(object: _149.QueryPacketAcknowledgementResponseAminoMsg): _149.QueryPacketAcknowledgementResponse;
@@ -2293,9 +2125,10 @@ export declare namespace ibc {
                 };
                 QueryPacketAcknowledgementsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryPacketAcknowledgementsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryPacketAcknowledgementsRequest;
-                    fromPartial(object: Partial<_149.QueryPacketAcknowledgementsRequest>): _149.QueryPacketAcknowledgementsRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryPacketAcknowledgementsRequest>): _149.QueryPacketAcknowledgementsRequest;
                     fromAmino(object: _149.QueryPacketAcknowledgementsRequestAmino): _149.QueryPacketAcknowledgementsRequest;
                     toAmino(message: _149.QueryPacketAcknowledgementsRequest): _149.QueryPacketAcknowledgementsRequestAmino;
                     fromAminoMsg(object: _149.QueryPacketAcknowledgementsRequestAminoMsg): _149.QueryPacketAcknowledgementsRequest;
@@ -2306,9 +2139,10 @@ export declare namespace ibc {
                 };
                 QueryPacketAcknowledgementsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryPacketAcknowledgementsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryPacketAcknowledgementsResponse;
-                    fromPartial(object: Partial<_149.QueryPacketAcknowledgementsResponse>): _149.QueryPacketAcknowledgementsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryPacketAcknowledgementsResponse>): _149.QueryPacketAcknowledgementsResponse;
                     fromAmino(object: _149.QueryPacketAcknowledgementsResponseAmino): _149.QueryPacketAcknowledgementsResponse;
                     toAmino(message: _149.QueryPacketAcknowledgementsResponse): _149.QueryPacketAcknowledgementsResponseAmino;
                     fromAminoMsg(object: _149.QueryPacketAcknowledgementsResponseAminoMsg): _149.QueryPacketAcknowledgementsResponse;
@@ -2319,9 +2153,10 @@ export declare namespace ibc {
                 };
                 QueryPacketReceiptRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryPacketReceiptRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryPacketReceiptRequest;
-                    fromPartial(object: Partial<_149.QueryPacketReceiptRequest>): _149.QueryPacketReceiptRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryPacketReceiptRequest>): _149.QueryPacketReceiptRequest;
                     fromAmino(object: _149.QueryPacketReceiptRequestAmino): _149.QueryPacketReceiptRequest;
                     toAmino(message: _149.QueryPacketReceiptRequest): _149.QueryPacketReceiptRequestAmino;
                     fromAminoMsg(object: _149.QueryPacketReceiptRequestAminoMsg): _149.QueryPacketReceiptRequest;
@@ -2332,9 +2167,10 @@ export declare namespace ibc {
                 };
                 QueryPacketReceiptResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryPacketReceiptResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryPacketReceiptResponse;
-                    fromPartial(object: Partial<_149.QueryPacketReceiptResponse>): _149.QueryPacketReceiptResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryPacketReceiptResponse>): _149.QueryPacketReceiptResponse;
                     fromAmino(object: _149.QueryPacketReceiptResponseAmino): _149.QueryPacketReceiptResponse;
                     toAmino(message: _149.QueryPacketReceiptResponse): _149.QueryPacketReceiptResponseAmino;
                     fromAminoMsg(object: _149.QueryPacketReceiptResponseAminoMsg): _149.QueryPacketReceiptResponse;
@@ -2345,9 +2181,10 @@ export declare namespace ibc {
                 };
                 QueryUnreceivedPacketsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryUnreceivedPacketsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryUnreceivedPacketsRequest;
-                    fromPartial(object: Partial<_149.QueryUnreceivedPacketsRequest>): _149.QueryUnreceivedPacketsRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryUnreceivedPacketsRequest>): _149.QueryUnreceivedPacketsRequest;
                     fromAmino(object: _149.QueryUnreceivedPacketsRequestAmino): _149.QueryUnreceivedPacketsRequest;
                     toAmino(message: _149.QueryUnreceivedPacketsRequest): _149.QueryUnreceivedPacketsRequestAmino;
                     fromAminoMsg(object: _149.QueryUnreceivedPacketsRequestAminoMsg): _149.QueryUnreceivedPacketsRequest;
@@ -2358,9 +2195,10 @@ export declare namespace ibc {
                 };
                 QueryUnreceivedPacketsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryUnreceivedPacketsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryUnreceivedPacketsResponse;
-                    fromPartial(object: Partial<_149.QueryUnreceivedPacketsResponse>): _149.QueryUnreceivedPacketsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryUnreceivedPacketsResponse>): _149.QueryUnreceivedPacketsResponse;
                     fromAmino(object: _149.QueryUnreceivedPacketsResponseAmino): _149.QueryUnreceivedPacketsResponse;
                     toAmino(message: _149.QueryUnreceivedPacketsResponse): _149.QueryUnreceivedPacketsResponseAmino;
                     fromAminoMsg(object: _149.QueryUnreceivedPacketsResponseAminoMsg): _149.QueryUnreceivedPacketsResponse;
@@ -2371,9 +2209,10 @@ export declare namespace ibc {
                 };
                 QueryUnreceivedAcksRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryUnreceivedAcksRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryUnreceivedAcksRequest;
-                    fromPartial(object: Partial<_149.QueryUnreceivedAcksRequest>): _149.QueryUnreceivedAcksRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryUnreceivedAcksRequest>): _149.QueryUnreceivedAcksRequest;
                     fromAmino(object: _149.QueryUnreceivedAcksRequestAmino): _149.QueryUnreceivedAcksRequest;
                     toAmino(message: _149.QueryUnreceivedAcksRequest): _149.QueryUnreceivedAcksRequestAmino;
                     fromAminoMsg(object: _149.QueryUnreceivedAcksRequestAminoMsg): _149.QueryUnreceivedAcksRequest;
@@ -2384,9 +2223,10 @@ export declare namespace ibc {
                 };
                 QueryUnreceivedAcksResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _149.QueryUnreceivedAcksResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _149.QueryUnreceivedAcksResponse;
-                    fromPartial(object: Partial<_149.QueryUnreceivedAcksResponse>): _149.QueryUnreceivedAcksResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_149.QueryUnreceivedAcksResponse>): _149.QueryUnreceivedAcksResponse;
                     fromAmino(object: _149.QueryUnreceivedAcksResponseAmino): _149.QueryUnreceivedAcksResponse;
                     toAmino(message: _149.QueryUnreceivedAcksResponse): _149.QueryUnreceivedAcksResponseAmino;
                     fromAminoMsg(object: _149.QueryUnreceivedAcksResponseAminoMsg): _149.QueryUnreceivedAcksResponse;
@@ -2398,13 +2238,13 @@ export declare namespace ibc {
                 packetStatusFromJSON(object: any): _148.PacketStatus;
                 packetStatusToJSON(object: _148.PacketStatus): string;
                 PacketStatus: typeof _148.PacketStatus;
-                PacketStatusSDKType: typeof _148.PacketStatus;
                 PacketStatusAmino: typeof _148.PacketStatus;
                 Packet: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _148.Packet, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _148.Packet;
-                    fromPartial(object: Partial<_148.Packet>): _148.Packet;
+                    fromPartial(object: import("../helpers").DeepPartial<_148.Packet>): _148.Packet;
                     fromAmino(object: _148.PacketAmino): _148.Packet;
                     toAmino(message: _148.Packet): _148.PacketAmino;
                     fromAminoMsg(object: _148.PacketAminoMsg): _148.Packet;
@@ -2415,9 +2255,10 @@ export declare namespace ibc {
                 };
                 Payload: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _148.Payload, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _148.Payload;
-                    fromPartial(object: Partial<_148.Payload>): _148.Payload;
+                    fromPartial(object: import("../helpers").DeepPartial<_148.Payload>): _148.Payload;
                     fromAmino(object: _148.PayloadAmino): _148.Payload;
                     toAmino(message: _148.Payload): _148.PayloadAmino;
                     fromAminoMsg(object: _148.PayloadAminoMsg): _148.Payload;
@@ -2428,9 +2269,10 @@ export declare namespace ibc {
                 };
                 Acknowledgement: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _148.Acknowledgement, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _148.Acknowledgement;
-                    fromPartial(object: Partial<_148.Acknowledgement>): _148.Acknowledgement;
+                    fromPartial(object: import("../helpers").DeepPartial<_148.Acknowledgement>): _148.Acknowledgement;
                     fromAmino(object: _148.AcknowledgementAmino): _148.Acknowledgement;
                     toAmino(message: _148.Acknowledgement): _148.AcknowledgementAmino;
                     fromAminoMsg(object: _148.AcknowledgementAminoMsg): _148.Acknowledgement;
@@ -2441,9 +2283,10 @@ export declare namespace ibc {
                 };
                 RecvPacketResult: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _148.RecvPacketResult, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _148.RecvPacketResult;
-                    fromPartial(object: Partial<_148.RecvPacketResult>): _148.RecvPacketResult;
+                    fromPartial(object: import("../helpers").DeepPartial<_148.RecvPacketResult>): _148.RecvPacketResult;
                     fromAmino(object: _148.RecvPacketResultAmino): _148.RecvPacketResult;
                     toAmino(message: _148.RecvPacketResult): _148.RecvPacketResultAmino;
                     fromAminoMsg(object: _148.RecvPacketResultAminoMsg): _148.RecvPacketResult;
@@ -2454,9 +2297,10 @@ export declare namespace ibc {
                 };
                 GenesisState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _147.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _147.GenesisState;
-                    fromPartial(object: Partial<_147.GenesisState>): _147.GenesisState;
+                    fromPartial(object: import("../helpers").DeepPartial<_147.GenesisState>): _147.GenesisState;
                     fromAmino(object: _147.GenesisStateAmino): _147.GenesisState;
                     toAmino(message: _147.GenesisState): _147.GenesisStateAmino;
                     fromAminoMsg(object: _147.GenesisStateAminoMsg): _147.GenesisState;
@@ -2467,9 +2311,10 @@ export declare namespace ibc {
                 };
                 PacketState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _147.PacketState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _147.PacketState;
-                    fromPartial(object: Partial<_147.PacketState>): _147.PacketState;
+                    fromPartial(object: import("../helpers").DeepPartial<_147.PacketState>): _147.PacketState;
                     fromAmino(object: _147.PacketStateAmino): _147.PacketState;
                     toAmino(message: _147.PacketState): _147.PacketStateAmino;
                     fromAminoMsg(object: _147.PacketStateAminoMsg): _147.PacketState;
@@ -2480,9 +2325,10 @@ export declare namespace ibc {
                 };
                 PacketSequence: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _147.PacketSequence, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _147.PacketSequence;
-                    fromPartial(object: Partial<_147.PacketSequence>): _147.PacketSequence;
+                    fromPartial(object: import("../helpers").DeepPartial<_147.PacketSequence>): _147.PacketSequence;
                     fromAmino(object: _147.PacketSequenceAmino): _147.PacketSequence;
                     toAmino(message: _147.PacketSequence): _147.PacketSequenceAmino;
                     fromAminoMsg(object: _147.PacketSequenceAminoMsg): _147.PacketSequence;
@@ -2496,6 +2342,7 @@ export declare namespace ibc {
         namespace client {
             const v1: {
                 MsgClientImpl: typeof _322.MsgClientImpl;
+                createClientImpl: (rpc: import("..").TxRpc) => _322.MsgClientImpl;
                 QueryClientImpl: typeof _313.QueryClientImpl;
                 createRpcQueryExtension: (base: QueryClient) => {
                     clientState(request: _153.QueryClientStateRequest): Promise<_153.QueryClientStateResponse>;
@@ -2511,112 +2358,7 @@ export declare namespace ibc {
                     verifyMembership(request: _153.QueryVerifyMembershipRequest): Promise<_153.QueryVerifyMembershipResponse>;
                 };
                 LCDQueryClient: typeof _304.LCDQueryClient;
-                registry: ReadonlyArray<[string, GeneratedType]>;
-                load: (protoRegistry: Registry) => void;
-                MessageComposer: {
-                    encoded: {
-                        createClient(value: _154.MsgCreateClient): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        updateClient(value: _154.MsgUpdateClient): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        upgradeClient(value: _154.MsgUpgradeClient): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        submitMisbehaviour(value: _154.MsgSubmitMisbehaviour): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        recoverClient(value: _154.MsgRecoverClient): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        iBCSoftwareUpgrade(value: _154.MsgIBCSoftwareUpgrade): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        updateClientParams(value: _154.MsgUpdateParams): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        deleteClientCreator(value: _154.MsgDeleteClientCreator): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                    };
-                    withTypeUrl: {
-                        createClient(value: _154.MsgCreateClient): {
-                            typeUrl: string;
-                            value: _154.MsgCreateClient;
-                        };
-                        updateClient(value: _154.MsgUpdateClient): {
-                            typeUrl: string;
-                            value: _154.MsgUpdateClient;
-                        };
-                        upgradeClient(value: _154.MsgUpgradeClient): {
-                            typeUrl: string;
-                            value: _154.MsgUpgradeClient;
-                        };
-                        submitMisbehaviour(value: _154.MsgSubmitMisbehaviour): {
-                            typeUrl: string;
-                            value: _154.MsgSubmitMisbehaviour;
-                        };
-                        recoverClient(value: _154.MsgRecoverClient): {
-                            typeUrl: string;
-                            value: _154.MsgRecoverClient;
-                        };
-                        iBCSoftwareUpgrade(value: _154.MsgIBCSoftwareUpgrade): {
-                            typeUrl: string;
-                            value: _154.MsgIBCSoftwareUpgrade;
-                        };
-                        updateClientParams(value: _154.MsgUpdateParams): {
-                            typeUrl: string;
-                            value: _154.MsgUpdateParams;
-                        };
-                        deleteClientCreator(value: _154.MsgDeleteClientCreator): {
-                            typeUrl: string;
-                            value: _154.MsgDeleteClientCreator;
-                        };
-                    };
-                    fromPartial: {
-                        createClient(value: _154.MsgCreateClient): {
-                            typeUrl: string;
-                            value: _154.MsgCreateClient;
-                        };
-                        updateClient(value: _154.MsgUpdateClient): {
-                            typeUrl: string;
-                            value: _154.MsgUpdateClient;
-                        };
-                        upgradeClient(value: _154.MsgUpgradeClient): {
-                            typeUrl: string;
-                            value: _154.MsgUpgradeClient;
-                        };
-                        submitMisbehaviour(value: _154.MsgSubmitMisbehaviour): {
-                            typeUrl: string;
-                            value: _154.MsgSubmitMisbehaviour;
-                        };
-                        recoverClient(value: _154.MsgRecoverClient): {
-                            typeUrl: string;
-                            value: _154.MsgRecoverClient;
-                        };
-                        iBCSoftwareUpgrade(value: _154.MsgIBCSoftwareUpgrade): {
-                            typeUrl: string;
-                            value: _154.MsgIBCSoftwareUpgrade;
-                        };
-                        updateClientParams(value: _154.MsgUpdateParams): {
-                            typeUrl: string;
-                            value: _154.MsgUpdateParams;
-                        };
-                        deleteClientCreator(value: _154.MsgDeleteClientCreator): {
-                            typeUrl: string;
-                            value: _154.MsgDeleteClientCreator;
-                        };
-                    };
-                };
+                registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
                 AminoConverter: {
                     "/ibc.core.client.v1.MsgCreateClient": {
                         aminoType: string;
@@ -2661,9 +2403,10 @@ export declare namespace ibc {
                 };
                 MsgCreateClient: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _154.MsgCreateClient, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgCreateClient;
-                    fromPartial(object: Partial<_154.MsgCreateClient>): _154.MsgCreateClient;
+                    fromPartial(object: import("../helpers").DeepPartial<_154.MsgCreateClient>): _154.MsgCreateClient;
                     fromAmino(object: _154.MsgCreateClientAmino): _154.MsgCreateClient;
                     toAmino(message: _154.MsgCreateClient): _154.MsgCreateClientAmino;
                     fromAminoMsg(object: _154.MsgCreateClientAminoMsg): _154.MsgCreateClient;
@@ -2674,9 +2417,10 @@ export declare namespace ibc {
                 };
                 MsgCreateClientResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _154.MsgCreateClientResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgCreateClientResponse;
-                    fromPartial(object: Partial<_154.MsgCreateClientResponse>): _154.MsgCreateClientResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_154.MsgCreateClientResponse>): _154.MsgCreateClientResponse;
                     fromAmino(object: _154.MsgCreateClientResponseAmino): _154.MsgCreateClientResponse;
                     toAmino(message: _154.MsgCreateClientResponse): _154.MsgCreateClientResponseAmino;
                     fromAminoMsg(object: _154.MsgCreateClientResponseAminoMsg): _154.MsgCreateClientResponse;
@@ -2687,9 +2431,10 @@ export declare namespace ibc {
                 };
                 MsgUpdateClient: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _154.MsgUpdateClient, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgUpdateClient;
-                    fromPartial(object: Partial<_154.MsgUpdateClient>): _154.MsgUpdateClient;
+                    fromPartial(object: import("../helpers").DeepPartial<_154.MsgUpdateClient>): _154.MsgUpdateClient;
                     fromAmino(object: _154.MsgUpdateClientAmino): _154.MsgUpdateClient;
                     toAmino(message: _154.MsgUpdateClient): _154.MsgUpdateClientAmino;
                     fromAminoMsg(object: _154.MsgUpdateClientAminoMsg): _154.MsgUpdateClient;
@@ -2700,9 +2445,10 @@ export declare namespace ibc {
                 };
                 MsgUpdateClientResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _154.MsgUpdateClientResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgUpdateClientResponse;
-                    fromPartial(_: Partial<_154.MsgUpdateClientResponse>): _154.MsgUpdateClientResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_154.MsgUpdateClientResponse>): _154.MsgUpdateClientResponse;
                     fromAmino(_: _154.MsgUpdateClientResponseAmino): _154.MsgUpdateClientResponse;
                     toAmino(_: _154.MsgUpdateClientResponse): _154.MsgUpdateClientResponseAmino;
                     fromAminoMsg(object: _154.MsgUpdateClientResponseAminoMsg): _154.MsgUpdateClientResponse;
@@ -2713,9 +2459,10 @@ export declare namespace ibc {
                 };
                 MsgUpgradeClient: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _154.MsgUpgradeClient, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgUpgradeClient;
-                    fromPartial(object: Partial<_154.MsgUpgradeClient>): _154.MsgUpgradeClient;
+                    fromPartial(object: import("../helpers").DeepPartial<_154.MsgUpgradeClient>): _154.MsgUpgradeClient;
                     fromAmino(object: _154.MsgUpgradeClientAmino): _154.MsgUpgradeClient;
                     toAmino(message: _154.MsgUpgradeClient): _154.MsgUpgradeClientAmino;
                     fromAminoMsg(object: _154.MsgUpgradeClientAminoMsg): _154.MsgUpgradeClient;
@@ -2726,9 +2473,10 @@ export declare namespace ibc {
                 };
                 MsgUpgradeClientResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _154.MsgUpgradeClientResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgUpgradeClientResponse;
-                    fromPartial(_: Partial<_154.MsgUpgradeClientResponse>): _154.MsgUpgradeClientResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_154.MsgUpgradeClientResponse>): _154.MsgUpgradeClientResponse;
                     fromAmino(_: _154.MsgUpgradeClientResponseAmino): _154.MsgUpgradeClientResponse;
                     toAmino(_: _154.MsgUpgradeClientResponse): _154.MsgUpgradeClientResponseAmino;
                     fromAminoMsg(object: _154.MsgUpgradeClientResponseAminoMsg): _154.MsgUpgradeClientResponse;
@@ -2739,9 +2487,10 @@ export declare namespace ibc {
                 };
                 MsgSubmitMisbehaviour: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _154.MsgSubmitMisbehaviour, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgSubmitMisbehaviour;
-                    fromPartial(object: Partial<_154.MsgSubmitMisbehaviour>): _154.MsgSubmitMisbehaviour;
+                    fromPartial(object: import("../helpers").DeepPartial<_154.MsgSubmitMisbehaviour>): _154.MsgSubmitMisbehaviour;
                     fromAmino(object: _154.MsgSubmitMisbehaviourAmino): _154.MsgSubmitMisbehaviour;
                     toAmino(message: _154.MsgSubmitMisbehaviour): _154.MsgSubmitMisbehaviourAmino;
                     fromAminoMsg(object: _154.MsgSubmitMisbehaviourAminoMsg): _154.MsgSubmitMisbehaviour;
@@ -2752,9 +2501,10 @@ export declare namespace ibc {
                 };
                 MsgSubmitMisbehaviourResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _154.MsgSubmitMisbehaviourResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgSubmitMisbehaviourResponse;
-                    fromPartial(_: Partial<_154.MsgSubmitMisbehaviourResponse>): _154.MsgSubmitMisbehaviourResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_154.MsgSubmitMisbehaviourResponse>): _154.MsgSubmitMisbehaviourResponse;
                     fromAmino(_: _154.MsgSubmitMisbehaviourResponseAmino): _154.MsgSubmitMisbehaviourResponse;
                     toAmino(_: _154.MsgSubmitMisbehaviourResponse): _154.MsgSubmitMisbehaviourResponseAmino;
                     fromAminoMsg(object: _154.MsgSubmitMisbehaviourResponseAminoMsg): _154.MsgSubmitMisbehaviourResponse;
@@ -2765,9 +2515,10 @@ export declare namespace ibc {
                 };
                 MsgRecoverClient: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _154.MsgRecoverClient, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgRecoverClient;
-                    fromPartial(object: Partial<_154.MsgRecoverClient>): _154.MsgRecoverClient;
+                    fromPartial(object: import("../helpers").DeepPartial<_154.MsgRecoverClient>): _154.MsgRecoverClient;
                     fromAmino(object: _154.MsgRecoverClientAmino): _154.MsgRecoverClient;
                     toAmino(message: _154.MsgRecoverClient): _154.MsgRecoverClientAmino;
                     fromAminoMsg(object: _154.MsgRecoverClientAminoMsg): _154.MsgRecoverClient;
@@ -2778,9 +2529,10 @@ export declare namespace ibc {
                 };
                 MsgRecoverClientResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _154.MsgRecoverClientResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgRecoverClientResponse;
-                    fromPartial(_: Partial<_154.MsgRecoverClientResponse>): _154.MsgRecoverClientResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_154.MsgRecoverClientResponse>): _154.MsgRecoverClientResponse;
                     fromAmino(_: _154.MsgRecoverClientResponseAmino): _154.MsgRecoverClientResponse;
                     toAmino(_: _154.MsgRecoverClientResponse): _154.MsgRecoverClientResponseAmino;
                     fromAminoMsg(object: _154.MsgRecoverClientResponseAminoMsg): _154.MsgRecoverClientResponse;
@@ -2791,9 +2543,10 @@ export declare namespace ibc {
                 };
                 MsgIBCSoftwareUpgrade: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _154.MsgIBCSoftwareUpgrade, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgIBCSoftwareUpgrade;
-                    fromPartial(object: Partial<_154.MsgIBCSoftwareUpgrade>): _154.MsgIBCSoftwareUpgrade;
+                    fromPartial(object: import("../helpers").DeepPartial<_154.MsgIBCSoftwareUpgrade>): _154.MsgIBCSoftwareUpgrade;
                     fromAmino(object: _154.MsgIBCSoftwareUpgradeAmino): _154.MsgIBCSoftwareUpgrade;
                     toAmino(message: _154.MsgIBCSoftwareUpgrade): _154.MsgIBCSoftwareUpgradeAmino;
                     fromAminoMsg(object: _154.MsgIBCSoftwareUpgradeAminoMsg): _154.MsgIBCSoftwareUpgrade;
@@ -2804,9 +2557,10 @@ export declare namespace ibc {
                 };
                 MsgIBCSoftwareUpgradeResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _154.MsgIBCSoftwareUpgradeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgIBCSoftwareUpgradeResponse;
-                    fromPartial(_: Partial<_154.MsgIBCSoftwareUpgradeResponse>): _154.MsgIBCSoftwareUpgradeResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_154.MsgIBCSoftwareUpgradeResponse>): _154.MsgIBCSoftwareUpgradeResponse;
                     fromAmino(_: _154.MsgIBCSoftwareUpgradeResponseAmino): _154.MsgIBCSoftwareUpgradeResponse;
                     toAmino(_: _154.MsgIBCSoftwareUpgradeResponse): _154.MsgIBCSoftwareUpgradeResponseAmino;
                     fromAminoMsg(object: _154.MsgIBCSoftwareUpgradeResponseAminoMsg): _154.MsgIBCSoftwareUpgradeResponse;
@@ -2817,9 +2571,10 @@ export declare namespace ibc {
                 };
                 MsgUpdateParams: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _154.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgUpdateParams;
-                    fromPartial(object: Partial<_154.MsgUpdateParams>): _154.MsgUpdateParams;
+                    fromPartial(object: import("../helpers").DeepPartial<_154.MsgUpdateParams>): _154.MsgUpdateParams;
                     fromAmino(object: _154.MsgUpdateParamsAmino): _154.MsgUpdateParams;
                     toAmino(message: _154.MsgUpdateParams): _154.MsgUpdateParamsAmino;
                     fromAminoMsg(object: _154.MsgUpdateParamsAminoMsg): _154.MsgUpdateParams;
@@ -2830,9 +2585,10 @@ export declare namespace ibc {
                 };
                 MsgUpdateParamsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _154.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgUpdateParamsResponse;
-                    fromPartial(_: Partial<_154.MsgUpdateParamsResponse>): _154.MsgUpdateParamsResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_154.MsgUpdateParamsResponse>): _154.MsgUpdateParamsResponse;
                     fromAmino(_: _154.MsgUpdateParamsResponseAmino): _154.MsgUpdateParamsResponse;
                     toAmino(_: _154.MsgUpdateParamsResponse): _154.MsgUpdateParamsResponseAmino;
                     fromAminoMsg(object: _154.MsgUpdateParamsResponseAminoMsg): _154.MsgUpdateParamsResponse;
@@ -2843,9 +2599,10 @@ export declare namespace ibc {
                 };
                 MsgDeleteClientCreator: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _154.MsgDeleteClientCreator, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgDeleteClientCreator;
-                    fromPartial(object: Partial<_154.MsgDeleteClientCreator>): _154.MsgDeleteClientCreator;
+                    fromPartial(object: import("../helpers").DeepPartial<_154.MsgDeleteClientCreator>): _154.MsgDeleteClientCreator;
                     fromAmino(object: _154.MsgDeleteClientCreatorAmino): _154.MsgDeleteClientCreator;
                     toAmino(message: _154.MsgDeleteClientCreator): _154.MsgDeleteClientCreatorAmino;
                     fromAminoMsg(object: _154.MsgDeleteClientCreatorAminoMsg): _154.MsgDeleteClientCreator;
@@ -2856,9 +2613,10 @@ export declare namespace ibc {
                 };
                 MsgDeleteClientCreatorResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _154.MsgDeleteClientCreatorResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _154.MsgDeleteClientCreatorResponse;
-                    fromPartial(_: Partial<_154.MsgDeleteClientCreatorResponse>): _154.MsgDeleteClientCreatorResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_154.MsgDeleteClientCreatorResponse>): _154.MsgDeleteClientCreatorResponse;
                     fromAmino(_: _154.MsgDeleteClientCreatorResponseAmino): _154.MsgDeleteClientCreatorResponse;
                     toAmino(_: _154.MsgDeleteClientCreatorResponse): _154.MsgDeleteClientCreatorResponseAmino;
                     fromAminoMsg(object: _154.MsgDeleteClientCreatorResponseAminoMsg): _154.MsgDeleteClientCreatorResponse;
@@ -2869,9 +2627,10 @@ export declare namespace ibc {
                 };
                 QueryClientStateRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryClientStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryClientStateRequest;
-                    fromPartial(object: Partial<_153.QueryClientStateRequest>): _153.QueryClientStateRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryClientStateRequest>): _153.QueryClientStateRequest;
                     fromAmino(object: _153.QueryClientStateRequestAmino): _153.QueryClientStateRequest;
                     toAmino(message: _153.QueryClientStateRequest): _153.QueryClientStateRequestAmino;
                     fromAminoMsg(object: _153.QueryClientStateRequestAminoMsg): _153.QueryClientStateRequest;
@@ -2882,9 +2641,10 @@ export declare namespace ibc {
                 };
                 QueryClientStateResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryClientStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryClientStateResponse;
-                    fromPartial(object: Partial<_153.QueryClientStateResponse>): _153.QueryClientStateResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryClientStateResponse>): _153.QueryClientStateResponse;
                     fromAmino(object: _153.QueryClientStateResponseAmino): _153.QueryClientStateResponse;
                     toAmino(message: _153.QueryClientStateResponse): _153.QueryClientStateResponseAmino;
                     fromAminoMsg(object: _153.QueryClientStateResponseAminoMsg): _153.QueryClientStateResponse;
@@ -2895,9 +2655,10 @@ export declare namespace ibc {
                 };
                 QueryClientStatesRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryClientStatesRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryClientStatesRequest;
-                    fromPartial(object: Partial<_153.QueryClientStatesRequest>): _153.QueryClientStatesRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryClientStatesRequest>): _153.QueryClientStatesRequest;
                     fromAmino(object: _153.QueryClientStatesRequestAmino): _153.QueryClientStatesRequest;
                     toAmino(message: _153.QueryClientStatesRequest): _153.QueryClientStatesRequestAmino;
                     fromAminoMsg(object: _153.QueryClientStatesRequestAminoMsg): _153.QueryClientStatesRequest;
@@ -2908,9 +2669,10 @@ export declare namespace ibc {
                 };
                 QueryClientStatesResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryClientStatesResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryClientStatesResponse;
-                    fromPartial(object: Partial<_153.QueryClientStatesResponse>): _153.QueryClientStatesResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryClientStatesResponse>): _153.QueryClientStatesResponse;
                     fromAmino(object: _153.QueryClientStatesResponseAmino): _153.QueryClientStatesResponse;
                     toAmino(message: _153.QueryClientStatesResponse): _153.QueryClientStatesResponseAmino;
                     fromAminoMsg(object: _153.QueryClientStatesResponseAminoMsg): _153.QueryClientStatesResponse;
@@ -2921,9 +2683,10 @@ export declare namespace ibc {
                 };
                 QueryConsensusStateRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryConsensusStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryConsensusStateRequest;
-                    fromPartial(object: Partial<_153.QueryConsensusStateRequest>): _153.QueryConsensusStateRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryConsensusStateRequest>): _153.QueryConsensusStateRequest;
                     fromAmino(object: _153.QueryConsensusStateRequestAmino): _153.QueryConsensusStateRequest;
                     toAmino(message: _153.QueryConsensusStateRequest): _153.QueryConsensusStateRequestAmino;
                     fromAminoMsg(object: _153.QueryConsensusStateRequestAminoMsg): _153.QueryConsensusStateRequest;
@@ -2934,9 +2697,10 @@ export declare namespace ibc {
                 };
                 QueryConsensusStateResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryConsensusStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryConsensusStateResponse;
-                    fromPartial(object: Partial<_153.QueryConsensusStateResponse>): _153.QueryConsensusStateResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryConsensusStateResponse>): _153.QueryConsensusStateResponse;
                     fromAmino(object: _153.QueryConsensusStateResponseAmino): _153.QueryConsensusStateResponse;
                     toAmino(message: _153.QueryConsensusStateResponse): _153.QueryConsensusStateResponseAmino;
                     fromAminoMsg(object: _153.QueryConsensusStateResponseAminoMsg): _153.QueryConsensusStateResponse;
@@ -2947,9 +2711,10 @@ export declare namespace ibc {
                 };
                 QueryConsensusStatesRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryConsensusStatesRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryConsensusStatesRequest;
-                    fromPartial(object: Partial<_153.QueryConsensusStatesRequest>): _153.QueryConsensusStatesRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryConsensusStatesRequest>): _153.QueryConsensusStatesRequest;
                     fromAmino(object: _153.QueryConsensusStatesRequestAmino): _153.QueryConsensusStatesRequest;
                     toAmino(message: _153.QueryConsensusStatesRequest): _153.QueryConsensusStatesRequestAmino;
                     fromAminoMsg(object: _153.QueryConsensusStatesRequestAminoMsg): _153.QueryConsensusStatesRequest;
@@ -2960,9 +2725,10 @@ export declare namespace ibc {
                 };
                 QueryConsensusStatesResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryConsensusStatesResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryConsensusStatesResponse;
-                    fromPartial(object: Partial<_153.QueryConsensusStatesResponse>): _153.QueryConsensusStatesResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryConsensusStatesResponse>): _153.QueryConsensusStatesResponse;
                     fromAmino(object: _153.QueryConsensusStatesResponseAmino): _153.QueryConsensusStatesResponse;
                     toAmino(message: _153.QueryConsensusStatesResponse): _153.QueryConsensusStatesResponseAmino;
                     fromAminoMsg(object: _153.QueryConsensusStatesResponseAminoMsg): _153.QueryConsensusStatesResponse;
@@ -2973,9 +2739,10 @@ export declare namespace ibc {
                 };
                 QueryConsensusStateHeightsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryConsensusStateHeightsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryConsensusStateHeightsRequest;
-                    fromPartial(object: Partial<_153.QueryConsensusStateHeightsRequest>): _153.QueryConsensusStateHeightsRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryConsensusStateHeightsRequest>): _153.QueryConsensusStateHeightsRequest;
                     fromAmino(object: _153.QueryConsensusStateHeightsRequestAmino): _153.QueryConsensusStateHeightsRequest;
                     toAmino(message: _153.QueryConsensusStateHeightsRequest): _153.QueryConsensusStateHeightsRequestAmino;
                     fromAminoMsg(object: _153.QueryConsensusStateHeightsRequestAminoMsg): _153.QueryConsensusStateHeightsRequest;
@@ -2986,9 +2753,10 @@ export declare namespace ibc {
                 };
                 QueryConsensusStateHeightsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryConsensusStateHeightsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryConsensusStateHeightsResponse;
-                    fromPartial(object: Partial<_153.QueryConsensusStateHeightsResponse>): _153.QueryConsensusStateHeightsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryConsensusStateHeightsResponse>): _153.QueryConsensusStateHeightsResponse;
                     fromAmino(object: _153.QueryConsensusStateHeightsResponseAmino): _153.QueryConsensusStateHeightsResponse;
                     toAmino(message: _153.QueryConsensusStateHeightsResponse): _153.QueryConsensusStateHeightsResponseAmino;
                     fromAminoMsg(object: _153.QueryConsensusStateHeightsResponseAminoMsg): _153.QueryConsensusStateHeightsResponse;
@@ -2999,9 +2767,10 @@ export declare namespace ibc {
                 };
                 QueryClientStatusRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryClientStatusRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryClientStatusRequest;
-                    fromPartial(object: Partial<_153.QueryClientStatusRequest>): _153.QueryClientStatusRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryClientStatusRequest>): _153.QueryClientStatusRequest;
                     fromAmino(object: _153.QueryClientStatusRequestAmino): _153.QueryClientStatusRequest;
                     toAmino(message: _153.QueryClientStatusRequest): _153.QueryClientStatusRequestAmino;
                     fromAminoMsg(object: _153.QueryClientStatusRequestAminoMsg): _153.QueryClientStatusRequest;
@@ -3012,9 +2781,10 @@ export declare namespace ibc {
                 };
                 QueryClientStatusResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryClientStatusResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryClientStatusResponse;
-                    fromPartial(object: Partial<_153.QueryClientStatusResponse>): _153.QueryClientStatusResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryClientStatusResponse>): _153.QueryClientStatusResponse;
                     fromAmino(object: _153.QueryClientStatusResponseAmino): _153.QueryClientStatusResponse;
                     toAmino(message: _153.QueryClientStatusResponse): _153.QueryClientStatusResponseAmino;
                     fromAminoMsg(object: _153.QueryClientStatusResponseAminoMsg): _153.QueryClientStatusResponse;
@@ -3025,9 +2795,10 @@ export declare namespace ibc {
                 };
                 QueryClientParamsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _153.QueryClientParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryClientParamsRequest;
-                    fromPartial(_: Partial<_153.QueryClientParamsRequest>): _153.QueryClientParamsRequest;
+                    fromPartial(_: import("../helpers").DeepPartial<_153.QueryClientParamsRequest>): _153.QueryClientParamsRequest;
                     fromAmino(_: _153.QueryClientParamsRequestAmino): _153.QueryClientParamsRequest;
                     toAmino(_: _153.QueryClientParamsRequest): _153.QueryClientParamsRequestAmino;
                     fromAminoMsg(object: _153.QueryClientParamsRequestAminoMsg): _153.QueryClientParamsRequest;
@@ -3038,9 +2809,10 @@ export declare namespace ibc {
                 };
                 QueryClientParamsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryClientParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryClientParamsResponse;
-                    fromPartial(object: Partial<_153.QueryClientParamsResponse>): _153.QueryClientParamsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryClientParamsResponse>): _153.QueryClientParamsResponse;
                     fromAmino(object: _153.QueryClientParamsResponseAmino): _153.QueryClientParamsResponse;
                     toAmino(message: _153.QueryClientParamsResponse): _153.QueryClientParamsResponseAmino;
                     fromAminoMsg(object: _153.QueryClientParamsResponseAminoMsg): _153.QueryClientParamsResponse;
@@ -3051,9 +2823,10 @@ export declare namespace ibc {
                 };
                 QueryClientCreatorRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryClientCreatorRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryClientCreatorRequest;
-                    fromPartial(object: Partial<_153.QueryClientCreatorRequest>): _153.QueryClientCreatorRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryClientCreatorRequest>): _153.QueryClientCreatorRequest;
                     fromAmino(object: _153.QueryClientCreatorRequestAmino): _153.QueryClientCreatorRequest;
                     toAmino(message: _153.QueryClientCreatorRequest): _153.QueryClientCreatorRequestAmino;
                     fromAminoMsg(object: _153.QueryClientCreatorRequestAminoMsg): _153.QueryClientCreatorRequest;
@@ -3064,9 +2837,10 @@ export declare namespace ibc {
                 };
                 QueryClientCreatorResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryClientCreatorResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryClientCreatorResponse;
-                    fromPartial(object: Partial<_153.QueryClientCreatorResponse>): _153.QueryClientCreatorResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryClientCreatorResponse>): _153.QueryClientCreatorResponse;
                     fromAmino(object: _153.QueryClientCreatorResponseAmino): _153.QueryClientCreatorResponse;
                     toAmino(message: _153.QueryClientCreatorResponse): _153.QueryClientCreatorResponseAmino;
                     fromAminoMsg(object: _153.QueryClientCreatorResponseAminoMsg): _153.QueryClientCreatorResponse;
@@ -3077,9 +2851,10 @@ export declare namespace ibc {
                 };
                 QueryUpgradedClientStateRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _153.QueryUpgradedClientStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryUpgradedClientStateRequest;
-                    fromPartial(_: Partial<_153.QueryUpgradedClientStateRequest>): _153.QueryUpgradedClientStateRequest;
+                    fromPartial(_: import("../helpers").DeepPartial<_153.QueryUpgradedClientStateRequest>): _153.QueryUpgradedClientStateRequest;
                     fromAmino(_: _153.QueryUpgradedClientStateRequestAmino): _153.QueryUpgradedClientStateRequest;
                     toAmino(_: _153.QueryUpgradedClientStateRequest): _153.QueryUpgradedClientStateRequestAmino;
                     fromAminoMsg(object: _153.QueryUpgradedClientStateRequestAminoMsg): _153.QueryUpgradedClientStateRequest;
@@ -3090,9 +2865,10 @@ export declare namespace ibc {
                 };
                 QueryUpgradedClientStateResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryUpgradedClientStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryUpgradedClientStateResponse;
-                    fromPartial(object: Partial<_153.QueryUpgradedClientStateResponse>): _153.QueryUpgradedClientStateResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryUpgradedClientStateResponse>): _153.QueryUpgradedClientStateResponse;
                     fromAmino(object: _153.QueryUpgradedClientStateResponseAmino): _153.QueryUpgradedClientStateResponse;
                     toAmino(message: _153.QueryUpgradedClientStateResponse): _153.QueryUpgradedClientStateResponseAmino;
                     fromAminoMsg(object: _153.QueryUpgradedClientStateResponseAminoMsg): _153.QueryUpgradedClientStateResponse;
@@ -3103,9 +2879,10 @@ export declare namespace ibc {
                 };
                 QueryUpgradedConsensusStateRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _153.QueryUpgradedConsensusStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryUpgradedConsensusStateRequest;
-                    fromPartial(_: Partial<_153.QueryUpgradedConsensusStateRequest>): _153.QueryUpgradedConsensusStateRequest;
+                    fromPartial(_: import("../helpers").DeepPartial<_153.QueryUpgradedConsensusStateRequest>): _153.QueryUpgradedConsensusStateRequest;
                     fromAmino(_: _153.QueryUpgradedConsensusStateRequestAmino): _153.QueryUpgradedConsensusStateRequest;
                     toAmino(_: _153.QueryUpgradedConsensusStateRequest): _153.QueryUpgradedConsensusStateRequestAmino;
                     fromAminoMsg(object: _153.QueryUpgradedConsensusStateRequestAminoMsg): _153.QueryUpgradedConsensusStateRequest;
@@ -3116,9 +2893,10 @@ export declare namespace ibc {
                 };
                 QueryUpgradedConsensusStateResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryUpgradedConsensusStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryUpgradedConsensusStateResponse;
-                    fromPartial(object: Partial<_153.QueryUpgradedConsensusStateResponse>): _153.QueryUpgradedConsensusStateResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryUpgradedConsensusStateResponse>): _153.QueryUpgradedConsensusStateResponse;
                     fromAmino(object: _153.QueryUpgradedConsensusStateResponseAmino): _153.QueryUpgradedConsensusStateResponse;
                     toAmino(message: _153.QueryUpgradedConsensusStateResponse): _153.QueryUpgradedConsensusStateResponseAmino;
                     fromAminoMsg(object: _153.QueryUpgradedConsensusStateResponseAminoMsg): _153.QueryUpgradedConsensusStateResponse;
@@ -3129,9 +2907,10 @@ export declare namespace ibc {
                 };
                 QueryVerifyMembershipRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryVerifyMembershipRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryVerifyMembershipRequest;
-                    fromPartial(object: Partial<_153.QueryVerifyMembershipRequest>): _153.QueryVerifyMembershipRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryVerifyMembershipRequest>): _153.QueryVerifyMembershipRequest;
                     fromAmino(object: _153.QueryVerifyMembershipRequestAmino): _153.QueryVerifyMembershipRequest;
                     toAmino(message: _153.QueryVerifyMembershipRequest): _153.QueryVerifyMembershipRequestAmino;
                     fromAminoMsg(object: _153.QueryVerifyMembershipRequestAminoMsg): _153.QueryVerifyMembershipRequest;
@@ -3142,9 +2921,10 @@ export declare namespace ibc {
                 };
                 QueryVerifyMembershipResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _153.QueryVerifyMembershipResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _153.QueryVerifyMembershipResponse;
-                    fromPartial(object: Partial<_153.QueryVerifyMembershipResponse>): _153.QueryVerifyMembershipResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_153.QueryVerifyMembershipResponse>): _153.QueryVerifyMembershipResponse;
                     fromAmino(object: _153.QueryVerifyMembershipResponseAmino): _153.QueryVerifyMembershipResponse;
                     toAmino(message: _153.QueryVerifyMembershipResponse): _153.QueryVerifyMembershipResponseAmino;
                     fromAminoMsg(object: _153.QueryVerifyMembershipResponseAminoMsg): _153.QueryVerifyMembershipResponse;
@@ -3155,9 +2935,10 @@ export declare namespace ibc {
                 };
                 GenesisState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _152.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _152.GenesisState;
-                    fromPartial(object: Partial<_152.GenesisState>): _152.GenesisState;
+                    fromPartial(object: import("../helpers").DeepPartial<_152.GenesisState>): _152.GenesisState;
                     fromAmino(object: _152.GenesisStateAmino): _152.GenesisState;
                     toAmino(message: _152.GenesisState): _152.GenesisStateAmino;
                     fromAminoMsg(object: _152.GenesisStateAminoMsg): _152.GenesisState;
@@ -3168,9 +2949,10 @@ export declare namespace ibc {
                 };
                 GenesisMetadata: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _152.GenesisMetadata, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _152.GenesisMetadata;
-                    fromPartial(object: Partial<_152.GenesisMetadata>): _152.GenesisMetadata;
+                    fromPartial(object: import("../helpers").DeepPartial<_152.GenesisMetadata>): _152.GenesisMetadata;
                     fromAmino(object: _152.GenesisMetadataAmino): _152.GenesisMetadata;
                     toAmino(message: _152.GenesisMetadata): _152.GenesisMetadataAmino;
                     fromAminoMsg(object: _152.GenesisMetadataAminoMsg): _152.GenesisMetadata;
@@ -3181,9 +2963,10 @@ export declare namespace ibc {
                 };
                 IdentifiedGenesisMetadata: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _152.IdentifiedGenesisMetadata, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _152.IdentifiedGenesisMetadata;
-                    fromPartial(object: Partial<_152.IdentifiedGenesisMetadata>): _152.IdentifiedGenesisMetadata;
+                    fromPartial(object: import("../helpers").DeepPartial<_152.IdentifiedGenesisMetadata>): _152.IdentifiedGenesisMetadata;
                     fromAmino(object: _152.IdentifiedGenesisMetadataAmino): _152.IdentifiedGenesisMetadata;
                     toAmino(message: _152.IdentifiedGenesisMetadata): _152.IdentifiedGenesisMetadataAmino;
                     fromAminoMsg(object: _152.IdentifiedGenesisMetadataAminoMsg): _152.IdentifiedGenesisMetadata;
@@ -3194,9 +2977,10 @@ export declare namespace ibc {
                 };
                 IdentifiedClientState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _151.IdentifiedClientState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _151.IdentifiedClientState;
-                    fromPartial(object: Partial<_151.IdentifiedClientState>): _151.IdentifiedClientState;
+                    fromPartial(object: import("../helpers").DeepPartial<_151.IdentifiedClientState>): _151.IdentifiedClientState;
                     fromAmino(object: _151.IdentifiedClientStateAmino): _151.IdentifiedClientState;
                     toAmino(message: _151.IdentifiedClientState): _151.IdentifiedClientStateAmino;
                     fromAminoMsg(object: _151.IdentifiedClientStateAminoMsg): _151.IdentifiedClientState;
@@ -3207,9 +2991,10 @@ export declare namespace ibc {
                 };
                 ConsensusStateWithHeight: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _151.ConsensusStateWithHeight, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _151.ConsensusStateWithHeight;
-                    fromPartial(object: Partial<_151.ConsensusStateWithHeight>): _151.ConsensusStateWithHeight;
+                    fromPartial(object: import("../helpers").DeepPartial<_151.ConsensusStateWithHeight>): _151.ConsensusStateWithHeight;
                     fromAmino(object: _151.ConsensusStateWithHeightAmino): _151.ConsensusStateWithHeight;
                     toAmino(message: _151.ConsensusStateWithHeight): _151.ConsensusStateWithHeightAmino;
                     fromAminoMsg(object: _151.ConsensusStateWithHeightAminoMsg): _151.ConsensusStateWithHeight;
@@ -3220,9 +3005,10 @@ export declare namespace ibc {
                 };
                 ClientConsensusStates: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _151.ClientConsensusStates, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _151.ClientConsensusStates;
-                    fromPartial(object: Partial<_151.ClientConsensusStates>): _151.ClientConsensusStates;
+                    fromPartial(object: import("../helpers").DeepPartial<_151.ClientConsensusStates>): _151.ClientConsensusStates;
                     fromAmino(object: _151.ClientConsensusStatesAmino): _151.ClientConsensusStates;
                     toAmino(message: _151.ClientConsensusStates): _151.ClientConsensusStatesAmino;
                     fromAminoMsg(object: _151.ClientConsensusStatesAminoMsg): _151.ClientConsensusStates;
@@ -3233,9 +3019,10 @@ export declare namespace ibc {
                 };
                 Height: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _151.Height, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _151.Height;
-                    fromPartial(object: Partial<_151.Height>): _151.Height;
+                    fromPartial(object: import("../helpers").DeepPartial<_151.Height>): _151.Height;
                     fromAmino(object: _151.HeightAmino): _151.Height;
                     toAmino(message: _151.Height): _151.HeightAmino;
                     fromAminoMsg(object: _151.HeightAminoMsg): _151.Height;
@@ -3246,9 +3033,10 @@ export declare namespace ibc {
                 };
                 Params: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _151.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _151.Params;
-                    fromPartial(object: Partial<_151.Params>): _151.Params;
+                    fromPartial(object: import("../helpers").DeepPartial<_151.Params>): _151.Params;
                     fromAmino(object: _151.ParamsAmino): _151.Params;
                     toAmino(message: _151.Params): _151.ParamsAmino;
                     fromAminoMsg(object: _151.ParamsAminoMsg): _151.Params;
@@ -3260,46 +3048,14 @@ export declare namespace ibc {
             };
             const v2: {
                 MsgClientImpl: typeof _323.MsgClientImpl;
+                createClientImpl: (rpc: import("..").TxRpc) => _323.MsgClientImpl;
                 QueryClientImpl: typeof _314.QueryClientImpl;
                 createRpcQueryExtension: (base: QueryClient) => {
                     counterpartyInfo(request: _158.QueryCounterpartyInfoRequest): Promise<_158.QueryCounterpartyInfoResponse>;
                     config(request: _158.QueryConfigRequest): Promise<_158.QueryConfigResponse>;
                 };
                 LCDQueryClient: typeof _305.LCDQueryClient;
-                registry: ReadonlyArray<[string, GeneratedType]>;
-                load: (protoRegistry: Registry) => void;
-                MessageComposer: {
-                    encoded: {
-                        registerCounterparty(value: _159.MsgRegisterCounterparty): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        updateClientConfig(value: _159.MsgUpdateClientConfig): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                    };
-                    withTypeUrl: {
-                        registerCounterparty(value: _159.MsgRegisterCounterparty): {
-                            typeUrl: string;
-                            value: _159.MsgRegisterCounterparty;
-                        };
-                        updateClientConfig(value: _159.MsgUpdateClientConfig): {
-                            typeUrl: string;
-                            value: _159.MsgUpdateClientConfig;
-                        };
-                    };
-                    fromPartial: {
-                        registerCounterparty(value: _159.MsgRegisterCounterparty): {
-                            typeUrl: string;
-                            value: _159.MsgRegisterCounterparty;
-                        };
-                        updateClientConfig(value: _159.MsgUpdateClientConfig): {
-                            typeUrl: string;
-                            value: _159.MsgUpdateClientConfig;
-                        };
-                    };
-                };
+                registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
                 AminoConverter: {
                     "/ibc.core.client.v2.MsgRegisterCounterparty": {
                         aminoType: string;
@@ -3314,9 +3070,10 @@ export declare namespace ibc {
                 };
                 MsgRegisterCounterparty: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _159.MsgRegisterCounterparty, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _159.MsgRegisterCounterparty;
-                    fromPartial(object: Partial<_159.MsgRegisterCounterparty>): _159.MsgRegisterCounterparty;
+                    fromPartial(object: import("../helpers").DeepPartial<_159.MsgRegisterCounterparty>): _159.MsgRegisterCounterparty;
                     fromAmino(object: _159.MsgRegisterCounterpartyAmino): _159.MsgRegisterCounterparty;
                     toAmino(message: _159.MsgRegisterCounterparty): _159.MsgRegisterCounterpartyAmino;
                     fromAminoMsg(object: _159.MsgRegisterCounterpartyAminoMsg): _159.MsgRegisterCounterparty;
@@ -3327,9 +3084,10 @@ export declare namespace ibc {
                 };
                 MsgRegisterCounterpartyResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _159.MsgRegisterCounterpartyResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _159.MsgRegisterCounterpartyResponse;
-                    fromPartial(_: Partial<_159.MsgRegisterCounterpartyResponse>): _159.MsgRegisterCounterpartyResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_159.MsgRegisterCounterpartyResponse>): _159.MsgRegisterCounterpartyResponse;
                     fromAmino(_: _159.MsgRegisterCounterpartyResponseAmino): _159.MsgRegisterCounterpartyResponse;
                     toAmino(_: _159.MsgRegisterCounterpartyResponse): _159.MsgRegisterCounterpartyResponseAmino;
                     fromAminoMsg(object: _159.MsgRegisterCounterpartyResponseAminoMsg): _159.MsgRegisterCounterpartyResponse;
@@ -3340,9 +3098,10 @@ export declare namespace ibc {
                 };
                 MsgUpdateClientConfig: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _159.MsgUpdateClientConfig, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _159.MsgUpdateClientConfig;
-                    fromPartial(object: Partial<_159.MsgUpdateClientConfig>): _159.MsgUpdateClientConfig;
+                    fromPartial(object: import("../helpers").DeepPartial<_159.MsgUpdateClientConfig>): _159.MsgUpdateClientConfig;
                     fromAmino(object: _159.MsgUpdateClientConfigAmino): _159.MsgUpdateClientConfig;
                     toAmino(message: _159.MsgUpdateClientConfig): _159.MsgUpdateClientConfigAmino;
                     fromAminoMsg(object: _159.MsgUpdateClientConfigAminoMsg): _159.MsgUpdateClientConfig;
@@ -3353,9 +3112,10 @@ export declare namespace ibc {
                 };
                 MsgUpdateClientConfigResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _159.MsgUpdateClientConfigResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _159.MsgUpdateClientConfigResponse;
-                    fromPartial(_: Partial<_159.MsgUpdateClientConfigResponse>): _159.MsgUpdateClientConfigResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_159.MsgUpdateClientConfigResponse>): _159.MsgUpdateClientConfigResponse;
                     fromAmino(_: _159.MsgUpdateClientConfigResponseAmino): _159.MsgUpdateClientConfigResponse;
                     toAmino(_: _159.MsgUpdateClientConfigResponse): _159.MsgUpdateClientConfigResponseAmino;
                     fromAminoMsg(object: _159.MsgUpdateClientConfigResponseAminoMsg): _159.MsgUpdateClientConfigResponse;
@@ -3366,9 +3126,10 @@ export declare namespace ibc {
                 };
                 QueryCounterpartyInfoRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _158.QueryCounterpartyInfoRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _158.QueryCounterpartyInfoRequest;
-                    fromPartial(object: Partial<_158.QueryCounterpartyInfoRequest>): _158.QueryCounterpartyInfoRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_158.QueryCounterpartyInfoRequest>): _158.QueryCounterpartyInfoRequest;
                     fromAmino(object: _158.QueryCounterpartyInfoRequestAmino): _158.QueryCounterpartyInfoRequest;
                     toAmino(message: _158.QueryCounterpartyInfoRequest): _158.QueryCounterpartyInfoRequestAmino;
                     fromAminoMsg(object: _158.QueryCounterpartyInfoRequestAminoMsg): _158.QueryCounterpartyInfoRequest;
@@ -3379,9 +3140,10 @@ export declare namespace ibc {
                 };
                 QueryCounterpartyInfoResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _158.QueryCounterpartyInfoResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _158.QueryCounterpartyInfoResponse;
-                    fromPartial(object: Partial<_158.QueryCounterpartyInfoResponse>): _158.QueryCounterpartyInfoResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_158.QueryCounterpartyInfoResponse>): _158.QueryCounterpartyInfoResponse;
                     fromAmino(object: _158.QueryCounterpartyInfoResponseAmino): _158.QueryCounterpartyInfoResponse;
                     toAmino(message: _158.QueryCounterpartyInfoResponse): _158.QueryCounterpartyInfoResponseAmino;
                     fromAminoMsg(object: _158.QueryCounterpartyInfoResponseAminoMsg): _158.QueryCounterpartyInfoResponse;
@@ -3392,9 +3154,10 @@ export declare namespace ibc {
                 };
                 QueryConfigRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _158.QueryConfigRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _158.QueryConfigRequest;
-                    fromPartial(object: Partial<_158.QueryConfigRequest>): _158.QueryConfigRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_158.QueryConfigRequest>): _158.QueryConfigRequest;
                     fromAmino(object: _158.QueryConfigRequestAmino): _158.QueryConfigRequest;
                     toAmino(message: _158.QueryConfigRequest): _158.QueryConfigRequestAmino;
                     fromAminoMsg(object: _158.QueryConfigRequestAminoMsg): _158.QueryConfigRequest;
@@ -3405,9 +3168,10 @@ export declare namespace ibc {
                 };
                 QueryConfigResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _158.QueryConfigResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _158.QueryConfigResponse;
-                    fromPartial(object: Partial<_158.QueryConfigResponse>): _158.QueryConfigResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_158.QueryConfigResponse>): _158.QueryConfigResponse;
                     fromAmino(object: _158.QueryConfigResponseAmino): _158.QueryConfigResponse;
                     toAmino(message: _158.QueryConfigResponse): _158.QueryConfigResponseAmino;
                     fromAminoMsg(object: _158.QueryConfigResponseAminoMsg): _158.QueryConfigResponse;
@@ -3418,9 +3182,10 @@ export declare namespace ibc {
                 };
                 GenesisCounterpartyInfo: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _157.GenesisCounterpartyInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _157.GenesisCounterpartyInfo;
-                    fromPartial(object: Partial<_157.GenesisCounterpartyInfo>): _157.GenesisCounterpartyInfo;
+                    fromPartial(object: import("../helpers").DeepPartial<_157.GenesisCounterpartyInfo>): _157.GenesisCounterpartyInfo;
                     fromAmino(object: _157.GenesisCounterpartyInfoAmino): _157.GenesisCounterpartyInfo;
                     toAmino(message: _157.GenesisCounterpartyInfo): _157.GenesisCounterpartyInfoAmino;
                     fromAminoMsg(object: _157.GenesisCounterpartyInfoAminoMsg): _157.GenesisCounterpartyInfo;
@@ -3431,9 +3196,10 @@ export declare namespace ibc {
                 };
                 GenesisState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _157.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _157.GenesisState;
-                    fromPartial(object: Partial<_157.GenesisState>): _157.GenesisState;
+                    fromPartial(object: import("../helpers").DeepPartial<_157.GenesisState>): _157.GenesisState;
                     fromAmino(object: _157.GenesisStateAmino): _157.GenesisState;
                     toAmino(message: _157.GenesisState): _157.GenesisStateAmino;
                     fromAminoMsg(object: _157.GenesisStateAminoMsg): _157.GenesisState;
@@ -3444,9 +3210,10 @@ export declare namespace ibc {
                 };
                 CounterpartyInfo: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _156.CounterpartyInfo, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _156.CounterpartyInfo;
-                    fromPartial(object: Partial<_156.CounterpartyInfo>): _156.CounterpartyInfo;
+                    fromPartial(object: import("../helpers").DeepPartial<_156.CounterpartyInfo>): _156.CounterpartyInfo;
                     fromAmino(object: _156.CounterpartyInfoAmino): _156.CounterpartyInfo;
                     toAmino(message: _156.CounterpartyInfo): _156.CounterpartyInfoAmino;
                     fromAminoMsg(object: _156.CounterpartyInfoAminoMsg): _156.CounterpartyInfo;
@@ -3457,9 +3224,10 @@ export declare namespace ibc {
                 };
                 Config: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _155.Config, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _155.Config;
-                    fromPartial(object: Partial<_155.Config>): _155.Config;
+                    fromPartial(object: import("../helpers").DeepPartial<_155.Config>): _155.Config;
                     fromAmino(object: _155.ConfigAmino): _155.Config;
                     toAmino(message: _155.Config): _155.ConfigAmino;
                     fromAminoMsg(object: _155.ConfigAminoMsg): _155.Config;
@@ -3474,9 +3242,10 @@ export declare namespace ibc {
             const v1: {
                 MerkleRoot: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _160.MerkleRoot, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _160.MerkleRoot;
-                    fromPartial(object: Partial<_160.MerkleRoot>): _160.MerkleRoot;
+                    fromPartial(object: import("../helpers").DeepPartial<_160.MerkleRoot>): _160.MerkleRoot;
                     fromAmino(object: _160.MerkleRootAmino): _160.MerkleRoot;
                     toAmino(message: _160.MerkleRoot): _160.MerkleRootAmino;
                     fromAminoMsg(object: _160.MerkleRootAminoMsg): _160.MerkleRoot;
@@ -3487,9 +3256,10 @@ export declare namespace ibc {
                 };
                 MerklePrefix: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _160.MerklePrefix, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _160.MerklePrefix;
-                    fromPartial(object: Partial<_160.MerklePrefix>): _160.MerklePrefix;
+                    fromPartial(object: import("../helpers").DeepPartial<_160.MerklePrefix>): _160.MerklePrefix;
                     fromAmino(object: _160.MerklePrefixAmino): _160.MerklePrefix;
                     toAmino(message: _160.MerklePrefix): _160.MerklePrefixAmino;
                     fromAminoMsg(object: _160.MerklePrefixAminoMsg): _160.MerklePrefix;
@@ -3500,9 +3270,10 @@ export declare namespace ibc {
                 };
                 MerkleProof: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _160.MerkleProof, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _160.MerkleProof;
-                    fromPartial(object: Partial<_160.MerkleProof>): _160.MerkleProof;
+                    fromPartial(object: import("../helpers").DeepPartial<_160.MerkleProof>): _160.MerkleProof;
                     fromAmino(object: _160.MerkleProofAmino): _160.MerkleProof;
                     toAmino(message: _160.MerkleProof): _160.MerkleProofAmino;
                     fromAminoMsg(object: _160.MerkleProofAminoMsg): _160.MerkleProof;
@@ -3515,9 +3286,10 @@ export declare namespace ibc {
             const v2: {
                 MerklePath: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _161.MerklePath, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _161.MerklePath;
-                    fromPartial(object: Partial<_161.MerklePath>): _161.MerklePath;
+                    fromPartial(object: import("../helpers").DeepPartial<_161.MerklePath>): _161.MerklePath;
                     fromAmino(object: _161.MerklePathAmino): _161.MerklePath;
                     toAmino(message: _161.MerklePath): _161.MerklePathAmino;
                     fromAminoMsg(object: _161.MerklePathAminoMsg): _161.MerklePath;
@@ -3531,6 +3303,7 @@ export declare namespace ibc {
         namespace connection {
             const v1: {
                 MsgClientImpl: typeof _324.MsgClientImpl;
+                createClientImpl: (rpc: import("..").TxRpc) => _324.MsgClientImpl;
                 QueryClientImpl: typeof _315.QueryClientImpl;
                 createRpcQueryExtension: (base: QueryClient) => {
                     connection(request: _164.QueryConnectionRequest): Promise<_164.QueryConnectionResponse>;
@@ -3541,76 +3314,7 @@ export declare namespace ibc {
                     connectionParams(request?: _164.QueryConnectionParamsRequest): Promise<_164.QueryConnectionParamsResponse>;
                 };
                 LCDQueryClient: typeof _306.LCDQueryClient;
-                registry: ReadonlyArray<[string, GeneratedType]>;
-                load: (protoRegistry: Registry) => void;
-                MessageComposer: {
-                    encoded: {
-                        connectionOpenInit(value: _165.MsgConnectionOpenInit): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        connectionOpenTry(value: _165.MsgConnectionOpenTry): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        connectionOpenAck(value: _165.MsgConnectionOpenAck): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        connectionOpenConfirm(value: _165.MsgConnectionOpenConfirm): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        updateConnectionParams(value: _165.MsgUpdateParams): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                    };
-                    withTypeUrl: {
-                        connectionOpenInit(value: _165.MsgConnectionOpenInit): {
-                            typeUrl: string;
-                            value: _165.MsgConnectionOpenInit;
-                        };
-                        connectionOpenTry(value: _165.MsgConnectionOpenTry): {
-                            typeUrl: string;
-                            value: _165.MsgConnectionOpenTry;
-                        };
-                        connectionOpenAck(value: _165.MsgConnectionOpenAck): {
-                            typeUrl: string;
-                            value: _165.MsgConnectionOpenAck;
-                        };
-                        connectionOpenConfirm(value: _165.MsgConnectionOpenConfirm): {
-                            typeUrl: string;
-                            value: _165.MsgConnectionOpenConfirm;
-                        };
-                        updateConnectionParams(value: _165.MsgUpdateParams): {
-                            typeUrl: string;
-                            value: _165.MsgUpdateParams;
-                        };
-                    };
-                    fromPartial: {
-                        connectionOpenInit(value: _165.MsgConnectionOpenInit): {
-                            typeUrl: string;
-                            value: _165.MsgConnectionOpenInit;
-                        };
-                        connectionOpenTry(value: _165.MsgConnectionOpenTry): {
-                            typeUrl: string;
-                            value: _165.MsgConnectionOpenTry;
-                        };
-                        connectionOpenAck(value: _165.MsgConnectionOpenAck): {
-                            typeUrl: string;
-                            value: _165.MsgConnectionOpenAck;
-                        };
-                        connectionOpenConfirm(value: _165.MsgConnectionOpenConfirm): {
-                            typeUrl: string;
-                            value: _165.MsgConnectionOpenConfirm;
-                        };
-                        updateConnectionParams(value: _165.MsgUpdateParams): {
-                            typeUrl: string;
-                            value: _165.MsgUpdateParams;
-                        };
-                    };
-                };
+                registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
                 AminoConverter: {
                     "/ibc.core.connection.v1.MsgConnectionOpenInit": {
                         aminoType: string;
@@ -3640,9 +3344,10 @@ export declare namespace ibc {
                 };
                 MsgConnectionOpenInit: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _165.MsgConnectionOpenInit, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _165.MsgConnectionOpenInit;
-                    fromPartial(object: Partial<_165.MsgConnectionOpenInit>): _165.MsgConnectionOpenInit;
+                    fromPartial(object: import("../helpers").DeepPartial<_165.MsgConnectionOpenInit>): _165.MsgConnectionOpenInit;
                     fromAmino(object: _165.MsgConnectionOpenInitAmino): _165.MsgConnectionOpenInit;
                     toAmino(message: _165.MsgConnectionOpenInit): _165.MsgConnectionOpenInitAmino;
                     fromAminoMsg(object: _165.MsgConnectionOpenInitAminoMsg): _165.MsgConnectionOpenInit;
@@ -3653,9 +3358,10 @@ export declare namespace ibc {
                 };
                 MsgConnectionOpenInitResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _165.MsgConnectionOpenInitResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _165.MsgConnectionOpenInitResponse;
-                    fromPartial(_: Partial<_165.MsgConnectionOpenInitResponse>): _165.MsgConnectionOpenInitResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_165.MsgConnectionOpenInitResponse>): _165.MsgConnectionOpenInitResponse;
                     fromAmino(_: _165.MsgConnectionOpenInitResponseAmino): _165.MsgConnectionOpenInitResponse;
                     toAmino(_: _165.MsgConnectionOpenInitResponse): _165.MsgConnectionOpenInitResponseAmino;
                     fromAminoMsg(object: _165.MsgConnectionOpenInitResponseAminoMsg): _165.MsgConnectionOpenInitResponse;
@@ -3666,9 +3372,10 @@ export declare namespace ibc {
                 };
                 MsgConnectionOpenTry: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _165.MsgConnectionOpenTry, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _165.MsgConnectionOpenTry;
-                    fromPartial(object: Partial<_165.MsgConnectionOpenTry>): _165.MsgConnectionOpenTry;
+                    fromPartial(object: import("../helpers").DeepPartial<_165.MsgConnectionOpenTry>): _165.MsgConnectionOpenTry;
                     fromAmino(object: _165.MsgConnectionOpenTryAmino): _165.MsgConnectionOpenTry;
                     toAmino(message: _165.MsgConnectionOpenTry): _165.MsgConnectionOpenTryAmino;
                     fromAminoMsg(object: _165.MsgConnectionOpenTryAminoMsg): _165.MsgConnectionOpenTry;
@@ -3679,9 +3386,10 @@ export declare namespace ibc {
                 };
                 MsgConnectionOpenTryResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _165.MsgConnectionOpenTryResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _165.MsgConnectionOpenTryResponse;
-                    fromPartial(_: Partial<_165.MsgConnectionOpenTryResponse>): _165.MsgConnectionOpenTryResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_165.MsgConnectionOpenTryResponse>): _165.MsgConnectionOpenTryResponse;
                     fromAmino(_: _165.MsgConnectionOpenTryResponseAmino): _165.MsgConnectionOpenTryResponse;
                     toAmino(_: _165.MsgConnectionOpenTryResponse): _165.MsgConnectionOpenTryResponseAmino;
                     fromAminoMsg(object: _165.MsgConnectionOpenTryResponseAminoMsg): _165.MsgConnectionOpenTryResponse;
@@ -3692,9 +3400,10 @@ export declare namespace ibc {
                 };
                 MsgConnectionOpenAck: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _165.MsgConnectionOpenAck, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _165.MsgConnectionOpenAck;
-                    fromPartial(object: Partial<_165.MsgConnectionOpenAck>): _165.MsgConnectionOpenAck;
+                    fromPartial(object: import("../helpers").DeepPartial<_165.MsgConnectionOpenAck>): _165.MsgConnectionOpenAck;
                     fromAmino(object: _165.MsgConnectionOpenAckAmino): _165.MsgConnectionOpenAck;
                     toAmino(message: _165.MsgConnectionOpenAck): _165.MsgConnectionOpenAckAmino;
                     fromAminoMsg(object: _165.MsgConnectionOpenAckAminoMsg): _165.MsgConnectionOpenAck;
@@ -3705,9 +3414,10 @@ export declare namespace ibc {
                 };
                 MsgConnectionOpenAckResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _165.MsgConnectionOpenAckResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _165.MsgConnectionOpenAckResponse;
-                    fromPartial(_: Partial<_165.MsgConnectionOpenAckResponse>): _165.MsgConnectionOpenAckResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_165.MsgConnectionOpenAckResponse>): _165.MsgConnectionOpenAckResponse;
                     fromAmino(_: _165.MsgConnectionOpenAckResponseAmino): _165.MsgConnectionOpenAckResponse;
                     toAmino(_: _165.MsgConnectionOpenAckResponse): _165.MsgConnectionOpenAckResponseAmino;
                     fromAminoMsg(object: _165.MsgConnectionOpenAckResponseAminoMsg): _165.MsgConnectionOpenAckResponse;
@@ -3718,9 +3428,10 @@ export declare namespace ibc {
                 };
                 MsgConnectionOpenConfirm: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _165.MsgConnectionOpenConfirm, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _165.MsgConnectionOpenConfirm;
-                    fromPartial(object: Partial<_165.MsgConnectionOpenConfirm>): _165.MsgConnectionOpenConfirm;
+                    fromPartial(object: import("../helpers").DeepPartial<_165.MsgConnectionOpenConfirm>): _165.MsgConnectionOpenConfirm;
                     fromAmino(object: _165.MsgConnectionOpenConfirmAmino): _165.MsgConnectionOpenConfirm;
                     toAmino(message: _165.MsgConnectionOpenConfirm): _165.MsgConnectionOpenConfirmAmino;
                     fromAminoMsg(object: _165.MsgConnectionOpenConfirmAminoMsg): _165.MsgConnectionOpenConfirm;
@@ -3731,9 +3442,10 @@ export declare namespace ibc {
                 };
                 MsgConnectionOpenConfirmResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _165.MsgConnectionOpenConfirmResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _165.MsgConnectionOpenConfirmResponse;
-                    fromPartial(_: Partial<_165.MsgConnectionOpenConfirmResponse>): _165.MsgConnectionOpenConfirmResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_165.MsgConnectionOpenConfirmResponse>): _165.MsgConnectionOpenConfirmResponse;
                     fromAmino(_: _165.MsgConnectionOpenConfirmResponseAmino): _165.MsgConnectionOpenConfirmResponse;
                     toAmino(_: _165.MsgConnectionOpenConfirmResponse): _165.MsgConnectionOpenConfirmResponseAmino;
                     fromAminoMsg(object: _165.MsgConnectionOpenConfirmResponseAminoMsg): _165.MsgConnectionOpenConfirmResponse;
@@ -3744,9 +3456,10 @@ export declare namespace ibc {
                 };
                 MsgUpdateParams: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _165.MsgUpdateParams, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _165.MsgUpdateParams;
-                    fromPartial(object: Partial<_165.MsgUpdateParams>): _165.MsgUpdateParams;
+                    fromPartial(object: import("../helpers").DeepPartial<_165.MsgUpdateParams>): _165.MsgUpdateParams;
                     fromAmino(object: _165.MsgUpdateParamsAmino): _165.MsgUpdateParams;
                     toAmino(message: _165.MsgUpdateParams): _165.MsgUpdateParamsAmino;
                     fromAminoMsg(object: _165.MsgUpdateParamsAminoMsg): _165.MsgUpdateParams;
@@ -3757,9 +3470,10 @@ export declare namespace ibc {
                 };
                 MsgUpdateParamsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _165.MsgUpdateParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _165.MsgUpdateParamsResponse;
-                    fromPartial(_: Partial<_165.MsgUpdateParamsResponse>): _165.MsgUpdateParamsResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_165.MsgUpdateParamsResponse>): _165.MsgUpdateParamsResponse;
                     fromAmino(_: _165.MsgUpdateParamsResponseAmino): _165.MsgUpdateParamsResponse;
                     toAmino(_: _165.MsgUpdateParamsResponse): _165.MsgUpdateParamsResponseAmino;
                     fromAminoMsg(object: _165.MsgUpdateParamsResponseAminoMsg): _165.MsgUpdateParamsResponse;
@@ -3770,9 +3484,10 @@ export declare namespace ibc {
                 };
                 QueryConnectionRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _164.QueryConnectionRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _164.QueryConnectionRequest;
-                    fromPartial(object: Partial<_164.QueryConnectionRequest>): _164.QueryConnectionRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_164.QueryConnectionRequest>): _164.QueryConnectionRequest;
                     fromAmino(object: _164.QueryConnectionRequestAmino): _164.QueryConnectionRequest;
                     toAmino(message: _164.QueryConnectionRequest): _164.QueryConnectionRequestAmino;
                     fromAminoMsg(object: _164.QueryConnectionRequestAminoMsg): _164.QueryConnectionRequest;
@@ -3783,9 +3498,10 @@ export declare namespace ibc {
                 };
                 QueryConnectionResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _164.QueryConnectionResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _164.QueryConnectionResponse;
-                    fromPartial(object: Partial<_164.QueryConnectionResponse>): _164.QueryConnectionResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_164.QueryConnectionResponse>): _164.QueryConnectionResponse;
                     fromAmino(object: _164.QueryConnectionResponseAmino): _164.QueryConnectionResponse;
                     toAmino(message: _164.QueryConnectionResponse): _164.QueryConnectionResponseAmino;
                     fromAminoMsg(object: _164.QueryConnectionResponseAminoMsg): _164.QueryConnectionResponse;
@@ -3796,9 +3512,10 @@ export declare namespace ibc {
                 };
                 QueryConnectionsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _164.QueryConnectionsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _164.QueryConnectionsRequest;
-                    fromPartial(object: Partial<_164.QueryConnectionsRequest>): _164.QueryConnectionsRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_164.QueryConnectionsRequest>): _164.QueryConnectionsRequest;
                     fromAmino(object: _164.QueryConnectionsRequestAmino): _164.QueryConnectionsRequest;
                     toAmino(message: _164.QueryConnectionsRequest): _164.QueryConnectionsRequestAmino;
                     fromAminoMsg(object: _164.QueryConnectionsRequestAminoMsg): _164.QueryConnectionsRequest;
@@ -3809,9 +3526,10 @@ export declare namespace ibc {
                 };
                 QueryConnectionsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _164.QueryConnectionsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _164.QueryConnectionsResponse;
-                    fromPartial(object: Partial<_164.QueryConnectionsResponse>): _164.QueryConnectionsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_164.QueryConnectionsResponse>): _164.QueryConnectionsResponse;
                     fromAmino(object: _164.QueryConnectionsResponseAmino): _164.QueryConnectionsResponse;
                     toAmino(message: _164.QueryConnectionsResponse): _164.QueryConnectionsResponseAmino;
                     fromAminoMsg(object: _164.QueryConnectionsResponseAminoMsg): _164.QueryConnectionsResponse;
@@ -3822,9 +3540,10 @@ export declare namespace ibc {
                 };
                 QueryClientConnectionsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _164.QueryClientConnectionsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _164.QueryClientConnectionsRequest;
-                    fromPartial(object: Partial<_164.QueryClientConnectionsRequest>): _164.QueryClientConnectionsRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_164.QueryClientConnectionsRequest>): _164.QueryClientConnectionsRequest;
                     fromAmino(object: _164.QueryClientConnectionsRequestAmino): _164.QueryClientConnectionsRequest;
                     toAmino(message: _164.QueryClientConnectionsRequest): _164.QueryClientConnectionsRequestAmino;
                     fromAminoMsg(object: _164.QueryClientConnectionsRequestAminoMsg): _164.QueryClientConnectionsRequest;
@@ -3835,9 +3554,10 @@ export declare namespace ibc {
                 };
                 QueryClientConnectionsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _164.QueryClientConnectionsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _164.QueryClientConnectionsResponse;
-                    fromPartial(object: Partial<_164.QueryClientConnectionsResponse>): _164.QueryClientConnectionsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_164.QueryClientConnectionsResponse>): _164.QueryClientConnectionsResponse;
                     fromAmino(object: _164.QueryClientConnectionsResponseAmino): _164.QueryClientConnectionsResponse;
                     toAmino(message: _164.QueryClientConnectionsResponse): _164.QueryClientConnectionsResponseAmino;
                     fromAminoMsg(object: _164.QueryClientConnectionsResponseAminoMsg): _164.QueryClientConnectionsResponse;
@@ -3848,9 +3568,10 @@ export declare namespace ibc {
                 };
                 QueryConnectionClientStateRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _164.QueryConnectionClientStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _164.QueryConnectionClientStateRequest;
-                    fromPartial(object: Partial<_164.QueryConnectionClientStateRequest>): _164.QueryConnectionClientStateRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_164.QueryConnectionClientStateRequest>): _164.QueryConnectionClientStateRequest;
                     fromAmino(object: _164.QueryConnectionClientStateRequestAmino): _164.QueryConnectionClientStateRequest;
                     toAmino(message: _164.QueryConnectionClientStateRequest): _164.QueryConnectionClientStateRequestAmino;
                     fromAminoMsg(object: _164.QueryConnectionClientStateRequestAminoMsg): _164.QueryConnectionClientStateRequest;
@@ -3861,9 +3582,10 @@ export declare namespace ibc {
                 };
                 QueryConnectionClientStateResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _164.QueryConnectionClientStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _164.QueryConnectionClientStateResponse;
-                    fromPartial(object: Partial<_164.QueryConnectionClientStateResponse>): _164.QueryConnectionClientStateResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_164.QueryConnectionClientStateResponse>): _164.QueryConnectionClientStateResponse;
                     fromAmino(object: _164.QueryConnectionClientStateResponseAmino): _164.QueryConnectionClientStateResponse;
                     toAmino(message: _164.QueryConnectionClientStateResponse): _164.QueryConnectionClientStateResponseAmino;
                     fromAminoMsg(object: _164.QueryConnectionClientStateResponseAminoMsg): _164.QueryConnectionClientStateResponse;
@@ -3874,9 +3596,10 @@ export declare namespace ibc {
                 };
                 QueryConnectionConsensusStateRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _164.QueryConnectionConsensusStateRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _164.QueryConnectionConsensusStateRequest;
-                    fromPartial(object: Partial<_164.QueryConnectionConsensusStateRequest>): _164.QueryConnectionConsensusStateRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_164.QueryConnectionConsensusStateRequest>): _164.QueryConnectionConsensusStateRequest;
                     fromAmino(object: _164.QueryConnectionConsensusStateRequestAmino): _164.QueryConnectionConsensusStateRequest;
                     toAmino(message: _164.QueryConnectionConsensusStateRequest): _164.QueryConnectionConsensusStateRequestAmino;
                     fromAminoMsg(object: _164.QueryConnectionConsensusStateRequestAminoMsg): _164.QueryConnectionConsensusStateRequest;
@@ -3887,9 +3610,10 @@ export declare namespace ibc {
                 };
                 QueryConnectionConsensusStateResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _164.QueryConnectionConsensusStateResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _164.QueryConnectionConsensusStateResponse;
-                    fromPartial(object: Partial<_164.QueryConnectionConsensusStateResponse>): _164.QueryConnectionConsensusStateResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_164.QueryConnectionConsensusStateResponse>): _164.QueryConnectionConsensusStateResponse;
                     fromAmino(object: _164.QueryConnectionConsensusStateResponseAmino): _164.QueryConnectionConsensusStateResponse;
                     toAmino(message: _164.QueryConnectionConsensusStateResponse): _164.QueryConnectionConsensusStateResponseAmino;
                     fromAminoMsg(object: _164.QueryConnectionConsensusStateResponseAminoMsg): _164.QueryConnectionConsensusStateResponse;
@@ -3900,9 +3624,10 @@ export declare namespace ibc {
                 };
                 QueryConnectionParamsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _164.QueryConnectionParamsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _164.QueryConnectionParamsRequest;
-                    fromPartial(_: Partial<_164.QueryConnectionParamsRequest>): _164.QueryConnectionParamsRequest;
+                    fromPartial(_: import("../helpers").DeepPartial<_164.QueryConnectionParamsRequest>): _164.QueryConnectionParamsRequest;
                     fromAmino(_: _164.QueryConnectionParamsRequestAmino): _164.QueryConnectionParamsRequest;
                     toAmino(_: _164.QueryConnectionParamsRequest): _164.QueryConnectionParamsRequestAmino;
                     fromAminoMsg(object: _164.QueryConnectionParamsRequestAminoMsg): _164.QueryConnectionParamsRequest;
@@ -3913,9 +3638,10 @@ export declare namespace ibc {
                 };
                 QueryConnectionParamsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _164.QueryConnectionParamsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _164.QueryConnectionParamsResponse;
-                    fromPartial(object: Partial<_164.QueryConnectionParamsResponse>): _164.QueryConnectionParamsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_164.QueryConnectionParamsResponse>): _164.QueryConnectionParamsResponse;
                     fromAmino(object: _164.QueryConnectionParamsResponseAmino): _164.QueryConnectionParamsResponse;
                     toAmino(message: _164.QueryConnectionParamsResponse): _164.QueryConnectionParamsResponseAmino;
                     fromAminoMsg(object: _164.QueryConnectionParamsResponseAminoMsg): _164.QueryConnectionParamsResponse;
@@ -3926,9 +3652,10 @@ export declare namespace ibc {
                 };
                 GenesisState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _163.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _163.GenesisState;
-                    fromPartial(object: Partial<_163.GenesisState>): _163.GenesisState;
+                    fromPartial(object: import("../helpers").DeepPartial<_163.GenesisState>): _163.GenesisState;
                     fromAmino(object: _163.GenesisStateAmino): _163.GenesisState;
                     toAmino(message: _163.GenesisState): _163.GenesisStateAmino;
                     fromAminoMsg(object: _163.GenesisStateAminoMsg): _163.GenesisState;
@@ -3940,13 +3667,13 @@ export declare namespace ibc {
                 stateFromJSON(object: any): _162.State;
                 stateToJSON(object: _162.State): string;
                 State: typeof _162.State;
-                StateSDKType: typeof _162.State;
                 StateAmino: typeof _162.State;
                 ConnectionEnd: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _162.ConnectionEnd, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _162.ConnectionEnd;
-                    fromPartial(object: Partial<_162.ConnectionEnd>): _162.ConnectionEnd;
+                    fromPartial(object: import("../helpers").DeepPartial<_162.ConnectionEnd>): _162.ConnectionEnd;
                     fromAmino(object: _162.ConnectionEndAmino): _162.ConnectionEnd;
                     toAmino(message: _162.ConnectionEnd): _162.ConnectionEndAmino;
                     fromAminoMsg(object: _162.ConnectionEndAminoMsg): _162.ConnectionEnd;
@@ -3957,9 +3684,10 @@ export declare namespace ibc {
                 };
                 IdentifiedConnection: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _162.IdentifiedConnection, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _162.IdentifiedConnection;
-                    fromPartial(object: Partial<_162.IdentifiedConnection>): _162.IdentifiedConnection;
+                    fromPartial(object: import("../helpers").DeepPartial<_162.IdentifiedConnection>): _162.IdentifiedConnection;
                     fromAmino(object: _162.IdentifiedConnectionAmino): _162.IdentifiedConnection;
                     toAmino(message: _162.IdentifiedConnection): _162.IdentifiedConnectionAmino;
                     fromAminoMsg(object: _162.IdentifiedConnectionAminoMsg): _162.IdentifiedConnection;
@@ -3970,9 +3698,10 @@ export declare namespace ibc {
                 };
                 Counterparty: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _162.Counterparty, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _162.Counterparty;
-                    fromPartial(object: Partial<_162.Counterparty>): _162.Counterparty;
+                    fromPartial(object: import("../helpers").DeepPartial<_162.Counterparty>): _162.Counterparty;
                     fromAmino(object: _162.CounterpartyAmino): _162.Counterparty;
                     toAmino(message: _162.Counterparty): _162.CounterpartyAmino;
                     fromAminoMsg(object: _162.CounterpartyAminoMsg): _162.Counterparty;
@@ -3983,9 +3712,10 @@ export declare namespace ibc {
                 };
                 ClientPaths: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _162.ClientPaths, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _162.ClientPaths;
-                    fromPartial(object: Partial<_162.ClientPaths>): _162.ClientPaths;
+                    fromPartial(object: import("../helpers").DeepPartial<_162.ClientPaths>): _162.ClientPaths;
                     fromAmino(object: _162.ClientPathsAmino): _162.ClientPaths;
                     toAmino(message: _162.ClientPaths): _162.ClientPathsAmino;
                     fromAminoMsg(object: _162.ClientPathsAminoMsg): _162.ClientPaths;
@@ -3996,9 +3726,10 @@ export declare namespace ibc {
                 };
                 ConnectionPaths: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _162.ConnectionPaths, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _162.ConnectionPaths;
-                    fromPartial(object: Partial<_162.ConnectionPaths>): _162.ConnectionPaths;
+                    fromPartial(object: import("../helpers").DeepPartial<_162.ConnectionPaths>): _162.ConnectionPaths;
                     fromAmino(object: _162.ConnectionPathsAmino): _162.ConnectionPaths;
                     toAmino(message: _162.ConnectionPaths): _162.ConnectionPathsAmino;
                     fromAminoMsg(object: _162.ConnectionPathsAminoMsg): _162.ConnectionPaths;
@@ -4009,9 +3740,10 @@ export declare namespace ibc {
                 };
                 Version: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _162.Version, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _162.Version;
-                    fromPartial(object: Partial<_162.Version>): _162.Version;
+                    fromPartial(object: import("../helpers").DeepPartial<_162.Version>): _162.Version;
                     fromAmino(object: _162.VersionAmino): _162.Version;
                     toAmino(message: _162.Version): _162.VersionAmino;
                     fromAminoMsg(object: _162.VersionAminoMsg): _162.Version;
@@ -4022,9 +3754,10 @@ export declare namespace ibc {
                 };
                 Params: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _162.Params, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _162.Params;
-                    fromPartial(object: Partial<_162.Params>): _162.Params;
+                    fromPartial(object: import("../helpers").DeepPartial<_162.Params>): _162.Params;
                     fromAmino(object: _162.ParamsAmino): _162.Params;
                     toAmino(message: _162.Params): _162.ParamsAmino;
                     fromAminoMsg(object: _162.ParamsAminoMsg): _162.Params;
@@ -4042,13 +3775,13 @@ export declare namespace ibc {
                 dataTypeFromJSON(object: any): _166.DataType;
                 dataTypeToJSON(object: _166.DataType): string;
                 DataType: typeof _166.DataType;
-                DataTypeSDKType: typeof _166.DataType;
                 DataTypeAmino: typeof _166.DataType;
                 ClientState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.ClientState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.ClientState;
-                    fromPartial(object: Partial<_166.ClientState>): _166.ClientState;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.ClientState>): _166.ClientState;
                     fromAmino(object: _166.ClientStateAmino): _166.ClientState;
                     toAmino(message: _166.ClientState): _166.ClientStateAmino;
                     fromAminoMsg(object: _166.ClientStateAminoMsg): _166.ClientState;
@@ -4059,9 +3792,10 @@ export declare namespace ibc {
                 };
                 ConsensusState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.ConsensusState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.ConsensusState;
-                    fromPartial(object: Partial<_166.ConsensusState>): _166.ConsensusState;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.ConsensusState>): _166.ConsensusState;
                     fromAmino(object: _166.ConsensusStateAmino): _166.ConsensusState;
                     toAmino(message: _166.ConsensusState): _166.ConsensusStateAmino;
                     fromAminoMsg(object: _166.ConsensusStateAminoMsg): _166.ConsensusState;
@@ -4072,9 +3806,10 @@ export declare namespace ibc {
                 };
                 Header: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.Header, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.Header;
-                    fromPartial(object: Partial<_166.Header>): _166.Header;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.Header>): _166.Header;
                     fromAmino(object: _166.HeaderAmino): _166.Header;
                     toAmino(message: _166.Header): _166.HeaderAmino;
                     fromAminoMsg(object: _166.HeaderAminoMsg): _166.Header;
@@ -4085,9 +3820,10 @@ export declare namespace ibc {
                 };
                 Misbehaviour: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.Misbehaviour, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.Misbehaviour;
-                    fromPartial(object: Partial<_166.Misbehaviour>): _166.Misbehaviour;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.Misbehaviour>): _166.Misbehaviour;
                     fromAmino(object: _166.MisbehaviourAmino): _166.Misbehaviour;
                     toAmino(message: _166.Misbehaviour): _166.MisbehaviourAmino;
                     fromAminoMsg(object: _166.MisbehaviourAminoMsg): _166.Misbehaviour;
@@ -4098,9 +3834,10 @@ export declare namespace ibc {
                 };
                 SignatureAndData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.SignatureAndData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.SignatureAndData;
-                    fromPartial(object: Partial<_166.SignatureAndData>): _166.SignatureAndData;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.SignatureAndData>): _166.SignatureAndData;
                     fromAmino(object: _166.SignatureAndDataAmino): _166.SignatureAndData;
                     toAmino(message: _166.SignatureAndData): _166.SignatureAndDataAmino;
                     fromAminoMsg(object: _166.SignatureAndDataAminoMsg): _166.SignatureAndData;
@@ -4111,9 +3848,10 @@ export declare namespace ibc {
                 };
                 TimestampedSignatureData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.TimestampedSignatureData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.TimestampedSignatureData;
-                    fromPartial(object: Partial<_166.TimestampedSignatureData>): _166.TimestampedSignatureData;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.TimestampedSignatureData>): _166.TimestampedSignatureData;
                     fromAmino(object: _166.TimestampedSignatureDataAmino): _166.TimestampedSignatureData;
                     toAmino(message: _166.TimestampedSignatureData): _166.TimestampedSignatureDataAmino;
                     fromAminoMsg(object: _166.TimestampedSignatureDataAminoMsg): _166.TimestampedSignatureData;
@@ -4124,9 +3862,10 @@ export declare namespace ibc {
                 };
                 SignBytes: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.SignBytes, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.SignBytes;
-                    fromPartial(object: Partial<_166.SignBytes>): _166.SignBytes;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.SignBytes>): _166.SignBytes;
                     fromAmino(object: _166.SignBytesAmino): _166.SignBytes;
                     toAmino(message: _166.SignBytes): _166.SignBytesAmino;
                     fromAminoMsg(object: _166.SignBytesAminoMsg): _166.SignBytes;
@@ -4137,9 +3876,10 @@ export declare namespace ibc {
                 };
                 HeaderData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.HeaderData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.HeaderData;
-                    fromPartial(object: Partial<_166.HeaderData>): _166.HeaderData;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.HeaderData>): _166.HeaderData;
                     fromAmino(object: _166.HeaderDataAmino): _166.HeaderData;
                     toAmino(message: _166.HeaderData): _166.HeaderDataAmino;
                     fromAminoMsg(object: _166.HeaderDataAminoMsg): _166.HeaderData;
@@ -4150,9 +3890,10 @@ export declare namespace ibc {
                 };
                 ClientStateData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.ClientStateData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.ClientStateData;
-                    fromPartial(object: Partial<_166.ClientStateData>): _166.ClientStateData;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.ClientStateData>): _166.ClientStateData;
                     fromAmino(object: _166.ClientStateDataAmino): _166.ClientStateData;
                     toAmino(message: _166.ClientStateData): _166.ClientStateDataAmino;
                     fromAminoMsg(object: _166.ClientStateDataAminoMsg): _166.ClientStateData;
@@ -4163,9 +3904,10 @@ export declare namespace ibc {
                 };
                 ConsensusStateData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.ConsensusStateData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.ConsensusStateData;
-                    fromPartial(object: Partial<_166.ConsensusStateData>): _166.ConsensusStateData;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.ConsensusStateData>): _166.ConsensusStateData;
                     fromAmino(object: _166.ConsensusStateDataAmino): _166.ConsensusStateData;
                     toAmino(message: _166.ConsensusStateData): _166.ConsensusStateDataAmino;
                     fromAminoMsg(object: _166.ConsensusStateDataAminoMsg): _166.ConsensusStateData;
@@ -4176,9 +3918,10 @@ export declare namespace ibc {
                 };
                 ConnectionStateData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.ConnectionStateData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.ConnectionStateData;
-                    fromPartial(object: Partial<_166.ConnectionStateData>): _166.ConnectionStateData;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.ConnectionStateData>): _166.ConnectionStateData;
                     fromAmino(object: _166.ConnectionStateDataAmino): _166.ConnectionStateData;
                     toAmino(message: _166.ConnectionStateData): _166.ConnectionStateDataAmino;
                     fromAminoMsg(object: _166.ConnectionStateDataAminoMsg): _166.ConnectionStateData;
@@ -4189,9 +3932,10 @@ export declare namespace ibc {
                 };
                 ChannelStateData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.ChannelStateData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.ChannelStateData;
-                    fromPartial(object: Partial<_166.ChannelStateData>): _166.ChannelStateData;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.ChannelStateData>): _166.ChannelStateData;
                     fromAmino(object: _166.ChannelStateDataAmino): _166.ChannelStateData;
                     toAmino(message: _166.ChannelStateData): _166.ChannelStateDataAmino;
                     fromAminoMsg(object: _166.ChannelStateDataAminoMsg): _166.ChannelStateData;
@@ -4202,9 +3946,10 @@ export declare namespace ibc {
                 };
                 PacketCommitmentData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.PacketCommitmentData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.PacketCommitmentData;
-                    fromPartial(object: Partial<_166.PacketCommitmentData>): _166.PacketCommitmentData;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.PacketCommitmentData>): _166.PacketCommitmentData;
                     fromAmino(object: _166.PacketCommitmentDataAmino): _166.PacketCommitmentData;
                     toAmino(message: _166.PacketCommitmentData): _166.PacketCommitmentDataAmino;
                     fromAminoMsg(object: _166.PacketCommitmentDataAminoMsg): _166.PacketCommitmentData;
@@ -4215,9 +3960,10 @@ export declare namespace ibc {
                 };
                 PacketAcknowledgementData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.PacketAcknowledgementData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.PacketAcknowledgementData;
-                    fromPartial(object: Partial<_166.PacketAcknowledgementData>): _166.PacketAcknowledgementData;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.PacketAcknowledgementData>): _166.PacketAcknowledgementData;
                     fromAmino(object: _166.PacketAcknowledgementDataAmino): _166.PacketAcknowledgementData;
                     toAmino(message: _166.PacketAcknowledgementData): _166.PacketAcknowledgementDataAmino;
                     fromAminoMsg(object: _166.PacketAcknowledgementDataAminoMsg): _166.PacketAcknowledgementData;
@@ -4228,9 +3974,10 @@ export declare namespace ibc {
                 };
                 PacketReceiptAbsenceData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.PacketReceiptAbsenceData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.PacketReceiptAbsenceData;
-                    fromPartial(object: Partial<_166.PacketReceiptAbsenceData>): _166.PacketReceiptAbsenceData;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.PacketReceiptAbsenceData>): _166.PacketReceiptAbsenceData;
                     fromAmino(object: _166.PacketReceiptAbsenceDataAmino): _166.PacketReceiptAbsenceData;
                     toAmino(message: _166.PacketReceiptAbsenceData): _166.PacketReceiptAbsenceDataAmino;
                     fromAminoMsg(object: _166.PacketReceiptAbsenceDataAminoMsg): _166.PacketReceiptAbsenceData;
@@ -4241,9 +3988,10 @@ export declare namespace ibc {
                 };
                 NextSequenceRecvData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _166.NextSequenceRecvData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _166.NextSequenceRecvData;
-                    fromPartial(object: Partial<_166.NextSequenceRecvData>): _166.NextSequenceRecvData;
+                    fromPartial(object: import("../helpers").DeepPartial<_166.NextSequenceRecvData>): _166.NextSequenceRecvData;
                     fromAmino(object: _166.NextSequenceRecvDataAmino): _166.NextSequenceRecvData;
                     toAmino(message: _166.NextSequenceRecvData): _166.NextSequenceRecvDataAmino;
                     fromAminoMsg(object: _166.NextSequenceRecvDataAminoMsg): _166.NextSequenceRecvData;
@@ -4256,9 +4004,10 @@ export declare namespace ibc {
             const v3: {
                 ClientState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _167.ClientState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _167.ClientState;
-                    fromPartial(object: Partial<_167.ClientState>): _167.ClientState;
+                    fromPartial(object: import("../helpers").DeepPartial<_167.ClientState>): _167.ClientState;
                     fromAmino(object: _167.ClientStateAmino): _167.ClientState;
                     toAmino(message: _167.ClientState): _167.ClientStateAmino;
                     fromAminoMsg(object: _167.ClientStateAminoMsg): _167.ClientState;
@@ -4269,9 +4018,10 @@ export declare namespace ibc {
                 };
                 ConsensusState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _167.ConsensusState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _167.ConsensusState;
-                    fromPartial(object: Partial<_167.ConsensusState>): _167.ConsensusState;
+                    fromPartial(object: import("../helpers").DeepPartial<_167.ConsensusState>): _167.ConsensusState;
                     fromAmino(object: _167.ConsensusStateAmino): _167.ConsensusState;
                     toAmino(message: _167.ConsensusState): _167.ConsensusStateAmino;
                     fromAminoMsg(object: _167.ConsensusStateAminoMsg): _167.ConsensusState;
@@ -4282,9 +4032,10 @@ export declare namespace ibc {
                 };
                 Header: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _167.Header, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _167.Header;
-                    fromPartial(object: Partial<_167.Header>): _167.Header;
+                    fromPartial(object: import("../helpers").DeepPartial<_167.Header>): _167.Header;
                     fromAmino(object: _167.HeaderAmino): _167.Header;
                     toAmino(message: _167.Header): _167.HeaderAmino;
                     fromAminoMsg(object: _167.HeaderAminoMsg): _167.Header;
@@ -4295,9 +4046,10 @@ export declare namespace ibc {
                 };
                 Misbehaviour: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _167.Misbehaviour, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _167.Misbehaviour;
-                    fromPartial(object: Partial<_167.Misbehaviour>): _167.Misbehaviour;
+                    fromPartial(object: import("../helpers").DeepPartial<_167.Misbehaviour>): _167.Misbehaviour;
                     fromAmino(object: _167.MisbehaviourAmino): _167.Misbehaviour;
                     toAmino(message: _167.Misbehaviour): _167.MisbehaviourAmino;
                     fromAminoMsg(object: _167.MisbehaviourAminoMsg): _167.Misbehaviour;
@@ -4308,9 +4060,10 @@ export declare namespace ibc {
                 };
                 SignatureAndData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _167.SignatureAndData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _167.SignatureAndData;
-                    fromPartial(object: Partial<_167.SignatureAndData>): _167.SignatureAndData;
+                    fromPartial(object: import("../helpers").DeepPartial<_167.SignatureAndData>): _167.SignatureAndData;
                     fromAmino(object: _167.SignatureAndDataAmino): _167.SignatureAndData;
                     toAmino(message: _167.SignatureAndData): _167.SignatureAndDataAmino;
                     fromAminoMsg(object: _167.SignatureAndDataAminoMsg): _167.SignatureAndData;
@@ -4321,9 +4074,10 @@ export declare namespace ibc {
                 };
                 TimestampedSignatureData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _167.TimestampedSignatureData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _167.TimestampedSignatureData;
-                    fromPartial(object: Partial<_167.TimestampedSignatureData>): _167.TimestampedSignatureData;
+                    fromPartial(object: import("../helpers").DeepPartial<_167.TimestampedSignatureData>): _167.TimestampedSignatureData;
                     fromAmino(object: _167.TimestampedSignatureDataAmino): _167.TimestampedSignatureData;
                     toAmino(message: _167.TimestampedSignatureData): _167.TimestampedSignatureDataAmino;
                     fromAminoMsg(object: _167.TimestampedSignatureDataAminoMsg): _167.TimestampedSignatureData;
@@ -4334,9 +4088,10 @@ export declare namespace ibc {
                 };
                 SignBytes: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _167.SignBytes, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _167.SignBytes;
-                    fromPartial(object: Partial<_167.SignBytes>): _167.SignBytes;
+                    fromPartial(object: import("../helpers").DeepPartial<_167.SignBytes>): _167.SignBytes;
                     fromAmino(object: _167.SignBytesAmino): _167.SignBytes;
                     toAmino(message: _167.SignBytes): _167.SignBytesAmino;
                     fromAminoMsg(object: _167.SignBytesAminoMsg): _167.SignBytes;
@@ -4347,9 +4102,10 @@ export declare namespace ibc {
                 };
                 HeaderData: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _167.HeaderData, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _167.HeaderData;
-                    fromPartial(object: Partial<_167.HeaderData>): _167.HeaderData;
+                    fromPartial(object: import("../helpers").DeepPartial<_167.HeaderData>): _167.HeaderData;
                     fromAmino(object: _167.HeaderDataAmino): _167.HeaderData;
                     toAmino(message: _167.HeaderData): _167.HeaderDataAmino;
                     fromAminoMsg(object: _167.HeaderDataAminoMsg): _167.HeaderData;
@@ -4364,9 +4120,10 @@ export declare namespace ibc {
             const v1: {
                 ClientState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _168.ClientState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _168.ClientState;
-                    fromPartial(object: Partial<_168.ClientState>): _168.ClientState;
+                    fromPartial(object: import("../helpers").DeepPartial<_168.ClientState>): _168.ClientState;
                     fromAmino(object: _168.ClientStateAmino): _168.ClientState;
                     toAmino(message: _168.ClientState): _168.ClientStateAmino;
                     fromAminoMsg(object: _168.ClientStateAminoMsg): _168.ClientState;
@@ -4377,9 +4134,10 @@ export declare namespace ibc {
                 };
                 ConsensusState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _168.ConsensusState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _168.ConsensusState;
-                    fromPartial(object: Partial<_168.ConsensusState>): _168.ConsensusState;
+                    fromPartial(object: import("../helpers").DeepPartial<_168.ConsensusState>): _168.ConsensusState;
                     fromAmino(object: _168.ConsensusStateAmino): _168.ConsensusState;
                     toAmino(message: _168.ConsensusState): _168.ConsensusStateAmino;
                     fromAminoMsg(object: _168.ConsensusStateAminoMsg): _168.ConsensusState;
@@ -4390,9 +4148,10 @@ export declare namespace ibc {
                 };
                 Misbehaviour: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _168.Misbehaviour, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _168.Misbehaviour;
-                    fromPartial(object: Partial<_168.Misbehaviour>): _168.Misbehaviour;
+                    fromPartial(object: import("../helpers").DeepPartial<_168.Misbehaviour>): _168.Misbehaviour;
                     fromAmino(object: _168.MisbehaviourAmino): _168.Misbehaviour;
                     toAmino(message: _168.Misbehaviour): _168.MisbehaviourAmino;
                     fromAminoMsg(object: _168.MisbehaviourAminoMsg): _168.Misbehaviour;
@@ -4403,9 +4162,10 @@ export declare namespace ibc {
                 };
                 Header: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _168.Header, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _168.Header;
-                    fromPartial(object: Partial<_168.Header>): _168.Header;
+                    fromPartial(object: import("../helpers").DeepPartial<_168.Header>): _168.Header;
                     fromAmino(object: _168.HeaderAmino): _168.Header;
                     toAmino(message: _168.Header): _168.HeaderAmino;
                     fromAminoMsg(object: _168.HeaderAminoMsg): _168.Header;
@@ -4416,9 +4176,10 @@ export declare namespace ibc {
                 };
                 Fraction: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _168.Fraction, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _168.Fraction;
-                    fromPartial(object: Partial<_168.Fraction>): _168.Fraction;
+                    fromPartial(object: import("../helpers").DeepPartial<_168.Fraction>): _168.Fraction;
                     fromAmino(object: _168.FractionAmino): _168.Fraction;
                     toAmino(message: _168.Fraction): _168.FractionAmino;
                     fromAminoMsg(object: _168.FractionAminoMsg): _168.Fraction;
@@ -4432,58 +4193,14 @@ export declare namespace ibc {
         namespace wasm {
             const v1: {
                 MsgClientImpl: typeof _325.MsgClientImpl;
+                createClientImpl: (rpc: import("..").TxRpc) => _325.MsgClientImpl;
                 QueryClientImpl: typeof _316.QueryClientImpl;
                 createRpcQueryExtension: (base: QueryClient) => {
                     checksums(request?: _170.QueryChecksumsRequest): Promise<_170.QueryChecksumsResponse>;
                     code(request: _170.QueryCodeRequest): Promise<_170.QueryCodeResponse>;
                 };
                 LCDQueryClient: typeof _307.LCDQueryClient;
-                registry: ReadonlyArray<[string, GeneratedType]>;
-                load: (protoRegistry: Registry) => void;
-                MessageComposer: {
-                    encoded: {
-                        storeCode(value: _171.MsgStoreCode): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        removeChecksum(value: _171.MsgRemoveChecksum): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                        migrateContract(value: _171.MsgMigrateContract): {
-                            typeUrl: string;
-                            value: Uint8Array<ArrayBufferLike>;
-                        };
-                    };
-                    withTypeUrl: {
-                        storeCode(value: _171.MsgStoreCode): {
-                            typeUrl: string;
-                            value: _171.MsgStoreCode;
-                        };
-                        removeChecksum(value: _171.MsgRemoveChecksum): {
-                            typeUrl: string;
-                            value: _171.MsgRemoveChecksum;
-                        };
-                        migrateContract(value: _171.MsgMigrateContract): {
-                            typeUrl: string;
-                            value: _171.MsgMigrateContract;
-                        };
-                    };
-                    fromPartial: {
-                        storeCode(value: _171.MsgStoreCode): {
-                            typeUrl: string;
-                            value: _171.MsgStoreCode;
-                        };
-                        removeChecksum(value: _171.MsgRemoveChecksum): {
-                            typeUrl: string;
-                            value: _171.MsgRemoveChecksum;
-                        };
-                        migrateContract(value: _171.MsgMigrateContract): {
-                            typeUrl: string;
-                            value: _171.MsgMigrateContract;
-                        };
-                    };
-                };
+                registry: ReadonlyArray<[string, import("..").TelescopeGeneratedType<any, any, any>]>;
                 AminoConverter: {
                     "/ibc.lightclients.wasm.v1.MsgStoreCode": {
                         aminoType: string;
@@ -4503,9 +4220,10 @@ export declare namespace ibc {
                 };
                 ClientState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _172.ClientState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _172.ClientState;
-                    fromPartial(object: Partial<_172.ClientState>): _172.ClientState;
+                    fromPartial(object: import("../helpers").DeepPartial<_172.ClientState>): _172.ClientState;
                     fromAmino(object: _172.ClientStateAmino): _172.ClientState;
                     toAmino(message: _172.ClientState): _172.ClientStateAmino;
                     fromAminoMsg(object: _172.ClientStateAminoMsg): _172.ClientState;
@@ -4516,9 +4234,10 @@ export declare namespace ibc {
                 };
                 ConsensusState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _172.ConsensusState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _172.ConsensusState;
-                    fromPartial(object: Partial<_172.ConsensusState>): _172.ConsensusState;
+                    fromPartial(object: import("../helpers").DeepPartial<_172.ConsensusState>): _172.ConsensusState;
                     fromAmino(object: _172.ConsensusStateAmino): _172.ConsensusState;
                     toAmino(message: _172.ConsensusState): _172.ConsensusStateAmino;
                     fromAminoMsg(object: _172.ConsensusStateAminoMsg): _172.ConsensusState;
@@ -4529,9 +4248,10 @@ export declare namespace ibc {
                 };
                 ClientMessage: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _172.ClientMessage, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _172.ClientMessage;
-                    fromPartial(object: Partial<_172.ClientMessage>): _172.ClientMessage;
+                    fromPartial(object: import("../helpers").DeepPartial<_172.ClientMessage>): _172.ClientMessage;
                     fromAmino(object: _172.ClientMessageAmino): _172.ClientMessage;
                     toAmino(message: _172.ClientMessage): _172.ClientMessageAmino;
                     fromAminoMsg(object: _172.ClientMessageAminoMsg): _172.ClientMessage;
@@ -4542,9 +4262,10 @@ export declare namespace ibc {
                 };
                 Checksums: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _172.Checksums, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _172.Checksums;
-                    fromPartial(object: Partial<_172.Checksums>): _172.Checksums;
+                    fromPartial(object: import("../helpers").DeepPartial<_172.Checksums>): _172.Checksums;
                     fromAmino(object: _172.ChecksumsAmino): _172.Checksums;
                     toAmino(message: _172.Checksums): _172.ChecksumsAmino;
                     fromAminoMsg(object: _172.ChecksumsAminoMsg): _172.Checksums;
@@ -4555,9 +4276,10 @@ export declare namespace ibc {
                 };
                 MsgStoreCode: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _171.MsgStoreCode, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _171.MsgStoreCode;
-                    fromPartial(object: Partial<_171.MsgStoreCode>): _171.MsgStoreCode;
+                    fromPartial(object: import("../helpers").DeepPartial<_171.MsgStoreCode>): _171.MsgStoreCode;
                     fromAmino(object: _171.MsgStoreCodeAmino): _171.MsgStoreCode;
                     toAmino(message: _171.MsgStoreCode): _171.MsgStoreCodeAmino;
                     fromAminoMsg(object: _171.MsgStoreCodeAminoMsg): _171.MsgStoreCode;
@@ -4568,9 +4290,10 @@ export declare namespace ibc {
                 };
                 MsgStoreCodeResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _171.MsgStoreCodeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _171.MsgStoreCodeResponse;
-                    fromPartial(object: Partial<_171.MsgStoreCodeResponse>): _171.MsgStoreCodeResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_171.MsgStoreCodeResponse>): _171.MsgStoreCodeResponse;
                     fromAmino(object: _171.MsgStoreCodeResponseAmino): _171.MsgStoreCodeResponse;
                     toAmino(message: _171.MsgStoreCodeResponse): _171.MsgStoreCodeResponseAmino;
                     fromAminoMsg(object: _171.MsgStoreCodeResponseAminoMsg): _171.MsgStoreCodeResponse;
@@ -4581,9 +4304,10 @@ export declare namespace ibc {
                 };
                 MsgRemoveChecksum: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _171.MsgRemoveChecksum, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _171.MsgRemoveChecksum;
-                    fromPartial(object: Partial<_171.MsgRemoveChecksum>): _171.MsgRemoveChecksum;
+                    fromPartial(object: import("../helpers").DeepPartial<_171.MsgRemoveChecksum>): _171.MsgRemoveChecksum;
                     fromAmino(object: _171.MsgRemoveChecksumAmino): _171.MsgRemoveChecksum;
                     toAmino(message: _171.MsgRemoveChecksum): _171.MsgRemoveChecksumAmino;
                     fromAminoMsg(object: _171.MsgRemoveChecksumAminoMsg): _171.MsgRemoveChecksum;
@@ -4594,9 +4318,10 @@ export declare namespace ibc {
                 };
                 MsgRemoveChecksumResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _171.MsgRemoveChecksumResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _171.MsgRemoveChecksumResponse;
-                    fromPartial(_: Partial<_171.MsgRemoveChecksumResponse>): _171.MsgRemoveChecksumResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_171.MsgRemoveChecksumResponse>): _171.MsgRemoveChecksumResponse;
                     fromAmino(_: _171.MsgRemoveChecksumResponseAmino): _171.MsgRemoveChecksumResponse;
                     toAmino(_: _171.MsgRemoveChecksumResponse): _171.MsgRemoveChecksumResponseAmino;
                     fromAminoMsg(object: _171.MsgRemoveChecksumResponseAminoMsg): _171.MsgRemoveChecksumResponse;
@@ -4607,9 +4332,10 @@ export declare namespace ibc {
                 };
                 MsgMigrateContract: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _171.MsgMigrateContract, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _171.MsgMigrateContract;
-                    fromPartial(object: Partial<_171.MsgMigrateContract>): _171.MsgMigrateContract;
+                    fromPartial(object: import("../helpers").DeepPartial<_171.MsgMigrateContract>): _171.MsgMigrateContract;
                     fromAmino(object: _171.MsgMigrateContractAmino): _171.MsgMigrateContract;
                     toAmino(message: _171.MsgMigrateContract): _171.MsgMigrateContractAmino;
                     fromAminoMsg(object: _171.MsgMigrateContractAminoMsg): _171.MsgMigrateContract;
@@ -4620,9 +4346,10 @@ export declare namespace ibc {
                 };
                 MsgMigrateContractResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(_: _171.MsgMigrateContractResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _171.MsgMigrateContractResponse;
-                    fromPartial(_: Partial<_171.MsgMigrateContractResponse>): _171.MsgMigrateContractResponse;
+                    fromPartial(_: import("../helpers").DeepPartial<_171.MsgMigrateContractResponse>): _171.MsgMigrateContractResponse;
                     fromAmino(_: _171.MsgMigrateContractResponseAmino): _171.MsgMigrateContractResponse;
                     toAmino(_: _171.MsgMigrateContractResponse): _171.MsgMigrateContractResponseAmino;
                     fromAminoMsg(object: _171.MsgMigrateContractResponseAminoMsg): _171.MsgMigrateContractResponse;
@@ -4633,9 +4360,10 @@ export declare namespace ibc {
                 };
                 QueryChecksumsRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _170.QueryChecksumsRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _170.QueryChecksumsRequest;
-                    fromPartial(object: Partial<_170.QueryChecksumsRequest>): _170.QueryChecksumsRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_170.QueryChecksumsRequest>): _170.QueryChecksumsRequest;
                     fromAmino(object: _170.QueryChecksumsRequestAmino): _170.QueryChecksumsRequest;
                     toAmino(message: _170.QueryChecksumsRequest): _170.QueryChecksumsRequestAmino;
                     fromAminoMsg(object: _170.QueryChecksumsRequestAminoMsg): _170.QueryChecksumsRequest;
@@ -4646,9 +4374,10 @@ export declare namespace ibc {
                 };
                 QueryChecksumsResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _170.QueryChecksumsResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _170.QueryChecksumsResponse;
-                    fromPartial(object: Partial<_170.QueryChecksumsResponse>): _170.QueryChecksumsResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_170.QueryChecksumsResponse>): _170.QueryChecksumsResponse;
                     fromAmino(object: _170.QueryChecksumsResponseAmino): _170.QueryChecksumsResponse;
                     toAmino(message: _170.QueryChecksumsResponse): _170.QueryChecksumsResponseAmino;
                     fromAminoMsg(object: _170.QueryChecksumsResponseAminoMsg): _170.QueryChecksumsResponse;
@@ -4659,9 +4388,10 @@ export declare namespace ibc {
                 };
                 QueryCodeRequest: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _170.QueryCodeRequest, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _170.QueryCodeRequest;
-                    fromPartial(object: Partial<_170.QueryCodeRequest>): _170.QueryCodeRequest;
+                    fromPartial(object: import("../helpers").DeepPartial<_170.QueryCodeRequest>): _170.QueryCodeRequest;
                     fromAmino(object: _170.QueryCodeRequestAmino): _170.QueryCodeRequest;
                     toAmino(message: _170.QueryCodeRequest): _170.QueryCodeRequestAmino;
                     fromAminoMsg(object: _170.QueryCodeRequestAminoMsg): _170.QueryCodeRequest;
@@ -4672,9 +4402,10 @@ export declare namespace ibc {
                 };
                 QueryCodeResponse: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _170.QueryCodeResponse, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _170.QueryCodeResponse;
-                    fromPartial(object: Partial<_170.QueryCodeResponse>): _170.QueryCodeResponse;
+                    fromPartial(object: import("../helpers").DeepPartial<_170.QueryCodeResponse>): _170.QueryCodeResponse;
                     fromAmino(object: _170.QueryCodeResponseAmino): _170.QueryCodeResponse;
                     toAmino(message: _170.QueryCodeResponse): _170.QueryCodeResponseAmino;
                     fromAminoMsg(object: _170.QueryCodeResponseAminoMsg): _170.QueryCodeResponse;
@@ -4685,9 +4416,10 @@ export declare namespace ibc {
                 };
                 GenesisState: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _169.GenesisState, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _169.GenesisState;
-                    fromPartial(object: Partial<_169.GenesisState>): _169.GenesisState;
+                    fromPartial(object: import("../helpers").DeepPartial<_169.GenesisState>): _169.GenesisState;
                     fromAmino(object: _169.GenesisStateAmino): _169.GenesisState;
                     toAmino(message: _169.GenesisState): _169.GenesisStateAmino;
                     fromAminoMsg(object: _169.GenesisStateAminoMsg): _169.GenesisState;
@@ -4698,9 +4430,10 @@ export declare namespace ibc {
                 };
                 Contract: {
                     typeUrl: string;
+                    aminoType: string;
                     encode(message: _169.Contract, writer?: import("..").BinaryWriter): import("..").BinaryWriter;
                     decode(input: import("..").BinaryReader | Uint8Array, length?: number): _169.Contract;
-                    fromPartial(object: Partial<_169.Contract>): _169.Contract;
+                    fromPartial(object: import("../helpers").DeepPartial<_169.Contract>): _169.Contract;
                     fromAmino(object: _169.ContractAmino): _169.Contract;
                     toAmino(message: _169.Contract): _169.ContractAmino;
                     fromAminoMsg(object: _169.ContractAminoMsg): _169.Contract;